kezban.core — kezban 0.1.94

->>> clj/s macro

(->>> & form)

Takes a set of functions and value at the end of the arguments. Returns a result that is the composition of those funtions.Applies the rightmost of fns to the args(last arg is the value/input!), the next fn (left-to-right) to the result, etc.

any-pred clj/s

(any-pred & preds)

array? clj/s

(array? arr)

(array? type arr)

assert-all clj/s≠ macro

clj

(assert-all & pairs)

cljs

(assert-all fnname & pairs)

Internal - do not use!

cond-as-> clj/s macro

(cond-as-> expr name & clauses)

cond-let clj/s macro

(cond-let bindings & forms)

def- clj/s macro

(def- name x)

defay clj macro

(defay name & forms)

defm clj/s macro

(defm name params & body)

dissoc-in clj/s

(dissoc-in m ks)

(dissoc-in m ks & kss)

if-let* clj/s macro

(if-let* bindings then)

(if-let* bindings then else)

Multiple binding version of if-let

in? clj/s

(in? x coll)

keywordize clj/s

(keywordize s)

lazy? clj/s

(lazy? x)

letm clj/s macro

(letm bindings)

locals clj macro

(locals)

multi-comp clj/s

(multi-comp fns a b)

(multi-comp [f & others :as fns] order a b)

nnth clj/s

(nnth coll index & indices)

nth-safe clj/s

(nth-safe coll n)

(nth-safe coll n not-found)

Returns the value at the index. get returns nil if index out of bounds,unlike nth nth-safe does not throw an exception, returns nil instead.nth-safe also works for strings, Java arrays, regex Matchers and Lists, and, in O(n) time, for sequences.

pprint-macro clj macro

(pprint-macro form)

process-lazy-seq clj/s

(process-lazy-seq f threshold lazy-s)

prog1 clj/s macro

(prog1 first-form & body)

quoted? clj/s macro

(quoted? form)

source-clj-file clj

(source-clj-file ns)

take-while-and-n-more clj/s

(take-while-and-n-more pred n coll)

time* clj macro

(time* & forms)

try-> clj/s macro

(try-> x & forms)

try->> clj/s macro

(try->> x & forms)

url->file clj

(url->file src f)

when-let* clj/s macro

(when-let* bindings & body)

Multiple binding version of when-let

when-no-aot clj macro

(when-no-aot & body)

with-out clj macro

(with-out & body)

with-timeout clj macro

(with-timeout ms & body)

xor clj macro

(xor)

(xor x)

(xor x & next)