AndFilter

AnyValue

App

ArrayCLJS

B

BooleanCLJS

BotFilter

Bounds

ClassPE

CountPE

CountRange

DataType

DottedPretype

EmptyObject

F

FilterSet

FirstPE

FlowSet

FnIntersection

FnResult

Function

FunctionCLJS

GTRange

HeterogeneousList

HeterogeneousMap

HeterogeneousSeq

HeterogeneousVector

ImpFilter

Intersection

KeyPE

KwArgs

LTRange

ListDots

Mu

Name

NextPE

NoFilter

NoObject

NotType

NotTypeFilter

NumberCLJS

ObjectCLJS

OrFilter

Path

Poly

PolyDots

PrimitiveArray

Projection

PropEnv

Protocol

RClass

Record

RecurTarget

Result

Scope

StringCLJS

SymbolCLJS

TApp

TCResult

Top

TopFilter

TopFunction

TypeFilter

TypeFn

Union

Value

c

cset

cset-entry

dcon

dcon-dotted

dcon-exact

dmap

i-subst

i-subst-dotted

i-subst-starred

t-subst

->AndFilter

Usage: (->AndFilter fs)

->AnyValue

Usage: (->AnyValue)

->App

Usage: (->App rator rands)

->ArrayCLJS

Usage: (->ArrayCLJS)

->B

Usage: (->B idx)

->BooleanCLJS

Usage: (->BooleanCLJS)

->BotFilter

Usage: (->BotFilter)

->Bounds

Usage: (->Bounds upper-bound lower-bound higher-kind)

->ClassPE

Usage: (->ClassPE)

->CountPE

Usage: (->CountPE)

->CountRange

Usage: (->CountRange lower upper)

->DataType

Usage: (->DataType the-class variances poly? fields)

->DottedPretype

Usage: (->DottedPretype pre-type name)

->F

Usage: (->F name)

->FilterSet

Usage: (->FilterSet then else)

->FirstPE

Usage: (->FirstPE)

->FlowSet

Usage: (->FlowSet normal)

->FnIntersection

Usage: (->FnIntersection types)

->FnResult

Usage: (->FnResult args kws rest drest body)

->Function

Usage: (->Function dom rng rest drest kws)

->FunctionCLJS

Usage: (->FunctionCLJS)

->GTRange

Usage: (->GTRange n)

->HeterogeneousList

Usage: (->HeterogeneousList types)

->HeterogeneousSeq

Usage: (->HeterogeneousSeq types)

->HeterogeneousVector

Usage: (->HeterogeneousVector types)

->Intersection

Usage: (->Intersection types)

->KeyPE

Usage: (->KeyPE val)

->KwArgs

Usage: (->KwArgs mandatory optional)

->LTRange

Usage: (->LTRange n)

->ListDots

Usage: (->ListDots pre-type bound)

->Mu

Usage: (->Mu scope)

->Name

Usage: (->Name id)

->NextPE

Usage: (->NextPE)

->NoFilter

Usage: (->NoFilter)

->NoObject

Usage: (->NoObject)

->NotType

Usage: (->NotType type)

->NotTypeFilter

Usage: (->NotTypeFilter type path id)

->NumberCLJS

Usage: (->NumberCLJS)

->ObjectCLJS

Usage: (->ObjectCLJS)

->OrFilter

Usage: (->OrFilter fs)

->Path

Usage: (->Path path id)

->Poly

Usage: (->Poly nbound bbnds scope actual-frees)

->PolyDots

Usage: (->PolyDots nbound bbnds scope)

->PrimitiveArray

Usage: (->PrimitiveArray jtype input-type output-type)

->Projection

Usage: (->Projection afn ts)

->PropEnv

Usage: (->PropEnv l props)

->Protocol

Usage: (->Protocol the-var variances poly? on-class methods)

->RClass

Usage: (->RClass variances poly? the-class replacements)

->Record

Usage: (->Record the-class fields)

->Scope

Usage: (->Scope body)

->StringCLJS

Usage: (->StringCLJS)

->SymbolCLJS

Usage: (->SymbolCLJS)

->TApp

Usage: (->TApp rator rands)

->TCResult

Usage: (->TCResult t fl o flow)

->Top

Usage: (->Top)

->TopFilter

Usage: (->TopFilter)

->TopFunction

Usage: (->TopFunction)

->TypeFilter

Usage: (->TypeFilter type path id)

->TypeFn

Usage: (->TypeFn nbound variances bbnds scope)

->Union

Usage: (->Union types)

->Value

Usage: (->Value val)

->c

Usage: (->c S X T bnds)

->cset

Usage: (->cset maps)

->cset-entry

Usage: (->cset-entry fixed dmap projections)

->dcon

Usage: (->dcon fixed rest)

->dcon-dotted

Usage: (->dcon-dotted fixed dc dbound)

->dcon-exact

Usage: (->dcon-exact fixed rest)

->dmap

Usage: (->dmap map)

->i-subst

Usage: (->i-subst types)

->i-subst-dotted

Usage: (->i-subst-dotted types dty dbound)

->i-subst-starred

Usage: (->i-subst-starred types starred)

RClass-supers*

Usage: (RClass-supers* {:keys [poly? replacements the-class], :as rcls})

Return a set of ancestors to the RClass

abstract-many

Usage: (abstract-many names ty)

Names Type -> Scope^n  where n is (count names)

add-multimethod-dispatch-type

Usage: (add-multimethod-dispatch-type mmsym dtype)

Add the type of the dispatch function of the multimethod named by mmsym
to the environment. If already exists, must be identical.

cf

Usage: (cf form)
       (cf form expected)

Type check a Clojure form and return its type

cf-cljs

Usage: (cf-cljs form)
       (cf-cljs form expected)

Type check a Clojurescript form and return its type

check-anon-fn

Usage: (check-anon-fn {:keys [methods], :as expr} methods-types & {:keys [poly]})

Check anonymous function, with annotated methods. methods-types
is a (Seqable (HMap {:dom (Seqable Type) :rng (U nil Type)}))

check-cljs-ns*

Usage: (check-cljs-ns*)
       (check-cljs-ns* nsym)

Type check a CLJS namespace. If not provided default to current namespace

check-fn

Usage: (check-fn {:keys [methods], :as fexpr} expected)

Check a fn to be under expected and annotate the inferred type

check-ns

Usage: (check-ns)
       (check-ns nsym)

Type check a namespace. If not provided default to current namespace

ctor-Class->symbol

Usage: (ctor-Class->symbol cls)

Returns a symbol representing this constructor's Class, removing any compiler stubs.

declare-alias-kind

Usage: (declare-alias-kind sym ty)

Declare a kind for an alias, similar to declare but on the kind level.

declare-datatypes

Usage: (declare-datatypes & syms)

Declare datatypes, similar to declare but on the type level.

declare-names

Usage: (declare-names & syms)

Declare names, similar to declare but on the type level.

declare-protocols

Usage: (declare-protocols & syms)

Declare protocols, similar to declare but on the type level.

def-alias

Usage: (def-alias sym type)

Define a type alias

fi

Usage: (fi t)

All index variables in type (dotted bounds, etc.)

fn>

Usage: (fn> & forms)

Define a typed anonymous function.
(fn> name? :- type? [[param :- type]* & [param :- type *]?] exprs*)
(fn> name? (:- type? [[param :- type]* & [param :- type *]?] exprs*)+)

free-in-scope

Usage: (free-in-scope name)

Find the free scoped as name

free-in-scope-bnds

Usage: (free-in-scope-bnds name)

Find the bounds for the free scoped as name

free-with-name

Usage: (free-with-name name)

Find the free with the actual name name, as opposed to
the alias used for scoping

free-with-name-bnds

Usage: (free-with-name-bnds name)

Find the bounds for the free with the actual name name, as opposed to
the alias used for scoping

fv

Usage: (fv t)

All frees in type

idx-variances

Usage: (idx-variances t)

Map of indexes to their variances

inst

Usage: (inst inst-of & types)

Instantiate a polymorphic type with a number of types

inst-ctor

Usage: (inst-ctor inst-of & types)

Instantiate a call to a constructor with a number of types.
First argument must be an immediate call to a constructor.

instantiate-many

Usage: (instantiate-many images sc)

instantiate-many : List[Symbols] Scope^n -> Type
Instantiate de Bruijn indices in sc to frees named by
images, preserving upper/lower bounds

into-array>

Usage: (into-array> cljt coll)
       (into-array> javat cljt coll)

Make a Java array with Java class javat and Typed Clojure type
cljt. Resulting array will be of type javat, but elements of coll must be under
cljt. cljt should be a subtype of javat (the same or more specific).

loop>

Usage: (loop> bndings* & forms)

Define a typed loop

make-F

Usage: (make-F name)

Make a free variable 

make-Function

Usage: (make-Function dom rng)
       (make-Function dom rng rest)
       (make-Function dom rng rest drest & {:keys [filter object kws]})

Make a function, wrap range type in a Result.
Accepts optional :filter and :object parameters that default to the most general filter
and EmptyObject

make-Result

Usage: (make-Result t)
       (make-Result t f)
       (make-Result t f o)

Make a result. ie. the range of a Function

manual-inst

Usage: (manual-inst ptype argtys)

Poly Type^n -> Type
Substitute the type parameters of the polymorphic type
with given types

map->AndFilter

Usage: (map->AndFilter {:as kwargs__2627__auto__, :keys [fs]})

map->AnyValue

Usage: (map->AnyValue {:as kwargs__2627__auto__, :keys []})

map->App

Usage: (map->App {:as kwargs__2627__auto__, :keys [rator rands]})

map->ArrayCLJS

Usage: (map->ArrayCLJS {:as kwargs__2627__auto__, :keys []})

map->B

Usage: (map->B {:as kwargs__2627__auto__, :keys [idx]})

map->BooleanCLJS

Usage: (map->BooleanCLJS {:as kwargs__2627__auto__, :keys []})

map->BotFilter

Usage: (map->BotFilter {:as kwargs__2627__auto__, :keys []})

map->Bounds

Usage: (map->Bounds {:as kwargs__2627__auto__, :keys [upper-bound lower-bound higher-kind]})

map->ClassPE

Usage: (map->ClassPE {:as kwargs__2627__auto__, :keys []})

map->CountPE

Usage: (map->CountPE {:as kwargs__2627__auto__, :keys []})

map->CountRange

Usage: (map->CountRange {:as kwargs__2627__auto__, :keys [lower upper]})

map->DataType

Usage: (map->DataType {:as kwargs__2627__auto__, :keys [the-class variances poly? fields]})

map->DottedPretype

Usage: (map->DottedPretype {:as kwargs__2627__auto__, :keys [pre-type name]})

map->EmptyObject

Usage: (map->EmptyObject {:as kwargs__2627__auto__, :keys []})

map->F

Usage: (map->F {:as kwargs__2627__auto__, :keys [name]})

map->FilterSet

Usage: (map->FilterSet {:as kwargs__2627__auto__, :keys [then else]})

map->FirstPE

Usage: (map->FirstPE {:as kwargs__2627__auto__, :keys []})

map->FlowSet

Usage: (map->FlowSet {:as kwargs__2627__auto__, :keys [normal]})

map->FnIntersection

Usage: (map->FnIntersection {:as kwargs__2627__auto__, :keys [types]})

map->FnResult

Usage: (map->FnResult {:as kwargs__2627__auto__, :keys [args kws rest drest body]})

map->Function

Usage: (map->Function {:as kwargs__2627__auto__, :keys [dom rng rest drest kws]})

map->FunctionCLJS

Usage: (map->FunctionCLJS {:as kwargs__2627__auto__, :keys []})

map->GTRange

Usage: (map->GTRange {:as kwargs__2627__auto__, :keys [n]})

map->HeterogeneousList

Usage: (map->HeterogeneousList {:as kwargs__2627__auto__, :keys [types]})

map->HeterogeneousMap

Usage: (map->HeterogeneousMap {:as kwargs__2627__auto__, :keys [types other-entries]})

map->HeterogeneousSeq

Usage: (map->HeterogeneousSeq {:as kwargs__2627__auto__, :keys [types]})

map->HeterogeneousVector

Usage: (map->HeterogeneousVector {:as kwargs__2627__auto__, :keys [types]})

map->ImpFilter

Usage: (map->ImpFilter {:as kwargs__2627__auto__, :keys [a c]})

map->Intersection

Usage: (map->Intersection {:as kwargs__2627__auto__, :keys [types]})

map->KeyPE

Usage: (map->KeyPE {:as kwargs__2627__auto__, :keys [val]})

map->KwArgs

Usage: (map->KwArgs {:as kwargs__2627__auto__, :keys [mandatory optional]})

map->LTRange

Usage: (map->LTRange {:as kwargs__2627__auto__, :keys [n]})

map->ListDots

Usage: (map->ListDots {:as kwargs__2627__auto__, :keys [pre-type bound]})

map->Mu

Usage: (map->Mu {:as kwargs__2627__auto__, :keys [scope]})

map->Name

Usage: (map->Name {:as kwargs__2627__auto__, :keys [id]})

map->NextPE

Usage: (map->NextPE {:as kwargs__2627__auto__, :keys []})

map->NoFilter

Usage: (map->NoFilter {:as kwargs__2627__auto__, :keys []})

map->NoObject

Usage: (map->NoObject {:as kwargs__2627__auto__, :keys []})

map->NotType

Usage: (map->NotType {:as kwargs__2627__auto__, :keys [type]})

map->NotTypeFilter

Usage: (map->NotTypeFilter {:as kwargs__2627__auto__, :keys [type path id]})

map->NumberCLJS

Usage: (map->NumberCLJS {:as kwargs__2627__auto__, :keys []})

map->ObjectCLJS

Usage: (map->ObjectCLJS {:as kwargs__2627__auto__, :keys []})

map->OrFilter

Usage: (map->OrFilter {:as kwargs__2627__auto__, :keys [fs]})

map->Path

Usage: (map->Path {:as kwargs__2627__auto__, :keys [path id]})

map->Poly

Usage: (map->Poly {:as kwargs__2627__auto__, :keys [nbound bbnds scope actual-frees]})

map->PolyDots

Usage: (map->PolyDots {:as kwargs__2627__auto__, :keys [nbound bbnds scope]})

map->PrimitiveArray

Usage: (map->PrimitiveArray {:as kwargs__2627__auto__, :keys [jtype input-type output-type]})

map->Projection

Usage: (map->Projection {:as kwargs__2627__auto__, :keys [afn ts]})

map->PropEnv

Usage: (map->PropEnv {:as kwargs__2627__auto__, :keys [l props]})

map->Protocol

Usage: (map->Protocol {:as kwargs__2627__auto__, :keys [the-var variances poly? on-class methods]})

map->RClass

Usage: (map->RClass {:as kwargs__2627__auto__, :keys [variances poly? the-class replacements]})

map->Record

Usage: (map->Record {:as kwargs__2627__auto__, :keys [the-class fields]})

map->RecurTarget

Usage: (map->RecurTarget {:as kwargs__2627__auto__, :keys [dom rest drest kws]})

map->Result

Usage: (map->Result {:as kwargs__2627__auto__, :keys [t fl o]})

map->Scope

Usage: (map->Scope {:as kwargs__2627__auto__, :keys [body]})

map->StringCLJS

Usage: (map->StringCLJS {:as kwargs__2627__auto__, :keys []})

map->SymbolCLJS

Usage: (map->SymbolCLJS {:as kwargs__2627__auto__, :keys []})

map->TApp

Usage: (map->TApp {:as kwargs__2627__auto__, :keys [rator rands]})

map->TCResult

Usage: (map->TCResult {:as kwargs__2627__auto__, :keys [t fl o flow]})

map->Top

Usage: (map->Top {:as kwargs__2627__auto__, :keys []})

map->TopFilter

Usage: (map->TopFilter {:as kwargs__2627__auto__, :keys []})

map->TopFunction

Usage: (map->TopFunction {:as kwargs__2627__auto__, :keys []})

map->TypeFilter

Usage: (map->TypeFilter {:as kwargs__2627__auto__, :keys [type path id]})

map->TypeFn

Usage: (map->TypeFn {:as kwargs__2627__auto__, :keys [nbound variances bbnds scope]})

map->Union

Usage: (map->Union {:as kwargs__2627__auto__, :keys [types]})

map->Value

Usage: (map->Value {:as kwargs__2627__auto__, :keys [val]})

map->c

Usage: (map->c {:as kwargs__2627__auto__, :keys [S X T bnds]})

map->cset

Usage: (map->cset {:as kwargs__2627__auto__, :keys [maps]})

map->cset-entry

Usage: (map->cset-entry {:as kwargs__2627__auto__, :keys [fixed dmap projections]})

map->dcon

Usage: (map->dcon {:as kwargs__2627__auto__, :keys [fixed rest]})

map->dcon-dotted

Usage: (map->dcon-dotted {:as kwargs__2627__auto__, :keys [fixed dc dbound]})

map->dcon-exact

Usage: (map->dcon-exact {:as kwargs__2627__auto__, :keys [fixed rest]})

map->dmap

Usage: (map->dmap {:as kwargs__2627__auto__, :keys [map]})

map->i-subst

Usage: (map->i-subst {:as kwargs__2627__auto__, :keys [types]})

map->i-subst-dotted

Usage: (map->i-subst-dotted {:as kwargs__2627__auto__, :keys [types dty dbound]})

map->i-subst-starred

Usage: (map->i-subst-starred {:as kwargs__2627__auto__, :keys [types starred]})

map->t-subst

Usage: (map->t-subst {:as kwargs__2627__auto__, :keys [type bnds]})

method-type

Usage: (method-type mname)

Given a method symbol, print the core.typed types assigned to it

nilable-param

Usage: (nilable-param msym mmap)

Overrides which parameters in a method may accept
nilable values. If the parameter is a parameterised type or
an Array, this also declares the parameterised types and the Array type as nilable.

mmap is a map mapping arity parameter number to a set of parameter
positions (integers). If the map contains the key :all then this overrides
other entries. The key can also be :all, which declares all parameters nilable.

non-nil-return

Usage: (non-nil-return msym arities)

Override the return type of method msym to be non-nil.
Takes a set of relevant arities,
represented by the number of parameters it takes (rest parameter counts as one),
or :all which overrides all arities.

eg.  (non-nil-return java.lang.Class/getDeclaredMethod :all)

open-Result

Usage: (open-Result {t :t, fs :fl, old-obj :o, :as r} objs & [ts])

Substitute ids for objs in Result t

pfn>

Usage: (pfn> & forms)

Define a polymorphic typed anonymous function.
(pfn> name? [binder+] :- type? [[param :- type]* & [param :- type *]?] exprs*)
(pfn> name? [binder+] (:- type? [[param :- type]* & [param :- type *]?] exprs*)+)

print-filterset

Usage: (print-filterset debug-string frm)

Print the filter set attached to form, and debug-string

relevant-Fns

Usage: (relevant-Fns required-params rest-param fin)

Given a set of required-param exprs, rest-param expr, and a FnIntersection,
returns a seq of Functions containing Function types
whos arities could be a subtype to the method with the fixed and rest parameters given

ret

Usage: (ret t)
       (ret t f)
       (ret t f o)
       (ret t f o flow)

Convenience function for returning the type of an expression

scope-depth?

Usage: (scope-depth? scope depth)

True if scope is has depth number of scopes nested

simplify-prop

Usage: (simplify-prop a b)

Try and use atomic proposition a to simplify composite
proposition b. a must be correct polarity.

subtypes-varargs?

Usage: (subtypes-varargs? argtys dom rst)

True if argtys are under dom

symbol->Class

Usage: (symbol->Class sym)

Returns the Class represented by the symbol. Works for
primitives (eg. byte, int). Does not further resolve the symbol.

tc-ignore

Usage: (tc-ignore & body)

Ignore forms in body during type checking

unwrap-datatype

Usage: (unwrap-datatype dt nms)
       (unwrap-datatype dt)

Takes a possibly polymorphic DataType and returns the 
DataType after instantiating it

unwrap-poly

Usage: (unwrap-poly t)

Return a pair vector of the instantiated body of the possibly polymorphic
type and the names used