nemesis.impl.utils — pbaille/nemesis 0.1.2

$ clj

$! clj

$fn clj

($fn ffn)

$vals clj

($vals m f)

argv_litt clj

(argv_litt n & [prefix])

argv_unvariadify clj

(argv_unvariadify argv)

argv_variadic? clj

(argv_variadic? x)

argv_variadify clj

(argv_variadify v)

binding-pattern_ensure-top-level-sym clj

(binding-pattern_ensure-top-level-sym pat default-sym)

this checks that the given pattern has a top level binding for symbols it is itself for destructuring patterns it is handle via the :as syntax if not present the given default-sym will be inserted

we will return a tuple of the form [top-lvl-sym pattern]

cljs_prototype-assoc clj macro

(cljs_prototype-assoc obj meth impl)

cljs_prototype-assoc-form clj

(cljs_prototype-assoc-form obj meth impl)

defmac clj macro

(defmac & body)

personal defmacro define a regular macro but also a function that do the same thing as the macro (when receiving quoted args) here I hope that it could ease macro composition and later ckish embeddings note that if used from clojurescript, body have to contain only functions that are defined both in clojure and clojurescript

doall-rec clj

(doall-rec x)

realize all nested potetially nested lazy sequences usefull in macros, because when using dynamic vars based expansion state, we have to be sure that there is no lazyness in the expansion otherwise dynamic vars will not be bounded as intended when expansion lazy parts are realized

empty clj

(empty x)

error clj

(error & xs)

error-form clj

(error-form & xs)

findeep clj

(findeep x p)

fn-case_bodify clj

(fn-case_bodify [pattern b1 & bs])

fn-cases_normalize clj

(fn-cases_normalize xs)

fullname clj

(fullname x)

kset clj

map_diff clj

(map_diff m1 m2)

return m1 minus the entries (key and val) that are in m2

name_arify clj

(name_arify n a)

name_derive clj

(name_derive n)

ns-sym clj

(ns-sym)

parse-fn clj

(parse-fn [fst & nxt :as all])

pp clj

(pp & xs)

pretty-str clj

(pretty-str & xs)

shrink+ clj

shrink- clj

sym clj

(sym & xs)

with-ns clj

(with-ns sym)

(with-ns ns sym)