Function raceAll

packages/effect/src/internal/fiberRuntime.ts:2657–2708

(all: Iterable<Effect.Effect<A, E, R>>)

export const raceAll: <Eff extends Effect.Effect<any, any, any>>(
  all: Iterable<Eff>
) => Effect.Effect<Effect.Effect.Success<Eff>, Effect.Effect.Error<Eff>, Effect.Effect.Context<Eff>> = <
  A,
  E,
  R
>(all: Iterable<Effect.Effect<A, E, R>>): Effect.Effect<A, E, R> =>
  core.withFiberRuntime((state, status) =>
    core.async<A, E, R>((resume) => {
      const fibers = new Set<FiberRuntime<A, E>>()
      let winner: FiberRuntime<A, E> | undefined
      let failures: Cause.Cause<E> = internalCause.empty
      const interruptAll = () => {
        for (const fiber of fibers) {
          fiber.unsafeInterruptAsFork(state.id())
        }
      }
      let latch = false
      let empty = true
      for (const self of all) {
        empty = false
        const fiber = unsafeFork(
          core.interruptible(self),
          state,
          status.runtimeFlags
        )
        fibers.add(fiber)
        fiber.addObserver((exit) => {
          fibers.delete(fiber)
          if (!winner) {
            if (exit._tag === "Success") {
              latch = true
              winner = fiber
              failures = internalCause.empty
              interruptAll()
            } else {
              failures = internalCause.parallel(exit.cause, failures)
            }
          }
          if (latch && fibers.size === 0) {
            resume(
              winner ? core.zipRight(internalFiber.inheritAll(winner), winner.unsafePoll()!) : core.failCause(failures)
            )
          }
        })
        if (winner) break
      }
      if (empty) {
        return resume(core.dieSync(() => new core.IllegalArgumentException(`Received an empty collection of effects`)))
      }
      latch = true
      return internalFiber.interruptAllAs(fibers, state.id())
    })
  )

/* @internal */
export const reduceEffect = dual<