Class Zip

packages/effect/src/internal/supervisor.ts:77–128

/** @internal */
export class Zip<out T0, out T1> implements Supervisor.Supervisor<readonly [T0, T1]> {
  readonly _tag = "Zip"
  readonly [SupervisorTypeId] = supervisorVariance

  constructor(
    readonly left: Supervisor.Supervisor<T0>,
    readonly right: Supervisor.Supervisor<T1>
  ) {
  }

  get value(): Effect.Effect<[T0, T1]> {
    return core.zip(this.left.value, this.right.value)
  }

  onStart<A, E, R>(
    context: Context.Context<R>,
    effect: Effect.Effect<A, E, R>,
    parent: Option.Option<Fiber.RuntimeFiber<any, any>>,
    fiber: Fiber.RuntimeFiber<A, E>
  ): void {
    this.left.onStart(context, effect, parent, fiber)
    this.right.onStart(context, effect, parent, fiber)
  }

  onEnd<A, E>(value: Exit.Exit<A, E>, fiber: Fiber.RuntimeFiber<A, E>): void {
    this.left.onEnd(value, fiber)
    this.right.onEnd(value, fiber)
  }

  onEffect<A, E>(fiber: Fiber.RuntimeFiber<A, E>, effect: Effect.Effect<any, any, any>): void {
    this.left.onEffect(fiber, effect)
    this.right.onEffect(fiber, effect)
  }

  onSuspend<A, E>(fiber: Fiber.RuntimeFiber<A, E>): void {
    this.left.onSuspend(fiber)
    this.right.onSuspend(fiber)
  }

  onResume<A, E>(fiber: Fiber.RuntimeFiber<A, E>): void {
    this.left.onResume(fiber)
    this.right.onResume(fiber)
  }

  map<B>(f: (a: [T0, T1]) => B): Supervisor.Supervisor<B> {
    return new ProxySupervisor(this, pipe(this.value, core.map(f)))
  }

  zip<A>(right: Supervisor.Supervisor<A>): Supervisor.Supervisor<[[T0, T1], A]> {
    return new Zip(this, right)
  }
}

/** @internal */
export const isZip = (self: unknown): self is Zip<any, any> =>