only assoc if the value in the original map is nil

(assoc-new {:a 1} :b 2) => {:a 1 :b 2}

(assoc-new {:a 1} :a 2 :b 2) => {:a 1 :b 2}

checks if object is instance of clojure.lang.Cons

(cons? (cons 1 1 2 3)) => true

checks if elements in the collection are unique

(deduped? 1 2 3 4) => true

(deduped? 1 2 1 4) => false

Finds the difference between two maps

Outputs what has changed between the two maps

(diff:changed {:a {:b {:c 3 :d 4}}} {:a {:b {:c 3}}}) => {:a {:b {:d 4}}}

Finds changes in nested maps, does not consider new elements

Finds new elements in nested maps, does not consider changes

patch from old to new

unpatch from new to old

dissocs recursively into a map removing empty entries

(dissoc-nested {:a {:b {:c 1}}} :a :b :c) => {}

finds the element within an array

(element-at keyword? 1 2 :hello 4) => :hello

creates an empty record from an existing one

(defrecord Database host port)

(empty-record (Database. “localhost” 8080)) => (just {:host nil :port nil})

filters map based upon map keys

(filter-keys even? {0 :a 1 :b 2 :c}) => {0 :a, 2 :c}

filters map based upon map values

(filter-vals even? {:a 1 :b 2 :c 3}) => {:b 2}

finds the template with associated path

flattens all elements the collection

(flatten-nested 1 2 #{3 {4 5}}) => 1 2 3 4 5

checks if object is a lisp form

Returns true if x implements clojure.lang.APersistentMap.

(hash-map? {}) => true (hash-map? []) => false

finds the index of the first matching element in an array

(index-at even? 1 2 3 4) => 1

(index-at keyword? 1 2 :hello 4) => 2

insert one or more elements at the given index

(insert-at :a :b 1 :b :c) => :a :b :c :b

filters map based upon map values

(keep-vals even? {:a 1 :b 2 :c 3}) => {:b true}

Returns true if x implements clojure.lang.LazySeq.

(lazy-seq? (map inc 1 2 3)) => true (lazy-seq? ()) => false

manipulates a map given the function

(map-entries (fn k v (keyword (str v)) (name k)) {:a 1 :b 2 :c 3}) => {:1 “a”, :2 “b”, :3 “c”}

creates a map from sequence with key and val functions

(map-juxt str inc 1 2 3 4 5) => {“1” 2, “2” 3, “3” 4, “4” 5, “5” 6}

changes the keys of a map

(map-keys inc {0 :a 1 :b 2 :c}) => {1 :a, 2 :b, 3 :c}

changes the values of a map

(map-vals inc {:a 1 :b 2 :c 3}) => {:a 2, :b 3, :c 4}

Merges nested values from left to right.

(merge-nested {:a {:b {:c 3}}} {:a {:b 3}}) => {:a {:b 3}}

(merge-nested {:a {:b {:c 1 :d 2}}} {:a {:b {:c 3}}}) => {:a {:b {:c 3 :d 2}}}

Merges nested values from left to right, provided the merged value does not exist

(merge-nested-new {:a {:b 2}} {:a {:c 2}}) => {:a {:b 2 :c 2}}

(merge-nested-new {:b {:c :old}} {:b {:c :new}}) => {:b {:c :old}}

uses pmap across the entries

uses pmap across the map values

takes only the namespaced keys of a map

(qualified-keys {:a 1 :ns/b 1}) => #:ns{:b 1}

(qualified-keys {:a 1 :ns.1/b 1 :ns.2/c 1} :ns.1) => #:ns.1{:b 1}

lifts all unqualified keys

(qualify-keys {:a 1} :ns.1) => #:ns.1{:a 1}

(qualify-keys {:a 1 :ns.2/c 1} :ns.1) => {:ns.1/a 1, :ns.2/c 1}

returns a clojure.lang.PersistentQueue object.

(pop a) => 2 3 4

removes element at the specified index

(remove-at :a :b :c :d 2) => :a :b :d

rename keys in map

(rename-keys {:a 1} {:a :b}) => {:b 1}

moves values around in a map according to a table

(reshape {:a 1 :b 2} {:c :d :a}) => {:b 2, :c {:d 1}}

if not a sequence, then make one

(seqify 1) => 1

(seqify 1) => 1

splits a sequences using a predicate

creates a transformation function

creates a transformation function ((transform-fn {:keystore {:hash “{{hash}}” :salt “{{salt}}” :email “{{email}}”}

            :db       {:login {:user {:hash "{{hash}}"
                                      :salt "{{salt}}"}
                               :value "{{email}}"}}}
           [:keystore :db]) ^:hidden

{:type :email, :hash “1234” :salt “ABCD” :email “[email protected]”}) => {:type :email :login {:user {:hash “1234”, :salt “ABCD”}, :value “[email protected]”}}

sets the vals and keys and vice-versa

(transpose {:a 1 :b 2 :c 3}) => {1 :a, 2 :b, 3 :c}

flattens the entire map tree

(->> (tree-flatten {“a” {“b” {“c” 3 “d” 4} “e” {“f” 5 “g” 6}} “h” {“i” {}}}) (map-keys h/strn)) => {“a/b/c” 3, “a/b/d” 4, “a/e/f” 5, “a/e/g” 6}

nests keys in the map

(tree-nestify {:a/b 2 :a/c 3}) => {:a {:b 2 :c 3}}

(tree-nestify {:a/b {:e/f 1} :a/c {:g/h 1}}) => {:a {:b {:e/f 1} :c {:g/h 1}}}

nests keys in the map and all submaps

(tree-nestify:all {:a/b 2 :a/c 3}) => {:a {:b 2 :c 3}}

(tree-nestify:all {:a/b {:e/f 1} :a/c {:g/h 1}}) => {:a {:b {:e {:f 1}} :c {:g {:h 1}}}}

unfolds using a generated function

(unfold (fn i :as seed (if i (if-not (neg? i) [(* i 2) (dec i)]))) 10) => 20 18 16 14 12 10 8 6 4 2 0

works on both lazy seqs and objects

takes only the namespaced keys of a map

(unqualified-keys {:a 1 :ns/b 1}) => {:a 1}

unqualifies keys in the map

(unqualify-keys {:a 1 :ns.1/b 1 :ns.2/c 1}) => {:a 1, :b 1, :c 1}

(unqualify-keys {:a 1 :ns.1/b 1 :ns.2/c 1} :ns.1) => {:a 1, :b 1, :ns.2/c 1}

if a sequence, takes first element

(unseqify 1) => 1

(unseqify 1) => 1