Coroutine

< Yield | Up: Coroutines & Concurrency | Index | FiberPool >

A Coroutine wraps a computation into a resumable fiber with typed states. It's the primitive that FiberPool schedules and AsyncCoroutine bridges across processes.

Sum-type states

A coroutine is always exactly one of these states — pattern-match on the struct name to determine what to do next:

Two entry points: run vs call

Following Comp.call/Comp.run convention:

• call/1,2 — raw step, no ISentinel.run. Returns typed states directly. For use inside the FiberPool scheduler.
• run/1,2 — step + ISentinel.run. Applies transform_suspend and leave_scope before returning typed states. For standalone use.

Lifecycle

fiber = Coroutine.new(comp, env)        # %Pending{}

# Standalone (with ISentinel.run):
case Coroutine.run(fiber) do
  %Coroutine.ExternalSuspended{value: v}  -> # yielded, await resume
  %Coroutine.Completed{result: r}         -> # done
  %Coroutine.Errored{error: e}            -> # error
end

# Resume:
case Coroutine.run(fiber, value) do
  %Coroutine.ExternalSuspended{} -> # yielded again
  %Coroutine.Completed{result: r} -> # done
end

# Cancel:
%Coroutine.Cancelled{reason: r} = Coroutine.cancel(fiber, :timeout)

Standalone example

comp = comp do
  name <- Yield.yield(:get_name)
  {:ok, "Hello, #{name}!"}
end
|> Yield.with_handler()

fiber = Coroutine.new(comp, Env.new())

%Coroutine.ExternalSuspended{value: :get_name} = Coroutine.run(fiber)
%Coroutine.Completed{result: {:ok, "Hello, Alice!"}} = Coroutine.run(fiber, "Alice")

API

< Yield | Up: Coroutines & Concurrency | Index | FiberPool >