thi.ng.common.data.core — thi.ng/common 0.3.2

all-after clj/s

(all-after item coll)

Returns a new collection of all items after item in original coll. If coll is a vector, the new collection is created with subvec. Returns original coll if item isn't found.

append-first clj/s

(append-first xs)

apply-to-keys clj/s

(apply-to-keys type keys f & args)

Applies f with args to all given keys in type.

bisect clj/s

(bisect f coll)

(bisect f f2 coll)

cartesian-product clj/s

(cartesian-product & seqs)

All the ways to take one item from each sequence (taken from clojure.contrib.combinatorics)

check-intervals clj/s

(check-intervals & ivals)

collect-indexed clj/s

(collect-indexed f f2 coll)

collect-set clj/s

(collect-set f coll)

demunge-flags clj/s

(demunge-flags kw xs)

Takes a keyword or string and string/seq of items, returns map with items as keys and boolean values indicating if an item has been found in the string representation of the kw. If kw is nil, returns nil.

(demunge-flags :cad "abcd")
#_=> {:a true :b false :c true :d true}

demunge-flags-seq clj/s

(demunge-flags-seq kw xs)

Like demunge-flags but returns lazyseq of booleans in same order as xs.

(demunge-flags-seq :cad "abcd") #_=> [true false true true]

filter-tree clj/s

(filter-tree f root)

Applies f to root coll and every of its (nested) elements. Returns a vector of items for which f returned a truthy value.

index clj/s

(index i t)

index! clj/s

(index! i t)

index-kv clj/s

(index-kv m k v)

index-kv! clj/s

(index-kv! m k v)

index-of clj/s

(index-of coll item)

interval-set clj/s

(interval-set & ivals)

iterate-n clj/s

(iterate-n n f x)

iterate-while clj/s

(iterate-while pred f x)

neighbors clj/s

(neighbors x coll)

reduce-pairs clj/s

(reduce-pairs f1 f2 coll)

(reduce-pairs f1 f2 acc coll)

rotate-left clj/s

(rotate-left n xs)

set-conj clj/s

set-conj2* clj/s

stringify-keys clj/s

(stringify-keys m)

successive-nth clj/s

(successive-nth n coll)

(successive-nth n step coll)

Returns a lazyseq of n-element vectors, each one containing a successive elements of the original collection.

(successive-nth 3 [1 2 3 4])
=> ([1 2 3] [2 3 4] [3 4 5])

successive-nth-indexed clj/s

(successive-nth-indexed n coll)

(successive-nth-indexed n idx coll)

Returns a lazyseq of nested 2-element vectors, each one containing a vector of n successive elements of the original collection and an sequence index.

(successive-nth-indexed 2 [10 20 30 40])
=> ([[10 20] 0] [[20 30] 1] [[30 40] 2])

unwrap-string clj/s

(unwrap-string s n)

value-set clj/s

(value-set idx v)

(value-set f idx v)

vec-conj clj/s

vec-conj2* clj/s

wrap clj/s

(wrap a b s)

wrap-seq clj/s

(wrap-seq s head tail)