Given a db (map of maps), and a multi-valued attribute children-att, compute the single-valued inverse relationship as parent-att

Given a db (map of maps), and a multi-valued attribute children-att, compute the single-valued inverse relationship as parent-att

Given a seq of maps, return the union of all keys

True if c1 and c2 are equal considered as bags

Name or str of thing. Name means ‘better str’, better in some contexts anyway,

Remove values from ‘map’ based on applying ‘pred’ to value (default is nullish?).

Remove values recursively from ‘map’ based on applying ‘pred’ to value (default is nullish?).

Remove all nullish values from a seq

Remove values from all maps in ‘struct’ based on ‘pred’ (default is nullish?).

Coerce a value (eg a string from a web API) into a boolean

Attempt to turn thing into a number (long or double). Return number if succesful, otherwise original string

Coerce thing to a number if possible, otherwise return nil

Exec is a fn of one argument, which is called and passed another fn it can use to collect values; the collection is returned. See tests for example

Exec is a fn of one argument, which is called and passed another fn it can use to collect values which are merged with merge-recursive; the result is returned. See tests for example TODO

Splice the non-nullish elements of list together in a string, separated by ‘, ’

Concatenate vectors

De-namespace. Remove the namespaces that backquote insists on adding. See tests for illustration.

Like def but produces a delay; value is acceessed via @ and won’t be computed until needed

Like defn, but produces a memoized function

Convert string keys to keywords, recursively

Dissoc in a nested map structure

Given a seq, return true if all elements are distinct. See distinct?

Like distinct, but equality determined by keyfn

split map by whether (f v) is true or false

Realize lazy sequences, if arg is such, otherwise acts as identity

Like doseq, but goes down lists in parallel rather than nested. Assumes lists are same size.

Return elements that occur more than once.

Returns a fn that acts like f, but return value is (true result) or (false errmsg) in the case of an error

Template is a string containing {foo} elements, which get replaced by corresponding values from bindings. See tests for examples.

Like expand-template but will recurse, so the template replacements can contain parameters

Return a seq padded out to infinity with nils

A lazy sequence generated by applying f to seq and its tails

Fixed-point combinator, useful in conjunction with memoization

Like for but goes down lists in parallel rather than nested. Assumes lists are same size.

Like for but filters out nullish? values

Takes a glob-format string and returns an equivalent regex.

Like group-by, but the values of the resultant map have f mapped over them

Like group-by but return only groups with >1 member

Like group-by, but f produces a seq of values rather than a single one; the orginal value gets grouped with each of them

Output number as hex string

Execute body; if an exception occurs ignore it and return nil. Note: strongly deprecated for production code.

Execute body, if an exception occurs, print a message and continue

Execute body, if an exception occurs, return it

Return a map of the elements of coll indexed by (f elt). Similar to group-by, but overwrites elts with same index rather than producing vectors.

Return a map of the elements of coll indexed by (f elt) and transformed by (g elt).

Like index-by, but f produces a seq of values rather than a single one

Return an array map of the elements of coll indexed by (f elt), preserving the order. See index-by

Return a map of the elements of coll indexed by (f elt). Throw an exception of there are duplicate keys.

Given 2 seqs, produce a seq with alternating elements.

Convert a set or seq of chars into a string. Like (into "" ) if that worked.

Like str/join but makes a list, useful for HTML generation

Concatenate parts (which are keywords, strings, anything acceptable to name) into a keyword

Make a string into a readable keyword by replacing certain punctuation

Convert the values of selected keys to keywords

Convert - and _ to spaces

Conj a value to the front (left) of vector. Not performant

Compute the set difference of list1 - `list2’

Compute the intersection of lists

Compute the union of lists

Call f with chunk-sized subsequences of l, concat the results

Returns a recursive diff of two maps, which you will want to prettyprint.

Make a map entry

Returns the inverse of map with the vals mapped to the keys. Like set/map-invert, but does the sensible thing with multiple values. Ex: (map-invert-multiple {:a 1, :b 2, :c [3 4], :d 3}) ==>⇒ {2 #{:b}, 4 #{:c}, 3 #{:c :d}, 1 #{:a}}

Map f over [k v] of hashmap, returning new v

Map f over the keys of hashmap

Map f over the keys of hashmap, and any nested hashmaps

Map f over the values of hashmap

Like mapcat but filters out nullish? values

Like map but filters out nullish? values. Close to clojure.core/keep but uses different test.

Find the maximum element of seq based on keyfn

Return the cache (map of args to values) for a named memoizer.

Like clojure.core/memoize, but retains a ptr to the cache so it can be cleared (see memoize-reset)

Clear the cache of one or all memoized fns

Return information about all memoize-name fns

Merge in a nested map structure

Recursively merge two arbitrariy nested map structures. Terminal seqs are concatentated, terminal sets are merged.

Recursively merge two arbitrariy nested map structures, merging terminals (non-maps) with f

Find the minimum element of seq based on keyfn

Computes the neighborhood of radius n from from, neighbors is a function that produces the immediate neighbors

Convert nullish values to nil

True if value is something we probably don’t care about (nil, false, empty seqs, empty strings)

Provide a key for sorting strings with leading numbers

true if exactly one of its arguments is non-nil.

Given a 1-arg pred, return a new fn that acts as identity if pred is true, nil otherwise

Ordinal string for number n, eg 123 → “123rd”

The suffix for the ordinal version of n

Map backwards. Like map, but takes its args in inverse order. useful in conjunction with ->

Partition coll between v1 and v2 at points for which (f v1 v2) is true

Partition coll at every v for which (f v) is true

Ultra-simple structure pattern matcher. Variables are (? ), bindings

Returns the first index of coll for which pred is true

Returns the first index of coll that equals elt

Returns a list of indexes of coll for which pred is true

Return list of indexes of coll that equals elt

Compute the powerset of a set

Return a random float within range of p

Return a random float between a and b

Return a random int between a and b

Return a random element from a seq

Return n random elements from a seq

Return the closest value to v within range [lower, upper]

Return a regex that will match the literal string

Returns a lazy sequence of successive matches of pattern in string, returning [start end] pairs

Match re against s, apply subfn to matching substrings. Return list of fragments, processed and otherwise

True iff thing is a real vector. Shouldn’t be necessary, but (vector? (first {:a 1})) ⇒ true. Most useful for walker fns.

Remove occurences of elt in seq, applying key-fn before testing if supplied

Iterate f on start until a value is produced that passes pred, returns value.

Like take-while but applies pred to successive tails of the seq, and returns a seq of tails

Round the argument

Like nth but will return nil if out of bounds rather than erroring

Given f, produce new function that permits nulling.

Given f, produce new function that will return nils if exception is thrown. Not recommended for production code

Given f, produce new function that will return original if exception is thrown. Not recommended for production code

Like conj but will always create a set.

Given a map HASHMAP with maps as values, adds the index to each value as the value of attriute ATTR

Separate coll into two collections based on pred.

Turn thing into a sequence if it already isn’t one

True if c1 and c2 are equal considered as sets

Walks form, an arbitrary data structure, evaluating f on each element for side effects. Note: has nothing to do with the standard (functional) walker, and maybe should have a different name (traverse?)

Like some, but returns the original value of the seq rather than the result of the predicate.

Sort a seq of strings, treating leading numbers in a sane way

g is a map, predecessors is a function of g values to g indices. computes for each node the depth: if no predecssors 0, otherwise (inc (max (depth predecssors))) useful for laying out DAGs, possibly elsewhere

Case insensitive version of str/includes?

Removes every character of a given set from a string

Returns a seq of all i-length subseqs

vmap defines a substitution; Walk struct, replacing any keys that appear in vmap with corresponding value.

Like substitute, but for any terminal elements not in map, call generator on first occurance to generate a value.

Return a fn like f but with first two arguments swapped

f is a fn of one arg that returns a list. Returns a new fn that computes the transitive closure of f.

Removes every character of a given set from the ends of a string

Removes every character of a given set from the left end of a string

Removes every character of a given set from the right end of a string

Return false if x is nil or false, true otherwise

Given a seq, return a new seq where the elements are guaranteed unique (relative to key-fn), using new-key-fn to generate new elements

Convert foo_bar into fooBar

Return unique elements in (union s1 s2) given f as identity key

Produce a unique keyword based on root.

Generate a name based on s, that is not already found in existing.

Validate a template, defined as in expand-template-string; fields is a set of allowed field names

Given a fn f with scalar args, (vectorized f) is a fn that takes either scalars or vectors for any argument, doing the appropriate vectorization. All vector args should be the same length.

Walk all the keywords in thing recursively

Walk f over thing and return a list of the non-nil returned values

Walk thing, applying f to every object that passes filter

Walk over thing and return the first val for which f is non-nil

Walk all the map entries in thing matching key (a key or set)

Walk all the map entries in thing

Walks form with an accumulator. f is a function of [accumulator elt], init is initial val of accumulator.

boolean a xor b