Class Latch

repos/effect/packages/effect/src/internal/effect.ts:5352–5412

      readonly uninterruptible?: boolean | "inherit" | undefined
    } | undefined
  ): [Arg] extends [Effect.Effect<infer _A, infer _E, infer _R>] ?
    Effect.Effect<Fiber.Fiber<_A, _E>, never, _R | Scope.Scope>
    : <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Fiber.Fiber<A, E>, never, R | Scope.Scope>
} = dual((args) => isEffect(args[0]), <A, E, R>(
  self: Effect.Effect<A, E, R>,
  options?: {
    readonly startImmediately?: boolean
    readonly uninterruptible?: boolean | "inherit"
  }
): Effect.Effect<Fiber.Fiber<A, E>, never, R | Scope.Scope> => flatMap(scope, (scope) => forkIn(self, scope, options)))

// ----------------------------------------------------------------------------
// execution
// ----------------------------------------------------------------------------

/** @internal */
export const runForkWith = <R>(context: Context.Context<R>) =>
<A, E>(
  effect: Effect.Effect<A, E, R>,
  options?: Effect.RunOptions | undefined
): Fiber.Fiber<A, E> => {
  const fiber = new FiberImpl<A, E>(
    options?.scheduler ? Context.add(context, Scheduler.Scheduler, options.scheduler) : context,
    options?.uninterruptible !== true
  )
  fiber.evaluate(effect as any)
  if (fiber._exit) return fiber

  if (options?.signal) {
    if (options.signal.aborted) {
      fiber.interruptUnsafe()
    } else {
      const abort = () => fiber.interruptUnsafe()
      options.signal.addEventListener("abort", abort, { once: true })
      fiber.addObserver(() => options.signal!.removeEventListener("abort", abort))
    }
  }
  if (options?.onFiberStart) {
    options.onFiberStart(fiber)
  }
  return fiber
}

/** @internal */
export const fiberRunIn: {
  (scope: Scope.Scope): <A, E>(self: Fiber.Fiber<A, E>) => Fiber.Fiber<A, E>
  <A, E>(
    self: Fiber.Fiber<A, E>,
    scope: Scope.Scope
  ): Fiber.Fiber<A, E>
} = dual(2, <A, E>(
  self: FiberImpl<A, E>,
  scope: Scope.Scope
): Fiber.Fiber<A, E> => {
  if (self._exit) {
    return self
  } else if (scope.state._tag === "Closed") {
    self.interruptUnsafe(self.id)