potpuri.core — metosin/potpuri 0.5.3

assoc-first clj/s

(assoc-first coll where v)

Finds the first element in collection matching where parameter and replaces that with v.

Implementation depends on collection type.

assoc-if clj/s

(assoc-if m key val)

(assoc-if m key val & kvs)

Assoc key-value pairs with non-nil values into map.

assoc-in-path-vals clj/s

(assoc-in-path-vals c)

Re-created a map from it's path-vals extracted with (path-vals).

build-tree clj/s

(build-tree {:keys [parent-fn id-fn assoc-children-fn] :as opts} items)

Builds a tree from given items collections.

ID is what is used to match parents and children. Root items are those where parent-fn returns nil.

Options:

• :parent-fn (required) Used to create a map from ID => children
• :id-fn (required) Used to get the ID from an item
• :assoc-children-fn (required) Attach the children to an item
• :item-fn (optional) Called for each item, after children has been attached to the item
• :children-fn (optional) Called for each children collection

Example: (build-tree {:id-fn :id, :parent-fn :parent, :assoc-children-fn #(assoc %1 :children %2)} [{:id 1} {:id 2 :parent 1} {:id 3 :parent 1}]) => [{:id 1 :children [{:id 2} {:id 3}]}]

Check test file for more examples.

condas-> clj/s macro

(condas-> expr name & clauses)

A mixture of cond-> and as-> allowing more flexibility in the test and step forms

conjv clj/s

(conjv coll el)

Append an element to a collection. If collection is nil, creates vector instead of sequence. The appending might happen on different places depending on the type of collection.

Examples:

(conjv nil 5) => [5]
(conjv [1] 2) => [1 2]
(update-in {} [:a] conjv 5) => {:a [5]}
(-> [] (conjv 5)) => [5]

consv clj/s

(consv coll el)

Prepend an element to a collection. Returns a vector.

Examples:

(consv nil 1) => [1]
(consv [2] 1) => [1 2]
(update-in {:a 2} [:a] consv 1) => {:a [1 2]}
(-> [2] (consv 5)) => [1 2]

deep-merge clj/s≠

clj

(deep-merge values)

(deep-merge strategy & values)

cljs

(deep-merge & values)

Recursively merges maps.

If the first parameter is a keyword it tells the strategy to use when merging non-map collections. Options are

• :replace, the default, the last value is used
• :into, if the value in every map is a collection they are concatenated using into. Thus the type of (first) value is maintained.

Examples:

(deep-merge {:a {:c 2}} {:a {:b 1}}) => {:a {:b 1 :c 2}}
(deep-merge :replace {:a [1]} {:a [2]}) => {:a [2]}
(deep-merge :into {:a [1]} {:a [2]}) => {:a [1 2]}
(deep-merge {:a 1} nil) => nil

See also: meta-merge.

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.

filter-entries clj/s

(filter-entries pred coll)

Filter given associative collection using function on the values.

filter-keys clj/s

(filter-keys pred coll)

Filter given associative collection using function on the keys.

filter-vals clj/s

(filter-vals pred coll)

Filter given associative collection using function on the values.

find-first clj/s

(find-first coll where)

Find first value from collection which matches the where parameter.

If where parameter is:

• a map, a predicate is created which compares every key/value pair of where value to collection value.
• something which implements IFn, e.g. keywords and sets, is used as is
• other values, compares the item using using clojure.core/=

Examples:

(find-first [1 2 3] even?) => 2
(find-first [{:id 1} {:id 2, :foo :bar}] {:id 2}) => {:id 2, :foo :bar}
(find-first [{:a 1} {:b 2, :foo :bar}] :b) => {:b 2, :foo :bar}
(find-first [1 2 3] #{3}) => 3
(find-first [1 2 3] 3) => 3
(-> [1 2 3] (find-first odd?)) => 1

find-index clj/s

(find-index coll where)

Find index of vector which matches the where parameter.

If where parameter is:

• a map, a predicate is created which compares every key/value pair of where value to collection value.
• something which implements IFn, e.g. keywords and sets, is used as is
• other values, compares the item using using clojure.core/=

Examples:

(find-index [1 2 3] even?) => 1
(find-index [{:id 1} {:id 2}] {:id 2}) => 1
(find-index [{:a 1} {:b 2}] :b) => 1
(find-index [1 2 3] #{3}) => 2
(find-index [1 2 3] 3) => 2
(-> [1 2 3] (find-index odd?)) => 0

fn-> clj/s macro

(fn-> & body)

Creates a function that threads on input with some->

fn->> clj/s macro

(fn->> & body)

Creates a function that threads on input with some->>

if-all-let clj/s macro

(if-all-let bindings then)

(if-all-let bindings then else)

bindings => [binding-form test, binding-form test ...]

If all tests are true, evaluates then with binding-forms bound to the values of tests, if not, yields else.

index-by clj/s

(index-by f coll)

Returns a map of the elements of coll keyed by the result of f on each element. The value at each key will the last item for given f result.

map-entries clj/s

(map-entries f coll)

Map the entries of given associative collection using function.

map-keys clj/s

(map-keys f coll)

Map the keys of given associative collection using function.

map-of clj/s macro

(map-of & syms)

Creates map with symbol names as keywords as keys and symbol values as values.

map-vals clj/s

(map-vals f coll)

Map the values of given associative collection using function.

path-vals clj/s

(path-vals m)

Returns vector of tuples containing path vector to the value and the value.

remove-entries clj/s

(remove-entries pred coll)

Removes given associative collection using function on the values.

remove-keys clj/s

(remove-keys pred coll)

Removes given associative collection using function on the keys.

remove-vals clj/s

(remove-vals pred coll)

Removes given associative collection using function on the values.

update-first clj/s

(update-first coll where f & args)

Finds the first element in collection matching the where parameter and updates that using f. f is called with current value and rest of update-first params.

Implementation depends on collection type.

update-if-contains clj/s

(update-if-contains m k & rest)

Applies clojure.core/update on an associative structure, when k is a key contained in that structure. If the key does not exist, the associative structure is returned as is.

Examples:

(update-if-contains {} :a inc) => {}
(update-if-contains {:a 0} :a inc) => {:a 1}

where-fn clj/s

(where-fn where)

Returns a predicate that accepts a value and performs a check based on where argument.

If where is a map, returns a predicate that compares all key/value pairs of where to the key/values of the value given to the predicate, and returns truthy value if all pairs are found.

If where is a function (either fn? or ifn?), returns where.

For all other values of where returns a predicate that compares the argument of predicate against where using clojure.core/=.

wrap-into clj/s

(wrap-into coll v)

Wrap non-collection values into given collection. Collections are only put into the collection (non-wrapped).

Examples:

(wrap-into [] :a) => [:a]
(wrap-into [] [:a]) => [:a]
(wrap-into #{} [:a]) => #{:a}

zip clj/s

(zip & colls)

Returns a sequence of vectors where the i-th vector contains the i-th element from each of the argument collections. The returned sequence is as long as the shortest argument.

Example:

(zip [1 2 3] [:a :b :c])  => ([1 :a] [2 :b] [3 :c])
(zip [1] [1 2] [1 2 3])   => ([1 1 1])