spectrum.conform — spectrum 0.2.2

*resolve-seen* clj

*unify-call-count* clj

*unify-recursion-count* clj

*unify-seen* clj

*unify-temp-cache* clj

accept-nil? clj multimethod

True if this (regex) type may accept no input

add-value-pred-whitelist! clj

(add-value-pred-whitelist! v)

Declare var predicate v as safe for calling to unify with values. v should be a predicate, pure (free of side-effects) and fast

apply-invoke clj

apply-invoke-dispatch clj

(apply-invoke-dispatch it subst)

apply-t clj

(apply-t f args)

Utility/test fn. Given an invoke, return all possible return types

arities-complementary? clj

(arities-complementary? x y)

True if x and y are both fn-ts, and they have no arities in common

assoc-subst clj

(assoc-subst subst x y)

cacheable? clj

(cacheable? x y)

composite? clj

(composite? x)

cyclic-t? clj

(cyclic-t? t subst)

debug-substs clj

(debug-substs t substs)

Given a subst, print the parts relevant to type t

debug-unify clj

(debug-unify x y)

(debug-unify x y substs)

derive-all-any clj

(derive-all-any)

We need all tagged types to derive from #'any?, so default dispatching works

disentangle clj

(disentangle x)

Given a type containing possible choices, such as alt or or, resolve the choices and return a seq of all possible concrete specs that don't contain ambiguity.

(disentangle (cat [(c/? ?t1) ?t2]) => ([cat ?t1 ?t2] [cat ?t2])

disentangle* clj multimethod

dx clj multimethod

dx-dispatch clj

(dx-dispatch x y substs)

dx-methods clj

(dx-methods)

dx? clj

(dx? t)

first-dispatch clj

(first-dispatch t)

first-t clj multimethod

For regexes, returns a seq of possible values of calling first on the type

free-t? clj

(free-t? t subst)

get-var-type clj

(get-var-type v)

maybe-thunk clj

(maybe-thunk it)

(maybe-thunk it substs)

Thunk if possible, else return the invoke-t

merge-substs clj

(merge-substs substs)

merge-substs-1 clj

(merge-substs-1 substs)

narrow-unify-any-logic-1 clj

(narrow-unify-any-logic-1 x y subst)

occurs? clj

(occurs? a b subst)

Does a occur anywhere inside b

pending? clj

(pending? x)

printable-invoke-t clj

(printable-invoke-t it)

recursive-type? clj

(recursive-type? t subst)

resolve-type clj

(resolve-type t subst)

resolve-type* clj multimethod

resolve-type-dispatch clj

(resolve-type-dispatch t subst)

thunk clj

(thunk it)

(thunk it substs)

unify clj

Unifies term x and y with initial subst.

Returns a seq of subst maps, (map of name->term) that unify x and y, or nil if they can't be unified.

unify* clj

(unify* x y)

(unify* x y substs)

unify-any-any clj

(unify-any-any x y substs)

unify-any-logic clj

(unify-any-logic x y substs)

unify-any-logic-1 clj

(unify-any-logic-1 x y subst)

unify-any-or clj

(unify-any-or x y substs)

unify-dx-dx clj

(unify-dx-dx tx ty substs)

unify-logic-any clj

(unify-logic-any x y substs)

unify-logic-any-1 clj

(unify-logic-any-1 x y subst)

unify-logic-logic-1 clj

(unify-logic-logic-1 x y subst)

unify-term-value clj

(unify-term-value x)

unify-terms clj multimethod

unify-terms-dispatch clj

(unify-terms-dispatch x y subst)

unify-terms-equiv clj

(unify-terms-equiv x y)

Define unify-terms such that x and y unify, bidirectionally

unify-terms-method? clj

(unify-terms-method? x y)

Is there a direct dispatch value for (unify-terms x y)?

unify-terms-methods clj

(unify-terms-methods)

valid? clj

(valid? x y)

value-pred-whitelist clj

var-pred? clj

(var-pred? x)

verify-unify clj

(verify-unify x y old-substs new-substs)

with-canonical clj

(with-canonical unify-f)

with-class-cast clj

(with-class-cast unify-f)

with-debug clj

(with-debug unify-f)

with-depth clj

(with-depth unify-f)

with-detect-loop clj

(with-detect-loop unify-f)

with-disentangle clj

(with-disentangle unify-f)

with-doall clj

(with-doall unify-f)

with-ensure-temp-cache clj

(with-ensure-temp-cache unify-f)

with-no-infinite clj

(with-no-infinite unify-f)

with-perm-cache clj

(with-perm-cache unify-f)

with-require-substs clj

(with-require-substs unify-f)

It's easy to accidentally call the 2-arity unify from inside unify-terms, which can cause serious, hard-to-find bugs. Assert that never happens

with-temp-cache clj

(with-temp-cache unify-f)

with-unify-call-count clj

(with-unify-call-count unify-f)