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

Implementation depends on collection type.

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

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

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.

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

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

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 nil 1) => [1]
(consv [2] 1) => [1 2]
(update-in {:a 2} [:a] consv 1) => {:a [1 2]}
(-> [2] (consv 5)) => [1 2]

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 {: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

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](https://github.com/weavejester/meta-merge).

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 given associative collection using function on the values.

Filter given associative collection using function on the keys.

Filter given associative collection using function on the values.

(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 first value from collection which mathes the where parameter.

If where parameter is:

- a fn, it's used as predicate as is
- a map, a predicate is created which checks if value in collection has
  same values for each key in where map
- Something which implements IFn, e.g. keywords and sets, is used as is
- any value, a predicate is created which checks if value is identitical

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 [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

Find index of vector which matches the where parameter.

If where parameter is:

- a fn, it's used as predicate as is
- a map, a predicate is created which checks if value in collection has
  same values for each key in where map
- Something which implements IFn, e.g. keywords and sets, is used as is
- any value, a predicate is created which checks if value is identitical

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

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

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

`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.`

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 the entries of given associative collection using function.

Map the keys of given associative collection using function.

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

Map the values of given associative collection using function.

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

Removes given associative collection using function on the values.

Removes given associative collection using function on the keys.

Removes given associative collection using function on the values.

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.

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

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 [1 2 3] [:a :b :c])  => ([1 :a] [2 :b] [3 :c])
(zip [1] [1 2] [1 2 3])   => ([1 1 1])

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])