Function async_

packages/effect/src/internal/core.ts:512–554

(
  resume: (
    callback: (_: Effect.Effect<A, E, R>) => void,
    signal: AbortSignal
  ) => void | Effect.Effect<void, never, R>,
  blockingOn: FiberId.FiberId = FiberId.none
)

): Effect.Effect<A, E, R> => suspend(() => unsafeAsync(register, blockingOn))

const async_ = <A, E = never, R = never>(
  resume: (
    callback: (_: Effect.Effect<A, E, R>) => void,
    signal: AbortSignal
  ) => void | Effect.Effect<void, never, R>,
  blockingOn: FiberId.FiberId = FiberId.none
): Effect.Effect<A, E, R> => {
  return custom(resume, function() {
    let backingResume: ((_: Effect.Effect<A, E, R>) => void) | undefined = undefined
    let pendingEffect: Effect.Effect<A, E, R> | undefined = undefined
    function proxyResume(effect: Effect.Effect<A, E, R>) {
      if (backingResume) {
        backingResume(effect)
      } else if (pendingEffect === undefined) {
        pendingEffect = effect
      }
    }
    const effect = new EffectPrimitive(OpCodes.OP_ASYNC) as any
    effect.effect_instruction_i0 = (resume: (_: Effect.Effect<A, E, R>) => void) => {
      backingResume = resume
      if (pendingEffect) {
        resume(pendingEffect)
      }
    }
    effect.effect_instruction_i1 = blockingOn
    let cancelerRef: Effect.Effect<void, never, R> | void = undefined
    let controllerRef: AbortController | void = undefined
    if (this.effect_instruction_i0.length !== 1) {
      controllerRef = new AbortController()
      cancelerRef = internalCall(() => this.effect_instruction_i0(proxyResume, controllerRef!.signal))
    } else {
      cancelerRef = internalCall(() => (this.effect_instruction_i0 as any)(proxyResume))
    }
    return (cancelerRef || controllerRef) ?
      onInterrupt(effect, (_) => {
        if (controllerRef) {
          controllerRef.abort()
        }
        return cancelerRef ?? void_
      }) :
      effect
  })
}
export {
  /** @internal */
  async_ as async