Standard library referenceModules
i/task
Structured tasks, rendezvous channels and events (§9.9).
Scheduler
The scheduler service: detached outside a run.
Scheduler = (state = SchedulerState) Runner
The runner service: detached until a run installs one.
Runner = (state = RunnerState) Scope
Scope(E) = (info = ScopeInfo, errors = Key(E)) Task
Task(A, E) = (info = TaskInfo, result = Key(Result(A, E)), owner = Scope(E)) Channel
Channel(A) = (info = ChannelInfo, values = Key(A)) Event
Event(A, E, N) = (identity = Key(Nil), branches = List(Branch(A, E, N))) Shared
Shared(A) = (run = Key(Nil), owner = Keyed, id = Keyed, values = Key(A)) Ref
Ref(A) = (run = Key(Nil), id = Keyed, values = Key(A)) ScheduleError
ScheduleError = NotRunnable top
top = (seed : rng.Generator) <- (current : Runner) -> Runner { run
run = <A, N>(body : () <- N -> A) <- (runner : Runner) -> A { test
test = <A, N>( scope
scope = <A, E, N>(body : (Scope(E)) <- (Fail(E), ..N) -> A) <- ( local_scope
local_scope = <A, E, N>(body : (Scope(E)) <- (Fail(E), ..N) -> A) <- ( go
go = <A, E, N>(s : Scope(E), body : () <- (Fail(E), ..N) -> A) -> Task(A, E) { join
join = <A, E>(t : Task(A, E)) -> A { sync(join_event(t)) } yield
yield = () <- (own : Scheduler) { path
path = () <- (own : Scheduler) { random
random = () <- (own : Scheduler) { keep
keep = <S, A, E, N>(f : (S) <- (Fail(E), ..N) -> A) <- (_own : Scheduler) -> ( channel
channel = <A>() <- (own : Scheduler) -> Channel(A) { local_channel
local_channel = <A>() <- (own : Scheduler) -> Channel(A) { send
send = <A>(c : Channel(A), value : A) <- (own : Scheduler) -> Nil { receive
receive = <A>(c : Channel(A)) -> A { sync(receive_event(c)) } send_event
send_event = <A>(c : Channel(A), value : A) -> Event(Nil, Never, Never) { receive_event
receive_event = <A>(c : Channel(A)) -> Event(A, Never, Never) { join_event
join_event = <A, E>(t : Task(A, E)) -> Event(A, E, Never) { always
always = <A>(value : A) -> Event(A, Never, Never) { never
never = () -> Event(Never, Never, Never) { choose
choose = <A, E, N>(events : List(Event(A, E, N))) -> Event(A, E, N) { map
map = <A, B, E, F, N, M>( sync
sync = <A, E, N>(e : Event(A, E, N)) <- (own : Scheduler) -> A { share
share = <A, E>(s : Scope(E), value : A) <- (own : Scheduler) -> Shared(A) { get
get = <A>(s : Shared(A)) <- (own : Scheduler) -> A { ref
A state ref owned by the current scope, or by the run at its root. Values are portable; update callbacks are pure and execute atomically.
ref = <A>(value : A) <- (own : Scheduler) -> Ref(A) { update
update = <A, B>(ref : Ref(A), change : (A) -> (A, B)) <- ( both
both = <A, B, N>(left : () <- N -> A, right : () <- N -> B) -> (A, B) { race
race = <A, E, N>( map_concurrently
map_concurrently = <A, B, N>(xs : List(A), f : (A) <- N -> B) -> List(B) {