nemesis.core — pbaille/nemesis 0.1.2

compile-all! clj macro

(compile-all!)

compile-all!-fn clj

(compile-all!-fn)

compile-all!-fn* clj

defg clj macro

(defg & form)

create a generic function

defg-fn clj

(defg-fn & form)

defg-fn* clj

deft clj macro

(deft {:as spec :keys [tag parents impls fields childs class-sym]})

(deft tag fields)

(deft tag fields x & xs)

declare a new usertype (a clojure record) tag: the typetag (keyword) corresponding to our freshly created record fields: the fields of our record parents: a seq of other typetags that our type belongs to & impls: optional generic implementations for the defined type

deft-fn clj

(deft-fn {:as spec :keys [tag parents impls fields childs class-sym]})

(deft-fn tag fields)

(deft-fn tag fields x & xs)

deft-fn* clj

generic+ clj macro

(generic+ name & cases)

add new cases to an existant generic all given arities must already be known

generic+-fn clj

(generic+-fn name & cases)

generic+-fn* clj

implements? clj macro

(implements? v name)

(implements? v name & names)

test if something implements one or several generics

implements?-fn clj

(implements?-fn v name)

(implements?-fn v name & names)

implements?-fn* clj

prototypes clj/s

tag+ clj macro

(tag+ {:keys [tag childs parents impls]})

(tag+ tag childs)

(tag+ tag childs parents & impls)

add a type tag to the type registry (living in nemesis.state/state) tag: the typetag we are defining/extending (a keyword) childs: a seq of other typetags or classes that belongs to the defined tag parents: a seq of other typetags that the defined tag belongs to & impls: optional generic implementations for the defined tag

tag+-fn clj

(tag+-fn {:keys [tag childs parents impls]})

(tag+-fn tag childs)

(tag+-fn tag childs parents & impls)

tag+-fn* clj

thing clj macro

(thing & impls)

like reify but for generics

thing-fn clj

(thing-fn & impls)

thing-fn* clj

type+ clj macro

(type+ tag & impls)

like extend type

type+-fn clj

(type+-fn tag & impls)

type+-fn* clj