kezban.core — kezban 0.1.92

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

dissoc-in clj/s

(dissoc-in m ks)

(dissoc-in m ks & kss)

drop-first clj/s

(drop-first coll)

Return a lazy sequence of all, except first value

eighth clj/s

(eighth coll)

Gets the eighth element from collection

error? clj/s macro

(error? & body)

Returns true if executing body throws an error(exception, error etc.), false otherwise.

eval-when clj

(eval-when test form)

fifth clj/s

(fifth coll)

Gets the fifth element from collection

forall clj/s macro

(forall seq-exprs body-expr)

fourth clj/s

(fourth coll)

Gets the fourth element from collection

has-ns? clj/s

(has-ns? ns)

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)

ninth clj/s

(ninth coll)

Gets the ninth element from collection

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)

seventh clj/s

(seventh coll)

Gets the seventh element from collection

sixth clj/s

(sixth coll)

Gets the sixth element from collection

source-clj-file clj

(source-clj-file ns)

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

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

tenth clj/s

(tenth coll)

Gets the tenth element from collection

third clj/s

(third coll)

Gets the third element from collection

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-err-str clj macro

(with-err-str & body)

with-out-str-data-map clj macro

(with-out-str-data-map & body)

with-timeout clj macro

(with-timeout msec & body)

xor clj macro

(xor)

(xor x)

(xor x & next)