Returns the absolute value of a number.

Associates a key k, with a value v in a map m, if and only if v is not nil.

Returns true if x is a boolean.

Similar to clojure.core/group-by, this groups values in a collection, coll, based on the return value of a function, keyf applied to each element.

Unlike group-by, the values of the map are constructed via an initf and collatef function. The initf function is applied to the first element matched by keyf, and defaults to the identity function. The collatef function takes the result of initf and the next keyed element, and produces a new value.

To put this in context, the group-by function can be defined as:

(defn group-by [f coll]
  (collate-by f conj vector coll))

While the medley.core/index-by function can be (and is) defined as:

(defn index-by [f coll]
  (collate-by f (fn [_ x] x) coll))

Returns a lazy sequence of the elements of coll, removing any consecutive elements that return duplicate values when passed to a function f. Returns a stateful transducer when no collection is provided.

Recursively merges maps together. If all the maps supplied have nested maps under the same keys, these nested maps are merged. Otherwise the value is overwritten, as in clojure.core/merge.

Sets the value of the atom without regard for the current value, then returns the original value of the atom. See also: deref-swap!.

Atomically swaps the value of the atom to be (apply f x args), where x is the current value of the atom, then returns the original value of the atom. This function therefore acts like an atomic deref then swap!.

Dissociate a value in a nested associative structure, identified by a sequence of keys. Any collections left empty by the operation will be dissociated from their containing structures.

Returns a lazy sequence of the elements of coll, removing any elements that return duplicate values when passed to a function f. Returns a stateful transducer when no collection is provided.

Returns a lazy sequence of the items in coll starting after the first item for which (pred item) returns true. Returns a stateful transducer when no collection is provided.

Returns the cause attached to the given ExceptionInfo/Throwable object. For all other types returns nil. Same as cljs.core/ex-cause except it works for Clojure as well as ClojureScript.

Returns the message attached to the given Error/Throwable object. For all other types returns nil. Same as cljs.core/ex-message except it works for Clojure as well as ClojureScript.

Returns a new associative collection of the items in coll for which (pred (key item)) returns true.

Returns a new associative collection of the items in coll for which (pred (key item) (val item)) returns true.

Returns a new associative collection of the items in coll for which (pred (val item)) returns true.

Finds the first item in a collection that matches a predicate. Returns a transducer when no collection is provided.

Find the greatest argument (as defined by the compare function) in O(n) time.

Return the argument for which (keyfn x) is greatest. Determined by the compare function in O(n) time. Prefer clojure.core/max-key if keyfn returns numbers.

Returns a map of the elements of coll keyed by the result of f on each element. The value at each key will be the last element in coll associated with that key. This function is similar to clojure.core/group-by, except that elements with the same key are overwritten, rather than added to a vector of values.

Returns an ordered, lazy sequence of vectors [index item], where item is a value in coll, and index its position starting from zero. Returns a stateful transducer when no collection is provided.

Returns a lazy sequence of the items in coll, with a new item inserted at the supplied index, followed by all subsequent items of the collection. Runs in O(n) time. Returns a stateful transducer when no collection is provided.

Returns a lazy seq of the first item in each coll, then the second, etc. Unlike clojure.core/interleave, the returned seq contains all items in the supplied collections, even if the collections are different sizes.

Lazily concatenates a collection of collections into a flat sequence.

Return the least argument (as defined by the compare function) in O(n) time.

Return the argument for which (keyfn x) is least. Determined by the compare function in O(n) time. Prefer clojure.core/min-key if keyfn returns numbers.

Create a map entry for a key and value pair.

Maps a function over the keys of an associative collection.

Maps a function over the key/value pairs of an associative collection. Expects a function that takes two arguments, the key and value, and returns the new key and value as a collection of two elements.

Maps a function over the key/value pairs of an associative collection, using the return of the function as the new key.

Maps a function over the key/value pairs of an associative collection, using the return of the function as the new value.

Maps a function over the values of one or more associative collections. The function should accept number-of-colls arguments. Any keys which are not shared among all collections are ignored.

Applies a function f to the argument list formed by concatenating everything but the last element of args with the last element of args. This is useful for applying a function that accepts keyword arguments to a map.

Returns a lazy sequence of partitions, splitting after (pred item) returns true. Returns a stateful transducer when no collection is provided.

Returns a lazy sequence of partitions, splitting before (pred item) returns true. Returns a stateful transducer when no collection is provided.

Applies pred to successive values in coll, splitting it each time (pred prev-item item) returns logical true. Returns a lazy seq of partitions. Returns a stateful transducer when no collection is provided.

Creates an empty persistent queue, or one populated with a collection.

Returns true if x implements clojure.lang.PersistentQueue.

Generates a new random UUID. Same as cljs.core/random-uuid except it works for Clojure as well as ClojureScript.

Returns true if the value is a regular expression.

Returns a new associative collection of the items in coll for which (pred (key item)) returns false.

Returns a new associative collection of the items in coll for which (pred (key item) (val item)) returns false.

Returns a lazy sequence of the items in coll, except for the item at the supplied index. Runs in O(n) time. Returns a stateful transducer when no collection is provided.

Returns a new associative collection of the items in coll for which (pred (val item)) returns false.

Returns a lazy sequence of the items in coll, with a new item replacing the item at the supplied index. Runs in O(n) time. Returns a stateful transducer when no collection is provided.

Returns a lazy sequence of successive items from coll up to and including the first item for which (pred item) returns true. Returns a transducer when no collection is provided.

Updates a value in a map given a key and a function, if and only if the key exists in the map. See: clojure.core/update.

Updates a value in a nested associative structure, if and only if the key path exists. See: clojure.core/update-in.

Returns a UUID generated from the supplied string. Same as cljs.core/uuid in ClojureScript, while in Clojure it returns a java.util.UUID object.

Returns true if the value is a UUID.