CrossClj

1.10.339 docs

SourceDocs



RECENT
    VARS
    *coll-check-limit*
    *coll-error-limit*
    *compile-asserts*
    *explain-out*
    *fspec-iterations*
    *recursion-limit*
    *runtime-asserts*
    ->sym
    abbrev
    accept
    accept-nil?
    accept?
    add-ret
    alt*
    alt-impl
    alt2
    alts
    amp-impl
    and-preds
    and-spec-impl
    assert*
    call-valid?
    cat-impl
    check-asserts
    check-asserts?
    coll-prob
    conform
    deep-resolve
    def-impl
    deriv
    describe
    dt
    every-impl
    exercise
    explain
    explain-1
    explain-data
    explain-data*
    explain-out
    explain-pred-list
    explain-printer
    explain-str
    filter-alt
    form
    fspec-impl
    gen
    gensub
    get-spec
    inck
    inst-in-range?
    int-in-range?
    invalid?
    macroexpand-check
    map-spec
    map-spec-impl
    MAX_INT
    maybe-impl
    maybe-spec
    merge-spec-impl
    multi-spec-impl
    nilable-impl
    nonconforming
    noret?
    op-describe
    op-explain
    op-unform
    or-spec-impl
    pcat
    pcat*
    preturn
    pvalid?
    re-conform
    re-explain
    re-gen
    recur-limit?
    reg-resolve
    reg-resolve!
    regex-spec-impl
    regex?
    registry
    registry-ref
    rep*
    rep+impl
    rep-impl
    Spec
    spec-impl
    spec-name
    spec?
    Specize
    specize
    tagged-ret
    the-spec
    tuple-impl
    unform
    valid?
    validate-fn
    with-gen
    with-name

    « Index of all namespaces of this project

    Dynamic
    The number of items validated in a collection spec'ed with 'every'
    
    Dynamic
    The number of errors reported by explain in a collection spec'ed with 'every'
    
    Dynamic
    If true, compiler will enable spec asserts, which are then
    subject to runtime control via check-asserts? If false, compiler
    will eliminate all spec assert overhead. See 'assert'.
    Initially set to the negation of the ':elide-asserts' compiler option.
    Defaults to true.
    Dynamic
    The number of times an anonymous fn specified by fspec will be (generatively) tested during conform
    
    Dynamic
    A soft limit on how many times a branching spec (or/alt/*/opt-keys/multi-spec)
    can be recursed through during generation. After this a
    non-recursive branch will be chosen.
    Private
    (->sym x)
    Returns a symbol from a symbol or var
    
    (abbrev form)
    Private
    (accept x)
    Private
    (accept-nil? p)
    Private
    (accept? {:keys [:cljs.spec.alpha/op]})
    Private
    (add-ret p r k)
    Private
    (alt* ps ks forms)
    (alt-impl ks ps forms)
    Do not call this directly, use 'alt'
    
    Private
    (alt2 p1 p2)
    Private
    (alts & ps)
    (amp-impl re preds pred-forms)
    Do not call this directly, use '&'
    
    Private
    (and-preds x preds forms)
    (and-spec-impl forms preds gfn)
    Do not call this directly, use 'and'
    
    (assert* spec x)
    Do not call this directly, use 'assert'.
    
    Private
    (call-valid? f specs args)
    (cat-impl ks ps forms)
    Do not call this directly, use 'cat'
    
    (check-asserts flag)
    Enable or disable spec asserts that have been compiled
    with '*compile-asserts*' true.  See 'assert'.
    Initially set to boolean value of cljs.spec.alpha/*runtime-asserts*.
    Defaults to false.
    (check-asserts?)
    Returns the value set by check-asserts.
    
    Private
    (coll-prob x kfn kform distinct count min-count max-count path via in)
    (conform spec x)
    Given a spec and a value, returns :cljs.spec.alpha/invalid if value does
    not match spec, else the (possibly destructured) value.
    Private
    (deep-resolve reg k)
    (def-impl k form spec)
    Do not call this directly, use 'def'
    
    Private
    (deriv p x)
    (describe spec)
    returns an abbreviated description of the spec as data
    
    Private
    (dt ???)(dt ???)(dt ???)(dt ???)
    (every-impl ???)(every-impl ???)(every-impl ???)(every-impl ???)
    Do not call this directly, use 'every', 'every-kv', 'coll-of' or 'map-of'
    
    (exercise ???)(exercise ???)
    generates a number (default 10) of values compatible with spec and maps conform over them,
    returning a sequence of [val conformed-val] tuples. Optionally takes
    a generator overrides map as per gen
    (explain spec x)
    Given a spec and a value that fails to conform, prints an explanation to *out*.
    
    Private
    (explain-1 form pred path via in v)
    (explain-data spec x)
    Given a spec and a value x which ought to conform, returns nil if x
    conforms, else a map with at least the key ::problems whose value is
    a collection of problem-maps, where problem-map has at least :path :pred and :val
    keys describing the predicate and the value that failed at that
    path.
    (explain-data* spec path via in x)
    (explain-out ed)
    Prints explanation data (per 'explain-data') to *out* using the printer in *explain-out*,
    by default explain-printer.
    Private
    (explain-pred-list forms preds path via in x)
    (explain-printer ed)
    Default printer for explain-data. nil indicates a successful validation.
    
    (explain-str spec x)
    Given a spec and a value that fails to conform, returns an explanation as a string.
    
    Private
    (filter-alt ps ks forms f)
    (form spec)
    returns the spec as data
    
    (fspec-impl argspec aform retspec rform fnspec fform gfn)
    Do not call this directly, use 'fspec'
    
    (gen ???)(gen ???)
    Given a spec, returns the generator for it, or throws if none can
    be constructed. Optionally an overrides map can be provided which
    should map spec names or paths (vectors of keywords) to no-arg
    generator-creating fns. These will be used instead of the generators at those
    names/paths. Note that parent generator (in the spec or overrides
    map) will supersede those of any subtrees. A generator for a regex
    op must always return a sequential collection (i.e. a generator for
    s/? should return either an empty sequence/vector or a
    sequence/vector with one item in it)
    Private
    (gensub spec overrides path rmap form)
    (get-spec k)
    Returns spec registered for keyword/symbol/var k, or nil.
    
    Private
    (inck m k)
    (inst-in-range? start end inst)
    Return true if inst at or after start and before end
    
    (int-in-range? start end val)
    Return true if start <= val, val < end and val is a fixed
    precision integer.
    (invalid? ret)
    tests the validity of a conform return value
    
    Private
    (macroexpand-check v args)
    (map-spec-impl {:keys [req-un opt-un keys-pred pred-exprs opt-keys req-specs req req-keys opt-specs pred-forms opt gfn], :as argm})
    Do not call this directly, use 'spec' with a map argument
    
    (maybe-impl p form)
    Do not call this directly, use '?'
    
    Private
    (maybe-spec spec-or-k)
    spec-or-k must be a spec, regex or resolvable kw/sym, else returns nil.
    
    (merge-spec-impl forms preds gfn)
    Do not call this directly, use 'merge'
    
    (multi-spec-impl ???)(multi-spec-impl ???)(multi-spec-impl ???)(multi-spec-impl ???)
    Do not call this directly, use 'multi-spec'
    
    (nilable-impl form pred gfn)
    Do not call this directly, use 'nilable'
    
    (nonconforming spec)
    takes a spec and returns a spec that has the same properties except
    'conform' returns the original (not the conformed) value. Note, will specize regex ops.
    Private
    (noret? p1 pret)
    Private
    (op-describe p)
    Private
    (op-explain form p path via in input)
    Private
    (op-unform p x)
    (or-spec-impl keys forms preds gfn)
    Do not call this directly, use 'or'
    
    Private
    (pcat & ps)
    Private
    (pcat* {[p1 & pr :as ps] :ps, [k1 & kr :as ks] :ks, [f1 & fr :as forms] :forms, ret :ret, rep+ :rep+})
    Private
    (preturn p)
    Private
    (pvalid? ???)(pvalid? ???)(pvalid? ???)
    internal helper function that returns true when x is valid for spec.
    
    Private
    (re-conform p [x & xs :as data])
    Private
    (re-explain path via in re input)
    Private
    (re-gen p overrides path rmap f)
    Private
    (recur-limit? rmap id path k)
    Private
    (reg-resolve k)
    returns the spec/regex at end of alias chain starting with k, nil if not found, k if k not ident
    
    Private
    (reg-resolve! k)
    returns the spec/regex at end of alias chain starting with k, throws if not found, k if k not ident
    
    (regex-spec-impl re gfn)
    Do not call this directly, use 'spec' with a regex op argument
    
    (regex? x)
    returns x if x is a (cljs.spec.alpha) regex op, else logical false
    
    (registry)
    returns the registry map, prefer 'get-spec' to lookup a spec by name
    
    Private
    (rep* p1 p2 ret splice form)
    (rep+impl form p)
    Do not call this directly, use '+'
    
    (rep-impl form p)
    Do not call this directly, use '*'
    
    protocol
    (describe* spec)
    (with-gen* spec gfn)
    (unform* spec y)
    (gen* spec overrides path rmap)
    (conform* spec x)
    (explain* spec path via in x)
    (spec-impl ???)(spec-impl ???)(spec-impl ???)(spec-impl ???)(spec-impl ???)
    Do not call this directly, use 'spec'
    
    Private
    (spec-name spec)
    (spec? x)
    returns x if x is a spec object, else logical false
    
    protocol
    (specize* ???)(specize* ???)
    Private
    (specize ???)(specize ???)
    Private
    (tagged-ret v)
    Private
    (the-spec spec-or-k)
    spec-or-k must be a spec, regex or kw/sym, else returns nil. Throws if unresolvable kw/sym
    
    (tuple-impl ???)(tuple-impl ???)(tuple-impl ???)
    Do not call this directly, use 'tuple'
    
    (unform spec x)
    Given a spec and a value created by or compliant with a call to
    'conform' with the same spec, returns a value with all conform
     destructuring undone.
    (valid? ???)(valid? ???)(valid? ???)
    Helper function that returns true when x is valid for spec.
    
    Private
    (validate-fn f specs iters)
    returns f if valid, else smallest
    
    (with-gen spec gen-fn)
    Takes a spec and a no-arg, generator-returning fn and returns a version of that spec that uses that generator
    
    Private
    (with-name spec name)