e85th.commons.ext — e85th/commons 0.1.29

Fns applicable to both jvm and js

as-coll clj/s

(as-coll x)

as-vector clj/s

(as-vector x)

assoc-in+ clj/s

(assoc-in+ m & path-vals)

Similar to assoc-in except can specify multiple kv pairs

assoc-some clj/s

(assoc-some m k v)

(assoc-some m k v & kvs)

Associate a key k to map m if v is not nil.

camel-case-keys clj/s

(camel-case-keys m)

Camel case all keys in map m.

camel-case-keyword clj/s

(camel-case-keyword x)

Namespace is omitted in returned value.

conform-map clj/s

(conform-map map kmap)

select-keys on map with keys from kmap and renamed keys to be from kmap.

deep-merge clj/s

(deep-merge a b)

Deep merge a data structure. Taken from http://stackoverflow.com/questions/17327733/merge-two-complex-data-structures

dissoc-in clj/s

(dissoc-in m [k & ks :as keys])

Dissociates an entry from a nested associative structure returning a new nested structure. keys is a sequence of keys. Any empty maps that result will not be present in the new structure.

elide-paths clj/s

(elide-paths elision-value coll & paths)

elide-paths* clj/s

(elide-paths* coll & paths)

paths is a collection of vectors that can be used to navigate a collection. Each path must be a non empty vector otherwise that path is skipped.

elide-vals clj/s

(elide-vals key-set m)

(elide-vals elision-value key-set m)

Walks the map eliding the values whose key appears in key-set.

elided clj/s

filter-keys clj/s

(filter-keys pred m)

Apply pred a one arity function to each map key and include the map entry if pred returns truthy.

filter-kv clj/s

(filter-kv pred m)

Apply pred a two arity function to each map entry and include the map entry if pred returns truthy.

filter-vals clj/s

(filter-vals pred m)

Apply pred a one arity function to each map val and include the map entry if pred returns truthy.

group-by+ clj/s

(group-by+ key-fn val-fn xs)

(group-by+ key-fn val-fn val-agg-fn xs)

Similar to group by, but allows applying val-fn to each item in the grouped by list of each key. Can also apply val-agg-fn to the result of mapping val-fn. All input fns are 1 arity. If val-fn and val-agg-fn were the identity fn then this behaves the same as group-by.

intersect-with clj/s

(intersect-with f map-1 map-2)

Returns a map whose keys exist in boty map-1 and map-2. f is a 2 arity function that is invoked wht the value from map-1 and map-2 respectively for each matching key.

key= clj/s

(key= k v)

Returns a predicate that takes a map as an argument. The predicate applies k to the map and does an equality check against v.

keyword->symbol clj/s

(keyword->symbol k)

lisp-case-keys clj/s

(lisp-case-keys m)

Lisp case all keys in map m.

lisp-case-keyword clj/s

(lisp-case-keyword x)

Turns :helloHow to :hello-how Namespace is omitted in returned value.

map-keys clj/s

(map-keys f m)

Applies a function f to each key in map m. This is shallow, it does not walk m.

map-kv clj/s

(map-kv f m)

Apply f a two arity function to each map entry in m.

map-vals clj/s

(map-vals f m)

Applies a function f to each value in map m. This is shallow, it does not walk m.

not-blank? clj/s

Opposite of str/blank

parse-bool clj/s

(parse-bool x)

(parse-bool x true-set)

parse-double clj/s

(parse-double s)

(parse-double s default)

parse-float clj/s

(parse-float s)

(parse-float s default)

parse-int clj/s

(parse-int s)

(parse-int s default)

parse-long clj/s

(parse-long s)

(parse-long s default)

parse-uuid clj/s

(parse-uuid s)

(parse-uuid s default)

prune-map clj/s

(prune-map m)

(prune-map m pred)

Prunes the map according to pred

random-uuid clj/s

(random-uuid)

Generates a new uuid.

remove-keys clj/s

(remove-keys pred m)

remove-kv clj/s

(remove-kv pred m)

remove-vals clj/s

(remove-vals pred m)

symbol->keyword clj/s

(symbol->keyword sym)

try-parse clj/s

(try-parse f s default)

unqualify clj/s

(unqualify x)

Unqualifies a keyword or symbol. Given :hello/world => :world. Given 'hello/world returns 'world.

walk clj/s

(walk kv-fn m)

(walk key-fn val-fn m)

Adapted from clojure.walk/keywordize-keys. Uses walk/postwalk and calls key-fn on each key and val-fn on each value for each map entry. The 2 arity version invokes kv-fn for each map entry. Recursively changes all keys and values as specified by kv-fn or key-fn and val-fn.