CrossClj

0.5.3 docs

SourceDocs


project

docs index

NAMESPACES
clojure.core.typed
collect
test
CTYP-234
ann-qualify
ctyp-294
fail
gradual
succeed

RECENT
    VARS
    add-cast
    already-checked?
    check-deps
    check-ns-and-deps*
    checked-ns!
    Constructor->Function
    DataType-ctor-type
    datatype-method-expected
    default-defmethod?
    error-ret
    expected-error
    expr-ns
    extend-method-expected
    Field->Type
    FieldExpr->Field
    find-updated-locals
    fn-self-name
    get-demunged-protocol-method
    hvec->rets
    instance-method->Function
    Java-symbol->Type
    KeyPE->Type
    map->TCResult
    Method->symbol
    Method->Type
    method-map?
    method-nilable-param?
    method-nonnilable-return?
    MethodExpr->Method
    MethodExpr->qualsym
    NewExpr->Ctor
    not-special
    protocol-implementation-type
    record-hidden-fields
    record-implicits
    relevant-Fns
    rewrap-poly
    should-rewrite?
    symbol->PArray
    TCResult->map
    Type->Class
    unwrap-datatype
    unwrap-poly

    « Index of all namespaces of this project

    (add-cast {:keys [env], :as expr} t {:keys [positive negative line column], :as opt})
    Given an AST node and a type, return a new AST that
    casts the original expression to the given type
    (already-checked? nsym)
    (check-deps nsym {:keys [check-ns], :as config})
    (check-ns-and-deps* nsym {:keys [ast-for-ns check-asts check-ns], :as config})
    Type check a namespace and its dependencies.
    Assumes type annotations in each namespace
    has already been collected.
    Private
    (checked-ns! nsym)
    (Constructor->Function {:keys [declaring-class parameter-types], :as ctor})
    (DataType-ctor-type sym)
    (datatype-method-expected datatype method-sig)
    (default-defmethod? var dispatch-val)
    (error-ret expected)
    Return a TCResult appropriate for when a type
    error occurs, with expected type expected.
    
    Use *only* in case of a type error.
    (expected-error actual expected & opt)
    (expr-ns expr)
    (extend-method-expected target-type expected)
    Returns the expected type with target-type intersected with the first argument
    
    (Field->Type {:keys [type flags], :as field})
    (FieldExpr->Field expr)
    (find-updated-locals env1 env2)
    (fn-self-name {:keys [op], :as fexpr})
    Private
    (get-demunged-protocol-method unwrapped-p mungedsym)
    Private
    (instance-method->Function {:keys [parameter-types declaring-class return-type], :as method})
    (Java-symbol->Type sym nilable?)
    (map->TCResult expected)
    (Method->symbol {name-sym :name, :keys [declaring-class], :as method})
    (Method->Type {:keys [parameter-types return-type flags], :as method})
    (method-nilable-param? msym nparams n)
    (method-nonnilable-return? msym nparams)
    (MethodExpr->Method expr)
    (MethodExpr->qualsym {c :class, :keys [op method], :as expr})
    (NewExpr->Ctor expr)
    (protocol-implementation-type datatype {:keys [declaring-class], :as method-sig})
    (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
    (rewrap-poly body inst-frees bnds poly?)
    Private
    (symbol->PArray sym nilable?)
    (TCResult->map ret)
    (unwrap-datatype dt nms)(unwrap-datatype dt)
    Takes a DataType that might be wrapped in a TypeFn and returns the 
    DataType after instantiating it
    (unwrap-poly t)
    Return a pair vector of the instantiated body of the possibly polymorphic
    type and the names used