CrossClj

1.10.312 docs

SourceDocs



RECENT
    VARS
    *
    *1
    *2
    *3
    *assert*
    *clojurescript-version*
    *command-line-args*
    *e
    *flush-on-newline*
    *loaded-libs*
    *main-cli-fn*
    *ns*
    *out*
    *print-dup*
    *print-err-fn*
    *print-fn*
    *print-fn-bodies*
    *print-length*
    *print-level*
    *print-meta*
    *print-namespace-maps*
    *print-newline*
    *print-readably*
    *target*
    *unchecked-arrays*
    *unchecked-if*
    *warn-on-infer*
    +
    -
    ->ArrayChunk
    ->ArrayIter
    ->ArrayList
    ->ArrayNode
    ->ArrayNodeIterator
    ->ArrayNodeSeq
    ->Atom
    ->BitmapIndexedNode
    ->BlackNode
    ->Box
    ->ChunkBuffer
    ->ChunkedCons
    ->ChunkedSeq
    ->Cons
    ->Delay
    ->Eduction
    ->Empty
    ->EmptyList
    ->ES6EntriesIterator
    ->ES6Iterator
    ->ES6IteratorSeq
    ->ES6SetEntriesIterator
    ->HashCollisionNode
    ->HashMapIter
    ->HashSetIter
    ->IndexedSeq
    ->IndexedSeqIterator
    ->KeySeq
    ->Keyword
    ->LazySeq
    ->List
    ->Many
    ->MapEntry
    ->MetaFn
    ->MultiFn
    ->MultiIterator
    ->Namespace
    ->NeverEquiv
    ->NodeIterator
    ->NodeSeq
    ->ObjMap
    ->PersistentArrayMap
    ->PersistentArrayMapIterator
    ->PersistentArrayMapSeq
    ->PersistentHashMap
    ->PersistentHashSet
    ->PersistentQueue
    ->PersistentQueueIter
    ->PersistentQueueSeq
    ->PersistentTreeMap
    ->PersistentTreeMapSeq
    ->PersistentTreeSet
    ->PersistentVector
    ->Range
    ->RangedIterator
    ->RangeIterator
    ->RecordIter
    ->RedNode
    ->Reduced
    ->RSeq
    ->SeqIter
    ->Single
    ->StringBufferWriter
    ->StringIter
    ->Subvec
    ->Symbol
    ->TaggedLiteral
    ->TransformerIterator
    ->TransientArrayMap
    ->TransientHashMap
    ->TransientHashSet
    ->TransientVector
    ->UUID
    ->ValSeq
    ->Var
    ->VectorNode
    ->Volatile
    -global-hierarchy
    -indexOf
    -lastIndexOf
    /
    <
    <=
    =
    ==
    >
    >=
    accumulating-seq-count
    aclone
    add-to-string-hash-cache
    add-watch
    aget
    alength
    alter-meta!
    ancestors
    any?
    APersistentVector
    apply
    apply-to
    apply-to-simple
    array
    array->transient-hash-map
    array-chunk
    array-copy
    array-copy-downward
    array-extend-kv
    array-for
    array-index-of
    array-index-of-equiv?
    array-index-of-identical?
    array-index-of-keyword?
    array-index-of-nil?
    array-index-of-symbol?
    array-iter
    array-list
    array-map
    array-map-extend-kv
    array-map-index-of
    array-reduce
    array-seq
    array?
    ArrayChunk
    ArrayIter
    ArrayList
    ArrayNode
    ArrayNodeIterator
    ArrayNodeSeq
    ASeq
    aset
    assoc
    assoc!
    assoc-in
    associative?
    atom
    Atom
    balance-left
    balance-left-del
    balance-right
    balance-right-del
    bit-and
    bit-and-not
    bit-clear
    bit-count
    bit-flip
    bit-not
    bit-or
    bit-set
    bit-shift-left
    bit-shift-right
    bit-shift-right-zero-fill
    bit-test
    bit-xor
    bitmap-indexed-node-index
    BitmapIndexedNode
    bitpos
    BlackNode
    boolean
    boolean?
    booleans
    bounded-count
    Box
    build-subvec
    butlast
    byte
    bytes
    cat
    char
    char-escapes
    char?
    CHAR_MAP
    chars
    checked-aget
    checked-aget'
    checked-aset
    checked-aset'
    chunk
    chunk-append
    chunk-buffer
    chunk-cons
    chunk-first
    chunk-next
    chunk-rest
    ChunkBuffer
    chunked-seq
    chunked-seq?
    ChunkedCons
    ChunkedSeq
    chunkIteratorSeq
    ci-reduce
    clj->js
    clone
    clone-and-set
    cloneable?
    coll?
    comp
    comparator
    compare
    compare-and-set!
    compare-indexed
    compare-keywords
    compare-symbols
    complement
    completing
    concat
    conj
    conj!
    cons
    Cons
    constantly
    contains?
    count
    counted?
    create-array-node-seq
    create-inode-seq
    create-node
    create-ns
    create-tree-map-seq
    cycle
    dec
    dedupe
    default-dispatch-val
    Delay
    delay?
    demunge
    demunge-pattern
    demunge-str
    DEMUNGE_MAP
    DEMUNGE_PATTERN
    deref
    derive
    descendants
    disj
    disj!
    dispatch-fn
    dissoc
    dissoc!
    distinct
    distinct?
    divide
    do-assoc
    doall
    dominates
    dorun
    double
    double-array
    double?
    doubles
    drop
    drop-last
    drop-while
    edit-and-set
    eduction
    Eduction
    empty
    Empty
    EMPTY
    empty-ordered-hash
    empty-unordered-hash
    empty?
    EmptyList
    enable-console-print!
    ensure-reduced
    equiv-map
    equiv-sequential
    es6-entries-iterator
    es6-iterator
    es6-iterator-seq
    es6-set-entries-iterator
    ES6EntriesIterator
    ES6Iterator
    ES6IteratorSeq
    ES6SetEntriesIterator
    even?
    every-pred
    every?
    ex-cause
    ex-data
    ex-info
    ex-message
    ExceptionInfo
    extend-object!
    false?
    ffirst
    filter
    filterv
    find
    find-and-cache-best-method
    find-macros-ns
    find-ns
    find-ns-obj
    find-ns-obj*
    first
    first-array-for-longvec
    fix
    fixture1
    fixture2
    flatten
    flatten1
    float
    float?
    floats
    flush
    Fn
    fn->comparator
    fn?
    fnext
    fnil
    force
    frequencies
    gensym
    gensym_counter
    get
    get-global-hierarchy
    get-in
    get-method
    get-validator
    group-by
    halt-when
    hash
    hash-coll
    hash-collision-node-find-index
    hash-combine
    hash-imap
    hash-iset
    hash-keyword
    hash-map
    hash-ordered-coll
    hash-set
    hash-string
    hash-string*
    hash-symbol
    hash-unordered-coll
    HashCollisionNode
    HashMapIter
    HashSetIter
    IAssociative
    IAtom
    IChunk
    IChunkedNext
    IChunkedSeq
    ICloneable
    ICollection
    IComparable
    ICounted
    ident?
    identical?
    identity
    IDeref
    IDerefWithTimeout
    IEditableCollection
    IEmptyableCollection
    IEncodeClojure
    IEncodeJS
    IEquiv
    IFind
    ifind?
    IFn
    ifn?
    IHash
    IIndexed
    IIterable
    IKVReduce
    IList
    ILookup
    IMap
    IMapEntry
    IMeta
    imul
    IMultiFn
    INamed
    inc
    indexed?
    IndexedSeq
    IndexedSeqIterator
    INext
    infinite?
    INIT
    inode-kv-reduce
    Inst
    inst-ms
    inst?
    instance?
    int
    int-array
    int-rotate-left
    int?
    integer?
    interleave
    interpose
    into
    into-array
    ints
    IPending
    IPrintWithWriter
    IRecord
    IReduce
    IReset
    IReversible
    is_proto_
    isa?
    ISeq
    ISeqable
    ISequential
    ISet
    ISorted
    IStack
    ISwap
    iter
    iter-reduce
    ITER_SYMBOL
    iterable?
    iterate
    ITransientAssociative
    ITransientCollection
    ITransientMap
    ITransientSet
    ITransientVector
    IUUID
    IVector
    IVolatile
    IWatchable
    IWithMeta
    IWriter
    js->clj
    js-delete
    js-invoke
    js-keys
    js-mod
    js-obj
    js-reserved
    js-reserved-arr
    js-reserved?
    juxt
    keep
    keep-indexed
    key
    key->js
    key-test
    keys
    KeySeq
    Keyword
    keyword
    keyword-identical?
    keyword?
    last
    LazySeq
    lift-ns
    linear-traversal-nth
    list
    List
    list*
    list?
    load-file
    long
    long-array
    longs
    lookup-sentinel
    m3-C1
    m3-C2
    m3-fmix
    m3-hash-int
    m3-hash-unencoded-chars
    m3-mix-H1
    m3-mix-K1
    m3-seed
    make-array
    make-hierarchy
    Many
    map
    map-indexed
    map?
    mapcat
    MapEntry
    mapv
    mask
    max
    max-key
    maybe-warn
    memoize
    merge
    merge-with
    meta
    MetaFn
    methods
    min
    min-key
    missing-protocol
    mix-collection-hash
    mk-bound-fn
    mod
    MODULE_INFOS
    MODULE_URIS
    MultiFn
    MultiIterator
    munge
    munge-str
    name
    namespace
    Namespace
    nat-int?
    native-satisfies?
    neg-int?
    neg?
    never-equiv
    NeverEquiv
    new-path
    newline
    next
    nfirst
    nil-iter
    nil?
    nnext
    NodeIterator
    NodeSeq
    NONE
    not
    not-any?
    not-empty
    not-every?
    not-native
    not=
    ns-interns*
    ns-lookup
    ns-name
    NS_CACHE
    nth
    nthnext
    nthrest
    number?
    obj-clone
    obj-map
    obj-map->hash-map
    obj-map-compare-keys
    object-array
    object?
    ObjMap
    odd?
    pack-array-node
    parents
    partial
    partition
    partition-all
    partition-by
    peek
    persistent!
    persistent-array-map-seq
    PersistentArrayMap
    PersistentArrayMapIterator
    PersistentArrayMapSeq
    PersistentHashMap
    PersistentHashSet
    PersistentQueue
    PersistentQueueIter
    PersistentQueueSeq
    PersistentTreeMap
    PersistentTreeMapSeq
    PersistentTreeSet
    PersistentVector
    pop
    pop!
    pop-tail
    pos-int?
    pos?
    pr
    pr-opts
    pr-sb-with-opts
    pr-seq-writer
    pr-sequential-writer
    pr-str
    pr-str*
    pr-str-with-opts
    pr-with-opts
    pr-writer
    pr-writer-ex-info
    pr-writer-impl
    prefer-method
    prefers
    prefers*
    preserving-reduced
    prim-seq
    print
    print-map
    print-meta?
    print-prefix-map
    print-str
    println
    println-str
    prn
    prn-str
    prn-str-with-opts
    PROTOCOL_SENTINEL
    push-tail
    pv-aget
    pv-aset
    pv-clone-node
    pv-fresh-node
    pv-reduce
    qualified-ident?
    qualified-keyword?
    qualified-symbol?
    quot
    quote-string
    rand
    rand-int
    rand-nth
    random-sample
    random-uuid
    range
    Range
    ranged-iterator
    RangedIterator
    RangeIterator
    re-find
    re-matches
    re-pattern
    re-seq
    realized?
    record?
    RecordIter
    RedNode
    reduce
    reduce-kv
    reduceable?
    Reduced
    reduced
    reduced?
    reductions
    regexp?
    rem
    remove
    remove-all-methods
    remove-method
    remove-pair
    remove-watch
    repeat
    repeatedly
    replace
    replicate
    reset!
    reset-cache
    reset-meta!
    reset-vals!
    rest
    reverse
    reversible?
    RSeq
    rseq
    rsubseq
    run!
    scan-array
    second
    select-keys
    seq
    seq-iter
    seq-reduce
    seq?
    seqable?
    SeqIter
    sequence
    sequential?
    set
    set-from-indexed-seq
    set-print-err-fn!
    set-print-fn!
    set-validator!
    set?
    short
    shorts
    shuffle
    simple-ident?
    simple-keyword?
    simple-symbol?
    Single
    some
    some-fn
    some?
    sort
    sort-by
    sorted-map
    sorted-map-by
    sorted-set
    sorted-set-by
    sorted?
    special-symbol?
    split-at
    split-with
    spread
    START
    str
    string-hash-cache
    string-hash-cache-count
    string-iter
    string-print
    string?
    StringBufferWriter
    StringIter
    strip-ns
    subs
    subseq
    Subvec
    subvec
    swap!
    swap-global-hierarchy!
    swap-vals!
    Symbol
    symbol
    symbol-identical?
    symbol?
    system-time
    tagged-literal
    tagged-literal?
    TaggedLiteral
    tail-off
    take
    take-last
    take-nth
    take-while
    test
    throw-no-method-error
    to-array
    to-array-2d
    trampoline
    transduce
    transformer-iterator
    TransformerIterator
    transient
    TransientArrayMap
    TransientHashMap
    TransientHashSet
    TransientVector
    tree-map-add
    tree-map-append
    tree-map-kv-reduce
    tree-map-remove
    tree-map-replace
    tree-map-seq-push
    tree-seq
    true?
    truth_
    tv-editable-root
    tv-editable-tail
    tv-ensure-editable
    tv-pop-tail
    tv-push-tail
    type
    type->str
    unchecked-add
    unchecked-add-int
    unchecked-array-for
    unchecked-byte
    unchecked-char
    unchecked-dec
    unchecked-dec-int
    unchecked-divide-int
    unchecked-double
    unchecked-editable-array-for
    unchecked-float
    unchecked-inc
    unchecked-inc-int
    unchecked-int
    unchecked-long
    unchecked-multiply
    unchecked-multiply-int
    unchecked-negate
    unchecked-negate-int
    unchecked-remainder-int
    unchecked-short
    unchecked-subtract
    unchecked-subtract-int
    undefined?
    underive
    unreduced
    unsigned-bit-shift-right
    update
    update-in
    uri?
    uuid
    UUID
    uuid?
    val
    vals
    ValSeq
    Var
    var?
    vary-meta
    vec
    vector
    vector-index-out-of-bounds
    vector?
    VectorNode
    Volatile
    volatile!
    volatile?
    vreset!
    with-meta
    write-all
    zero?
    zipmap

    « Index of all namespaces of this project

    (* ???)
    Returns the product of nums. (*) returns 1.
    
    bound in a repl thread to the most recent value printed
    
    bound in a repl thread to the second most recent value printed
    
    bound in a repl thread to the third most recent value printed
    
    A sequence of the supplied command line arguments, or nil if
    none were supplied
    bound in a repl thread to the most recent exception caught by the repl
    
    Dynamic
    When set to true, output will be flushed whenever a newline is printed.
    
    Defaults to true.
    When compiled for a command-line target, whatever function
    *main-cli-fn* is set to will be called with the command-line
    argv as arguments
    Dynamic
    Var bound to the current namespace. Only used for bootstrapping.
    
    Dynamic
    When set to logical true, objects will be printed in a way that preserves
    their type when read in later.
    
    Defaults to false.
    Dynamic
    Each runtime environment provides a different way to print error output.
    Whatever function *print-err-fn* is bound to will be passed any
    Strings which should be printed.
    Dynamic
    Each runtime environment provides a different way to print output.
    Whatever function *print-fn* is bound to will be passed any
    Strings which should be printed.
    Dynamic
    *print-fns-bodies* controls whether functions print their source or
    only their names.
    Dynamic
    *print-length* controls how many items of each collection the
    printer will print. If it is bound to logical false, there is no
    limit. Otherwise, it must be bound to an integer indicating the maximum
    number of items of each collection to print. If a collection contains
    more items, the printer will print items up to the limit followed by
    '...' to represent the remaining items. The root binding is nil
    indicating no limit.
    Dynamic
    *print-level* controls how many levels deep the printer will
    print nested objects. If it is bound to logical false, there is no
    limit. Otherwise, it must be bound to an integer indicating the maximum
    level to print. Each argument to print is at level 0; if an argument is a
    collection, its items are at level 1; and so on. If an object is a
    collection and is at a level greater than or equal to the value bound to
    *print-level*, the printer prints '#' to represent it. The root binding
    is nil indicating no limit.
    Dynamic
    If set to logical true, when printing an object, its metadata will also
    be printed in a form that can be read back by the reader.
    
    Defaults to false.
    Dynamic
    *print-namespace-maps* controls whether the printer will print
    namespace map literal syntax.
    
    Defaults to false, but the REPL binds it to true.
    Dynamic
    When set to logical false will drop newlines from printing calls.
    This is to work around the implicit newlines emitted by standard JavaScript
    console objects.
    Dynamic
    When set to logical false, strings and characters will be printed with
    non-alphanumeric characters converted to the appropriate escape sequences.
    
    Defaults to true
    Dynamic
    Var bound to the name value of the compiler build :target option.
    For example, if the compiler build :target is :nodejs, *target* will be bound
    to "nodejs". *target* is a Google Closure define and can be set by compiler
    :closure-defines option.
    (+ ???)
    Returns the sum of nums. (+) returns 0.
    
    (- ???)(- ???)
    If no ys are supplied, returns the negation of x, else subtracts
    the ys from x and returns the result.
    (->ArrayChunk arr off end)
    Positional factory function for cljs.core/ArrayChunk.
    
    (->ArrayIter arr i)
    Positional factory function for cljs.core/ArrayIter.
    
    (->ArrayList arr)
    Positional factory function for cljs.core/ArrayList.
    
    (->ArrayNode edit cnt arr)
    Positional factory function for cljs.core/ArrayNode.
    
    (->ArrayNodeIterator arr i next-iter)
    Positional factory function for cljs.core/ArrayNodeIterator.
    
    (->ArrayNodeSeq meta nodes i s __hash)
    Positional factory function for cljs.core/ArrayNodeSeq.
    
    (->Atom state meta validator watches)
    Positional factory function for cljs.core/Atom.
    
    (->BitmapIndexedNode edit bitmap arr)
    Positional factory function for cljs.core/BitmapIndexedNode.
    
    (->BlackNode key val left right __hash)
    Positional factory function for cljs.core/BlackNode.
    
    (->Box val)
    Positional factory function for cljs.core/Box.
    
    (->ChunkBuffer buf end)
    Positional factory function for cljs.core/ChunkBuffer.
    
    (->ChunkedCons chunk more meta __hash)
    Positional factory function for cljs.core/ChunkedCons.
    
    (->ChunkedSeq vec node i off meta __hash)
    Positional factory function for cljs.core/ChunkedSeq.
    
    (->Cons meta first rest __hash)
    Positional factory function for cljs.core/Cons.
    
    (->Delay f value)
    Positional factory function for cljs.core/Delay.
    
    (->Eduction xform coll)
    Positional factory function for cljs.core/Eduction.
    
    (->Empty)
    Positional factory function for cljs.core/Empty.
    
    (->EmptyList meta)
    Positional factory function for cljs.core/EmptyList.
    
    (->ES6EntriesIterator s)
    Positional factory function for cljs.core/ES6EntriesIterator.
    
    (->ES6Iterator s)
    Positional factory function for cljs.core/ES6Iterator.
    
    (->ES6IteratorSeq value iter _rest)
    Positional factory function for cljs.core/ES6IteratorSeq.
    
    (->ES6SetEntriesIterator s)
    Positional factory function for cljs.core/ES6SetEntriesIterator.
    
    (->HashCollisionNode edit collision-hash cnt arr)
    Positional factory function for cljs.core/HashCollisionNode.
    
    (->HashMapIter nil-val root-iter seen)
    Positional factory function for cljs.core/HashMapIter.
    
    (->HashSetIter iter)
    Positional factory function for cljs.core/HashSetIter.
    
    (->IndexedSeq arr i meta)
    Positional factory function for cljs.core/IndexedSeq.
    
    (->IndexedSeqIterator arr i)
    Positional factory function for cljs.core/IndexedSeqIterator.
    
    (->KeySeq mseq _meta)
    Positional factory function for cljs.core/KeySeq.
    
    (->Keyword ns name fqn _hash)
    Positional factory function for cljs.core/Keyword.
    
    (->LazySeq meta fn s __hash)
    Positional factory function for cljs.core/LazySeq.
    
    (->List meta first rest count __hash)
    Positional factory function for cljs.core/List.
    
    (->Many vals)
    Positional factory function for cljs.core/Many.
    
    (->MapEntry key val __hash)
    Positional factory function for cljs.core/MapEntry.
    
    (->MetaFn afn meta)
    Positional factory function for cljs.core/MetaFn.
    
    (->MultiFn name dispatch-fn default-dispatch-val hierarchy method-table prefer-table method-cache cached-hierarchy)
    Positional factory function for cljs.core/MultiFn.
    
    (->MultiIterator iters)
    Positional factory function for cljs.core/MultiIterator.
    
    (->Namespace obj name)
    Positional factory function for cljs.core/Namespace.
    
    (->NeverEquiv)
    Positional factory function for cljs.core/NeverEquiv.
    
    (->NodeIterator arr i next-entry next-iter)
    Positional factory function for cljs.core/NodeIterator.
    
    (->NodeSeq meta nodes i s __hash)
    Positional factory function for cljs.core/NodeSeq.
    
    (->ObjMap meta keys strobj update-count __hash)
    Positional factory function for cljs.core/ObjMap.
    
    (->PersistentArrayMap meta cnt arr __hash)
    Positional factory function for cljs.core/PersistentArrayMap.
    
    (->PersistentArrayMapIterator arr i cnt)
    Positional factory function for cljs.core/PersistentArrayMapIterator.
    
    (->PersistentArrayMapSeq arr i _meta)
    Positional factory function for cljs.core/PersistentArrayMapSeq.
    
    (->PersistentHashMap meta cnt root has-nil? nil-val __hash)
    Positional factory function for cljs.core/PersistentHashMap.
    
    (->PersistentHashSet meta hash-map __hash)
    Positional factory function for cljs.core/PersistentHashSet.
    
    (->PersistentQueue meta count front rear __hash)
    Positional factory function for cljs.core/PersistentQueue.
    
    (->PersistentQueueIter fseq riter)
    Positional factory function for cljs.core/PersistentQueueIter.
    
    (->PersistentQueueSeq meta front rear __hash)
    Positional factory function for cljs.core/PersistentQueueSeq.
    
    (->PersistentTreeMap comp tree cnt meta __hash)
    Positional factory function for cljs.core/PersistentTreeMap.
    
    (->PersistentTreeMapSeq meta stack ascending? cnt __hash)
    Positional factory function for cljs.core/PersistentTreeMapSeq.
    
    (->PersistentTreeSet meta tree-map __hash)
    Positional factory function for cljs.core/PersistentTreeSet.
    
    (->PersistentVector meta cnt shift root tail __hash)
    Positional factory function for cljs.core/PersistentVector.
    
    (->Range meta start end step __hash)
    Positional factory function for cljs.core/Range.
    
    (->RangedIterator i base arr v start end)
    Positional factory function for cljs.core/RangedIterator.
    
    (->RangeIterator i end step)
    Positional factory function for cljs.core/RangeIterator.
    
    (->RecordIter i record base-count fields ext-map-iter)
    Positional factory function for cljs.core/RecordIter.
    
    (->RedNode key val left right __hash)
    Positional factory function for cljs.core/RedNode.
    
    (->Reduced val)
    Positional factory function for cljs.core/Reduced.
    
    (->RSeq ci i meta)
    Positional factory function for cljs.core/RSeq.
    
    (->SeqIter _seq _next)
    Positional factory function for cljs.core/SeqIter.
    
    (->Single val)
    Positional factory function for cljs.core/Single.
    
    (->StringBufferWriter sb)
    Positional factory function for cljs.core/StringBufferWriter.
    
    (->StringIter s i)
    Positional factory function for cljs.core/StringIter.
    
    (->Subvec meta v start end __hash)
    Positional factory function for cljs.core/Subvec.
    
    (->Symbol ns name str _hash _meta)
    Positional factory function for cljs.core/Symbol.
    
    (->TaggedLiteral tag form)
    Positional factory function for cljs.core/TaggedLiteral.
    
    (->TransformerIterator buffer _next completed xf sourceIter multi)
    Positional factory function for cljs.core/TransformerIterator.
    
    (->TransientArrayMap editable? len arr)
    Positional factory function for cljs.core/TransientArrayMap.
    
    (->TransientHashMap edit root count has-nil? nil-val)
    Positional factory function for cljs.core/TransientHashMap.
    
    (->TransientHashSet transient-map)
    Positional factory function for cljs.core/TransientHashSet.
    
    (->TransientVector cnt shift root tail)
    Positional factory function for cljs.core/TransientVector.
    
    (->UUID uuid __hash)
    Positional factory function for cljs.core/UUID.
    
    (->ValSeq mseq _meta)
    Positional factory function for cljs.core/ValSeq.
    
    (->Var val sym _meta)
    Positional factory function for cljs.core/Var.
    
    (->VectorNode edit arr)
    Positional factory function for cljs.core/VectorNode.
    
    (->Volatile state)
    Positional factory function for cljs.core/Volatile.
    
    Private
    (-indexOf ???)(-indexOf ???)(-indexOf ???)
    Private
    (-lastIndexOf ???)(-lastIndexOf ???)(-lastIndexOf ???)
    (/ ???)(/ ???)
    If no denominators are supplied, returns 1/numerator,
    else returns numerator divided by all of the denominators.
    (< ???)(< ???)
    Returns non-nil if nums are in monotonically increasing order,
    otherwise false.
    (<= ???)(<= ???)
    Returns non-nil if nums are in monotonically non-decreasing order,
    otherwise false.
    (= ???)(= ???)
    Equality. Returns true if x equals y, false if not. Compares
    numbers and collections in a type-independent manner.  Clojure's immutable data
    structures define -equiv (and thus =) as a value, not an identity,
    comparison.
    (== ???)(== ???)
    Returns non-nil if nums all have the equivalent
    value, otherwise false. Behavior on non nums is
    undefined.
    (> ???)(> ???)
    Returns non-nil if nums are in monotonically decreasing order,
    otherwise false.
    (>= ???)(>= ???)
    Returns non-nil if nums are in monotonically non-increasing order,
    otherwise false.
    Private
    (accumulating-seq-count coll)
    (aclone arr)
    Returns a javascript array, cloned from the passed in array
    
    (add-to-string-hash-cache k)
    (add-watch iref key f)
    Adds a watch function to an atom reference. The watch fn must be a
    fn of 4 args: a key, the reference, its old-state, its
    new-state. Whenever the reference's state might have been changed,
    any registered watches will have their functions called. The watch
    fn will be called synchronously. Note that an atom's state
    may have changed again prior to the fn call, so use old/new-state
    rather than derefing the reference. Keys must be unique per
    reference, and can be used to remove the watch with remove-watch,
    but are otherwise considered opaque by the watch mechanism.  Bear in
    mind that regardless of the result or action of the watch fns the
    atom's value will change.  Example:
    
        (def a (atom 0))
        (add-watch a :inc (fn [k r o n] (assert (== 0 n))))
        (swap! a inc)
        ;; Assertion Error
        (deref a)
        ;=> 1
    (aget ???)(aget ???)(aget ???)(aget ???)
    Returns the value at the index/indices. Works on JavaScript arrays.
    
    (alength array)
    Returns the length of the array. Works on arrays of all types.
    
    (alter-meta! iref f & args)
    Atomically sets the metadata for a namespace/var/ref/agent/atom to be:
    
    (apply f its-current-meta args)
    
    f must be free of side-effects
    (ancestors ???)(ancestors ???)
    Returns the immediate and indirect parents of tag, either via a JavaScript type
    inheritance relationship or a relationship established via derive. h
    must be a hierarchy obtained from make-hierarchy, if not supplied
    defaults to the global hierarchy
    (any? x)
    Returns true if given any argument.
    
    protocol
    Marker protocol
    
    (apply ???)(apply ???)(apply ???)
    Applies fn f to the argument list formed by prepending intervening arguments to args.
    
    (apply-to f argc args)
    Private
    (apply-to-simple ???)(apply-to-simple ???)(apply-to-simple ???)
    Internal. DO NOT USE!
    Assumes args was already called with seq beforehand!
    (array var-args)
    Creates a new javascript array.
    @param {...*} var_args
    Private
    (array->transient-hash-map len arr)
    (array-chunk ???)(array-chunk ???)
    Private
    (array-copy from i to j len)
    Private
    (array-copy-downward from i to j len)
    Private
    (array-extend-kv arr k v)
    Private
    (array-for pv i)
    (array-index-of arr k)
    Private
    (array-index-of-equiv? arr k)
    Private
    (array-index-of-identical? arr k)
    Private
    (array-index-of-keyword? arr k)
    Private
    (array-index-of-nil? arr)
    Private
    (array-index-of-symbol? arr k)
    (array-map & keyvals)
    keyval => key val
    Returns a new array map with supplied mappings.
    Private
    (array-map-extend-kv m k v)
    Private
    (array-map-index-of m k)
    Private
    (array-reduce ???)(array-reduce ???)(array-reduce ???)
    (array-seq ???)(array-seq ???)
    Create a seq from a JavaScript array.
    
    (array? x)
    Returns true if x is a JavaScript array.
    
    protocol
    Marker protocol indicating an array sequence.
    
    (aset ???)(aset ???)(aset ???)(aset ???)(aset ???)
    Sets the value at the index/indices. Works on JavaScript arrays.
    Returns val.
    (assoc ???)(assoc ???)(assoc ???)(assoc ???)(assoc ???)
    assoc[iate]. When applied to a map, returns a new map of the
    same (hashed/sorted) type, that contains the mapping of key(s) to
    val(s). When applied to a vector, returns a new vector that
    contains val at index.
    (assoc! ???)(assoc! ???)(assoc! ???)(assoc! ???)(assoc! ???)
    When applied to a transient map, adds mapping of key(s) to
    val(s). When applied to a transient vector, sets the val at index.
    Note - index must be <= (count vector). Returns coll.
    (assoc-in m [k & ks] v)
    Associates a value in a nested associative structure, where ks is a
    sequence of keys and v is the new value and returns a new nested structure.
    If any levels do not exist, hash-maps will be created.
    (associative? x)
    Returns true if coll implements Associative
    
    (atom ???)(atom ???)(atom ???)
    Creates and returns an Atom with an initial value of x and zero or
    more options (in any order):
    
    :meta metadata-map
    
    :validator validate-fn
    
    If metadata-map is supplied, it will be come the metadata on the
    atom. validate-fn must be nil or a side-effect-free fn of one
    argument, which will be passed the intended new state on any state
    change. If the new state is unacceptable, the validate-fn should
    return false or throw an Error.  If either of these error conditions
    occur, then the value of the atom will not change.
    Private
    (balance-left key val ins right)
    Private
    (balance-left-del key val del right)
    Private
    (balance-right key val left ins)
    Private
    (balance-right-del key val left del)
    (bit-and ???)(bit-and ???)(bit-and ???)(bit-and ???)
    Bitwise and
    
    (bit-and-not ???)(bit-and-not ???)(bit-and-not ???)(bit-and-not ???)
    Bitwise and with complement
    
    (bit-clear x n)
    Clear bit at index n
    
    (bit-count v)
    Counts the number of bits set in n
    
    (bit-flip x n)
    Flip bit at index n
    
    (bit-not x)
    Bitwise complement
    
    (bit-or ???)(bit-or ???)(bit-or ???)(bit-or ???)
    Bitwise or
    
    (bit-set x n)
    Set bit at index n
    
    (bit-shift-left x n)
    Bitwise shift left
    
    (bit-shift-right x n)
    Bitwise shift right
    
    (bit-shift-right-zero-fill x n)
    DEPRECATED: Bitwise shift right with zero fill
    
    (bit-test x n)
    Test bit at index n
    
    (bit-xor ???)(bit-xor ???)(bit-xor ???)(bit-xor ???)
    Bitwise exclusive or
    
    Private
    (bitmap-indexed-node-index bitmap bit)
    Private
    (bitpos hash shift)
    (boolean x)
    Coerce to boolean
    
    (boolean? x)
    Return true if x is a Boolean
    
    (bounded-count n coll)
    If coll is counted? returns its count, else will count at most the first n
    elements of coll using its seq
    Private
    (build-subvec meta v start end __hash)
    (butlast s)
    Return a seq of all but the last item in coll, in linear time
    
    (cat rf)
    A transducer which concatenates the contents of each input, which must be a
    collection, into the reduction.
    (char x)
    Coerce to char
    
    (char? x)
    Returns true if x is a JavaScript string of length one.
    
    Private
    (checked-aget ???)(checked-aget ???)(checked-aget ???)(checked-aget ???)
    Private
    (checked-aget' ???)(checked-aget' ???)(checked-aget' ???)(checked-aget' ???)
    Private
    (checked-aset ???)(checked-aset ???)(checked-aset ???)(checked-aset ???)(checked-aset ???)
    Private
    (checked-aset' ???)(checked-aset' ???)(checked-aset' ???)(checked-aset' ???)(checked-aset' ???)
    (chunk-append b x)
    (chunk-buffer capacity)
    (chunk-cons chunk rest)
    (chunked-seq ???)(chunked-seq ???)(chunked-seq ???)(chunked-seq ???)
    (chunked-seq? x)
    Return true if x is satisfies IChunkedSeq.
    
    Private
    (chunkIteratorSeq iter)
    Private
    (ci-reduce ???)(ci-reduce ???)(ci-reduce ???)
    Accepts any collection which satisfies the ICount and IIndexed protocols and
    reduces them without incurring seq initialization
    (clj->js x)
    Recursively transforms ClojureScript values to JavaScript.
    sets/vectors/lists become Arrays, Keywords and Symbol become Strings,
    Maps become Objects. Arbitrary keys are encoded to by key->js.
    (clone value)
    Clone the supplied value which must implement ICloneable.
    
    Private
    (clone-and-set ???)(clone-and-set ???)(clone-and-set ???)(clone-and-set ???)(clone-and-set ???)
    (cloneable? value)
    Return true if x implements ICloneable protocol.
    
    (coll? x)
    Returns true if x satisfies ICollection
    
    (comp ???)
    Takes a set of functions and returns a fn that is the composition
    of those fns.  The returned fn takes a variable number of args,
    applies the rightmost of fns to the args, the next
    fn (right-to-left) to the result, etc.
    (comparator pred)
    Returns an JavaScript compatible comparator based upon pred.
    
    (compare x y)
    Comparator. Returns a negative number, zero, or a positive number
     when x is logically 'less than', 'equal to', or 'greater than'
     y. Uses IComparable if available and google.array.defaultCompare for objects
    of the same type and special-cases nil to be less than any other object.
    (compare-and-set! a oldval newval)
    Atomically sets the value of atom to newval if and only if the
    current value of the atom is equal to oldval. Returns true if
    set happened, else false.
    Private
    (compare-indexed ???)(compare-indexed ???)(compare-indexed ???)(compare-indexed ???)
    Compare indexed collection.
    
    Private
    (compare-keywords a b)
    Private
    (compare-symbols a b)
    (complement f)
    Takes a fn f and returns a fn that takes the same arguments as f,
    has the same effects, if any, and returns the opposite truth value.
    (completing ???)(completing ???)
    Takes a reducing function f of 2 args and returns a fn suitable for
    transduce by adding an arity-1 signature that calls cf (default -
    identity) on the result argument.
    (concat ???)
    Returns a lazy seq representing the concatenation of the elements in the supplied colls.
    
    (conj ???)
    conj[oin]. Returns a new collection with the xs
    'added'. (conj nil item) returns (item).  The 'addition' may
    happen at different 'places' depending on the concrete type.
    (conj! ???)
    Adds val to the transient collection, and return tcoll. The 'addition'
    may happen at different 'places' depending on the concrete type.
    (cons x coll)
    Returns a new seq where x is the first element and coll is the rest.
    
    (constantly x)
    Returns a function that takes any number of arguments and returns x.
    
    (contains? coll v)
    Returns true if key is present in the given collection, otherwise
    returns false.  Note that for numerically indexed collections like
    vectors and arrays, this tests if the numeric key is within the
    range of indexes. 'contains?' operates constant or logarithmic time;
    it will not perform a linear search for a value.  See also 'some'.
    (count coll)
    Returns the number of items in the collection. (count nil) returns
    0.  Also works on strings, arrays, and Maps
    (counted? x)
    Returns true if coll implements count in constant time
    
    Private
    (create-array-node-seq ???)(create-array-node-seq ???)(create-array-node-seq ???)(create-array-node-seq ???)
    Private
    (create-inode-seq ???)(create-inode-seq ???)(create-inode-seq ???)
    Private
    (create-node ???)(create-node ???)(create-node ???)(create-node ???)(create-node ???)(create-node ???)(create-node ???)
    (create-ns ???)(create-ns ???)
    Create a new namespace named by the symbol. Bootstrap only.
    
    Private
    (create-tree-map-seq tree ascending? cnt)
    (cycle coll)
    Returns a lazy (infinite!) sequence of repetitions of the items in coll.
    
    (dec x)
    Returns a number one less than num.
    
    (dedupe ???)
    Returns a lazy sequence removing consecutive duplicates in coll.
    Returns a transducer when no collection is provided.
    (default-dispatch-val multifn)
    Given a multimethod, return it's default-dispatch-val.
    
    (delay? x)
    returns true if x is a Delay created with delay
    
    (demunge name)
    Private
    (demunge-pattern)
    Private
    (demunge-str munged-name)
    (deref o)
    Also reader macro: @var/@atom/@delay. Returns the
    most-recently-committed value of ref. When applied to a var
    or atom, returns its current state. When applied to a delay, forces
    it if not already forced. See also - realized?.
    (derive ???)(derive ???)(derive ???)
    Establishes a parent/child relationship between parent and
    tag. Parent must be a namespace-qualified symbol or keyword and
    child can be either a namespace-qualified symbol or keyword or a
    class. h must be a hierarchy obtained from make-hierarchy, if not
    supplied defaults to, and modifies, the global hierarchy.
    (descendants ???)(descendants ???)
    Returns the immediate and indirect children of tag, through a
    relationship established via derive. h must be a hierarchy obtained
    from make-hierarchy, if not supplied defaults to the global
    hierarchy. Note: does not work on JavaScript type inheritance
    relationships.
    (disj ???)(disj ???)
    disj[oin]. Returns a new set of the same (hashed/sorted) type, that
    does not contain key(s).
    (disj! ???)(disj! ???)(disj! ???)(disj! ???)
    disj[oin]. Returns a transient set of the same (hashed/sorted) type, that
    does not contain key(s).
    (dispatch-fn multifn)
    Given a multimethod, return it's dispatch-fn.
    
    (dissoc ???)(dissoc ???)
    dissoc[iate]. Returns a new map of the same (hashed/sorted) type,
    that does not contain a mapping for key(s).
    (dissoc! ???)(dissoc! ???)(dissoc! ???)(dissoc! ???)
    Returns a transient map that doesn't contain a mapping for key(s).
    
    (distinct ???)
    Returns a lazy sequence of the elements of coll with duplicates removed.
    Returns a stateful transducer when no collection is provided.
    (distinct? ???)(distinct? ???)
    Returns true if no two of the arguments are =
    
    Private
    (do-assoc pv level node i val)
    (doall ???)(doall ???)
    When lazy sequences are produced via functions that have side
    effects, any effects other than those needed to produce the first
    element in the seq do not occur until the seq is consumed. doall can
    be used to force any effects. Walks through the successive nexts of
    the seq, retains the head and returns it, thus causing the entire
    seq to reside in memory at one time.
    Private
    (dominates x y prefer-table hierarchy)
    (dorun ???)(dorun ???)
    When lazy sequences are produced via functions that have side
    effects, any effects other than those needed to produce the first
    element in the seq do not occur until the seq is consumed. dorun can
    be used to force any effects. Walks through the successive nexts of
    the seq, does not retain the head and returns nil.
    (double-array ???)(double-array ???)
    Creates an array of doubles. Does not coerce array, provided for compatibility
    with Clojure.
    (double? x)
    Returns true for JavaScript numbers, false otherwise.
    
    (drop ???)(drop ???)
    Returns a lazy sequence of all but the first n items in coll.
    Returns a stateful transducer when no collection is provided.
    (drop-last ???)(drop-last ???)
    Return a lazy sequence of all but the last n (default 1) items in coll
    
    (drop-while ???)(drop-while ???)
    Returns a lazy sequence of the items in coll starting from the
    first item for which (pred item) returns logical false.  Returns a
    stateful transducer when no collection is provided.
    Private
    (edit-and-set ???)(edit-and-set ???)(edit-and-set ???)(edit-and-set ???)(edit-and-set ???)(edit-and-set ???)
    (eduction & xforms)
    Returns a reducible/iterable application of the transducers
    to the items in coll. Transducers are applied in order as if
    combined with comp. Note that these applications will be
    performed every time reduce/iterator is called.
    (empty coll)
    Returns an empty collection of the same category as coll, or nil
    
    (empty? coll)
    Returns true if coll has no items - same as (not (seq coll)).
    Please use the idiom (seq x) rather than (not (empty? x))
    (enable-console-print!)
    Set *print-fn* to console.log
    
    (ensure-reduced x)
    If x is already reduced?, returns it, else returns (reduced x)
    
    (equiv-map x y)
    Test map equivalence. Returns true if x equals y, otherwise returns false.
    
    Private
    (equiv-sequential x y)
    Assumes x is sequential. Returns true if x equals y, otherwise
    returns false.
    (es6-entries-iterator coll)
    (es6-iterator coll)
    EXPERIMENTAL: Return a ES2015 compatible iterator for coll.
    
    (es6-iterator-seq iter)
    EXPERIMENTAL: Given an ES2015 compatible iterator return a seq.
    
    (es6-set-entries-iterator coll)
    (even? n)
    Returns true if n is even, throws an exception if n is not an integer
    
    (every-pred ???)(every-pred ???)
    Takes a set of predicates and returns a function f that returns true if all of its
    composing predicates return a logical true value against all of its arguments, else it returns
    false. Note that f is short-circuiting in that it will stop execution on the first
    argument that triggers a logical false result against the original predicates.
    (every? pred coll)
    Returns true if (pred x) is logical true for every x in coll, else
    false.
    (ex-cause ex)
    Returns exception cause (an Error / ExceptionInfo) if ex is an
    ExceptionInfo.
    Otherwise returns nil.
    (ex-data ex)
    Returns exception data (a map) if ex is an ExceptionInfo.
    Otherwise returns nil.
    (ex-info ???)(ex-info ???)(ex-info ???)
    Create an instance of ExceptionInfo, an Error type that carries a
    map of additional data.
    (ex-message ex)
    Returns the message attached to the given Error / ExceptionInfo object.
    For non-Errors returns nil.
    (ExceptionInfo message data cause)
    Private
    (extend-object! obj fn-map)
    Takes a JavaScript object and a map of names to functions and
    attaches said functions as methods on the object.  Any references to
    JavaScript's implicit this (via the this-as macro) will resolve to the
    object that the function is attached.
    (false? x)
    Returns true if x is the value false, false otherwise.
    
    (ffirst coll)
    Same as (first (first x))
    
    (filter ???)(filter ???)
    Returns a lazy sequence of the items in coll for which
    (pred item) returns true. pred must be free of side-effects.
    Returns a transducer when no collection is provided.
    (filterv pred coll)
    Returns a vector of the items in coll for which
    (pred item) returns true. pred must be free of side-effects.
    (find coll k)
    Returns the map entry for key, or nil if key not present.
    
    Private
    (find-and-cache-best-method name dispatch-val hierarchy method-table prefer-table method-cache cached-hierarchy default-dispatch-val)
    (find-macros-ns ns)
    Returns the macros namespace named by the symbol or nil if it doesn't exist.
    Bootstrap only.
    (find-ns ns)
    Returns the namespace named by the symbol or nil if it doesn't exist.
    Bootstrap only.
    (find-ns-obj ns)
    Bootstrap only.
    
    Private
    (find-ns-obj* ctxt xs)
    Bootstrap only.
    
    (first coll)
    Returns the first item in the collection. Calls seq on its
    argument. If coll is nil, returns nil.
    Private
    (first-array-for-longvec pv)
    Private
    (fix q)
    (flatten x)
    Takes any nested combination of sequential things (lists, vectors,
    etc.) and returns their contents as a single, flat sequence.
    (flatten nil) returns nil.
    Private
    (flatten1 colls)
    Take a collection of collections, and return a lazy seq
    of items from the inner collection
    (float? x)
    Returns true for JavaScript numbers, false otherwise.
    
    protocol
    Marker protocol
    
    Private
    (fn->comparator f)
    Given a fn that might be boolean valued or a comparator,
    return a fn that is a comparator.
    (fn? f)
    Return true if f is a JavaScript function or satisfies the Fn protocol.
    
    (fnext coll)
    Same as (first (next x))
    
    (fnil ???)(fnil ???)(fnil ???)
    Takes a function f, and returns a function that calls f, replacing
    a nil first argument to f with the supplied value x. Higher arity
    versions can replace arguments in the second and third
    positions (y, z). Note that the function f can take any number of
    arguments, not just the one(s) being nil-patched.
    (force x)
    If x is a Delay, returns the (possibly cached) value of its expression, else returns x
    
    (frequencies coll)
    Returns a map from distinct items in coll to the number of times
    they appear.
    (gensym ???)
    Returns a new symbol with a unique name. If a prefix string is
    supplied, the name is prefix# where # is some unique number. If
    prefix is not supplied, the prefix is 'G__'.
    (get ???)(get ???)(get ???)
    Returns the value mapped to key, not-found or nil if key not present.
    
    Private
    (get-global-hierarchy)
    (get-in ???)(get-in ???)(get-in ???)
    Returns the value in a nested associative structure,
    where ks is a sequence of keys. Returns nil if the key is not present,
    or the not-found value if supplied.
    (get-method multifn dispatch-val)
    Given a multimethod and a dispatch value, returns the dispatch fn
    that would apply to that value, or nil if none apply and no default
    (get-validator iref)
    Gets the validator-fn for a var/ref/agent/atom.
    
    (group-by f coll)
    Returns a map of the elements of coll keyed by the result of
    f on each element. The value at each key will be a vector of the
    corresponding elements, in the order they appeared in coll.
    (halt-when ???)(halt-when ???)
    Returns a transducer that ends transduction when pred returns true
    for an input. When retf is supplied it must be a fn of 2 arguments -
    it will be passed the (completed) result so far and the input that
    triggered the predicate, and its return value (if it does not throw
    an exception) will be the return value of the transducer. If retf
    is not supplied, the input that triggered the predicate will be
    returned. If the predicate never returns true the transduction is
    unaffected.
    (hash o)
    Returns the hash code of its argument. Note this is the hash code
    consistent with =.
    Private
    (hash-coll coll)
    Private
    (hash-collision-node-find-index arr cnt key)
    (hash-combine seed hash)
    Private
    (hash-imap m)
    Private
    (hash-iset s)
    (hash-keyword k)
    (hash-map & keyvals)
    keyval => key val
    Returns a new hash map with supplied mappings.
    (hash-ordered-coll coll)
    Returns the hash code, consistent with =, for an external ordered
    collection implementing Iterable.
    See http://clojure.org/data_structures#hash for full algorithms.
    (hash-set ???)(hash-set ???)
    Returns a new hash set with supplied keys.  Any equal keys are
    handled as if by repeated uses of conj.
    (hash-string* s)
    Private
    (hash-symbol sym)
    (hash-unordered-coll coll)
    Returns the hash code, consistent with =, for an external unordered
    collection implementing Iterable. For maps, the iterator should
    return map entries whose hash is computed as
      (hash-ordered-coll [k v]).
    See http://clojure.org/data_structures#hash for full algorithms.
    protocol
    Protocol for adding associativity to collections.
    
    (-assoc coll k v)
    Returns a new collection of coll with a mapping from key k to
    value v added to it.
    (-contains-key? coll k)
    Returns true if k is a key in coll.
    
    protocol
    Marker protocol indicating an atom.
    
    protocol
    Protocol for accessing the items of a chunk.
    
    (-drop-first coll)
    Return a new chunk of coll with the first item removed.
    
    protocol
    Protocol for accessing the chunks of a collection.
    
    (-chunked-next coll)
    Returns a new collection of coll without the first chunk.
    
    protocol
    Protocol for accessing a collection as sequential chunks.
    
    (-chunked-rest coll)
    Return a new collection of coll with the first chunk removed.
    
    (-chunked-first coll)
    Returns the first chunk in coll.
    
    protocol
    Protocol for cloning a value.
    
    (-clone value)
    Creates a clone of value.
    
    protocol
    Protocol for adding to a collection.
    
    (-conj coll o)
    Returns a new collection of coll with o added to it. The new item
    should be added to the most efficient place, e.g.
    (conj [1 2 3 4] 5) => [1 2 3 4 5]
    (conj '(2 3 4 5) 1) => '(1 2 3 4 5)
    protocol
    Protocol for values that can be compared.
    
    (-compare x y)
    Returns a negative number, zero, or a positive number when x is logically
    'less than', 'equal to', or 'greater than' y.
    protocol
    Protocol for adding the ability to count a collection in constant time.
    
    (-count coll)
    Calculates the count of coll in constant time. Used by cljs.core/count.
    
    (ident? x)
    Return true if x is a symbol or keyword
    
    (identical? x y)
    Tests if 2 arguments are the same object
    
    (identity x)
    Returns its argument.
    
    protocol
    Protocol for adding dereference functionality to a reference.
    
    (-deref o)
    Returns the value of the reference o.
    
    protocol
    (-deref-with-timeout o msec timeout-val)
    protocol
    Protocol for collections which can transformed to transients.
    
    (-as-transient coll)
    Returns a new, transient version of the collection, in constant time.
    
    protocol
    Protocol for creating an empty collection.
    
    (-empty coll)
    Returns an empty collection of the same category as coll. Used
    by cljs.core/empty.
    protocol
    (-js->clj x options)
    Transforms JavaScript values to Clojure
    
    protocol
    (-clj->js x)
    Recursively transforms clj values to JavaScript
    
    (-key->js x)
    Transforms map keys to valid JavaScript keys. Arbitrary keys are
    encoded to their string representation via (pr-str x)
    protocol
    Protocol for adding value comparison functionality to a type.
    
    (-equiv o other)
    Returns true if o and other are equal, false otherwise.
    
    protocol
    Protocol for implementing entry finding in collections.
    
    (-find coll k)
    Returns the map entry for key, or nil if key not present.
    
    (ifind? x)
    Returns true if coll implements IFind
    
    protocol
    Protocol for adding the ability to invoke an object as a function.
    For example, a vector can also be used to look up a value:
    ([1 2 3 4] 1) => 2
    (-invoke ???)(-invoke ???)
    (ifn? f)
    Returns true if f returns true for fn? or satisfies IFn.
    
    protocol
    Protocol for adding hashing functionality to a type.
    
    (-hash o)
    Returns the hash code of o.
    
    protocol
    Protocol for collections to provide indexed-based access to their items.
    
    (-nth ???)(-nth ???)(-nth ???)
    Returns the value at the index n in the collection coll.
    Returns not-found if index n is out of bounds and not-found is supplied.
    protocol
    Protocol for iterating over a collection.
    
    (-iterator coll)
    Returns an iterator for coll.
    
    protocol
    Protocol for associative types that can reduce themselves
    via a function of key and val. Called by cljs.core/reduce-kv.
    (-kv-reduce coll f init)
    Reduces an associative collection and returns the result. f should be
    a function that takes three arguments.
    protocol
    Marker interface indicating a persistent list
    
    protocol
    Protocol for looking up a value in a data structure.
    
    (-lookup ???)(-lookup ???)(-lookup ???)
    Use k to look up a value in o. If not-found is supplied and k is not
    a valid value that can be used for look up, not-found is returned.
    protocol
    Protocol for adding mapping functionality to collections.
    
    (-dissoc coll k)
    Returns a new collection of coll without the mapping for key k.
    
    protocol
    Protocol for examining a map entry.
    
    (-key coll)
    Returns the key of the map entry.
    
    (-val coll)
    Returns the value of the map entry.
    
    protocol
    Protocol for accessing the metadata of an object.
    
    (-meta o)
    Returns the metadata of object o.
    
    protocol
    (-prefer-method mf dispatch-val dispatch-val-y)
    (-default-dispatch-val mf)
    (-remove-method mf dispatch-val)
    (-dispatch-fn mf)
    (-add-method mf dispatch-val method)
    (-get-method mf dispatch-val)
    protocol
    Protocol for adding a name.
    
    (-name x)
    Returns the name String of x.
    
    (-namespace x)
    Returns the namespace String of x.
    
    (inc x)
    Returns a number one greater than num.
    
    (indexed? x)
    Returns true if coll implements nth in constant time
    
    protocol
    Protocol for accessing the next items of a collection.
    
    (-next coll)
    Returns a new collection of coll without the first item. In contrast to
    rest, it should return nil if there are no more items, e.g.
    (next []) => nil
    (next nil) => nil
    (infinite? x)
    Returns true for Infinity and -Infinity values.
    
    Private
    (inode-kv-reduce arr f init)
    (inst-ms inst)
    Return the number of milliseconds since January 1, 1970, 00:00:00 GMT
    
    (inst? x)
    Return true if x satisfies Inst
    
    (instance? c x)
    Evaluates x and tests if it is an instance of the type
    c. Returns true or false
    (int x)
    Coerce to int by stripping decimal places.
    
    (int-array ???)(int-array ???)
    Creates an array of ints. Does not coerce array, provided for compatibility
    with Clojure.
    (int-rotate-left x n)
    (int? x)
    Return true if x satisfies integer? or is an instance of goog.math.Integer
    or goog.math.Long.
    (integer? n)
    Returns true if n is a JavaScript number with no decimal part.
    
    (interleave ???)
    Returns a lazy seq of the first item in each coll, then the second etc.
    
    (interpose ???)(interpose ???)
    Returns a lazy seq of the elements of coll separated by sep.
    Returns a stateful transducer when no collection is provided.
    (into ???)
    Returns a new coll consisting of to-coll with all of the items of
    from-coll conjoined. A transducer may be supplied.
    (into-array ???)(into-array ???)
    Returns an array with components set to the values in aseq. Optional type
    argument accepted for compatibility with Clojure.
    protocol
    Protocol for types which can have a deferred realization. Currently only
    implemented by Delay and LazySeq.
    (-realized? x)
    Returns true if a value for x has been produced, false otherwise.
    
    protocol
    The old IPrintable protocol's implementation consisted of building a giant
    list of strings to concatenate.  This involved lots of concat calls,
    intermediate vectors, and lazy-seqs, and was very slow in some older JS
    engines.  IPrintWithWriter implements printing via the IWriter protocol, so it
    be implemented efficiently in terms of e.g. a StringBuffer append.
    (-pr-writer o writer opts)
    protocol
    Marker interface indicating a record object
    
    protocol
    Protocol for seq types that can reduce themselves.
    Called by cljs.core/reduce.
    (-reduce ???)(-reduce ???)(-reduce ???)
    f should be a function of 2 arguments. If start is not supplied,
    returns the result of applying f to the first 2 items in coll, then
    applying f to that result and the 3rd item, etc.
    protocol
    Protocol for adding resetting functionality.
    
    (-reset! o new-value)
    Sets the value of o to new-value.
    
    protocol
    Protocol for reversing a seq.
    
    (-rseq coll)
    Returns a seq of the items in coll in reversed order.
    
    (isa? ???)(isa? ???)(isa? ???)
    Returns true if (= child parent), or child is directly or indirectly derived from
    parent, either via a JavaScript type inheritance relationship or a
    relationship established via derive. h must be a hierarchy obtained
    from make-hierarchy, if not supplied defaults to the global
    hierarchy
    protocol
    Protocol for collections to provide access to their items as sequences.
    
    (-first coll)
    Returns the first item in the collection coll. Used by cljs.core/first.
    
    (-rest coll)
    Returns a new collection of coll without the first item. It should
    always return a seq, e.g.
    (rest []) => ()
    (rest nil) => ()
    protocol
    Protocol for adding the ability to a type to be transformed into a sequence.
    
    (-seq o)
    Returns a seq of o, or nil if o is empty.
    
    protocol
    Marker interface indicating a persistent collection of sequential items
    
    protocol
    Protocol for adding set functionality to a collection.
    
    (-disjoin coll v)
    Returns a new collection of coll that does not contain v.
    
    protocol
    Protocol for a collection which can represent their items
    in a sorted manner. 
    (-sorted-seq-from coll k ascending?)
    Returns a sorted seq from coll in either ascending or descending order.
    If ascending is true, the result should contain all items which are > or >=
    than k. If ascending is false, the result should contain all items which
    are < or <= than k, e.g.
    (-sorted-seq-from (sorted-set 1 2 3 4 5) 3 true) => (3 4 5)
    (-sorted-seq-from (sorted-set 1 2 3 4 5) 3 false) => (3 2 1)
    (-sorted-seq coll ascending?)
    Returns a sorted seq from coll in either ascending or descending order.
    
    (-comparator coll)
    Returns the comparator for coll.
    
    (-entry-key coll entry)
    Returns the key for entry.
    
    protocol
    Protocol for collections to provide access to their items as stacks. The top
    of the stack should be accessed in the most efficient way for the different
    data structures.
    (-pop coll)
    Returns a new stack without the item on top of the stack. Is used
    by cljs.core/pop.
    (-peek coll)
    Returns the item from the top of the stack. Is used by cljs.core/peek.
    
    protocol
    Protocol for adding swapping functionality.
    
    (-swap! ???)(-swap! ???)(-swap! ???)
    Swaps the value of o to be (apply f current-value-of-atom args).
    
    (iter coll)
    Private
    (iter-reduce ???)(iter-reduce ???)(iter-reduce ???)
    (iterable? x)
    Return true if x implements IIterable protocol.
    
    (iterate f x)
    Returns a lazy sequence of x, (f x), (f (f x)) etc. f must be free of side-effects
    
    protocol
    Protocol for adding associativity to transient collections.
    
    (-assoc! tcoll key val)
    Returns a new transient collection of tcoll with a mapping from key to
    val added to it.
    protocol
    Protocol for adding basic functionality to transient collections.
    
    (-persistent! tcoll)
    Creates a persistent data structure from tcoll and returns it.
    
    (-conj! tcoll val)
    Adds value val to tcoll and returns tcoll.
    
    protocol
    Protocol for adding mapping functionality to transient collections.
    
    (-dissoc! tcoll key)
    Returns a new transient collection of tcoll without the mapping for key.
    
    protocol
    Protocol for adding set functionality to a transient collection.
    
    (-disjoin! tcoll v)
    Returns tcoll without v.
    
    protocol
    Protocol for adding vector functionality to transient collections.
    
    (-pop! tcoll)
    Returns tcoll with the last item removed from it.
    
    (-assoc-n! tcoll n val)
    Returns tcoll with value val added at position n.
    
    protocol
    A marker protocol for UUIDs
    
    protocol
    Protocol for adding vector functionality to collections.
    
    (-assoc-n coll n val)
    Returns a new vector with value val added at position n.
    
    protocol
    Protocol for adding volatile functionality.
    
    (-vreset! o new-value)
    Sets the value of volatile o to new-value without regard for the
    current value. Returns new-value.
    protocol
    Protocol for types that can be watched. Currently only implemented by Atom.
    
    (-remove-watch this key)
    Removes watcher that corresponds to key from this.
    
    (-add-watch this key f)
    Adds a watcher function f to this. Keys must be unique per reference,
    and can be used to remove the watch with -remove-watch.
    (-notify-watches this oldval newval)
    Calls all watchers with this, oldval and newval.
    
    protocol
    Protocol for adding metadata to an object.
    
    (-with-meta o meta)
    Returns a new object with value of o and metadata meta added to it.
    
    protocol
    Protocol for writing. Currently only implemented by StringBufferWriter.
    
    (-write writer s)
    Writes s with writer and returns the result.
    
    (-flush writer)
    Flush writer.
    
    (js->clj ???)(js->clj ???)(js->clj ???)
    Recursively transforms JavaScript arrays into ClojureScript
    vectors, and JavaScript objects into ClojureScript maps.  With
    option ':keywordize-keys true' will convert object fields from
    strings to keywords.
    (js-delete obj key)
    Delete a property from a JavaScript object.
    
    (js-invoke obj s & args)
    Invoke JavaScript object method via string. Needed when the
    string is not a valid unquoted property name.
    (js-keys obj)
    Return the JavaScript keys for an object.
    
    (js-mod n d)
    Modulus of num and div with original javascript behavior. i.e. bug for negative numbers
    
    (js-obj ???)(js-obj ???)
    Create JavaSript object from an even number arguments representing
    interleaved keys and values.
    Private
    (js-reserved? x)
    (juxt ???)(juxt ???)
    Takes a set of functions and returns a fn that is the juxtaposition
    of those fns.  The returned fn takes a variable number of args, and
    returns a vector containing the result of applying each fn to the
    args (left-to-right).
    ((juxt a b c) x) => [(a x) (b x) (c x)]
    (keep ???)(keep ???)
    Returns a lazy sequence of the non-nil results of (f item). Note,
    this means false return values will be included.  f must be free of
    side-effects.  Returns a transducer when no collection is provided.
    (keep-indexed ???)(keep-indexed ???)
    Returns a lazy sequence of the non-nil results of (f index item). Note,
    this means false return values will be included.  f must be free of
    side-effects.  Returns a stateful transducer when no collection is
    provided.
    (key map-entry)
    Returns the key of the map entry.
    
    (key-test key other)
    (keys hash-map)
    Returns a sequence of the map's keys.
    
    (keyword ???)(keyword ???)
    Returns a Keyword with the given namespace and name.  Do not use :
    in the keyword strings, it will be added automatically.
    (keyword-identical? x y)
    Efficient test to determine that two keywords are identical.
    
    (keyword? x)
    Return true if x is a Keyword
    
    (last s)
    Return the last item in coll, in linear time
    
    Private
    (lift-ns m)
    Returns [lifted-ns lifted-map] or nil if m can't be lifted.
    
    Private
    (linear-traversal-nth ???)(linear-traversal-nth ???)(linear-traversal-nth ???)
    (list & xs)
    Creates a new list containing the items.
    
    (list* ???)(list* ???)
    Creates a new list containing the items prepended to the rest, the
    last of which will be treated as a sequence.
    (list? x)
    Returns true if x implements IList
    
    (load-file file)
    (long x)
    Coerce to long by stripping decimal places. Identical to `int'.
    
    (long-array ???)(long-array ???)
    Creates an array of longs. Does not coerce array, provided for compatibility
    with Clojure.
    (m3-fmix h1 len)
    (m3-hash-int in)
    (m3-hash-unencoded-chars in)
    (m3-mix-H1 h1 k1)
    (m3-mix-K1 k1)
    (make-array ???)(make-array ???)
    Construct a JavaScript array of the specified dimensions. Accepts ignored
    type argument for compatibility with Clojure. Note that there is no efficient
    way to allocate multi-dimensional arrays in JavaScript; as such, this function
    will run in polynomial time when called with 3 or more arguments.
    (make-hierarchy)
    Creates a hierarchy object for use with derive, isa? etc.
    
    (map ???)(map ???)
    Returns a lazy sequence consisting of the result of applying f to
    the set of first items of each coll, followed by applying f to the
    set of second items in each coll, until any one of the colls is
    exhausted.  Any remaining items in other colls are ignored. Function
    f should accept number-of-colls arguments. Returns a transducer when
    no collection is provided.
    (map-indexed ???)(map-indexed ???)
    Returns a lazy sequence consisting of the result of applying f to 0
    and the first item of coll, followed by applying f to 1 and the second
    item in coll, etc, until coll is exhausted. Thus function f should
    accept 2 arguments, index and item. Returns a stateful transducer when
    no collection is provided.
    (map? x)
    Return true if x satisfies IMap
    
    (mapcat ???)(mapcat ???)(mapcat ???)
    Returns the result of applying concat to the result of applying map
    to f and colls.  Thus function f should return a collection. Returns
    a transducer when no collections are provided
    (mapv ???)(mapv ???)(mapv ???)
    Returns a vector consisting of the result of applying f to the
    set of first items of each coll, followed by applying f to the set
    of second items in each coll, until any one of the colls is
    exhausted.  Any remaining items in other colls are ignored. Function
    f should accept number-of-colls arguments.
    Private
    (mask hash shift)
    (max ???)(max ???)
    Returns the greatest of the nums.
    
    (max-key ???)(max-key ???)(max-key ???)
    Returns the x for which (k x), a number, is greatest.
    
    Private
    (maybe-warn e)
    (memoize f)
    Returns a memoized version of a referentially transparent function. The
    memoized version of the function keeps a cache of the mapping from arguments
    to results and, when calls with the same arguments are repeated often, has
    higher performance at the expense of higher memory use.
    (merge & maps)
    Returns a map that consists of the rest of the maps conj-ed onto
    the first.  If a key occurs in more than one map, the mapping from
    the latter (left-to-right) will be the mapping in the result.
    (merge-with f & maps)
    Returns a map that consists of the rest of the maps conj-ed onto
    the first.  If a key occurs in more than one map, the mapping(s)
    from the latter (left-to-right) will be combined with the mapping in
    the result by calling (f val-in-result val-in-latter).
    (meta o)
    Returns the metadata of obj, returns nil if there is no metadata.
    
    (methods multifn)
    Given a multimethod, returns a map of dispatch values -> dispatch fns
    
    (min ???)(min ???)
    Returns the least of the nums.
    
    (min-key ???)(min-key ???)(min-key ???)
    Returns the x for which (k x), a number, is least.
    
    (missing-protocol proto obj)
    (mix-collection-hash hash-basis count)
    Mix final collection hash for ordered or unordered collections.
    hash-basis is the combined collection hash, count is the number
    of elements included in the basis. Note this is the hash code
    consistent with =, different from .hashCode.
    See http://clojure.org/data_structures#hash for full algorithms.
    (mk-bound-fn sc test key)
    (mod n d)
    Modulus of num and div. Truncates toward negative infinity.
    
    (munge name)
    Private
    (munge-str name)
    (name x)
    Returns the name String of a string, symbol or keyword.
    
    (namespace x)
    Returns the namespace String of a symbol or keyword, or nil if not present.
    
    (nat-int? x)
    Return true if x satisfies int? and is a natural integer value.
    
    (native-satisfies? p x)
    Internal - do not use!
    
    (neg-int? x)
    Return true if x satisfies int? and is negative.
    
    (neg? x)
    Returns true if num is less than zero, else false
    
    Private
    (new-path edit level node)
    (newline ???)
    Prints a newline using *print-fn*
    
    (next coll)
    Returns a seq of the items after the first. Calls seq on its
    argument.  If there are no more items, returns nil
    (nfirst coll)
    Same as (next (first x))
    
    (nil? x)
    Returns true if x is nil, false otherwise.
    
    (nnext coll)
    Same as (next (next x))
    
    (not x)
    Returns true if x is logical false, false otherwise.
    
    (not-any? pred coll)
    Returns false if (pred x) is logical true for any x in coll,
    else true.
    (not-empty coll)
    If coll is empty, returns nil, else coll
    
    (not-every? pred coll)
    Returns false if (pred x) is logical true for every x in
    coll, else true.
    (not= ???)(not= ???)
    Same as (not (= obj1 obj2))
    
    (ns-interns* sym)
    Returns a map of the intern mappings for the namespace.
    Bootstrap only.
    Private
    (ns-lookup ns-obj k)
    Bootstrap only.
    
    (ns-name ns-obj)
    Returns the name of the namespace, a Namespace object.
    Bootstrap only.
    Bootstrap only.
    
    (nth ???)(nth ???)(nth ???)
    Returns the value at the index. get returns nil if index out of
    bounds, nth throws an exception unless not-found is supplied.  nth
    also works for strings, arrays, regex Matchers and Lists, and,
    in O(n) time, for sequences.
    (nthnext coll n)
    Returns the nth next of coll, (seq coll) when n is 0.
    
    (nthrest coll n)
    Returns the nth rest of coll, coll when n is 0.
    
    (number? x)
    Returns true if x is a JavaScript number.
    
    Private
    (obj-clone obj ks)
    (obj-map & keyvals)
    keyval => key val
    Returns a new object map with supplied mappings.
    Private
    (obj-map->hash-map m k v)
    Private
    (obj-map-compare-keys a b)
    (object-array ???)(object-array ???)
    Creates an array of objects. Does not coerce array, provided for compatibility
    with Clojure.
    (object? x)
    Returns true if x's constructor is Object
    
    (odd? n)
    Returns true if n is odd, throws an exception if n is not an integer
    
    Private
    (pack-array-node array-node edit idx)
    (parents ???)(parents ???)
    Returns the immediate parents of tag, either via a JavaScript type
    inheritance relationship or a relationship established via derive. h
    must be a hierarchy obtained from make-hierarchy, if not supplied
    defaults to the global hierarchy
    (partial ???)(partial ???)
    Takes a function f and fewer than the normal arguments to f, and
    returns a fn that takes a variable number of additional args. When
    called, the returned function calls f with args + additional args.
    (partition ???)(partition ???)(partition ???)
    Returns a lazy sequence of lists of n items each, at offsets step
    apart. If step is not supplied, defaults to n, i.e. the partitions
    do not overlap. If a pad collection is supplied, use its elements as
    necessary to complete last partition up to n items. In case there are
    not enough padding elements, return a partition with less than n items.
    (partition-all ???)(partition-all ???)
    Returns a lazy sequence of lists like partition, but may include
    partitions with fewer than n items at the end.  Returns a stateful
    transducer when no collection is provided.
    (partition-by ???)(partition-by ???)
    Applies f to each value in coll, splitting it each time f returns a
    new value.  Returns a lazy seq of partitions.  Returns a stateful
    transducer when no collection is provided.
    (peek coll)
    For a list or queue, same as first, for a vector, same as, but much
    more efficient than, last. If the collection is empty, returns nil.
    (persistent! tcoll)
    Returns a new, persistent version of the transient collection, in
    constant time. The transient collection cannot be used after this
    call, any such use will throw an exception.
    (persistent-array-map-seq arr i _meta)
    (pop coll)
    For a list or queue, returns a new list/queue without the first
    item, for a vector, returns a new vector without the last item.
    Note - not the same as next/butlast.
    (pop! tcoll)
    Removes the last item from a transient vector. If
    the collection is empty, throws an exception. Returns tcoll
    Private
    (pop-tail pv level node)
    (pos-int? x)
    Return true if x satisfies int? and is positive.
    
    (pos? x)
    Returns true if num is greater than zero, else false
    
    (pr & objs)
    Prints the object(s) using string-print.  Prints the
    object(s), separated by spaces if there is more than one.
    By default, pr and prn print in a way that objects can be
    read by the reader
    Private
    (pr-opts)
    Private
    (pr-sb-with-opts objs opts)
    (pr-seq-writer objs writer opts)
    (pr-sequential-writer writer print-one begin sep end opts coll)
    (pr-str & objs)
    pr to a string, returning it. Fundamental entrypoint to IPrintWithWriter.
    
    (pr-str* obj)
    Support so that collections can implement toString without
    loading all the printing machinery.
    (pr-str-with-opts objs opts)
    Prints a sequence of objects to a string, observing all the
    options given in opts
    Private
    (pr-with-opts objs opts)
    Prints a sequence of objects using string-print, observing all
    the options given in opts
    Private
    (pr-writer obj writer opts)
    Prefer this to pr-seq, because it makes the printing function
    configurable, allowing efficient implementations such as appending
    to a StringBuffer.
    Private
    (pr-writer-ex-info obj writer opts)
    Private
    (pr-writer-impl obj writer opts)
    (prefer-method multifn dispatch-val-x dispatch-val-y)
    Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y
    when there is a conflict
    (prefers multifn)
    Given a multimethod, returns a map of preferred value -> set of other values
    
    Private
    (prefers* x y prefer-table)
    Private
    (preserving-reduced rf)
    (prim-seq ???)(prim-seq ???)
    Create seq from a primitive JavaScript Array-like.
    
    Prints the object(s) using string-print.
    print and println produce output for human consumption.
    (print-map m print-one writer opts)
    (print-meta? opts obj)
    (print-prefix-map prefix m print-one writer opts)
    (print-str & objs)
    print to a string, returning it
    
    (println & objs)
    Same as print followed by (newline)
    
    (println-str & objs)
    println to a string, returning it
    
    (prn & objs)
    Same as pr followed by (newline).
    
    (prn-str & objs)
    Same as pr-str followed by (newline)
    
    (prn-str-with-opts objs opts)
    Same as pr-str-with-opts followed by (newline)
    
    Private
    (push-tail pv level parent tailnode)
    Private
    (pv-aget node idx)
    Private
    (pv-aset node idx val)
    Private
    (pv-clone-node node)
    Private
    (pv-fresh-node edit)
    Private
    (pv-reduce ???)(pv-reduce ???)(pv-reduce ???)(pv-reduce ???)(pv-reduce ???)
    (qualified-ident? x)
    Return true if x is a symbol or keyword with a namespace
    
    (qualified-keyword? x)
    Return true if x is a keyword with a namespace
    
    (qualified-symbol? x)
    Return true if x is a symbol with a namespace
    
    (quot n d)
    quot[ient] of dividing numerator by denominator.
    
    Private
    (quote-string s)
    (rand ???)
    Returns a random floating point number between 0 (inclusive) and
    n (default 1) (exclusive).
    (rand-int n)
    Returns a random integer between 0 (inclusive) and n (exclusive).
    
    (rand-nth coll)
    Return a random element of the (sequential) collection. Will have
    the same performance characteristics as nth for the given
    collection.
    (random-sample ???)(random-sample ???)
    Returns items from coll with random probability of prob (0.0 -
    1.0).  Returns a transducer when no collection is provided.
    (range ???)
    Returns a lazy seq of nums from start (inclusive) to end
    (exclusive), by step, where start defaults to 0, step to 1,
    and end to infinity.
    (ranged-iterator v start end)
    (re-find re s)
    Returns the first regex match, if any, of s to re, using
    re.exec(s). Returns a vector, containing first the matching
    substring, then any capturing groups if the regular expression contains
    capturing groups.
    (re-matches re s)
    Returns the result of (re-find re s) if re fully matches s.
    
    (re-pattern s)
    Returns an instance of RegExp which has compiled the provided string.
    
    (re-seq re s)
    Returns a lazy sequence of successive matches of re in s.
    
    (realized? x)
    Returns true if a value has been produced for a delay or lazy sequence.
    
    (record? x)
    Return true if x satisfies IRecord
    
    (reduce ???)(reduce ???)(reduce ???)
    f should be a function of 2 arguments. If val is not supplied,
    returns the result of applying f to the first 2 items in coll, then
    applying f to that result and the 3rd item, etc. If coll contains no
    items, f must accept no arguments as well, and reduce returns the
    result of calling f with no arguments.  If coll has only 1 item, it
    is returned and f is not called.  If val is supplied, returns the
    result of applying f to val and the first item in coll, then
    applying f to that result and the 2nd item, etc. If coll contains no
    items, returns val and f is not called.
    (reduce-kv f init coll)
    Reduces an associative collection. f should be a function of 3
    arguments. Returns the result of applying f to init, the first key
    and the first value in coll, then applying f to that result and the
    2nd key and value, etc. If coll contains no entries, returns init
    and f is not called. Note that reduce-kv is supported on vectors,
    where the keys will be the ordinals.
    (reduceable? x)
    Returns true if coll satisfies IReduce
    
    (reduced x)
    Wraps x in a way such that a reduce will terminate with the value x
    
    (reduced? r)
    Returns true if x is the result of a call to reduced
    
    (reductions ???)(reductions ???)(reductions ???)
    Returns a lazy seq of the intermediate values of the reduction (as
    per reduce) of coll by f, starting with init.
    (regexp? x)
    Returns true if x is a JavaScript RegExp instance.
    
    (rem n d)
    remainder of dividing numerator by denominator.
    
    (remove ???)(remove ???)
    Returns a lazy sequence of the items in coll for which
    (pred item) returns false. pred must be free of side-effects.
    Returns a transducer when no collection is provided.
    (remove-all-methods multifn)
    Removes all of the methods of multimethod.
    
    (remove-method multifn dispatch-val)
    Removes the method of multimethod associated with dispatch-value.
    
    Private
    (remove-pair arr i)
    (remove-watch iref key)
    Removes a watch (set by add-watch) from a reference
    
    (repeat ???)(repeat ???)
    Returns a lazy (infinite!, or length n if supplied) sequence of xs.
    
    (repeatedly ???)(repeatedly ???)
    Takes a function of no args, presumably with side effects, and
    returns an infinite (or length n if supplied) lazy sequence of calls
    to it
    (replace ???)(replace ???)
    Given a map of replacement pairs and a vector/collection, returns a
    vector/seq with any elements = a key in smap replaced with the
    corresponding val in smap.  Returns a transducer when no collection
    is provided.
    (replicate n x)
    DEPRECATED: Use 'repeat' instead.
    Returns a lazy seq of n xs.
    (reset! a new-value)
    Sets the value of atom to newval without regard for the
    current value. Returns new-value.
    Private
    (reset-cache method-cache method-table cached-hierarchy hierarchy)
    (reset-meta! iref m)
    Atomically resets the metadata for an atom
    
    (reset-vals! a new-value)
    Sets the value of atom to newval. Returns [old new], the value of the
    atom before and after the reset.
    (rest coll)
    Returns a possibly empty seq of the items after the first. Calls seq on its
    argument.
    (reverse coll)
    Returns a seq of the items in coll in reverse order. Not lazy.
    
    (reversible? coll)
    Returns true if coll satisfies? IReversible.
    
    (rseq rev)
    Returns, in constant time, a seq of the items in rev (which
    can be a vector or sorted-map), in reverse order. If rev is empty returns nil
    (rsubseq ???)(rsubseq ???)(rsubseq ???)(rsubseq ???)(rsubseq ???)
    sc must be a sorted collection, test(s) one of <, <=, > or
    >=. Returns a reverse seq of those entries with keys ek for
    which (test (.. sc comparator (compare ek key)) 0) is true
    (run! proc coll)
    Runs the supplied procedure (via reduce), for purposes of side
    effects, on successive items in the collection. Returns nil
    Private
    (scan-array incr k array)
    (second coll)
    Same as (first (next x))
    
    (select-keys map keyseq)
    Returns a map containing only those entries in map whose key is in keys
    
    (seq coll)
    Returns a seq on the collection. If the collection is
    empty, returns nil.  (seq nil) returns nil. seq also works on
    Strings.
    (seq-iter coll)
    Private
    (seq-reduce ???)(seq-reduce ???)(seq-reduce ???)
    (seq? s)
    Return true if s satisfies ISeq
    
    (seqable? s)
    Return true if the seq function is supported for s
    
    (sequence ???)(sequence ???)
    Coerces coll to a (possibly empty) sequence, if it is not already
    one. Will not force a lazy seq. (sequence nil) yields (), When a
    transducer is supplied, returns a lazy sequence of applications of
    the transform to the items in coll(s), i.e. to the set of first
    items of each coll, followed by the set of second
    items in each coll, until any one of the colls is exhausted.  Any
    remaining items in other colls are ignored. The transform should accept
    number-of-colls arguments
    (sequential? x)
    Returns true if coll satisfies ISequential
    
    (set coll)
    Returns a set of the distinct elements of coll.
    
    (set-from-indexed-seq iseq)
    (set-print-err-fn! f)
    Set *print-err-fn* to f.
    
    (set-print-fn! f)
    Set *print-fn* to f.
    
    (set-validator! iref val)
    Sets the validator-fn for an atom. validator-fn must be nil or a
    side-effect-free fn of one argument, which will be passed the intended
    new state on any state change. If the new state is unacceptable, the
    validator-fn should return false or throw an Error. If the current state
    is not acceptable to the new validator, an Error will be thrown and the
    validator will not be changed.
    (set? x)
    Returns true if x satisfies ISet
    
    (shuffle coll)
    Return a random permutation of coll
    
    (simple-ident? x)
    Return true if x is a symbol or keyword without a namespace
    
    (simple-keyword? x)
    Return true if x is a keyword without a namespace
    
    (simple-symbol? x)
    Return true if x is a symbol without a namespace
    
    (some pred coll)
    Returns the first logical true value of (pred x) for any x in coll,
    else nil.  One common idiom is to use a set as pred, for example
    this will return :fred if :fred is in the sequence, otherwise nil:
    (some #{:fred} coll)
    (some-fn ???)(some-fn ???)
    Takes a set of predicates and returns a function f that returns the first logical true value
    returned by one of its composing predicates against any of its arguments, else it returns
    logical false. Note that f is short-circuiting in that it will stop execution on the first
    argument that triggers a logical true result against the original predicates.
    (some? x)
    Returns true if x is not nil, false otherwise.
    
    (sort ???)(sort ???)
    Returns a sorted sequence of the items in coll. Comp can be
    boolean-valued comparison function, or a -/0/+ valued comparator.
    Comp defaults to compare.
    (sort-by ???)(sort-by ???)(sort-by ???)
    Returns a sorted sequence of the items in coll, where the sort
    order is determined by comparing (keyfn item).  Comp can be
    boolean-valued comparison funcion, or a -/0/+ valued comparator.
    Comp defaults to compare.
    (sorted-map & keyvals)
    keyval => key val
    Returns a new sorted map with supplied mappings.
    (sorted-map-by comparator & keyvals)
    keyval => key val
    Returns a new sorted map with supplied mappings, using the supplied comparator.
    (sorted-set & keys)
    Returns a new sorted set with supplied keys.
    
    (sorted-set-by comparator & keys)
    Returns a new sorted set with supplied keys, using the supplied comparator.
    
    (sorted? x)
    Returns true if coll satisfies ISorted
    
    (special-symbol? x)
    Returns true if x names a special form
    
    (split-at n coll)
    Returns a vector of [(take n coll) (drop n coll)]
    
    (split-with pred coll)
    Returns a vector of [(take-while pred coll) (drop-while pred coll)]
    
    (spread arglist)
    (str ???)
    With no args, returns the empty string. With one arg x, returns
    x.toString().  (str nil) returns the empty string. With more than
    one arg, returns the concatenation of the str values of the args.
    (string-print x)
    (string? x)
    Returns true if x is a JavaScript string.
    
    Private
    (strip-ns named)
    (subs ???)(subs ???)(subs ???)
    Returns the substring of s beginning at start inclusive, and ending
    at end (defaults to length of string), exclusive.
    (subseq ???)(subseq ???)(subseq ???)(subseq ???)(subseq ???)
    sc must be a sorted collection, test(s) one of <, <=, > or
    >=. Returns a seq of those entries with keys ek for
    which (test (.. sc comparator (compare ek key)) 0) is true
    (subvec ???)(subvec ???)(subvec ???)
    Returns a persistent vector of the items in vector from
    start (inclusive) to end (exclusive).  If end is not supplied,
    defaults to (count vector). This operation is O(1) and very fast, as
    the resulting vector shares structure with the original and no
    trimming is done.
    (swap! ???)(swap! ???)(swap! ???)
    Atomically swaps the value of atom to be:
    (apply f current-value-of-atom args). Note that f may be called
    multiple times, and thus should be free of side effects.  Returns
    the value that was swapped in.
    Private
    (swap-global-hierarchy! f & args)
    (swap-vals! ???)(swap-vals! ???)(swap-vals! ???)
    Atomically swaps the value of atom to be:
    (apply f current-value-of-atom args). Note that f may be called
    multiple times, and thus should be free of side effects.
    Returns [old new], the value of the atom before and after the swap.
    (symbol ???)(symbol ???)
    Returns a Symbol with the given namespace and name.
    
    (symbol-identical? x y)
    Efficient test to determine that two symbols are identical.
    
    (symbol? x)
    Return true if x is a Symbol
    
    (system-time)
    Returns highest resolution time offered by host in milliseconds.
    
    (tagged-literal tag form)
    Construct a data representation of a tagged literal from a
    tag symbol and a form.
    (tagged-literal? value)
    Return true if the value is the data representation of a tagged literal
    
    Private
    (tail-off pv)
    (take ???)(take ???)
    Returns a lazy sequence of the first n items in coll, or all items if
    there are fewer than n.  Returns a stateful transducer when
    no collection is provided.
    (take-last n coll)
    Returns a seq of the last n items in coll.  Depending on the type
    of coll may be no better than linear time.  For vectors, see also subvec.
    (take-nth ???)(take-nth ???)
    Returns a lazy seq of every nth item in coll.  Returns a stateful
    transducer when no collection is provided.
    (take-while ???)(take-while ???)
    Returns a lazy sequence of successive items from coll while
    (pred item) returns true. pred must be free of side-effects.
    Returns a transducer when no collection is provided.
    (test v)
    test [v] finds fn at key :test in var metadata and calls it,
    presuming failure will throw exception
    Private
    (throw-no-method-error name dispatch-val)
    (to-array s)
    Naive impl of to-array as a start.
    
    (to-array-2d coll)
    Returns a (potentially-ragged) 2-dimensional array
    containing the contents of coll.
    (trampoline ???)(trampoline ???)(trampoline ???)
    trampoline can be used to convert algorithms requiring mutual
    recursion without stack consumption. Calls f with supplied args, if
    any. If f returns a fn, calls that fn with no arguments, and
    continues to repeat, until the return value is not a fn, then
    returns that non-fn value. Note that if you want to return a fn as a
    final value, you must wrap it in some data structure and unpack it
    after trampoline returns.
    (transduce ???)(transduce ???)(transduce ???)(transduce ???)
    reduce with a transformation of f (xf). If init is not
    supplied, (f) will be called to produce it. f should be a reducing
    step function that accepts both 1 and 2 arguments, if it accepts
    only 2 you can add the arity-1 with 'completing'. Returns the result
    of applying (the transformed) xf to init and the first item in coll,
    then applying xf to that result and the 2nd item, etc. If coll
    contains no items, returns init and f is not called. Note that
    certain transforms may inject or skip items.
    (transformer-iterator xform sourceIter multi)
    (transient coll)
    Returns a new, transient version of the collection, in constant time.
    
    Private
    (tree-map-add comp tree k v found)
    Private
    (tree-map-append left right)
    Private
    (tree-map-kv-reduce node f init)
    Private
    (tree-map-remove comp tree k found)
    Private
    (tree-map-replace comp tree k v)
    Private
    (tree-map-seq-push node stack ascending?)
    (tree-seq branch? children root)
    Returns a lazy sequence of the nodes in a tree, via a depth-first walk.
    branch? must be a fn of one arg that returns true if passed a node
    that can have children (but may not).  children must be a fn of one
    arg that returns a sequence of the children. Will only be called on
    nodes for which branch? returns true. Root is the root node of the
    tree.
    (true? x)
    Returns true if x is the value true, false otherwise.
    
    (truth_ x)
    Internal - do not use!
    
    Private
    (tv-editable-root node)
    Private
    (tv-editable-tail tl)
    Private
    (tv-ensure-editable edit node)
    Private
    (tv-pop-tail tv level node)
    Private
    (tv-push-tail tv level parent tail-node)
    (type x)
    Return x's constructor.
    
    (type->str ty)
    (unchecked-add ???)
    Returns the sum of nums. (+) returns 0.
    
    (unchecked-add-int ???)
    Returns the sum of nums. (+) returns 0.
    
    Private
    (unchecked-array-for pv i)
    (unchecked-byte x)
    (unchecked-char x)
    (unchecked-dec x)
    Returns a number one less than x, an int.
    
    (unchecked-dec-int x)
    Returns a number one less than x, an int.
    
    (unchecked-divide-int ???)(unchecked-divide-int ???)
    If no denominators are supplied, returns 1/numerator,
    else returns numerator divided by all of the denominators.
    (unchecked-double x)
    Private
    (unchecked-editable-array-for tv i)
    (unchecked-float x)
    (unchecked-inc x)
    (unchecked-inc-int x)
    (unchecked-int x)
    Coerce to int by stripping decimal places.
    
    (unchecked-long x)
    Coerce to long by stripping decimal places. Identical to `int'.
    
    (unchecked-multiply ???)
    Returns the product of nums. (*) returns 1.
    
    (unchecked-multiply-int ???)
    Returns the product of nums. (*) returns 1.
    
    (unchecked-negate x)
    (unchecked-negate-int x)
    (unchecked-remainder-int x n)
    (unchecked-short x)
    (unchecked-subtract ???)(unchecked-subtract ???)
    If no ys are supplied, returns the negation of x, else subtracts
    the ys from x and returns the result.
    (unchecked-subtract-int ???)(unchecked-subtract-int ???)
    If no ys are supplied, returns the negation of x, else subtracts
    the ys from x and returns the result.
    (undefined? x)
    Returns true if x identical to the JavaScript undefined value.
    
    (underive ???)(underive ???)(underive ???)
    Removes a parent/child relationship between parent and
    tag. h must be a hierarchy obtained from make-hierarchy, if not
    supplied defaults to, and modifies, the global hierarchy.
    (unreduced x)
    If x is reduced?, returns (deref x), else returns x
    
    (unsigned-bit-shift-right x n)
    Bitwise shift right with zero fill
    
    (update ???)(update ???)(update ???)(update ???)
    'Updates' a value in an associative structure, where k is a
    key and f is a function that will take the old value
    and any supplied args and return the new value, and returns a new
    structure.  If the key does not exist, nil is passed as the old value.
    (update-in ???)(update-in k & ks)(update-in ???)(update-in ???)
    'Updates' a value in a nested associative structure, where ks is a
    sequence of keys and f is a function that will take the old value
    and any supplied args and return the new value, and returns a new
    nested structure.  If any levels do not exist, hash-maps will be
    created.
    (uri? x)
    Returns true X is a goog.Uri instance.
    
    (val map-entry)
    Returns the value in the map entry.
    
    (vals hash-map)
    Returns a sequence of the map's values.
    
    (var? v)
    Returns true if v is of type cljs.core.Var
    
    (vary-meta ???)(vary-meta ???)(vary-meta ???)
    Returns an object of the same type and value as obj, with
    (apply f (meta obj) args) as its metadata.
    (vec coll)
    Creates a new vector containing the contents of coll. JavaScript arrays
    will be aliased and should not be modified.
    (vector & args)
    Creates a new vector containing the args.
    
    Private
    (vector-index-out-of-bounds i cnt)
    (vector? x)
    Return true if x satisfies IVector
    
    (volatile! val)
    Creates and returns a Volatile with an initial value of val.
    
    (volatile? x)
    Returns true if x is a volatile.
    
    (vreset! vol newval)
    Sets the value of volatile to newval without regard for the
    current value. Returns newval.
    (with-meta o meta)
    Returns an object of the same type and value as obj, with
    map m as its metadata.
    (write-all writer & ss)
    (zero? x)
    Returns true if num is zero, else false
    
    (zipmap keys vals)
    Returns a map with the keys mapped to the corresponding vals.