Effect TS Concurrency

Effect-TS Concurrency

Overview

Effect-TS provides lightweight fibers for high-performance concurrency. The core principle is explicit control: always bound parallelism to prevent resource exhaustion.

When to Use

• Processing large arrays of effects (e.g., Effect.all, Effect.forEach)
• Rate limiting external API calls or database connections
• Coordinating work between background processes (fibers)
• Signaling completion or state changes across different parts of the app

When NOT to use:

• Simple sequential operations
• When standard Promise.all is sufficient (though Effect is usually preferred for consistency)

Core Pattern: Bounded Parallelism

Unbounded parallelism is the most common source of "Too many open files" or "Connection timeout" errors.

Quick Reference

Implementation

1. Bounded Parallelism (Critical)

Always specify concurrency when processing collections.

import { Effect } from 'effect';

// Process 1000 items, max 10 concurrent
const results = yield* Effect.all(
  items.map(processItem),
  { concurrency: 10 }
);

2. Semaphore for Rate Limiting

Use a Semaphore when multiple independent operations must share a global limit.

import { Effect } from 'effect';

const program = Effect.gen(function* () {
  const semaphore = yield* Effect.makeSemaphore(5); // Max 5 concurrent
  
  yield* Effect.all(
    requests.map((req) => 
      semaphore.withPermits(1)(handleRequest(req))
    ),
    { concurrency: 'unbounded' } // Semaphore controls actual concurrency
  );
});

3. Deferred for Signaling

Use Deferred to wait for a specific event or value from another fiber.

import { Deferred, Effect, Fiber } from 'effect';

const program = Effect.gen(function* () {
  const signal = yield* Deferred.make<void>();
  
  const worker = yield* Effect.fork(
    Effect.gen(function* () {
      yield* Deferred.await(signal); // Wait for signal
      yield* doWork();
    })
  );
  
  yield* setup();
  yield* Deferred.succeed(signal, undefined); // Trigger worker
  yield* Fiber.join(worker);
});

Common Mistakes

• Unbounded parallelism: Forgetting { concurrency: n } in Effect.all.
• Leaking Fibers: Forking fibers without joining or interrupting them (use Effect.scoped for safety).
• Deadlocks: Circular dependencies between semaphores or deferreds.

Red Flags - STOP and Start Over

• Using Effect.all on a large array without { concurrency: n }.
• Using Promise.all inside an Effect-TS codebase.
• Manual setTimeout for rate limiting instead of Effect.makeRateLimiter or Semaphore.

Rationalization Table

REQUIRED BACKGROUND: See effect-ts-anti-patterns for more on unbounded parallelism.