*verbose-forms*

If true, print complete forms in error messages.

*verbose-types*

If true, print fully qualified types in error messages
and return values.

-base-aliases

Internal use only.

-init-delayed-errors

Usage: (-init-delayed-errors)

Internal use only

ann

Usage: (ann varsym typesyn)

Annotate varsym with type. If unqualified, qualify in the current namespace.
If varsym has metadata {:nocheck true}, ignore definitions of varsym while type checking.

ann*

Usage: (ann* varsym typesyn check?)

Internal use only. Use ann.

ann-datatype

Usage: (ann-datatype dname fields & {ancests :unchecked-ancestors, rplc :replace, :as opts})

Annotate datatype Class name dname with expected fields.
If unqualified, qualify in the current namespace.

ann-datatype*

Usage: (ann-datatype* dname fields opts)

Internal use only. Use ann-datatype.

ann-form

Usage: (ann-form form ty)

Annotate a form with an expected type.

ann-form*

Usage: (ann-form* form ty)

Internal use only. Use ann-form.

ann-pdatatype

Usage: (ann-pdatatype dname vbnd fields & {ancests :unchecked-ancestors, rplc :replace, :as opt})

Annotate datatype Class name dname with a polymorphic binder and expected fields.
If unqualified, qualify in the current namespace.

ann-pdatatype*

Usage: (ann-pdatatype* dname vbnd fields opt)

Internal use only. Use ann-pdatatype.

ann-pprotocol

Usage: (ann-pprotocol varsym vbnd & {:as mth})

Annotate polymorphic protocol with a polymorphic binder and method types.

ann-pprotocol*

Usage: (ann-pprotocol* varsym vbnd mth)

Internal use only. Use ann-pprotocol.

ann-precord

Usage: (ann-precord dname vbnd fields & {ancests :unchecked-ancestors, rplc :replace, :as opt})

Annotate record Class name dname with a polymorphic binder and expected fields.
If unqualified, qualify in the current namespace.

ann-precord*

Usage: (ann-precord* dname vbnd fields opt)

Internal use only. Use ann-precord.

ann-protocol

Usage: (ann-protocol varsym & {:as mth})

Annotate protocol var with method types.

eg. (ann-protocol IFoo
      bar
      [IFoo -> Any]
      baz
      [IFoo -> Number])

ann-protocol*

Usage: (ann-protocol* varsym mth)

Internal use only. Use ann-protocol.

ann-record

Usage: (ann-record dname fields & {ancests :unchecked-ancestors, rplc :replace, :as opt})

Annotate record Class name dname with expected fields.
If unqualified, qualify in the current namespace.

ann-record*

Usage: (ann-record* dname fields opt)

Internal use only. Use ann-record

cf

Usage: (cf form)
       (cf form expected)

Type check a Clojure form and return its type

check-ns

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

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

Bind *verbose-types* to true to print fully qualified types.
Bind *verbose-forms* to print full forms in error messages.

declare-alias-kind

Usage: (declare-alias-kind sym ty)

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

declare-alias-kind*

Usage: (declare-alias-kind* sym ty)

Internal use only. Use declare-alias-kind.

declare-datatypes

Usage: (declare-datatypes & syms)

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

declare-datatypes*

Usage: (declare-datatypes* nms)

Internal use only. Use declare-datatypes.

declare-names

Usage: (declare-names & syms)

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

declare-names*

Usage: (declare-names* syms)

Internal use only. Use declare-names.

declare-protocols

Usage: (declare-protocols & syms)

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

declare-protocols*

Usage: (declare-protocols* syms)

Internal use only. Use declare-protocols.

def-alias

Usage: (def-alias sym doc-str type)
       (def-alias sym type)

Define a type alias. Takes an optional doc-string as a second
argument.

def-alias*

Usage: (def-alias* sym type)

Internal use only. Use def-alias.

doseq>

Usage: (doseq> seq-exprs & body)

Like doseq but requires annotation for each loop variable: 
[a [1 2]] becomes [a :- Long [1 2]]

eg.
(doseq> [a :- (U nil AnyInteger) [1 nil 2 3]
         :when a]
   (inc a))

dotimes>

Usage: (dotimes> bindings & body)

Like dotimes.

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*)+)

fn>-ann

Usage: (fn>-ann fn-of param-types-syn)

Internal use only. Use fn>.

for>

Usage: (for> tk ret-ann seq-exprs body-expr)

Like for but requires annotation for each loop variable: [a [1 2]] becomes [a :- Long [1 2]]
Also requires annotation for return type.

eg.
(for> :- Number
      [a :- (U nil AnyInteger) [1 nil 2 3]
       :when a]
   (inc a))

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.

inst-poly

Usage: (inst-poly inst-of types-syn)

Internal use only. Use inst.

inst-poly-ctor

Usage: (inst-poly-ctor inst-of types-syn)

Internal use only. Use inst-ctor

into-array>

Usage: (into-array> cljt coll)
       (into-array> javat cljt coll)
       (into-array> into-array-syn 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).

*Temporary hack*
into-array-syn is exactly the syntax to put as the first argument to into-array.
Calling resolve on this syntax should give the correct class.

into-array>*

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

Internal use only. Use into-array>.

letfn>

Usage: (letfn> bindings & body)

Like letfn, but each binding must be annotated.

eg.
(letfn> [a :- [Number -> Number]
         (a [b] 2)
         c :- [Symbol -> nil]
         (c [s] nil)]
  ...)

load-if-needed

Usage: (load-if-needed)

Load and initialize all of core.typed if not already

loop>

Usage: (loop> bndings* & forms)

Like loop, except loop variables require annotation.

eg. (loop> [a :- Number 1
            b :- (U nil Number) nil]
      ...)

loop>-ann

Usage: (loop>-ann loop-of bnding-types)

Internal use only. Use loop>

method-type

Usage: (method-type mname)

Given a method symbol, print the core.typed types assigned to it.
Intended for use at the REPL.

nilable-param

Usage: (nilable-param msym mmap)

Override which parameters in qualified method msym 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.

nilable-param*

Usage: (nilable-param* msym mmap)

Internal use only. Use nilable-param.

non-nil-return

Usage: (non-nil-return msym arities)

Override the return type of qualified 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)

non-nil-return*

Usage: (non-nil-return* msym arities)

Internal use only. Use non-nil-return.

override-constructor

Usage: (override-constructor ctorsym typesyn)

Override all constructors for Class ctorsym with type.

override-constructor*

Usage: (override-constructor* ctorsym typesyn)

Internal use only. Use override-constructor.

override-method

Usage: (override-method methodsym typesyn)

Override type for qualified method methodsym.

override-method*

Usage: (override-method* methodsym typesyn)

Internal use only. Use override-method.

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*)+)

pfn>-ann

Usage: (pfn>-ann fn-of polys param-types-syn)

Internal use only. Use pfn>.

print-env

Usage: (print-env debug-str)

During type checking, print the type environment to *out*,
preceeded by literal string debug-str.

print-filterset

Usage: (print-filterset debug-string frm)

During type checking, print the filter set attached to form, 
preceeded by literal string debug-string

tc-ignore

Usage: (tc-ignore & body)

Ignore forms in body during type checking

tc-ignore-forms*

Usage: (tc-ignore-forms* r)

Internal use only. Use tc-ignore

typed-deps

Usage: (typed-deps & args)

Declare namespaces which should be checked before the current namespace.
Accepts any number of symbols.

typed-deps*

Usage: (typed-deps* args)

Internal use only. Use typed-deps.

ast-for-form

Usage: (ast-for-form form)

Returns an AST node for the form

ast-for-form-in-ns

Usage: (ast-for-form-in-ns nsym form)

Returns an AST node for the form 
analyzed in the given namespace

ast-for-ns

Usage: (ast-for-ns nsym)

Returns a vector of AST nodes contained
in the given namespace symbol nsym

FnResult

RecurTarget

->FnResult

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

->RecurTarget

Usage: (->RecurTarget dom rest drest kws)

check-fn

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

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

check-ns-and-deps

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

Type check a namespace and its dependencies.
Assumes type annotations in each namespace
has already been collected.

ctor-Class->symbol

Usage: (ctor-Class->symbol cls)

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

map->FnResult

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

map->RecurTarget

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

open-Result

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

Substitute ids for objs in Result t

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

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

collect-ns

Usage: (collect-ns nsym)

Collect type annotations and dependency information
for namespace symbol nsym, and recursively check 
declared typed namespace dependencies.

c

cset

cset-entry

dcon

dcon-dotted

dcon-exact

dmap

i-subst

i-subst-dotted

i-subst-starred

t-subst

->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)

->t-subst

Usage: (->t-subst type bnds)

DCon

(U dcon dcon-exact dcon-dotted)

FreeBnds

A map of free variable names to their bounds.

(IPersistentMap Symbol Bounds)

SubstMap

A substutition map of symbols naming frees to types
  to instantitate them with.

(IPersistentMap Symbol SubstRHS)

SubstRHS

The substitution records.

(U t-subst i-subst i-subst-starred i-subst-dotted)

map->c

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

map->cset

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

map->cset-entry

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

map->dcon

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

map->dcon-dotted

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

map->dcon-exact

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

map->dmap

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

map->i-subst

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

map->i-subst-dotted

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

map->i-subst-starred

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

map->t-subst

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

DataTypeEnv

An Environment mapping datatype symbols to types.

(IPersistentMap Symbol r/TCType)

get-datatype

Usage: (get-datatype sym)

Get the datatype with class symbol sym.
Returns nil if not found.

resolve-datatype

Usage: (resolve-datatype sym)

Same as get-datatype, but fails if datatype is not found.

simplify-prop

Usage: (simplify-prop a b)

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

AndFilter

BotFilter

FilterSet

ImpFilter

NoFilter

NotTypeFilter

OrFilter

TopFilter

TypeFilter

->AndFilter

Usage: (->AndFilter fs)

->BotFilter

Usage: (->BotFilter)

->FilterSet

Usage: (->FilterSet then else)

->ImpFilter

Usage: (->ImpFilter a c)

->NoFilter

Usage: (->NoFilter)

->NotTypeFilter

Usage: (->NotTypeFilter type path id)

->OrFilter

Usage: (->OrFilter fs)

->TopFilter

Usage: (->TopFilter)

->TypeFilter

Usage: (->TypeFilter type path id)

NameRef

A name for a type variable, either a symbol or a number.

(U Symbol Number)

map->AndFilter

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

map->BotFilter

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

map->FilterSet

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

map->ImpFilter

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

map->NoFilter

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

map->NotTypeFilter

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

map->OrFilter

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

map->TopFilter

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

map->TypeFilter

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

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

with-bounded-frees

Usage: (with-bounded-frees bfrees & body)

Scopes bfrees, a map of instances of F to their bounds, inside body.

with-free-symbols

Usage: (with-free-symbols sfrees & body)

Scopes sfrees, a sequence of symbols, inside body as free variables, with default bounds.

with-frees

Usage: (with-frees frees & body)

Scopes frees, which are instances of F, inside body, with
default bounds.

fi

Usage: (fi t)

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

fv

Usage: (fv t)

All frees in type

fv-variances

Usage: (fv-variances t)

Map of frees to their variances

idx-variances

Usage: (idx-variances t)

Map of indexes to their variances

NoisyHole

->NoisyHole

Usage: (->NoisyHole)

Positional factory function for class clojure.core.typed.hole.NoisyHole.

noisy-hole

Usage: (noisy-hole)

A noisy hole. The type system will complain when
(noisy-hole) is used in positions that expect a type
more specific than Object or Any.
Use (noisy-hole) as a placeholder for code.
Throws an exception when evaluted.

silent-hole

Usage: (silent-hole)

A silent hole. (silent-hole) passes for any other type
when type checking.
Use (silent-hole) as a placeholder for code.
Throws an exception when evaluted.

manual-inst

Usage: (manual-inst ptype argtys)

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

PropEnv

->PropEnv

Usage: (->PropEnv l props)

map->PropEnv

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

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.

NameEnv

Environment mapping names to types. Keyword values are special.

(IPersistentMap Symbol (U Keyword r/TCType))

get-type-name

Usage: (get-type-name sym)

Return the name with var symbol sym.
Returns nil if not found.

DepMap

A map declaring possibly-circular namespace dependencies.

(IPersistentMap Symbol (IPersistentSet Symbol))

EmptyObject

NoObject

Path

->EmptyObject

Usage: (->EmptyObject)

->NoObject

Usage: (->NoObject)

->Path

Usage: (->Path path id)

map->EmptyObject

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

map->NoObject

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

map->Path

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

alias-in-ns

Usage: (alias-in-ns nsym ns)

Returns an alias for namespace sym in ns, or nil if none.

var-symbol-intern

Usage: (var-symbol-intern sym ns)

Returns a symbol interned in ns for var symbol, or nil if none.

(var-symbol-intern 'symbol (find-ns 'clojure.core))
;=> 'symbol
(var-symbol-intern 'bar (find-ns 'clojure.core))
;=> nil

ClassPE

CountPE

FirstPE

KeyPE

NextPE

->ClassPE

Usage: (->ClassPE)

->CountPE

Usage: (->CountPE)

->FirstPE

Usage: (->FirstPE)

->KeyPE

Usage: (->KeyPE val)

->NextPE

Usage: (->NextPE)

map->ClassPE

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

map->CountPE

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

map->FirstPE

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

map->KeyPE

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

map->NextPE

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

ProtocolEnv

A map mapping protocol symbols their types.

(IPersistentMap Symbol r/TCType)

get-protocol

Usage: (get-protocol sym)

Returns the protocol with var symbol sym.
Returns nil if not found.

get-rclass

Usage: (get-rclass csym)

Returns the RClass with class symbol csym.
Returns nil if not found.

class-isa?

Usage: (class-isa? s t)

A faster version of isa?, both parameters must be classes

subtypes-varargs?

Usage: (subtypes-varargs? argtys dom rst)

True if argtys are under dom

RClass-supers*

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

Return a set of ancestors to the RClass

TypeMap

A regular map with types as keys and vals.

(IPersistentMap TCType TCType)

abstract-many

Usage: (abstract-many names ty)

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

add-scopes

Usage: (add-scopes n t)

Wrap type in n Scopes

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

make-HMap

Usage: (make-HMap mandatory optional)
       (make-HMap mandatory optional complete?)

Generate a type which is every possible combination of mandatory
and optional key entries. Takes an optional third parameter which
is true if the entries are complete (ie. we know there are no more entries),
and false otherwise. Defaults to false.

remove-scopes

Usage: (remove-scopes n sc)

Unwrap n Scopes

AnyValue

App

B

Bounds

CountRange

DataType

DottedPretype

F

FlowSet

FnIntersection

Function

GTRange

HeterogeneousList

HeterogeneousMap

HeterogeneousSeq

HeterogeneousVector

Intersection

KwArgs

KwArgsSeq

LTRange

ListDots

Mu

Name

NotType

Poly

PolyDots

PrimitiveArray

Projection

Protocol

RClass

Result

Scope

TApp

TCError

TCResult

Top

TopFunction

TypeFn

Union

Value

->AnyValue

Usage: (->AnyValue)

->App

Usage: (->App rator rands)

->B

Usage: (->B idx)

->Bounds

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

->CountRange

Usage: (->CountRange lower upper)

->DataType

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

->DottedPretype

Usage: (->DottedPretype pre-type name)

->F

Usage: (->F name)

->FlowSet

Usage: (->FlowSet normal)

->FnIntersection

Usage: (->FnIntersection types)

->Function

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

->GTRange

Usage: (->GTRange n)

->HeterogeneousList

Usage: (->HeterogeneousList types)

->HeterogeneousMap

Usage: (->HeterogeneousMap types absent-keys other-keys?)

->HeterogeneousSeq

Usage: (->HeterogeneousSeq types)

->HeterogeneousVector

Usage: (->HeterogeneousVector types)

->Intersection

Usage: (->Intersection types)

->KwArgs

Usage: (->KwArgs mandatory optional)

->KwArgsSeq

Usage: (->KwArgsSeq mandatory optional)

->LTRange

Usage: (->LTRange n)

->ListDots

Usage: (->ListDots pre-type bound)

->Mu

Usage: (->Mu scope)

->Name

Usage: (->Name id)

->NotType

Usage: (->NotType type)

->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)

->Protocol

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

->RClass

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

->Scope

Usage: (->Scope body)

->TApp

Usage: (->TApp rator rands)

->TCError

Usage: (->TCError)

->TCResult

Usage: (->TCResult t fl o flow)

->Top

Usage: (->Top)

->TopFunction

Usage: (->TopFunction)

->TypeFn

Usage: (->TypeFn nbound variances bbnds scope)

->Union

Usage: (->Union types)

->Value

Usage: (->Value val)

TempFilterSet

Can't import FilterSet here, so an alias will do for now

clojure.core.typed.filter_rep.FilterSet

Variance

Keywords that represent a certain variance

(U ':constant ':covariant ':contravariant ':invariant ':dotted)

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 mandatory-kws optional-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

map->AnyValue

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

map->App

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

map->B

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

map->Bounds

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

map->CountRange

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

map->DataType

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

map->DottedPretype

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

map->F

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

map->FlowSet

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

map->FnIntersection

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

map->Function

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

map->GTRange

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

map->HeterogeneousList

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

map->HeterogeneousMap

Usage: (map->HeterogeneousMap {:as m#, :keys [types absent-keys other-keys?]})

map->HeterogeneousSeq

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

map->HeterogeneousVector

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

map->Intersection

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

map->KwArgs

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

map->KwArgsSeq

Usage: (map->KwArgsSeq {:as m#, :keys [mandatory optional]})

map->LTRange

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

map->ListDots

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

map->Mu

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

map->Name

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

map->NotType

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

map->Poly

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

map->PolyDots

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

map->PrimitiveArray

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

map->Projection

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

map->Protocol

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

map->RClass

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

map->Result

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

map->Scope

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

map->TApp

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

map->TCError

Usage: (map->TCError {:as m#, :keys []})

map->TCResult

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

map->Top

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

map->TopFunction

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

map->TypeFn

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

map->Union

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

map->Value

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

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

visit-bounds

Usage: (visit-bounds ty f)

Apply f to each element of bounds

ann-record

Usage: (ann-record nme & args)

Like ann-record, but also adds an unchecked annotation for core.contract's generated
nme? predicate.

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.

with-ex-info-handlers

Usage: (with-ex-info-handlers handlers & body)

Handle an ExceptionInfo e thrown in body. The first handler whos left hand
side returns true, then the right hand side is called passing (ex-info e) and e.