37d68e72be
With the three surface blockers fixed (0151 generic inference, 0152
Atomic(bool), 0153 re-export failable channel), the M:1 async surface works
end-to-end on the blocking Io default. Landed the corpus examples:
- 1805-concurrency-io-blocking-async.sx: context.io.async(lambda, ..args)
runs the worker inline, await() or {…} yields the result; context.io.now_ms()
reads the monotonic clock. Prints sum: 42 / double: 42 / clock ok.
- 1806-concurrency-io-cancel.sx: f.cancel() marks the future canceled so a
later await() raises error.Canceled out of its (R, !IoErr) channel, caught
with or. Prints ok: 7 / canceled: -99.
B1.2 (Io capability on Context + async/await/cancel + blocking CBlockingIo) is
complete. Suite green 732/0. Next: B1.3 (fiber runtime).
24 lines
945 B
Plaintext
24 lines
945 B
Plaintext
// B1.2 — the async ergonomic layer over the `Io` capability, blocking
|
|
// default. `context.io.async(worker, ..args)` runs the worker to completion
|
|
// inline and returns a `.ready` Future($R); `f.await()` yields the result
|
|
// (a value-failable `($R, !IoErr)`, handled with `or`). `context.io.now_ms()`
|
|
// reads the monotonic clock through the same capability.
|
|
//
|
|
// Worker form: a lambda whose params are annotated at the call site
|
|
// (`(a: i64, b: i64) -> i64 => …`); `..args` forwards the call-site
|
|
// arguments to it.
|
|
#import "modules/std.sx";
|
|
|
|
main :: () {
|
|
// Homogeneous args.
|
|
s := context.io.async((a: i64, b: i64) -> i64 => a + b, 40, 2);
|
|
print("sum: {}\n", s.await() or { -1 });
|
|
|
|
// Single arg.
|
|
d := context.io.async((x: i64) -> i64 => x * 2, 21);
|
|
print("double: {}\n", d.await() or { -1 });
|
|
|
|
// The Io capability also carries a monotonic clock.
|
|
if context.io.now_ms() >= 0 { print("clock ok\n"); }
|
|
}
|