Effect.ts: Absence as First-Class

Concurrency • Lesson 11 of 51

11. Sequential vs Parallel HOW

SAME operations, DIFFERENT resolution strategy

Code Example

const task = () => Effect.sleep("50 millis");

// HOW #1: Sequential
const sequential = Effect.gen(function* () {
  yield* task();  // 50ms
  yield* task();  // 50ms
  yield* task();  // 50ms
  // Total: ~150ms
});

// HOW #2: Parallel (SAME tasks!)
const parallel = Effect.all([
  task(),
  task(),
  task()
]);
// Total: ~50ms

// SAME description, DIFFERENT execution!

Interactive Example

const task = () => Effect.sleep('50 millis');
const seqStart = Date.now();
const sequential = Effect.gen(function* () {
      yield* task();
      yield* task();
      yield* task();
});
await Effect.runPromise(sequential);
const seqTime = Date.now() - seqStart;
const parStart = Date.now();
await Effect.runPromise(Effect.all([task(), task(), task()]));
const parTime = Date.now() - parStart;
return `Sequential vs Parallel

Sequential: ${seqTime}ms (~150ms)
Parallel: ${parTime}ms (~50ms)

Same tasks, different execution strategy!`;

Explanation

This crystallizes the absence-first philosophy!

The tasks are identical - they describe the SAME absence. But HOW we resolve that absence changes everything:

Sequential: resolve absences one by one
Parallel: resolve absences simultaneously
No assumptions about execution strategy in the task itself

The absence (Effect) is separate from HOW we resolve it. This is the power!

Part 11 of 51 in the Effect.ts Absence Modeling series

←→