tur/future

(future-cell-new :ptr<void>)

allocate and initialise a shared FutureCell (mutex, condvar, unset).

Since: Phase T20-C

(future-cell-free [cell :ptr<void>] :nil)

destroy the mutex/condvar and free a FutureCell.

Since: Phase T20-C

(promise-new :ptr<void>)

allocate a new unsettled Promise/Future shared cell.

Since: Phase T20-C

(promise-of-cell [cell :ptr<void>] :ptr<void>)

return the Promise handle for a FutureCell (identity; for API symmetry).

Since: Phase T20-C

(future-of-cell [cell :ptr<void>] :ptr<void>)

return the Future handle for a FutureCell (identity; for API symmetry).

Since: Phase T20-C

(promise-pair [cell :ptr<void>])

expand to a (Promise Future) pair list from a single shared cell.

Since: Phase T20-C

(promise-fulfill [p :ptr<void> v :int] :nil)

settle a promise with a successful value; wakes all future waiters.

Since: Phase T20-C

(promise-fail [p :ptr<void> e :int] :nil)

settle a promise with an error code; wakes all future waiters.

Since: Phase T20-C

(promise-free [p :ptr<void>] :nil)

free a promise and its shared FutureCell.

Since: Phase T20-C

(future-done? [f :ptr<void>] :bool)

non-blocking check: return true if the future has been settled.

Since: Phase T20-C

(future-get [f :ptr<void>] :ptr<void>)

block until the future is settled; return a heap-allocated Result struct.

Since: Phase T20-C

(future-free [f :ptr<void>] :nil)

free a future and its shared FutureCell.

Since: Phase T20-C

(future-of [v :int] :ptr<void>)

create a pre-fulfilled future holding value v.

Since: Phase T20-C

(future-error-of [e :int] :ptr<void>)

create a pre-rejected future with error code e.

Since: Phase T20-C

(future-cancel [f :ptr<void>] :nil)

cancel a future if not yet settled; sets error code -2 (TUR_FUTURE_CANCELLED).

Since: Phase T20-C

(future-cancelled? [f :ptr<void>] :bool)

return true if the future was cancelled (exn == -2).

Since: Phase T20-C

(future-map [f :ptr<void> fn :ptr<void>] :ptr<void>)

map fn over a fulfilled future value; propagate rejection unchanged.

Since: Phase T20-C

(future-then [f :ptr<void> fn :ptr<void>] :ptr<void>)

flat-map fn over a future; fn must return a new Future ptr<void>.

Since: Phase T20-C

(future-race [fa :ptr<void> fb :ptr<void>] :ptr<void>)

race two futures; return a new future settled by whichever finishes first.

Since: Phase T20-C

(future-all2 [fa :ptr<void> fb :ptr<void>] :ptr<void>)

await both futures; settle ok with fa's value only if both succeed.

Since: Phase T20-C

(future-any2 [fa :ptr<void> fb :ptr<void>] :ptr<void>)

return a future settled by the first fulfilled future; both rejecting yields fb's error.

Since: Phase T20-C

(future-join [fa :ptr<void> fb :ptr<void>] :ptr<void>)

await both futures and produce a new future holding a TurTuple2 of their values.

Since: Phase T20-C

(tuple-first [tup :ptr<void>] :int)

read the first element of a TurTuple2 returned by future-join.

Since: Phase T20-C

(tuple-second [tup :ptr<void>] :int)

read the second element of a TurTuple2 returned by future-join.

Since: Phase T20-C

(tuple-free [tup :ptr<void>] :nil)

free a TurTuple2 allocated by future-join.

Since: Phase T20-C

(promise-new-pair :ptr<void>)

allocate a new unsettled Promise/Future shared cell (alias for promise-new).

Since: Phase T20-C

(future-race-n [futures :ptr<void> n :int] :ptr<void>)

race an array of n futures; return a new future settled by the first to finish.

Since: Phase T20-C

(future-all-n [futures :ptr<void> n :int] :ptr<void>)

await all n futures; settle ok (value 0) only if every future succeeds.

Since: Phase T20-C

(future-any-n [futures :ptr<void> n :int] :ptr<void>)

return a future settled by the first successfully fulfilled future in the array.

Since: Phase T20-C

(future-timeout [ms :int] :ptr<void>)

create a future that settles with error -1 after ms milliseconds.

Since: Phase T20-C

(future-with-timeout [f :ptr<void> ms :int] :ptr<void>)

race a future against a timeout of ms milliseconds.

Since: Phase T20-C