tur/hamt

(hamt/new :ptr<void>)

create a new empty persistent HAMT.

Since: Phase P1

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

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

Since: Phase P1

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

increment the reference count of a HAMT and return it.

Since: Phase P1

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

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

Since: Phase P1

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

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

Since: Phase P1

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

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

Since: Phase P1

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

check whether a key exists in the HAMT.

Since: Phase P1

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

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

Since: Phase P1

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

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

Since: Phase P1

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

compute an xxHash64 of a NUL-terminated C string.

Since: Phase P1

(hamt/hash-ptr :int)

hash a pointer value directly (identity hash).

Since: Phase P1

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

initialize a stack-allocated iterator over a HAMT.

Since: Phase P1

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

release any resources held by an iterator.

Since: Phase P1

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

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

Since: Phase P1

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

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

Since: Phase P1

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

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

Since: Phase P1

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

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

Since: Phase P1

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

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

Since: Phase P1

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

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

Since: Phase P1

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

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

Since: Phase P1

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

fork a mutable transient from an immutable HAMT.

Since: Phase P1

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

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

Since: Phase P1

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

mutate a transient by deleting a key in place.

Since: Phase P1

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

seal a transient into an immutable HAMT.

Since: Phase P1