bortexz.utils.avl — io.github.bortexz/utils.avl 0.0.2

Utilities to work with data.avl sorted collections

-EntryKey clj protocol

Protocol to make some fns work both on sorted maps and sorted sets. For sorted maps, will return the key of the entry. For sorted sets, the entry is the key.

-entry-key clj

(-entry-key this entry)

-full-tail-vec-fn clj

(-full-tail-vec-fn f)

Returns a full-tail function where items are mapped using f when building the resulting vector.

-tail-vec-fn clj

(-tail-vec-fn f)

Returns a tail function where items are mapped using f when building the resulting vector.

datafy-avl! clj

(datafy-avl!)

Calls both datafy-avl-maps! and datafy-avl-sets!

datafy-avl-maps! clj

(datafy-avl-maps!)

Makes clojure.data.avl.AVLMap implement p/Datafiable. datafy on an AVLMap will return a clojure.core sorted-map.

datafy-avl-sets! clj

(datafy-avl-sets!)

Makes clojure.data.avl.AVLSet implement p/Datafiable. datafy on an AVLMap will return a clojure.core sorted-set

find-val clj

(find-val sm testf)

(find-val sm
          testf
          {:keys [start-rank end-rank]
           :or {start-rank 0 end-rank (dec (count sm))}})

Iterates over sorted-map sm testing vals against previous found val using 2-arity testf, fn accepting new val and previously found val. if testf returns logical true, then the new tested val will be the found val, used to test against following vals. Iteration starts on the second val, and the first val is used as the starting found val. Only tests non-nil values. Returns a tuple [found-rank found-val] if val is non-nil, nil otherwise.

Can optionally specify a map of options including:

• start-rank start rank of the iteration (included). Defaults to 0.
• end-rank last rank of the iteration (included). Defaults to latest-rank (dec (count sm))

E.g. find the maximum value and its rank of a sorted-map bounded by 2 ranks, returning first value found for the max value: (find-val sm > {:start-rank 1 :end-rank 10}) (if >= used then latest max-value is returned)

first clj

(first sc)

Returns the first element of sorted collection sc if not empty, else nil.

first-key clj

(first-key sm)

Returns the first key of sorted map sm, or nil if empty. Same as (some-> (first sm) key)

first-val clj

(first-val sm)

Returns the first val of sorted map sm, or nil if empty. Same as (some-> (first sm) val)

full-tail clj

full-tail-keys clj

full-tail-sorted clj

(full-tail-sorted sm n)

(full-tail-sorted sm n end-k)

Faster (some->> (full-tail sc n) (into (avl/sorted-map))). See full-tail

full-tail-vals clj

index-by clj

(index-by f coll)

(index-by cmp f coll)

Given an (optional) comparator cmp, function f and coll, creates a new sorted-map whose keys are obtained by calling f on each coll element and vals are the element untouched.

last clj

(last sc)

Returns the last element of sorted collection sc, or nil if sc is empty.

last-key clj

(last-key sc)

Returns last key of sorted map sm, or nil if sm is empty. Same as (some-> (last sm) key)

last-val clj

(last-val sc)

Returns last key of sorted map sm, or nil if sm is empty. Same as (some-> (last sm) val)

nearest-key clj

(nearest-key sm test k)

Same as (some-> (avl/nearest sm test k) key).

nearest-rank clj

(nearest-rank sc test k)

Returns the rank of the nearest key. Same as (rank-of sc (nearest-key sc test k))

nearest-val clj

(nearest-val sm test k)

Same as (some-> (avl/nearest sm test k) val).

nth clj

(nth sc idx)

Like clojure.core/nth, except it always returns nil if index ouf of bounds.

nth-key clj

(nth-key sm idx)

Returns key at idx for sorted map sm if it exists, otherwise nil. Same as (some-> (nth sc idx nil) key)

nth-val clj

(nth-val sc idx)

Returns val at idx for sorted map sm if it exists, otherwise nil. Same as (some-> (nth sc idx nil) val)

offset clj

(offset sc k n)

Takes the item that is n items away from k. If k or the resulting item do not exist, returns nil. e.g. (offset sc k -1) takes the previous item to key k e.g. (offset sc k 1) takes the next item to key k.

offset-key clj

(offset-key sm k n)

Same as (some-> (offset sc k n) key)

offset-val clj

(offset-val sm k n)

Same as (some-> (offset sc k n) val)

rank-of clj

(rank-of sc k)

like avl/rank-of, but returns nil instead of -1 when item not found

tail clj

tail-keys clj

tail-sorted clj

(tail-sorted sc n)

(tail-sorted sc n end-k)

Like tail but returns an avl sorted collection. Usually faster than (into (sorted-map) (tail sc n)), except when the resulting collection is very small ~(< 10 items)

tail-vals clj