me.tonsky.persistent-sorted-set — persistent-sorted-set 0.2.3

A B-tree based persistent sorted set. Supports transients, custom comparators, fast iteration, efficient slices (iterator over a part of the set) and reverse slices. Almost a drop-in replacement for [[clojure.core/sorted-set]], the only difference being this one can’t store nil.

bit-mask cljs

bits-per-level cljs

tunable param

conj clj/s≠

(conj set key cmp)

clj

Analogue to [[clojure.core/conj]] but with comparator that overrides the one stored in set.

cljs

Analogue to [[clojure.core/conj]] with comparator that overrides the one stored in set.

disj clj/s

(disj set key cmp)

Analogue to [[clojure.core/disj]] with comparator that overrides the one stored in set.

empty-path cljs

est-count cljs

(est-count iter)

factors cljs

from-sequential clj/s≠

clj

(from-sequential cmp keys)

cljs

(from-sequential cmp seq)

Create a set with custom comparator and a collection of keys. Useful when you don’t want to call [[clojure.core/apply]] on sorted-set-by.

from-sorted-array clj/s≠

clj

(from-sorted-array cmp keys)

(from-sorted-array cmp keys len)

cljs

(from-sorted-array cmp arr)

Fast path to create a set if you already have a sorted array of elements on your hands.

IIter cljs protocol

-copy cljs

(-copy this left right)

INode cljs protocol

node-conj cljs

(node-conj _ cmp key)

node-disj cljs

(node-disj _ cmp key root? left right)

node-len cljs

(node-len _)

node-lim-key cljs

(node-lim-key _)

node-lookup cljs

(node-lookup _ cmp key)

node-merge cljs

(node-merge _ next)

node-merge-n-split cljs

(node-merge-n-split _ next)

ISeek cljs protocol

-seek cljs

(-seek this key)

(-seek this key comparator)

iter cljs

(iter set left right)

max-len cljs

max-safe-level cljs

max-safe-path cljs

js limitation for bit ops

min-len cljs

restore clj

(restore address storage)

Constructs lazily-loaded set from storage and root address. Supports all operations that normal in-memory impl would, will fetch missing nodes by calling IStorage::restore when needed

restore-by clj

(restore-by cmp address storage)

Constructs lazily-loaded set from storage, root address and custom comparator. Supports all operations that normal in-memory impl would, will fetch missing nodes by calling IStorage::restore when needed

riter cljs

(riter set left right)

rslice clj/s≠

clj

(rslice set from to)

(rslice set from to cmp)

A reverse iterator for part of the set with provided boundaries. (rslice set from to) returns backwards iterator for all Xs where from <= X <= to. (rslice set from nil) returns backwards iterator for all Xs where X <= from. Optionally pass in comparator that will override the one that set uses. Supports efficient [[clojure.core/rseq]].

cljs

(rslice set key)

(rslice set key-from key-to)

(rslice set key-from key-to comparator)

A reverse iterator for part of the set with provided boundaries. (rslice set from to) returns backwards iterator for all Xs where from <= X <= to. Optionally pass in comparator that will override the one that set uses. Supports efficient [[clojure.core/rseq]].

seek clj/s

(seek seq to)

(seek seq to cmp)

An efficient way to seek to a specific key in a seq (either returned by [[clojure.core.seq]] or a slice.) (seek (seq set) to) returns iterator for all Xs where to <= X. Optionally pass in comparator that will override the one that set uses.

set-branching-factor! clj

(set-branching-factor! n)

Global -- applies to all sets. Must be power of 2. Defaults to 64

slice clj/s≠

clj

(slice set from to)

(slice set from to cmp)

An iterator for part of the set with provided boundaries. (slice set from to) returns iterator for all Xs where from <= X <= to. (slice set from nil) returns iterator for all Xs where X >= from. Optionally pass in comparator that will override the one that set uses. Supports efficient [[clojure.core/rseq]].

cljs

(slice set key-from key-to)

(slice set key-from key-to comparator)

An iterator for part of the set with provided boundaries. (slice set from to) returns iterator for all Xs where from <= X <= to. Optionally pass in comparator that will override the one that set uses. Supports efficient [[clojure.core/rseq]].

sorted-set clj/s≠

(sorted-set)

(sorted-set & keys)

clj

Create a set with default comparator.

sorted-set-by clj/s≠

(sorted-set-by cmp)

(sorted-set-by cmp & keys)

clj

Create a set with custom comparator.

store clj

(store set)

(store set storage)

Store each not-yet-stored node by calling IStorage::store and remembering returned address. Incremental, won’t store same node twice on subsequent calls. Returns root address. Remember it and use it for restore

walk-addresses clj

(walk-addresses set consume-fn)

Visit each address used by this set. Usable for cleaning up garbage left in storage from previous versions of the set