tur/hamt

(hamt/new)

create a new empty persistent HAMT.

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

Since: Phase P1

(hamt/free [m :ptr<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>])

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/count [m :ptr<void>])

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])

compute an xxHash64 of a NUL-terminated C string.

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

Since: Phase P1

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

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>])

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/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>])

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

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

Since: Phase P1

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

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

(hamt/dump my-map)

Since: Phase P1

(hamt/transient [m :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