org.candelbio.multitool.core — org.candelbio/multitool 0.1.0

Various generally useful utilities

<* clj/s

<=* clj/s

=* clj/s

>* clj/s

>=* clj/s

add-inverse clj/s

(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

add-inverse-multiple clj/s

(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

all-keys clj/s

(all-keys sheet-data)

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

bag= clj/s

(bag= c1 c2)

True if c1 and c2 are equal considered as bags

bstr clj/s

(bstr thing)

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

clean-map clj/s

(clean-map map)

(clean-map map pred)

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

clean-maps clj/s

(clean-maps map)

(clean-maps pred map)

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

clean-seq clj/s

(clean-seq s)

Remove all nullish values from a seq

clean-walk clj/s

(clean-walk struct)

(clean-walk struct pred)

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

coerce-boolean clj/s

(coerce-boolean v)

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

coerce-numeric clj/s

(coerce-numeric thing)

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

coerce-numeric-hard clj/s

(coerce-numeric-hard thing)

Coerce thing to a number if possible, otherwise return nil

collecting clj/s

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

collecting-merge clj/s

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

comma-list clj/s

(comma-list list)

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

de-ns clj/s

(de-ns struct)

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

def-lazy clj/s macro

(def-lazy var & body)

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

defaulted clj/s

defn-memoized clj/s macro

(defn-memoized name args & body)

Like defn, but produces a memoized function

delete-subseq clj/s

(delete-subseq seq subseq)

dissoc-if clj/s

(dissoc-if f hashmap)

dissoc-in clj/s

(dissoc-in map [k & k-rest])

Dissoc in a nested map structure

dissoc-walk clj/s

(dissoc-walk struct & keys)

distinctly clj/s

(distinctly coll keyfn)

Like distinct, but equality determined by keyfn

doall-safe clj/s

(doall-safe thing)

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

doseq* clj/s macro

(doseq* bindings & body)

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

double-braces clj/s

error-handling-fn clj/s

(error-handling-fn f)

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

expand-template clj/s

(expand-template template
                 bindings
                 &
                 {:keys [param-regex] :or {param-regex param-regex}})

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

expand-template-string clj/s

extend-seq clj/s

(extend-seq seq)

Return a seq padded out to infinity with nils

filter-rest clj/s

(filter-rest f seq)

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

fix clj/s

(fix f)

Fixed-point combinator, useful in conjunction with memoization

for* clj/s macro

(for* bindings & body)

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

forf clj/s macro

(forf forms body)

Like for but filters out nullish? values

freq-map clj/s

(freq-map seq)

glob->regex clj/s

(glob->regex s)

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

group-by-and-transform clj/s

(group-by-and-transform by f seq)

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

group-by-multiple clj/s

(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

hex-string clj/s

(hex-string n)

Output number as hex string

ignore-errors clj/s macro

(ignore-errors & body)

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

ignore-report clj/s macro

(ignore-report & body)

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

ignore-return clj/s macro

(ignore-return & body)

Execute body, if an exception occurs, return it

index-by clj/s

(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

index-by-and-transform clj/s

(index-by-and-transform f g coll)

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

index-by-multiple clj/s

(index-by-multiple f coll)

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

index-by-ordered clj/s

(index-by-ordered f coll)

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

key-counter clj/s

keyword-safe clj/s

(keyword-safe str)

Make a string into a readable keyword by replacing certain punctuation

labelize clj/s

(labelize s)

Convert - and _ to spaces

lintersection clj/s

(lintersection & lists)

Compute the intersection of lists

lset-difference clj/s

(lset-difference list1 list2)

Compute the set difference of list1 - `list2'

lunion clj/s

(lunion & lists)

Compute the union of lists

make-collecter clj/s

(make-collecter init collect-fn)

map-chunked clj/s

(map-chunked f chunk-size l)

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

map-diff clj/s

(map-diff a b)

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

map-invert-multiple clj/s

(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}}

map-key-values clj/s

(map-key-values f hashmap)

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

map-keys clj/s

(map-keys f hashmap)

Map f over the keys of hashmap

map-values clj/s

(map-values f hashmap)

Map f over the values of hashmap

mapcatf clj/s

(mapcatf f & args)

Like mapcat but filters out nullish? values

mapf clj/s

(mapf f & args)

Like map but filters out nullish? values

max* clj/s

max-by clj/s

(max-by keyfn seq)

Find the maximum element of seq based on keyfn

memoize-cache clj/s

(memoize-cache name)

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

memoize-named clj/s

(memoize-named name f)

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

memoize-reset! clj/s

(memoize-reset!)

(memoize-reset! name)

Clear the cache of one or all memoized fns

memoizer-stats clj/s

(memoizer-stats)

Return information about all memoize-name fns

memoizers clj/s

merge-in clj/s

(merge-in map [k & k-rest] changes)

Merge in a nested map structure

merge-recursive clj/s

(merge-recursive m1 m2)

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

min* clj/s

min-by clj/s

(min-by keyfn seq)

Find the minimum element of seq based on keyfn

n-chars clj

neighborhood clj/s

(neighborhood from n neighbors)

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

nullish? clj/s

(nullish? v)

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

numeric-prefix-sort-key clj/s

(numeric-prefix-sort-key s)

Provide a key for sorting strings with leading numbers

oneof clj/s

(oneof & things)

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

or-nil clj/s

(or-nil pred)

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

ordinal clj/s

(ordinal n)

Ordinal string for number n, eg 123 → "123rd"

ordinal-suffix clj/s

(ordinal-suffix n)

The suffix for the ordinal version of n

pam clj/s

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

param-regex clj/s

partition-diff clj/s

(partition-diff f coll)

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

partition-if clj/s

(partition-if f coll)

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

pattern-match clj/s

(pattern-match pat thing)

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

position clj/s

(position pred coll)

Returns the first index of coll for which pred is true

position= clj/s

(position= elt coll & [key-fn])

Returns the first index of coll that contains elt

positions clj/s

(positions pred coll)

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

positions= clj/s

(positions= elt coll & [key-fn])

Return list of indexes of coll that contain elt

powerset clj/s

(powerset s)

Compute the powerset of a set

rand-around clj/s

(rand-around p range)

Return a random float within range of p

rand-range clj/s

(rand-range a b)

Return a random float between a and b

rand-range-int clj/s

(rand-range-int a b)

Return a random int between a and b

random-element clj/s

(random-element l)

Return a random element from a seq

range-truncate clj/s

(range-truncate v lower upper)

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

re-pattern-literal clj/s

(re-pattern-literal string)

Return a regex that will match the literal string

re-quote clj/s

(re-quote s)

re-substitute clj

(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

real-vector? clj/s

(real-vector? thing)

True if thing is a real vector, not a map entry

remove-nil-values clj/s

(remove-nil-values hashmap)

remove= clj/s

(remove= elt seq & [key-fn])

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

repeat-until clj/s

(repeat-until pred f start)

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

rest-while clj/s

(rest-while pred coll)

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

round clj/s

(round n)

Round the argument

safe-name clj/s

(safe-name thing)

safe-nth clj/s

(safe-nth col n)

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

safely clj/s

(safely f)

Given f, produce new function that permits nulling.

saferly clj/s

(saferly f)

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

sconj clj/s

(sconj coll elt)

Like conj but will always create a set.

self-label clj/s

(self-label attr hashmap)

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

separate clj/s

(separate pred coll)

Separate coll into two collections based on pred.

sequencify clj/s

(sequencify thing)

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

set= clj/s

(set= c1 c2)

True if c1 and c2 are equal considered as sets

side-walk clj/s

(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?)

some-thing clj/s

(some-thing pred seq)

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

sort-map-by-values clj/s

(sort-map-by-values m)

sort-map-by-values-fn clj/s

(sort-map-by-values-fn f m)

sort-with-numeric-prefix clj/s

(sort-with-numeric-prefix seq)

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

str-replace-multiple clj/s

(str-replace-multiple map string)

stratify clj/s

(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

strip-chars clj/s

(strip-chars removed s)

Removes every character of a given set from a string

subseqs clj/s

(subseqs seq i)

Returns a seq of all i-length subseqs

substitute clj/s

(substitute struct vmap)

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

substitute-gen clj/s

(substitute-gen struct vmap generator)

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

swapped clj/s

(swapped f)

Return a fn like f but with first two arguments swapped

throwable? clj/s

(throwable? x)

transitive-closure clj/s

(transitive-closure f)

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

trim-chars clj/s

(trim-chars removed s)

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

trim-chars-left clj/s

(trim-chars-left removed s)

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

trim-chars-right clj/s

(trim-chars-right removed s)

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

truthy? clj/s

(truthy? x)

Return false if x is nil or false, true otherwise

uncollide clj/s≠

clj

(uncollide seq
           &
           {:keys [key-fn new-key-fn existing]
            :or {key-fn identity
                 new-key-fn (fn* [p1__1929#] (str p1__1929# "-1"))
                 existing #{}}})

cljs

(uncollide seq
           &
           {:keys [key-fn new-key-fn existing]
            :or {key-fn identity
                 new-key-fn (fn* [p1__3717#] (str p1__3717# "-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

underscore->camelcase clj/s

(underscore->camelcase s)

Convert foo_bar into fooBar

union-by clj/s

(union-by f s1 s2)

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

unique-key clj/s

(unique-key root)

Produce a unique keyword based on root.

unique-relative-to clj/s

(unique-relative-to s existing suffix)

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

unlist clj/s

(unlist thing)

update! clj/s

(update! map k f & args)

validate-template clj/s

(validate-template template
                   fields
                   &
                   {:keys [param-regex] :or {param-regex param-regex}})

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

vectorize clj/s

(vectorize f)

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-collect clj/s

(walk-collect f thing)

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

walk-find clj/s

(walk-find f thing)

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

walk-reduce clj/s

(walk-reduce f form init)

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

xor clj/s

(xor a b)

boolean a xor b