tur/stm-sync

(tmvar-new [v])

create a TMVar holding a value (full).

(let [mv (tmvar-new 42)] ...)

Since: 2026-08-20

(tmvar-new-empty)

create an empty TMVar.

(let [mv (tmvar-new-empty)] ...)

Since: 2026-08-20

(tmvar-take-stm [mv])

transaction BODY: block until full, then empty and return.

(atomically (stm (tmvar-take-stm mv)))

Since: 2026-08-20

(tmvar-take [mv])

block until the TMVar is full, then empty it and return it.

(let [mv (tmvar-new 42)]
    (println (:: (tmvar-take mv) :int)))  ; => 42

Since: 2026-08-20

(tmvar-put-stm [mv v])

transaction BODY: block until empty, then fill.

(atomically (stm (tmvar-put-stm mv 7)))

Since: 2026-08-20

(tmvar-put [mv v])

block until the TMVar is empty, then fill it.

(let [mv (tmvar-new-empty)]
    (tmvar-put mv 7)
    (println (:: (tmvar-take mv) :int)))  ; => 7

Since: 2026-08-20

(tmvar-read-stm [mv])

transaction BODY: block until full, return WITHOUT emptying.

(atomically (stm (tmvar-read-stm mv)))

Since: 2026-08-20

(tmvar-read [mv])

block until full, return the value without emptying.

(let [mv (tmvar-new 42)]
    (println (:: (tmvar-read mv) :int))   ; => 42
    (println (:: (tmvar-take mv) :int)))  ; => 42 -- still there

Since: 2026-08-20

(tmvar-full? [mv])

is the TMVar currently full? Does not block.

(println (tmvar-full? (tmvar-new-empty)))  ; => false

Since: 2026-08-20

(tchan-cons-append [lst : int v : int] :)

internal: append `v` to the end of cons list `lst`.

(tchan-cons-head [lst : int] :)

internal: first element, or -1 for an empty list.

(tchan-cons-tail [lst : int] :)

internal: the list without its first element.

(tchan-cons-len [lst : int] :)

internal: number of elements.

(tchan-new)

create an empty TChan.

(let [ch (tchan-new)] ...)

Since: 2026-08-20

(tchan-write-stm [ch v])

transaction BODY: append a value. Never blocks.

(atomically (stm (tchan-write-stm ch 1)))

Since: 2026-08-20

(tchan-write [ch v])

append a value to the channel. Never blocks (unbounded).

(let [ch (tchan-new)] (tchan-write ch 1))

Since: 2026-08-20

(tchan-read-stm [ch])

transaction BODY: block until non-empty, then pop.

(atomically (stm (tchan-read-stm ch)))

Since: 2026-08-20

(tchan-read [ch])

block until the channel is non-empty, then pop the oldest.

(let [ch (tchan-new)]
    (tchan-write ch 1)
    (tchan-write ch 2)
    (println (tchan-read ch)))   ; => 1

Since: 2026-08-20

(tchan-len [ch])

how many values are queued. Does not block.

(println (tchan-len (tchan-new)))  ; => 0

Since: 2026-08-20

(tchan-empty? [ch])

is the channel empty? Does not block.

(println (tchan-empty? (tchan-new)))  ; => true

Since: 2026-08-20