Various generally useful utilities
Various generally useful utilities
(add-inverse db children-att 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 db (map of maps), and a multi-valued attribute children-att, compute the single-valued inverse relationship as parent-att
(add-inverse-multiple db children-att 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 db (map of maps), and a multi-valued attribute children-att, compute the single-valued inverse relationship as parent-att
(all-keys sheet-data)Given a seq of maps, return the union of all keys
Given a seq of maps, return the union of all keys
(bag= c1 c2)True if collections c1 and c2 are equal considered as bags
True if collections c1 and c2 are equal considered as bags
(bstr thing)Name or str of thing. Name means 'better str', better in some contexts anyway,
Name or str of thing. Name means 'better str', better in some contexts anyway,
(clean-map map)(clean-map map pred)Remove values from 'map' based on applying 'pred' to value (default is nullish?).
Remove values from 'map' based on applying 'pred' to value (default is `nullish?`).
(clean-maps map)(clean-maps pred map)Remove values recursively 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?`).
(clean-seq s)Remove all nullish values from a seq
Remove all nullish values from a seq
(clean-walk struct)(clean-walk struct pred)Remove values from all maps in 'struct' based on 'pred' (default is nullish?).
Remove values from all maps in 'struct' based on 'pred' (default is `nullish?`).
(coerce-boolean v)Coerce a value (eg a string from a web API) into a boolean
Coerce a value (eg a string from a web API) into a boolean
(coerce-numeric thing)Attempt to turn thing into a number (long or double). Return number if succesful, otherwise original string
Attempt to turn thing into a number (long or double). Return number if succesful, otherwise original string
(coerce-numeric-hard thing)Coerce thing to a number if possible, otherwise return nil
Coerce thing to a number if possible, otherwise return nil
(collecting exec)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; 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
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
(collecting-set exec)Exec is a fn of one argument, which is called and passed another fn it can use to collect values; the collected set 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; the collected set returned. See tests for example
(comma-list list)Splice the non-nullish elements of list together in a string, separated by ', '
Splice the non-nullish elements of list together in a string, separated by ', '
(de-ns struct)De-namespace. Remove the namespaces that backquote insists on adding. See tests for illustration.
De-namespace. Remove the namespaces that backquote insists on adding. See tests for illustration.
(def-lazy var & body)Like def but produces a delay; value is acceessed via @ and won't be computed until needed
Like `def` but produces a delay; value is acceessed via @ and won't be computed until needed
(defn-memoized name args & body)Like defn, but produces a memoized function
Like `defn`, but produces a memoized function
(dehumanize map)Convert string keys to keywords, recursively
Convert string keys to keywords, recursively
(dissoc-in map [k & k-rest])Dissoc in a nested map structure
Dissoc in a nested map structure
(distinct*? seq)Given a seq, return true if all elements are distinct. See distinct?
Given a seq, return true if all elements are distinct. See distinct?
(distinct-by keyfn coll)Like distinct, but equality determined by keyfn
Like distinct, but equality determined by keyfn
(divide-map-by-value f map)split map by whether (f v) is true or false
split map by whether (f v) is true or false
(doall-safe thing)Realize lazy sequences, if arg is such, otherwise acts as identity
Realize lazy sequences, if arg is such, otherwise acts as identity
(doseq* bindings & body)Like doseq, but goes down lists in parallel rather than nested. Assumes lists are same size.
Like doseq, but goes down lists in parallel rather than nested. Assumes lists are same size.
(duplicates seq)Return elements that occur more than once.
Return elements that occur more than once.
(error-handling-fn f)Returns a fn that acts like f, but return value is [true result] or [false exception] in the case of an error
Returns a fn that acts like f, but return value is [true result] or [false exception] in the case of an error
(expand-template template
bindings
&
{:keys [param-regex key-fn allow-missing?]
:or {param-regex default-param-regex key-fn treeword}})Template is a string containing {{foo}} elements, which get replaced by corresponding values from bindings. See tests for examples. {{foo.bar}} works for nested maps
Template is a string containing {{foo}} elements, which get replaced by corresponding values from bindings. See tests for examples. {{foo.bar}} works for nested maps
(expand-template-recur tmplate & args)Like expand-template but will recurse, so the template replacements can contain parameters
Like expand-template but will recurse, so the template replacements can contain parameters
(extend-seq seq)Return a seq padded out to infinity with nils
Return a seq padded out to infinity with nils
(filter-rest f seq)A lazy sequence generated by applying f to seq and its tails
A lazy sequence generated by applying f to seq and its tails
(fix f)Fixed-point combinator, useful in conjunction with memoization
Fixed-point combinator, useful in conjunction with memoization
(for* bindings & body)Like for but goes down lists in parallel rather than nested. Assumes lists are same size.
Like for but goes down lists in parallel rather than nested. Assumes lists are same size.
(forf forms body)Like for but filters out nullish? values
Like for but filters out nullish? values
(fsbl o f & args)The first (arg) shall be last (for use in -> chains)
The first (arg) shall be last (for use in -> chains)
(get-in* m ks)Like core/get-in but a key (selector) can be a predicate fn which will pick an element from a sequence.
Like core/get-in but a key (selector) can be a predicate fn which will pick an element from a sequence.
(glob->regex s)Takes a glob-format string and returns an equivalent regex.
Takes a glob-format string and returns an equivalent regex.
(group-by-and-transform by f seq)Like group-by, but the values of the resultant map have f mapped over them
Like group-by, but the values of the resultant map have f mapped over them
(group-by-dups f seq)Like group-by but return only groups with >1 member
Like group-by but return only groups with >1 member
(group-by-multiple f coll)Like group-by, but f produces a seq of values rather than a single one; the orginal value gets grouped with each of them
Like group-by, but f produces a seq of values rather than a single one; the orginal value gets grouped with each of them
(hex-string n)Output number as hex string
Output number as hex string
(ignore-errors & body)Execute body; if an exception occurs ignore it and return nil. Note: strongly deprecated for production code.
Execute `body`; if an exception occurs ignore it and return `nil`. Note: strongly deprecated for production code.
(ignore-report & body)Execute body, if an exception occurs, print a message and continue
Execute `body`, if an exception occurs, print a message and continue
(ignore-return & body)Execute body, if an exception occurs, return it
Execute `body`, if an exception occurs, return it
(index-by f coll)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). Similar to group-by, but overwrites elts with same index rather than producing vectors.
(index-by-and-transform f g coll)Return a map of the elements of coll indexed by (f elt) and transformed by (g elt).
Return a map of the elements of coll indexed by (f elt) and transformed by (g elt).
(index-by-multiple f coll)Like index-by, but f produces a seq of values rather than a single one
Like index-by, but f produces a seq of values rather than a single one
(index-by-ordered f coll)Return an array map of the elements of coll indexed by (f elt), preserving the order. See index-by
Return an array map of the elements of coll indexed by (f elt), preserving the order. See index-by
(index-by-safely f coll)Return a map of the elements of coll indexed by (f elt). Throw an exception of there are duplicate keys.
Return a map of the elements of coll indexed by (f elt). Throw an exception of there are duplicate keys.
(insert-after seq elt after)Insert elt after after in seq. Throw exception if elt is not present.
Insert `elt` after `after` in `seq`. Throw exception if elt is not present.
(insert-before seq elt before)Insert elt before before in seq. Throw exception if elt is not present.
Insert `elt` before `before` in `seq`. Throw exception if elt is not present.
(intercalate l1 l2)Given 2 seqs, produce a seq with alternating elements.
Given 2 seqs, produce a seq with alternating elements.
(into-string thing)Convert a set or seq of chars into a string. Like (into "" <str>) if that worked.
Convert a set or seq of chars into a string. Like (into "" <str>) if that worked.
(iterate-until f start)(iterate-until pred f start)Iterate f on start until a value is produced that passes pred, returns value.
Iterate f on start until a value is produced that passes pred, returns value.
(join-seq sep seq)Like str/join but makes a list, useful for HTML generation
Like str/join but makes a list, useful for HTML generation
(keyword-conc & parts)Concatenate parts (which are keywords, strings, anything acceptable to name) into a keyword
Concatenate parts (which are keywords, strings, anything acceptable to name) into a keyword
(keyword-safe str)Make a string into a readable keyword by replacing certain punctuation
Make a string into a readable keyword by replacing certain punctuation
(keywordize map & keys)Convert the values of selected keys to keywords
Convert the values of selected keys to keywords
(lconj v e)Conj a value to the front (left) of vector. Not performant
Conj a value to the front (left) of vector. Not performant
(ldifference list1 list2)Compute the set difference of list1 - `list2'
Compute the set difference of `list1` - `list2'
(lintersection & lists)Compute the intersection of lists
Compute the intersection of `lists`
(lsbf f & args)The last (arg) shall be first (for use in ->> chains)
The last (arg) shall be first (for use in ->> chains)
(lunion & lists)Compute the union of lists
Compute the union of `lists`
(map-chunked f chunk-size l)Call f with chunk-sized subsequences of l, concat the results
Call f with chunk-sized subsequences of l, concat the results
(map-diff a b)Returns a recursive diff of two maps, which you will want to prettyprint.
Returns a recursive diff of two maps, which you will want to prettyprint.
(map-invert-multiple m)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}}
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-key-values f hashmap)Map f over [k v] of hashmap, returning new v
Map f over [k v] of hashmap, returning new v
(map-keys f hashmap)Map f over the keys of hashmap
Map f over the keys of hashmap
(map-keys-recursive f hashmap)Map f over the keys of hashmap, and any nested hashmaps
Map f over the keys of hashmap, and any nested hashmaps
(map-terminals f hashmap)Map f over all terminal elements of hashmap
Map f over all terminal elements of hashmap
(map-values f hashmap)Map f over the values of hashmap
Map f over the values of hashmap
(mapcatf f & args)Like mapcat but filters out nullish? values
Like mapcat but filters out nullish? values
(mapf f & args)Like map but filters out nullish? values. Close to clojure.core/keep but uses different test.
Like map but filters out nullish? values. Close to clojure.core/keep but uses different test.
(max-by keyfn seq)Find the maximum element of seq based on keyfn
Find the maximum element of `seq` based on keyfn
(memoize-cache name)Return the cache (map of args to values) for a named memoizer.
Return the cache (map of args to values) for a named memoizer.
(memoize-named name f)Like clojure.core/memoize, but retains a ptr to the cache so it can be cleared (see memoize-reset)
Like clojure.core/memoize, but retains a ptr to the cache so it can be cleared (see memoize-reset)
(memoize-reset!)(memoize-reset! name)Clear the cache of one or all memoized fns
Clear the cache of one or all memoized fns
(memoizer-stats)Return information about all memoize-name fns
Return information about all memoize-name fns
(merge-in map [k & k-rest] changes)Merge in a nested map structure
Merge in a nested map structure
(merge-recursive m1 m2)Recursively merge two arbitrariy nested map structures. Terminal seqs are concatentated, terminal sets are merged.
Recursively merge two arbitrariy nested map structures. Terminal seqs are concatentated, terminal sets are merged.
(merge-recursive-with f m1 m2)Recursively merge two arbitrariy nested map structures, merging terminals (non-maps) with f
Recursively merge two arbitrariy nested map structures, merging terminals (non-maps) with f
(min-by keyfn seq)Find the minimum element of seq based on keyfn
Find the minimum element of `seq` based on keyfn
(neighborhood from n neighbors)Computes the neighborhood of radius n from from, neighbors is a function that produces the immediate neighbors
Computes the neighborhood of radius n from from, neighbors is a function that produces the immediate neighbors
(nullify v)Convert nullish values to nil
Convert nullish values to nil
(nullish? v)True if value is something we probably don't care about (nil, false, empty seqs, empty strings)
True if value is something we probably don't care about (nil, false, empty seqs, empty strings)
(numeric-prefix-sort-key s)Provide a key for sorting strings with leading numbers
Provide a key for sorting strings with leading numbers
(oneof & things)true if exactly one of its arguments is non-nil.
true if exactly one of its arguments is non-nil.
(or-nil pred)Given a 1-arg pred, return a new fn that acts as identity if pred is true, nil otherwise
Given a 1-arg pred, return a new fn that acts as identity if pred is true, nil otherwise
(or-nullish)(or-nullish x)(or-nullish x & next)Like or but will return the first non-nullish value
Like or but will return the first non-nullish value
(ordinal n)Ordinal string for number n, eg 123 → "123rd"
Ordinal string for number n, eg 123 → "123rd"
(ordinal-suffix n)The suffix for the ordinal version of n
The suffix for the ordinal version of n
(parse-comma-list s)Parse a comma-separated string into parts
Parse a comma-separated string into parts
(partition-diff f coll)Partition coll between v1 and v2 at points for which (f v1 v2) is true
Partition coll between v1 and v2 at points for which (f v1 v2) is true
(partition-if f coll)Partition coll at every v for which (f v) is true
Partition coll at every v for which (f v) is true
(pattern-match pat thing)Ultra-simple structure pattern matcher. Variables are (? <name>), bindings
Ultra-simple structure pattern matcher. Variables are (? <name>), bindings
(position pred coll)Returns the first index of coll for which pred is true
Returns the first index of coll for which pred is true
(position= elt coll & [key-fn])Returns the first index of coll that equals elt
Returns the first index of coll that equals elt
(positions pred coll)Returns a list of indexes of coll for which pred is true
Returns a list of indexes of coll for which pred is true
(positions= elt coll & [key-fn])Return list of indexes of coll that equals elt
Return list of indexes of coll that equals elt
(powerset s)Compute the powerset P(s) of a set
Compute the powerset P(s) of a set
(rand-around p range)Return a random float within range of p
Return a random float within range of p
(rand-range a b)Return a random float between a and b
Return a random float between a and b
(rand-range-int a b)Return a random int between a and b
Return a random int between a and b
(random-element seq)Return a random element from a seq
Return a random element from a seq
(random-elements n seq)Return n random elements from a seq
Return n random elements from a seq
(range-truncate v lower upper)Return the closest value to v within range [lower, upper]
Return the closest value to v within range [lower, upper]
(re-pattern-literal string)Return a regex that will match the literal string
Return a regex that will match the literal string
(re-pattern-literal-nocase string)Return a regex that will match the literal string, case insensitive
Return a regex that will match the literal string, case insensitive
(re-seq-positions re s & [group])Returns a lazy sequence of successive matches of pattern in string, returning [start end] pairs
Returns a lazy sequence of successive matches of pattern in string, returning [start end] pairs
(re-substitute re s)(re-substitute re s subfn)Match re against s, apply subfn to matching substrings. Return list of fragments, processed and otherwise
Match re against s, apply subfn to matching substrings. Return list of fragments, processed and otherwise
(real-vector? thing)True iff thing is a real vector. Shouldn't be necessary, but (vector? (first {:a 1})) ⇒ true. Most useful for walker fns.
True iff thing is a real vector. Shouldn't be necessary, but (vector? (first {:a 1})) ⇒ true. Most useful for walker fns.
(redact-key m k)Takes a map and a key. Walks the map, if the key is anywhere in there, and has a value, redacts it. Used for hiding passwords in log files.
Takes a map and a key. Walks the map, if the key is anywhere in there, and has a value, redacts it. Used for hiding passwords in log files.
(redact-keys m ks)Takes a map and a coll of keys. Walks the map, if the key is anywhere in there, and has a value, redacts it. Used for hiding passwords in log files.
Takes a map and a coll of keys. Walks the map, if the key is anywhere in there, and has a value, redacts it. Used for hiding passwords in log files.
(remove= elt seq & [key-fn])Remove occurences of elt in seq, applying key-fn before testing if supplied
Remove occurences of elt in seq, applying key-fn before testing if supplied
(rest-while pred coll)Like take-while but applies pred to successive tails of the seq, and returns a seq of tails
Like take-while but applies pred to successive tails of the seq, and returns a seq of tails
(safe-nth col n)Like nth but will return nil if out of bounds rather than erroring
Like nth but will return nil if out of bounds rather than erroring
(safely f)(safely f default)Given f, produce new function that permits nulling.
Given f, produce new function that permits nulling.
(saferly f)(saferly f default)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 nils if exception is thrown. Not recommended for production code
(safestly f)Given f, produce new function that will return original 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
(sconj coll elt)Like conj but will always create a set.
Like conj but will always create a set.
(self-label attr hashmap)Given a map HASHMAP with maps as values, adds the index to each value as the value of attriute ATTR
Given a map HASHMAP with maps as values, adds the index to each value as the value of attriute ATTR
(separate pred coll)Separate coll into two collections based on pred.
Separate coll into two collections based on pred.
(sequencify thing)Turn thing into a sequence if it already isn't one
Turn thing into a sequence if it already isn't one
(set-toggle aset elt)Toggle presence of elt in set (set can be nil)
Toggle presence of elt in set (set can be nil)
(set= c1 c2)True if collections c1 and c2 are equal considered as sets
True if collections c1 and c2 are equal considered as sets
(side-walk f form)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?)
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?)
(some-thing pred seq)Like some, but returns the original value of the seq rather than the result of the predicate.
Like some, but returns the original value of the seq rather than the result of the predicate.
(sort-with-numeric-prefix seq)Sort a seq of strings, treating leading numbers in a sane way
Sort a seq of strings, treating leading numbers in a sane way
(stratify g predecessors depth-prop)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
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
(string-includes-uncased? s substr)Case insensitive version of str/includes?
Case insensitive version of str/includes?
(strip-chars removed s)Removes every character of a given set from a string
Removes every character of a given set from a string
(subseqs seq i)Returns a seq of all i-length subseqs
Returns a seq of all i-length subseqs
(substitute struct vmap)vmap defines a substitution; Walk struct, replacing any keys that appear in vmap with corresponding value.
vmap defines a substitution; Walk `struct`, replacing any keys that appear in vmap with corresponding value.
(substitute-gen struct vmap generator)Like substitute, but for any terminal elements not in map, call generator on first occurance to generate a value.
Like `substitute`, but for any terminal elements not in map, call `generator` on first occurance to generate a value.
(transitive-closure f)f is a fn of one arg that returns a list. Returns a new fn that computes the transitive closure of f.
f is a fn of one arg that returns a list. Returns a new fn that computes the transitive closure of f.
(treeword s)Like keyword but supports foo.bar syntax, will generate the appropriate accessor
Like keyword but supports foo.bar syntax, will generate the appropriate accessor
(trim-chars removed s)Removes every character of a given set from the ends of a string
Removes every character of a given set from the ends of a string
(trim-chars-left removed s)Removes every character of a given set from the left end of a string
Removes every character of a given set from the left end of a string
(trim-chars-right removed s)Removes every character of a given set from the right end of a string
Removes every character of a given set from the right end of a string
(truthy? x)Return false if x is nil or false, true otherwise
Return false if x is nil or false, true otherwise
(tx template)Expand a template based on lexically defined variables
Expand a template based on lexically defined variables
(uncollide seq
&
{:keys [key-fn new-key-fn existing]
:or {key-fn identity
new-key-fn (fn* [p1__2104#] (str p1__2104# "-1"))
existing #{}}})(uncollide seq
&
{:keys [key-fn new-key-fn existing]
:or {key-fn identity
new-key-fn (fn* [p1__4225#] (str p1__4225# "-1"))
existing #{}}})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
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
(underscore->camelcase s)Convert foo_bar into fooBar
Convert foo_bar into fooBar
(union-by f s1 s2)Return unique elements in (union s1 s2) given f as identity key
Return unique elements in (union s1 s2) given f as identity key
(unique-key root)Produce a unique keyword based on root.
Produce a unique keyword based on root.
(unique-relative-to s existing suffix)Generate a name based on s, that is not already found in existing.
Generate a name based on s, that is not already found in existing.
(validate-template template
fields
&
{:keys [param-regex] :or {param-regex default-param-regex}})Validate a template, defined as in expand-template-string; fields is a set of allowed field names
Validate a template, defined as in expand-template-string; fields is a set of allowed field names
(walk-all-keys f thing)Walk all the keywords in thing recursively
Walk all the keywords in thing recursively
(walk-collect f thing)Walk f over thing and return a vector of the non-nil returned values
Walk f over thing and return a vector of the non-nil returned values
(walk-collect-set f thing)Walk f over thing and return a set of the non-nil returned values
Walk f over thing and return a set of the non-nil returned values
(walk-filtered f thing filter)Walk thing, applying f to every object that passes filter
Walk thing, applying f to every object that passes filter
(walk-find f thing)Walk over thing and return the first val for which f is non-nil
Walk over thing and return the first val for which f is non-nil
(walk-find-path f thing)Walk over thing and return [<the first val for which f is non-nil>, <path>]
Walk over thing and return [<the first val for which f is non-nil>, <path>]
(walk-keys f keys thing)Walk all the map entries in thing matching key (a key or set)
Walk all the map entries in thing matching key (a key or set)
(walk-map-entries f thing)Walk all the map entries in thing
Walk all the map entries in thing
(walk-reduce f form init)Walks form with an accumulator. f is a function of [accumulator elt], init is initial val of accumulator.
Walks form with an accumulator. f is a function of [accumulator elt], init is initial val of accumulator.
cljdoc builds & hosts documentation for Clojure/Script libraries
| Ctrl+k | Jump to recent docs |
| ← | Move to previous article |
| → | Move to next article |
| Ctrl+/ | Jump to the search field |