async / await: the I/O is the logic

// The call fires immediately, mid-logic.
async function registerUser(input) {
  const found = await db.findUser(input.email);
  if (found) throw new Error('Email in use');
  return db.saveUser(input);
}

// To test it you must run it. When it fails
// in prod, nothing was recorded to replay.

You check behavior by executing it. The failed run leaves no trace you can step through.

pure-effect: the logic returns I/O as data

// Read what it would do first. Nothing ran.
const flow = registerUserFlow(input);
assert.equal(flow.cmd.name, 'cmdFindUser');

// Feed in what production saw and walk the
// exact same path, no database is touched.
const next = flow.next(recordedUser);
assert.equal(next.cmd.name, 'cmdSaveUser');

You check it by reading the tree. The same calls can be recorded in prod and replayed here, with no infrastructure.

i.

Success(value)

OK

A successful computation result. Returns { type: 'Success', value }. Any pipeline step can return one to feed the next.

ii.

Failure(error)

ERR

Stops the pipeline immediately and short-circuits remaining steps. Optional initialInput is preserved for diagnostics.

iii.

Command(cmd, next)

deferred I/O

A side effect described as data. cmd is the function that would run; next turns its result into the next Effect.

iv.

Ask(next)

context · DI

Reads the context object passed to runEffect such as tenant, request id, and config without threading it through every signature.

v.

Retry(effect, opts)

resilience

Wraps any Effect with retry-on-failure. Configure attempts, delay, backoff. On exhaustion: a structured Failure.

vi.

Parallel(effects, next)

concurrency

Runs Effect trees concurrently via Promise.all. Ask context flows into every branch. First Failure short-circuits.

Test without a database

Assert what your code would do.

Pipelines return inert objects. Walk the tree and check each step: no mock, no in-memory fake, no container.

assert.equal(step.cmd.name, 'cmdFindUser'); assert.equal(step.type, 'Command');

Replay production runs

Step through the failed request locally.

Record what each command returned in production, then feed those results back into the same tree to retrace the exact path, no infrastructure attached.

let step = flow; while (step.type === 'Command') step = step.next(recorded[step.cmd.name]); // replays the recorded path, no I/O

Retry as data

Test resilience without waiting.

Wrap any Effect with retry semantics. Because the config is plain data, tests assert on it directly: no timers, no sleeps, no flaky timing.

Retry(effect, { attempts: 3, delay: 200, backoff: 2 }); // 200·400·800

Parallel execution

Concurrent branches, ordered results.

Promise.all semantics with first-failure short-circuiting. Ask context flows into every branch automatically.

Parallel( [getUser(id), getPerms(id)], ([user, perms]) => Success({ user, perms }) );

Dependency injection

Context without polluting signatures.

Resolve tenant, trace id, or config from the framework layer. Domain functions stay clean and just Ask.

Ask((ctx) => { // ctx.tenant comes from runEffect return Command(...) });

OpenTelemetry

Lifecycle hooks for tracing.

onRun, onStep, and onBeforeCommand let you wrap workflows in spans without touching domain code.

configureEffect({ onRun: (eff, pipeline, name) => tracer.startActiveSpan(name, pipeline) });

Library

DESCRIPTION

Choose pure-effect if…

Effect-TS

A full functional ecosystem with fibers, streaming, schema validation, and structured concurrency. Powerful, with a steep learning curve.

…you need testable pipelines, retry, and dependency injection that can be learned in an afternoon.

fp-ts

Brings category-theory abstractions such as functors, monads, and applicatives to TypeScript. Teaches a lot of vocabulary along with effects.

…you want effects-as-data without the academic vocabulary.

async/await + mocks

The default. Simple for small surfaces. Falls apart when test isolation matters: mocks drift from real drivers and tests turn into theater.

…test isolation is a real pain point in your codebase.

async / await: run to verify

// Did the AI handle the error path?
// Did it thread context correctly?
// You won't know until you run it.
async function registerUser(input) {
  const found = await db.findUser(input.email);
  if (found) throw new Error('Email in use');
  return db.saveUser(input); // awaited? who knows.
}

You audit by executing. Every verification touches infrastructure.

pure-effect: read to verify

// AI generated this flow. Inspect it before it runs.
const flow = registerUserFlow(input);

assert.equal(flow.type, 'Command');
assert.equal(flow.cmd.name, 'cmdFindUser');

const step2 = flow.next(null);
assert.equal(step2.cmd.name, 'cmdSaveUser');
// Control flow confirmed. Nothing executed.

You audit by reading the tree. No database, no network.