Effect.ts: Absence as First-Class

State Management • Lesson 33 of 51

33. Queue Strategies - Handling Full/Empty

Different HOWs when queue is full or empty

Code Example
// Strategy: Bounded queue (block when full)
const bounded = Queue.bounded<number>(3);
// 4th offer WAITS for space

// Strategy: Dropping (drop new when full)
const dropping = Queue.dropping<number>(3);
// 4th offer is IGNORED

// Strategy: Sliding (drop old when full)
const sliding = Queue.sliding<number>(3);
// 4th offer REMOVES oldest

// Empty strategies:
Queue.take(queue);      // WAITS for item
Queue.poll(queue);      // Returns Option.none() immediately
Queue.takeUpTo(queue, 5); // Takes what's available

// Same absence, different HOWs!
Interactive Example
const { Queue } = await import('effect');
const bounded = await Effect.runPromise(Queue.bounded(2));
const dropping = await Effect.runPromise(Queue.dropping(2));
const sliding = await Effect.runPromise(Queue.sliding(2));
return `Queue strategies!

Bounded(2): Blocks when full
- offer #3 waits for space

Dropping(2): Drops new items
- offer #3 ignored

Sliding(2): Drops old items  
- offer #3 removes oldest

Different absence strategies!`;
Explanation

Queue strategies: different HOWs for handling absence limits.

Traditional approach: one strategy (usually blocking). Queue types multiple absence-handling strategies:

Full queue = "capacity for new values is absent":

  • Bounded: wait for capacity to appear
  • Dropping: accept that new values will be absent
  • Sliding: make old values absent to create capacity

Empty queue = "values are absent":

  • take: wait for values to appear
  • poll: acknowledge immediate absence (None)
  • takeUpTo: take whatever presence exists

Absence-first resource limits!

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

←→