noon.utils.misc — org.clojars.pbaille/noon 0.1.0

$ clj

($ x f)

>_ clj macro

(>_ seed & forms)

shorthand for (as-> x _ ...)

abs clj

(abs x)

all-paths clj

(all-paths m)

(all-paths x at)

given a nested map, returns a seq of the form: ([path val]*)

copy-file clj

(copy-file file name)

dbg clj macro

(dbg & xs)

deep-check clj

(deep-check m)

Deeply checks if all values in a map are truthy.

deep-find clj

(deep-find data x)

deep-merge clj

(deep-merge x y)

defn* clj macro

(defn* & form)

Like defn but last argument is bound variadicaly. it defines two functions,

• one that binds the last ARGV pattern to variadic arguments.
• one (postfixed by ) that expect it as a seq. This is somehow analogous to #'list and #'list

defreduction clj macro

(defreduction name x & xs)

dist clj

(dist a b)

divmod clj

(divmod mod x)

ensure-directory clj

(ensure-directory x)

ensure-file clj

(ensure-file name)

f_ clj macro

(f_ ret)

(f_ x & xs)

Unary lambda with threading body. arity 1: simple unary lambda with arg bound to _ arity 2+: shorthand for: (fn [x] (as-> x _ ...)).

factorize clj

(factorize num)

flagged clj

(flagged flag value)

(flagged flag1 flag2 value)

(flagged flag1 flag2 flag3 value)

(flagged flag1 flag2 flag3 flag4 & rest)

add some flags into metadata

flagged? clj

(flagged? flag)

(flagged? flag value)

hm->defs clj

(hm->defs ns hm)

takes an hashmap of type (named x) -> any, and def all in the given ns

hm-leaves clj

(hm-leaves m)

hm-nodes clj

(hm-nodes)

(hm-nodes x)

(hm-nodes x from acc)

index-of clj

(index-of s x)

lazy-map clj

(lazy-map xs f)

lazy-primes clj

(lazy-primes)

(lazy-primes current known-primes)

linear-interpolation clj

(linear-interpolation from to steps)

not sure about the name

map-vals clj

(map-vals f m)

negate clj

parse-defn clj

(parse-defn [name x & xs])

parse-file-path clj

(parse-file-path n)

pp clj

(pp & xs)

pretty-str clj

(pretty-str x)

prob clj macro

(prob & xs)

rand-int-between clj

(rand-int-between a b)

return an integer between a and b (inclusive).

random-kw? clj

reduction clj

(reduction f)

Turn a binary fn 'f into a variadic function that use 'f and reduce to produce a result, shortcircuiting on first nil intermediate result

round clj

(round x)

rounded-div clj

(rounded-div n d)

scale-range clj

(scale-range in [in-min in-max] [out-min out-max])

(scale-range x in-min in-max out-min out-max)

Scales a given input value within the specified input range to a corresponding value in the specified output range using the formula:

     (out-max - out-min) (x - in-min)

f (x) = -------------------------------- + out-min in-max - in-min

serialize-to-base64 clj

(serialize-to-base64 obj)

snoc clj

(snoc l x)

put 'x at the end of 'l

str->keyword clj

(str->keyword name)

sums clj

(sums total size steps)

(sums total size steps floor ceil)

t clj

(t e)

(t sym e)

artity 2: assign type sym to e arity 1: get the type tag of e

t= clj

(t= x & xs)

check if all given args are of same type (tag)

t? clj

(t? sym)

(t? sym e)

check if e is of type (type tag) sym

template clj macro

(template x)

throw* clj

(throw* & xs)

unserialize-from-base64 clj

(unserialize-from-base64 s)