facets.core — facets 0.1.0-SNAPSHOT

<alias clj/s

(<alias type)

<f clj/s

(<f facet this)

given a facet keyword and something, return the registered or default implementation

<fs clj/s

(<fs t)

get all facets implementations for the given type

aliases clj/s

any clj/s

assert-existing-derivations clj/s

(assert-existing-derivations impl-map)

assert-facet clj/s

(assert-facet name)

assert-facet-impl-map clj/s

(assert-facet-impl-map impl-map)

assert-new-facet clj/s

(assert-new-facet name)

assert-new-type clj/s

(assert-new-type name)

assert-no-overides clj/s

(assert-no-overides old-impls new-impls)

assert-nskw clj/s

(assert-nskw name)

assert-parents clj/s

(assert-parents parents)

assert-type clj/s

(assert-type name)

assert-type-impl-map clj/s

(assert-type-impl-map impl-map)

call clj/s

(call fk arg1 & args)

call facet f on args

declare-alias clj/s

(declare-alias type sym)

register a type-alias ex: (declare-alias clojure.lang.PersistentVector ::vec)

declare-aliases clj/s

(declare-aliases hm)

declare-derived-type clj/s

(declare-derived-type name parents & [constructor impl-map])

same as declare-type but inherit all impls of the given parents, unless overiden via impl-map parameter

declare-facet clj/s

(declare-facet name & [impl-map])

declare a new facet, just a fancy name for behavior or method ex: (declare-facet ::say-hello {::type1 (fn [x] (println "hello from type 1")) ::type2 (fn [x] (println "hello from type 2")) :default (fn [x] (println "default hello from a type that doesn't implement ::say-hello))})

declare-facets clj/s

(declare-facets m)

declare-type clj/s

(declare-type name & [constructor impl-map])

declare a new datatype, attaching it the given constructor and facets implementations. ex: (declare-type ::foo identity {:say-hello (fn [this] (println "hello from foo"))})

declare-type* clj/s

(declare-type* {:keys [id constructor facets spec gen]})

derivations clj/s

derived-impl-map clj/s

(derived-impl-map parents impl-map)

extend-facet clj/s

(extend-facet name impl-map)

assoc new implementations to existing facet

extend-facets clj/s

(extend-facets m)

extend-type clj/s

(extend-type name impl-map)

assoc new facets implementation to existing type

facets clj/s

known-type? clj/s

(known-type? t)

known-types clj/s

(known-types)

prefer clj/s

(prefer type & types)

register a type preference, 'type' will be prefered over 'types'

prefs clj/s

pstate clj/s

(pstate)

reified->impls clj/s

(reified->impls this)

reified? clj/s

(reified? this)

reify clj/s

(reify this parents-or-impl-map)

(reify this parents impl-map)

anonymous type, that can inherit from one or several existing types

reset-all! clj/s

(reset-all!)

t clj/s

(t e)

(t sym e)

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

t= clj/s

(t= x & xs)

check if all given args are of same type

t> clj/s

(t> t & args)

generic constructor call. apply the constructor of type t to args

t? clj/s

(t? sym e)

check if e is of type sym

throw-alias-error clj/s

(throw-alias-error matches)

(throw-alias-error matches type)

types clj/s

§ clj/s