Class MapDequeue

packages/effect/src/internal/groupBy.ts:317–396

const mapDequeue = <A, B>(dequeue: Queue.Dequeue<A>, f: (a: A) => B): Queue.Dequeue<B> => new MapDequeue(dequeue, f)

class MapDequeue<in out A, out B> extends Effectable.Class<B> implements Queue.Dequeue<B> {
  readonly [Queue.DequeueTypeId] = {
    _Out: (_: never) => _
  }

  constructor(
    readonly dequeue: Queue.Dequeue<A>,
    readonly f: (a: A) => B
  ) {
    super()
  }

  capacity(): number {
    return Queue.capacity(this.dequeue)
  }

  get size(): Effect.Effect<number> {
    return Queue.size(this.dequeue)
  }

  unsafeSize(): Option.Option<number> {
    return this.dequeue.unsafeSize()
  }

  get awaitShutdown(): Effect.Effect<void> {
    return Queue.awaitShutdown(this.dequeue)
  }

  isActive(): boolean {
    return this.dequeue.isActive()
  }

  get isShutdown(): Effect.Effect<boolean> {
    return Queue.isShutdown(this.dequeue)
  }

  get shutdown(): Effect.Effect<void> {
    return Queue.shutdown(this.dequeue)
  }

  get isFull(): Effect.Effect<boolean> {
    return Queue.isFull(this.dequeue)
  }

  get isEmpty(): Effect.Effect<boolean> {
    return Queue.isEmpty(this.dequeue)
  }

  get take(): Effect.Effect<B> {
    return pipe(Queue.take(this.dequeue), Effect.map((a) => this.f(a)))
  }

  get takeAll(): Effect.Effect<Chunk.Chunk<B>> {
    return pipe(Queue.takeAll(this.dequeue), Effect.map(Chunk.map((a) => this.f(a))))
  }

  takeUpTo(max: number): Effect.Effect<Chunk.Chunk<B>> {
    return pipe(Queue.takeUpTo(this.dequeue, max), Effect.map(Chunk.map((a) => this.f(a))))