Turns a thread-last macro into a thread first one.

(->> (range 3) (mapv inc) (<<-> (conj :foo))) ;=> [1 2 3 :foo]

Returns a lazy seq of the elements of coll followed by xs.

Returns a lazy seq of the elements of coll followed by the non-nil xs.

Associates a value in a nested associative structure, if and only if the value is not nil.

Associates a value in an associative structure, if and only if the value is not nil.

conj[oin]. Returns a new collection with the xs ‘added’ if and only if they are not nil. Otherwise behaves like core/conj.

Like merge, but also merges nested maps under the same key.

Like merge-with, but also merges nested maps under the same key.

defs(tructure) Like def, but can take a binding form instead of a symbol to destructure the results of the body, creating vars instead of locals. Returns a vector of the vars defined. Any metadata added to a symbol becomes metadata on the var.

Takes a function f and arguments args. Returns a function of one argument x that is f applied with x as it’s first argument and args as the rest.

Almost the opposite of partial, the difference being that the returned function takes exactly one argument, the “thing” that’s being operated upon, instead of an arbitrary number of arguments. This is to reduce confusion. Meant to be used with assoc, get, conj, etc. that all take the “thing” as the first argument.

The name is taken from haskell, although it’s not exactly equivalent to the haskell version.

The same as #(-> % ~@forms)

The same as #(->> % ~@forms)

Like core/for, but adds :do, :when-let and :while-let modifiers.

A drop-in replacement for core/for.

Like for, but takes a key and value expression and returns a map. Multiple equal keys are treated as if by repeated assoc (last one wins). Not lazy.

A for variant that presumes the body evaluates to a seqable thing. Returns a lazy sequence of all elements in each body.

Like comfy/for, accepts the :into modifier. (Which will make it non-lazy.)

Like for, but presumes that the body-expr evaluates to a seqable thing, and returns a vector of every element from each body. Not lazy.

Like for, but returns a vector. Not lazy.

Returns a map of the distinct values of (f item) in coll to the number of times they appear.

Returns a map of the elements of coll keyed by the result of f on each element. The value at each key will be a vector of the corresponding elements, in the order they appeared in coll.

When given a transducer, the resulting reducing function will be called on the vector and each element as it’s added. For each different key, a new instance of the reducing function will be created, with its own state, if any.

Eagerly evaluates all of coll, even if all results are reduced.

A drop-in replacement for core/group-by.

Returns a lazy sequence of the non-nil results of (f item). Note, this means false return values will be included. f must be free of side-effects. Returns a transducer when no collection is provided.

When given multiple collections, will behave as map. (This includes the transducer).

A drop-in replacement for core/keep.

ike map, but keeps going until the end of the longest collection, substituting nil when a collection is exhausted.

Returns true if x is one, else false.

Postwalk reduce. Performs a depth-first, post-order traversal of form calling rf on init and each sub-form. Unlike reduce, an init value is required.

Postwalk transduce. Traverses form depth-first, post-order, behaving otherwise like transduce.

Prewalk reduce. Performs a depth-first, pre-order traversal of form, calling rf on init and each sub-form. Unlike reduce, an init value is required.

Prewalk transduce. Traverses form depth-first, pre-order, behaving otherwise like transduce.

Runs the supplied procedure, for purposes of side effects, on successive items in the collection.

Returns nil. Not lazy.

When given multiple collections, proc will be called with number-of-colls arguments. Will go on for the length of the shortest collection.

A drop-in replacement for core/run!.

Returns something that is only equal to itself.

Returns an infinite sequence of distinct sentinels.

Parses a decimal number from a string. Returns nil if the string has the wrong format or is nil. Leading zeroes are ignored.

Parses a string to an integer. Returns nil if the string has the wrong format or is nil. Leading zeroes are ignored.

Take items until an item repeats (not inclusive).

Takes items until the f of an item repeats (not inclusive).

Returns true if x is two, else false.