Orkuncakilkaya
50ecb8472f
A layered concurrency library, safe by default. The recommended tier is Job.* / Promise.*: a Job is a future — Job.run(kind, arg) starts a cooperative background compute that advances each Job.pump(budget) and finishes after enough frames (heavy work spreads out instead of hitching), or Job.defer + Job.fulfill/fail/cancel drives one by hand. Poll with done/ok/failed/cancelled, read result/error, count outstanding work with Job.pending. Promise.all/race combine handle lists into a group job resolved on the main thread; Promise.count_done/all_done power a loading bar. The advanced, opt-in Sync.* tier (mutex/atomic/channel + cpu_count) is the "here be dragons" surface for engine-level message passing. The whole thing is a deterministic cooperative scheduler: results are collected on the main thread and a Job never touches the ECS world, so lockstep and replays stay bit-exact — same jobs + same budget reproduce byte-for-byte on every target, and a preemptive OS-thread backend can slot behind this same API later. Ludic has no closures, so a Job carries a compute kind + int arg (or a hand-driven defer) rather than fn()->…, and Promise progress is polled rather than chained through then. Written in Ludic and spliced on demand (like Regex/Dict/Numeric): a program that never mentions Job.*/Promise.*/Sync.* compiles byte-identically and the C-free bootstrap fixpoint is untouched. New: runtime/native/jobs.ludic, emit_ns_call dispatch, parse-time splice, examples/library/jobs.ludic (31 self-asserting checks), 33 docs pages + inventory, changeset. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
1.8 KiB
bump: minor
type: feat
Jobs, Promises & opt-in Sync — a layered concurrency library (#14). The safe default is Job.* / Promise.*: a Job is a future — start background work with Job.run(kind, arg) (a cooperative compute that advances a little each Job.pump(budget) and finishes after enough frames, so heavy work spreads out instead of hitching one), or drive one by hand with Job.defer + Job.fulfill / Job.fail / Job.cancel; poll it with done/ok/failed/cancelled, read result/error, and count outstanding work with Job.pending. Promise.all/Promise.race combine handle lists into a group job resolved on the main thread, and Promise.count_done/Promise.all_done give a loading bar its numerator and its ready check. The advanced, opt-in Sync.* tier — mutex/lock/unlock/try_lock, an atomic counter (atomic/get/set/add/cas) and a bounded int channel (send/recv/can_recv/len), plus cpu_count — is the "here be dragons" surface for engine-level message passing. The whole thing is a deterministic cooperative scheduler: results are collected on the main thread at a point you choose and a Job never touches the ECS world directly, so lockstep networking and replays stay bit-exact — the same jobs and the same budget reproduce byte-for-byte on every target, and a preemptive OS-thread backend can slot behind this same API later. Ludic has no first-class functions, so a Job carries a compute kind + int argument (or a hand-driven defer) rather than a closure, and Promise progress is polled rather than chained through a then. Written in Ludic and spliced on demand (like Regex/Dict/Numeric), so a program that never mentions Job.*/Promise.*/Sync.* compiles byte-identically and the C-free bootstrap fixpoint is untouched.