spectrum.types — spectrum 0.2.1

* clj

(* x)

+ clj

(+ x)

? clj

(? x)

accept-t clj

(accept-t & args__6031__auto__)

accept-t? clj

(accept-t? x__6025__auto__)

alt-t clj

(alt-t ps)

alt-t? clj

(alt-t? x__6025__auto__)

alt-types clj

(alt-types x)

ancestors clj

(ancestors t)

and-classes-compatible? clj

(and-classes-compatible? ts)

True if the and-t classes are compatible (doesn't contain concrete classes that aren't ancestors)

and-conj clj

(and-conj s x)

and-consolidate clj

(and-consolidate ts)

Given the types for an and, simplify and consolidate types, returning a seq of types

and-nots-compatible? clj

(and-nots-compatible? ts)

True if ts does not contains ?x and (not-t ?x)

and-rest clj

(and-rest a)

and-t clj

(and-t ts)

and-t? clj

(and-t? x__6025__auto__)

and-types clj

(and-types a)

and-values-compatible? clj

(and-values-compatible? ts)

true if and ts does not contain two non-equal values

any-t? clj

(any-t? t)

canonicalize clj

(canonicalize t)

Given a type, convert to it's most precise version

cat-length clj

(cat-length t)

Given a cat, return its length

cat-t clj

(cat-t ts)

cat-t? clj

(cat-t? x__6025__auto__)

cat-types clj

(cat-types x)

class-cast clj

(class-cast t)

cast to class-t If the type can be cast without losing precision, else nil

class-t clj

(class-t x)

class-t? clj

(class-t? x__6025__auto__)

class-value clj

coll-of clj

(coll-of & args__6031__auto__)

conformy? clj

(conformy? t)

core-predicates clj

(core-predicates)

defn-tagged-type clj macro

(defn-tagged-type name tag)

defn ~name as a fn that constructs a vector tagged type

defn-type-pred clj macro

(defn-type-pred name tag)

derive-type clj

(derive-type parent type)

(derive-type h parent type)

clojure.core/derive, but patched to allow types.

Note arguments are reversed from clojure.core/derive, to resemble (valid? x y)

equiv-types clj

fn-args clj

(fn-args f-t)

Return an or of all arities this fn will accept

fn-ret clj

(fn-ret f-t)

Return an or of all types this fn may return

fn-t clj

(fn-t m)

fn-t? clj

(fn-t? x__6025__auto__)

freshen clj

(freshen form)

Walk form, replacing all logic variables with unique versions

get-equiv-types clj

(get-equiv-types t)

get-lvars clj

(get-lvars expr)

Return a set of logic variables in expression

ignore? clj

instance-or-t? clj

(instance-or-t? t)

invalid clj

(invalid & args__6031__auto__)

invalid? clj

(invalid? x__6025__auto__)

invoke-t clj

(invoke-t & args__6031__auto__)

invoke-t? clj

(invoke-t? x__6025__auto__)

join-not-pairs clj

(join-not-pairs ts)

If two types in ts are (not x) and x, replace them with any?

keys-t clj

(keys-t & args__6031__auto__)

load-type-hierarchy clj

(load-type-hierarchy)

logic-name clj

(logic-name x)

logic? clj

(logic? x)

map-entry clj

(map-entry & args__6031__auto__)

map-of clj

(map-of & args__6031__auto__)

maybe-cat clj

(maybe-cat args)

maybe-t clj

(maybe-t & args__6031__auto__)

maybe-t? clj

(maybe-t? x__6025__auto__)

maybe-value clj

merge-fns clj

(merge-fns fns)

new-logic clj

(new-logic)

(new-logic prefix)

nilable clj

(nilable x)

not-core-predicates clj

not-t clj

(not-t & args__6031__auto__)

not-t? clj

(not-t? x__6025__auto__)

not-value clj

ns-predicates clj

(ns-predicates ns)

Return all var predicates in ns

object-t? clj

(object-t? t)

or-consolidate clj

(or-consolidate ts)

or-t clj

(or-t ts)

or-t? clj

(or-t? x__6025__auto__)

or-types clj

parents clj

(parents t)

Same as clojure.core/parents, but for types

predicate-symbol? clj

(predicate-symbol? x)

protocol-t clj

(protocol-t & args__6031__auto__)

recur-t clj

(recur-t & args__6031__auto__)

regex? clj multimethod

rename clj

(rename m form)

Given a map of lvars to lvars, walk form and replace all instances of keys values

seq-of clj

(seq-of & args__6031__auto__)

seq-t? clj

(seq-t? x__6025__auto__)

seq-value clj

set-equiv-types! clj

(set-equiv-types! x y)

Define types x and y as being equivalent

simplify-arities clj

(simplify-arities fn-map)

Merge fn arities with the same return type and same number of arguments

spec-t clj

(spec-t & args__6031__auto__)

spec-t? clj

(spec-t? x__6025__auto__)

tagged-type? clj

(tagged-type? name x)

tagged? clj

(tagged? t)

throw-t clj

(throw-t & args__6031__auto__)

type-counter clj

type-tag clj

(type-tag t)

type-value clj

(type-value t)

type-values clj

(type-values t)

type? clj

(type? x)

types-hierarchy clj

value-t clj

(value-t & args__6031__auto__)

value-t? clj

(value-t? x__6025__auto__)

value-value clj

vector-of clj

(vector-of & args__6031__auto__)