potemkin.types — potemkin 0.4.5

*expanded-types* clj

abstract-type? clj

(abstract-type? x)

clean-deftype clj

(clean-deftype x)

clojure-fn-subs clj

def-abstract-type clj macro

(def-abstract-type name & body)

An abstract type, which can be used in conjunction with deftype+.

definterface+ clj macro

(definterface+ name & body)

An interface that won't evaluate if an interface with that name already exists.

Self parameters and multiple arities are defined like defprotocol, as well as wrapping functions for each, so it can be used to replace defprotocol seamlessly.

defprotocol+ clj macro

(defprotocol+ name & body)

A protocol that won't evaluate if an equivalent protocol with the same name already exists.

defrecord+ clj macro

(defrecord+ name & body)

A defrecord that won't evaluate if an equivalent datatype with the same name already exists.

deftype*->deftype clj

(deftype*->deftype x)

deftype*->fn-map clj

(deftype*->fn-map x)

deftype+ clj macro

(deftype+ name params & body)

A deftype that won't evaluate if an equivalent datatype with the same name already exists, and allows abstract types to be used.

deftype->deftype* clj

(deftype->deftype* x)

expand-deftype clj

(expand-deftype x)

extend-protocol+ clj macro

(extend-protocol+ proto & body)

A variant of extend-protocol that allows proto to be extended over other protocols, as well as classes and nil.

merge-deftypes* clj

(merge-deftypes* a)

(merge-deftypes* a b & rest)

munge-fn-name clj

(munge-fn-name n)

protocol? clj

(protocol? x)

reify+ clj macro

(reify+ & body)

A reify that supports abstract types.

resolve-tag clj

(resolve-tag n)

transform-deftype* clj

(transform-deftype* f x)

type-bodies clj

untag clj

(untag n)