co.multiply.pathling.util — co.multiply/pathling 0.1.1

Internal utilities for Pathling. Not part of the public API.

acc-append! clj/s macro

(acc-append! acc v)

Append a single value to the accumulator. Mutates in place, returns the accumulator.

acc-append-many! clj/s macro

(acc-append-many! acc many)

Append all elements from a sequential collection to the accumulator. Mutates in place, returns the accumulator.

acc-get clj/s macro

(acc-get acc idx)

Get element at index position from the accumulator.

acc-init-append! clj/s macro

(acc-init-append! acc v)

Append a value to the accumulator, lazily initializing if nil. Use when accumulator may not be needed (avoids allocation in common case). Returns the (possibly new) accumulator.

acc-size clj/s macro

(acc-size acc)

Return the number of elements in the accumulator.

accumulator clj/s macro

(accumulator)

(accumulator initial-size)

Create a new accumulator for efficient mutable collection. Optionally accepts an initial-size for preallocation when final size is known. In ClojureScript, returns a raw JS array (preallocation hint is ignored).

accumulator->list clj/s

(accumulator->list acc)

Convert an accumulator to a list.

accumulator->vec clj/s

(accumulator->vec acc)

Convert an accumulator to a persistent vector.

arr-push! cljs

(arr-push! arr v)

cohorts clj/s

(cohorts pred coll)

Gather elements into piles by collecting elements matched by pred, and all elements succeeding it, until the next match of pred.

The predicate function receives two arguments:

• item: The current element being evaluated
• prev-match: The previous element that matched the predicate (or nil for the first match)

The first entry will contain all items leading up to the first match of pred. Empty if pred is matched on the first element.

editable? clj/s

(editable? v)

Check if a collection supports transient operations (implements IEditableCollection). Regular maps, vectors, and sets return true. Sorted collections and subvec return false.

extend-protocol-many clj/s macro

(extend-protocol-many protocol & groups)

Extend a protocol to multiple types with the same implementation. Supports multiple type groups, each with their own method implementations.

Usage: (extend-protocol-many Scannable [List EmptyList LazySeq] (method1 [this] ...) (method2 [this x] ...)

[PersistentArrayMap PersistentHashMap]
(method1 [this] ...)
(method2 [this x] ...))

forv clj/s macro

(forv [bind-to coll] & body)

Like for, but returns a vector. No bells and whistles.

with-transient clj/s macro

(with-transient [k v] & body)

Execute body with a transient version of the collection, then persist. Preserves metadata from the original collection.