tur/taskgroup

(task-group-new :ptr<void>)

create a new empty TaskGroup.

(let [g (task-group-new)] ...)  ; => ptr<void>

Since: Phase T22

(fiber-cancelled? :bool)

check whether the current fiber has been cancelled.

(if (fiber-cancelled?) ...)  ; => bool

Since: Phase T22

(task-group-cancelled? [group :ptr<void>] :bool)

check whether a specific task group has been cancelled.

(if (task-group-cancelled? g) ...)  ; => bool

Since: Phase T22

(task-group-should-exit? [group :ptr<void>] :bool)

return true if the current task should stop, checking both fiber and group cancellation.

(if (task-group-should-exit? g) ...)  ; => bool

Since: Phase T22

(fiber-should-exit? :bool)

check whether the current fiber should exit (without group context).

(if (fiber-should-exit?) ...)  ; => bool

Since: Phase T22

(task-group-done? [group :ptr<void>] :bool)

check whether all tasks in the group have completed.

(if (task-group-done? g) ...)  ; => bool

Since: Phase T22

(task-group-task-done [group :ptr<void>] :nil)

signal that the calling task has completed; must be called by each spawned task.

(task-group-task-done g)

Since: Phase T22

(task-group-wait [group :ptr<void>] :nil)

block until all tasks in the group have completed.

(task-group-wait g)

Since: Phase T22

(task-group-cancel [group :ptr<void>] :nil)

cooperatively cancel all tasks in the group (reason: manual).

(task-group-cancel g)

Since: Phase T22

(task-group-cancel-with-reason [group :ptr<void> reason :int] :nil)

cancel all tasks in the group with a specific reason code.

(task-group-cancel-with-reason g 2)

Since: Phase T22

(task-group-cancel-panic [group :ptr<void>] :nil)

cancel the group with reason 1 (panic).

(task-group-cancel-panic g)

Since: Phase T22

(task-group-cancel-timeout [group :ptr<void>] :nil)

cancel the group with reason 2 (timeout).

(task-group-cancel-timeout g)

Since: Phase T22

(task-group-cancel-error [group :ptr<void>] :nil)

cancel the group with reason 3 (error).

(task-group-cancel-error g)

Since: Phase T22

(task-group-cancel-reason [group :ptr<void>] :int)

return the reason code why the group was cancelled.

(task-group-cancel-reason g)  ; => int

Since: Phase T22

(task-group-spawn [group :ptr<void> f :ptr<void>] :ptr<void>)

spawn a fiber into the task group and return its handle.

(let [h (task-group-spawn g my-fiber-fn)] ...)  ; => ptr<void>

Since: Phase T22

(task-group-join [group :ptr<void> handle :ptr<void>] :nil)

wait for a specific spawned fiber to complete.

(task-group-join g h)

Since: Phase T22

(task-handle-done? [handle :ptr<void>] :bool)

non-blocking check whether a specific spawned fiber has completed.

(if (task-handle-done? h) ...)  ; => bool

Since: Phase T22

(task-group-free [group :ptr<void>] :nil)

destroy a task group and release its memory.

(task-group-free g)

Since: Phase T22

(task-group-with [group & body])

(task-group-with-timeout [group ms & body])

(spawn-timeout-thread [group :ptr<void> ms :int] :ptr<void>)

spawn a background thread that cancels the group after ms milliseconds.

Since: Phase T22

(join-timeout-thread [t :ptr<void>] :nil)

free the handle of a detached timeout thread.

(join-timeout-thread t)

Since: Phase T22

(task-group-with-cancellation [group & body])

(task-group-spawn-async [group :ptr<void> f :ptr<void>] :ptr<void>)

spawn an async computation into a task group and return a Future.

(let [fut (task-group-spawn-async g my-thunk)] (await fut))  ; => ptr<void>

Since: Phase T22

(task-group-async [group async-thunk])