tur/hamt

(hamt/new :ptr<void>)

create a new empty persistent HAMT.

(hamt/new)  ; => <hamt ptr>

Since: Phase P1

(hamt/free [m :ptr<void>] :void)

decrement the reference count of a HAMT; free if it reaches zero.

(hamt/free my-map)

Since: Phase P1

(hamt/retain [m :ptr<void>] :ptr<void>)

increment the reference count of a HAMT and return it.

(hamt/retain my-map)  ; => my-map

Since: Phase P1

(hamt/set [m :ptr<void> hash :int key :ptr<void> val :ptr<void>])

insert or update a key/value pair; returns a new HAMT.

(hamt/set m (hamt/hash-str "k") k v)  ; => <new hamt ptr>

Since: Phase P1

(hamt/del [m :ptr<void> hash :int key :ptr<void>])

delete a key from the HAMT; returns a new HAMT.

(hamt/del m (hamt/hash-str "k") k)  ; => <new hamt ptr>

Since: Phase P1

(hamt/get [m :ptr<void> hash :int key :ptr<void>])

look up a key and return its value, or NULL if absent.

(hamt/get m (hamt/hash-str "k") k)  ; => <value ptr or NULL>

Since: Phase P1

(hamt/has? [m :ptr<void> hash :int key :ptr<void>])

check whether a key exists in the HAMT.

(hamt/has? m (hamt/hash-str "k") k)  ; => true

Since: Phase P1

(hamt/set-cstr [m :ptr<void> key :cstr val :ptr<void>])

insert or update a string-keyed entry, compared by content.

The key is hashed by content (xxHash64 of the bytes) and compared by content on hash collision, so equal text at distinct addresses is one key. The map stores the key pointer (no copy); the caller owns its lifetime. Prefer this over hamt/set + hamt/hash-ptr for :cstr keys.

(hamt/set-cstr m "name" v)  ; => <new hamt ptr>

Since: Phase P3

(hamt/del-cstr [m :ptr<void> key :cstr])

delete a string key, compared by content; returns a new HAMT.

(hamt/del-cstr m "name")  ; => <new hamt ptr>

Since: Phase P3

(hamt/get-cstr [m :ptr<void> key :cstr])

look up a string key by content; NULL if absent.

(hamt/get-cstr m "name")  ; => <value ptr or NULL>

Since: Phase P3

(hamt/has-cstr? [m :ptr<void> key :cstr])

check whether a string key exists, compared by content.

(hamt/has-cstr? m "name")  ; => true

Since: Phase P3

(hamt/count [m :ptr<void>] :int)

return the number of key/value pairs in the HAMT.

(hamt/count my-map)  ; => 3

Since: Phase P1

(hamt/merge [a :ptr<void> b :ptr<void>])

merge two HAMTs; values from b win on key collision.

(hamt/merge map-a map-b)  ; => <merged hamt ptr>

Since: Phase P1

(hamt/hash-str [str :cstr] :int)

compute an xxHash64 of a NUL-terminated C string.

(hamt/hash-str "hello")  ; => <hash int>

Since: Phase P1

(hamt/hash-ptr [ptr :ptr<void>] :int)

hash a pointer value directly (identity hash).

(hamt/hash-ptr my-key)  ; => <hash int>

Since: Phase P1

(hamt/iter-init [iter :ptr<void> m :ptr<void>])

initialize a stack-allocated iterator over a HAMT.

(hamt/iter-init iter-buf my-map)

Since: Phase P1

(hamt/iter-free [iter :ptr<void>] :void)

release any resources held by an iterator.

(hamt/iter-free iter-buf)

Since: Phase P1

(hamt/iter-next [iter :ptr<void> hash-out :ptr<void> key-out :ptr<void> val-out :ptr<void>])

advance an iterator and write the next entry into out-pointers.

(hamt/iter-next iter hash-out key-out val-out)  ; => true/false

Since: Phase P1

(hamt/iter-alloc [m :ptr<void>] :ptr<void>)

allocate an iterator box for HAMT m.

Returns an opaque handle that owns a HamtIter plus cached current (hash, key, val) slots. Pair with hamt/iter-destroy! when done.

Since: Phase TCO-Eq-MapSet

(hamt/iter-destroy! [box :ptr<void>])

free an iterator box.

(hamt/iter-advance! [box :ptr<void>])

step to the next entry; returns false on exhaustion.

The current hash / key / value are exposed via the cur-* accessors.

(hamt/iter-cur-hash [box :ptr<void>])

current entry's 64-bit hash (only valid after a successful hamt/iter-advance!).

(hamt/iter-cur-key [box :ptr<void>])

current entry's key pointer.

(hamt/iter-cur-val [box :ptr<void>])

current entry's value pointer.

(hamt/keyeq [m :ptr<void>] :ptr<void>)

read the stamped key comparator off a HAMT (NULL = identity).

(hamt/get-dynamic [m :ptr<void> hash :int key :ptr<void> keyeq :ptr<void>])

lookup using the supplied key comparator when non-NULL, else identity. Used by the pure-Turmeric Eq[Map] loop so the loop body has no conditional around the per-entry lookup.

(hamt/has-dynamic? [m :ptr<void> hash :int key :ptr<void> keyeq :ptr<void>])

presence check matching hamt/get-dynamic's semantics.

(hamt/map [m :ptr<void> fn :ptr<void> ctx :ptr<void>])

return a new HAMT with each value replaced by fn(val, ctx).

(hamt/map my-map transform-fn ctx)  ; => <new hamt ptr>

Since: Phase P1

(hamt/filter [m :ptr<void> fn :ptr<void> ctx :ptr<void>])

return a new HAMT keeping only entries where fn(key, val, ctx) is true.

(hamt/filter my-map pred-fn ctx)  ; => <filtered hamt ptr>

Since: Phase P1

(hamt/reduce [m :ptr<void> fn :ptr<void> init :ptr<void> ctx :ptr<void>])

fold all entries into an accumulator using fn(acc, key, val, ctx).

(hamt/reduce my-map fold-fn init-acc ctx)  ; => <result ptr>

Since: Phase P1

(hamt/merge-with [a :ptr<void> b :ptr<void> fn :ptr<void> ctx :ptr<void>])

merge two HAMTs, resolving key conflicts with fn(val_a, val_b, ctx).

(hamt/merge-with map-a map-b merge-fn ctx)  ; => <merged hamt ptr>

Since: Phase P1

(hamt/show [m :ptr<void>] :cstr)

return a debug string "{k->v, ...}" for the HAMT; caller must free.

(hamt/show my-map)  ; => "{...}"

Since: Phase P1

(hamt/dump [m :ptr<void>] :void)

write the HAMT structure in DOT format to stderr for debugging.

(hamt/dump my-map)

Since: Phase P1

(hamt/transient [m :ptr<void>] :ptr<void>)

fork a mutable transient from an immutable HAMT.

(hamt/transient my-map)  ; => <transient ptr>

Since: Phase P1

(hamt/transient-set! [t :ptr<void> hash :int key :ptr<void> val :ptr<void>])

mutate a transient by inserting or updating a key in place.

(hamt/transient-set! t (hamt/hash-str "k") k v)

Since: Phase P1

(hamt/transient-del! [t :ptr<void> hash :int key :ptr<void>])

mutate a transient by deleting a key in place.

(hamt/transient-del! t (hamt/hash-str "k") k)

Since: Phase P1

(hamt/persistent! [t :ptr<void>])

seal a transient into an immutable HAMT.

(hamt/persistent! t)  ; => <immutable hamt ptr>

Since: Phase P1