org.replikativ.persistent-sorted-set.btset — org.replikativ/persistent-sorted-set 0.4.119

$contains? cljs

($contains? set key {:keys [sync?] :or {sync? true} :as opts})

$count cljs

($count set {:keys [sync?] :or {sync? true} :as opts})

$into cljs

($into to from)

($into to arg0 arg1)

($into to xform from {:keys [sync?] :or {sync? true}})

$reduce cljs

($reduce rf init from)

($reduce rf init from {:keys [sync?] :or {sync? true}})

$replace cljs

($replace set old-key new-key)

($replace set old-key new-key arg)

($replace set old-key new-key cmp {:keys [sync?] :or {sync? true} :as opts})

$rseq cljs

($rseq set)

($rseq set {:keys [sync?] :or {sync? true} :as opts})

$seq cljs

($seq set)

($seq set opts)

$transduce cljs

($transduce xform arf init from)

($transduce xform arf init from {:keys [sync?] :or {sync? true}})

-iter cljs

(-iter set {:keys [sync?] :or {sync? true} :as opts})

(-iter set left right {:keys [sync?] :or {sync? true} :as opts})

async-reduce cljs

(async-reduce arf set from)

async-transduce cljs

(async-transduce xform arf init from)

xform: synchronous transducer (core map/filter/comp/etc) arf: MUST BE ASYNC reducing fn with arities ([acc] ...) and ([acc x] ...) init: initial accumulator from: BTSet | aseq/PAsyncSeq | sequential

conjoin cljs

(conjoin set key)

(conjoin set key arg)

(conjoin set key cmp {:keys [sync?] :or {sync? true} :as opts})

count-slice cljs

(count-slice set from to)

(count-slice set from to arg)

(count-slice set from to cmp {:keys [sync?] :or {sync? true} :as opts})

Count elements in the range [from, to] inclusive. Uses O(log n) algorithm when subtree counts are available. If from is nil, counts from the beginning. If to is nil, counts to the end.

disjoin cljs

(disjoin set key)

(disjoin set key arg)

(disjoin set key cmp {:keys [sync?] :or {sync? true} :as opts})

EMPTY_PATH cljs

equivalent-sequential? cljs

(equivalent-sequential? xs ys {:keys [sync?] :or {sync? true} :as opts})

equivalent? cljs

(equivalent? set other {:keys [sync?] :or {sync? true} :as opts})

from-opts cljs

(from-opts opts)

Create a set with options map containing:

• :storage Storage implementation
• :comparator Custom comparator (defaults to compare)
• :measure Measure implementation (IMeasure protocol)
• :meta Metadata

from-sequential cljs

(from-sequential cmp seq opts)

from-sorted-array cljs

(from-sorted-array cmp arr _len opts)

get-nth cljs

(get-nth set n)

(get-nth set n {:keys [sync?] :or {sync? true} :as opts})

Find the entry at weighted rank n. Navigation uses cached subtree measure and IMeasure weight for O(log entries) performance.

Returns [entry local-offset] where local-offset is the rank within the found entry, or nil if out of bounds.

Requires measure with weight to be configured on the set.

IIter cljs protocol

-copy cljs

(-copy this left right)

ISeek cljs protocol

-seek cljs

(-seek this key)

(-seek this key comparator)

lookup cljs

(lookup set key cmp {:keys [sync?] :or {sync? true} :as opts})

measure cljs

(measure set {:keys [sync?] :or {sync? true} :as opts})

Get the aggregated statistics for the entire set.

measure-slice cljs

(measure-slice set from to)

(measure-slice set from to arg)

(measure-slice set from to cmp {:keys [sync?] :or {sync? true} :as opts})

Compute measure for elements in the range [from, to] inclusive. Uses O(log n) algorithm when subtree measure is available. If from is nil, computes from the beginning. If to is nil, computes to the end. Returns nil if no measure-ops configured.

restore cljs

(restore root-address-or-info storage opts)

rslice cljs

(rslice set key-from key-to)

(rslice set key-from key-to arg)

(rslice set key-from key-to cmp {:keys [sync?] :or {sync? true} :as opts})

seek cljs

(seek seq key)

(seek seq key arg)

(seek seq key cmp {:keys [sync?] :or {sync? true} :as opts})

slice cljs

(slice set key-from key-to)

(slice set key-from key-to arg)

(slice set key-from key-to cmp {:keys [sync?] :or {sync? true} :as opts})

sorted-set-by cljs

(sorted-set-by cmp)

(sorted-set-by cmp & keys)

store cljs

(store set arg)

(store set storage {:keys [sync?] :or {sync? true} :as opts})

UNINITIALIZED_HASH cljs

walk-addresses cljs

(walk-addresses set on-address {:keys [sync?] :or {sync? true} :as opts})