cljs.core

*+-./<=>A B C D E F G H I J K L M N O P Q R S T U V W Z

*

*
Returns the product of nums. (*) returns 1.
macro
([] [x] [x y] [x y & more])
*1
bound in a repl thread to the most recent value printed
value
*2
bound in a repl thread to the second most recent value printed
value
*3
bound in a repl thread to the third most recent value printed
value
*assert*
value
*clojurescript-version*
value
*command-line-args*
A sequence of the supplied command line arguments, or nil if none were supplied
value
*e
bound in a repl thread to the most recent exception caught by the repl
value
*eval*
Runtime environments may provide a way to evaluate ClojureScript forms. Whatever function *eval* is bound to will be pas...
value
*exec-tap-fn*
Arranges to have tap functions executed via the supplied f, a function of no arguments. Returns true if successful, fals...
value
([f])
*flush-on-newline*
When set to true, output will be flushed whenever a newline is printed. Defaults to true.
value
*global*
Manually set the JavaScript global context. Only "window", "self" , and "global" supported.
value
*loaded-libs*
value
*main-cli-fn*
When compiled for a command-line target, whatever function *main-cli-fn* is set to will be called with the command-line ...
value
*ns*
Var bound to the current namespace. Only used for bootstrapping.
value
*out*
value
*print-dup*
When set to logical true, objects will be printed in a way that preserves their type when read in later. Defaults to fa...
value
*print-err-fn*
Each runtime environment provides a different way to print error output. Whatever function *print-err-fn* is bound to wi...
value
*print-fn*
Each runtime environment provides a different way to print output. Whatever function *print-fn* is bound to will be pass...
value
*print-fn-bodies*
*print-fns-bodies* controls whether functions print their source or only their names.
value
*print-length*
*print-length* controls how many items of each collection the printer will print. If it is bound to logical false, there...
value
*print-level*
*print-level* controls how many levels deep the printer will print nested objects. If it is bound to logical false, ther...
value
*print-meta*
If set to logical true, when printing an object, its metadata will also be printed in a form that can be read back by th...
value
*print-namespace-maps*
*print-namespace-maps* controls whether the printer will print namespace map literal syntax. Defaults to false, but the...
value
*print-newline*
When set to logical false will drop newlines from printing calls. This is to work around the implicit newlines emitted b...
value
*print-readably*
When set to logical false, strings and characters will be printed with non-alphanumeric characters converted to the appr...
value
*target*
Var bound to the name value of the compiler build :target option. For example, if the compiler build :target is :nodejs,...
value
*unchecked-arrays*
value
*unchecked-if*
value
*warn-on-infer*
value

+

+
Returns the sum of nums. (+) returns 0.
macro
([] [x] [x y] [x y & more])

-

-
If no ys are supplied, returns the negation of x, else subtracts the ys from x and returns the result.
macro
([x] [x y] [x y & more])
--destructure-map
function
([gmap])
->
Threads the expr through the forms. Inserts x as the second item in the first form, making a list of it if it is not a l...
macro
([x & forms])
->>
Threads the expr through the forms. Inserts x as the last item in the first form, making a list of it if it is not a lis...
macro
([x & forms])

.

.
The instance member form works for methods and fields. They all expand into calls to the dot operator at macroexpansion ...
special-form
([.instanceMethod instance args*] [.-instanceField instance])
..
form => fieldName-symbol or (instanceMethodName-symbol args*) Expands into a member access (.) of the first member on t...
macro
([x form] [x form & more])

/

/
If no denominators are supplied, returns 1/numerator, else returns numerator divided by all of the denominators.
macro
([x] [x y] [x y & more])

<

<
Returns non-nil if nums are in monotonically increasing order, otherwise false.
macro
([x] [x y] [x y & more])
<=
Returns non-nil if nums are in monotonically non-decreasing order, otherwise false.
macro
([x] [x y] [x y & more])

=

=
Equality. Returns true if x equals y, false if not. Compares numbers and collections in a type-independent manner. Cloj...
function
([x] [x y] [x y & more])
==
Returns non-nil if nums all have the equivalent value, otherwise false. Behavior on non nums is undefined.
macro
([x] [x y] [x y & more])

>

>
Returns non-nil if nums are in monotonically decreasing order, otherwise false.
macro
([x] [x y] [x y & more])
>=
Returns non-nil if nums are in monotonically non-increasing order, otherwise false.
macro
([x] [x y] [x y & more])

A

APersistentVector
Marker protocol
protocol
ASeq
Marker protocol indicating an array sequence.
protocol
ArrayChunk
value
([arr off end])
ArrayIter
value
([arr i])
ArrayList
value
([arr])
ArrayNode
value
([edit cnt arr])
ArrayNodeIterator
value
([arr i next-iter])
ArrayNodeSeq
value
([meta nodes i s __hash])
Atom
value
([state meta validator watches])
abs
Returns the absolute value of a.
function
([a])
aclone
Returns a javascript array, cloned from the passed in array
function
([arr])
add-tap
Adds f, a fn of one argument, to the tap set. This function will be called with anything sent via tap>. Remember f in or...
function
([f])
add-to-string-hash-cache
function
([k])
add-watch
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, it...
function
([iref key f])
aget
Returns the value at the index/indices. Works on JavaScript arrays.
macro
([array idx] [array idx & idxs])
alength
Returns the length of the array. Works on arrays of all types.
macro
([array])
alter-meta!
Atomically sets the metadata for a namespace/var/ref/agent/atom to be: (apply f its-current-meta args) f must be free ...
function
([iref f & args])
amap
Maps an expression across an array a, using an index named idx, and return value named ret, initialized to a clone of a,...
macro
([a idx ret expr])
ancestors
Returns the immediate and indirect parents of tag, either via a JavaScript type inheritance relationship or a relationsh...
function
([tag] [h tag])
and
Evaluates exprs one at a time, from left to right. If a form returns logical false (nil or false), and returns that valu...
macro
([] [x] [x & next])
any?
Returns true if given any argument.
function
([x])
apply
Applies fn f to the argument list formed by prepending intervening arguments to args.
function
([f args] [f x args] [f x y args] [f x y z args] [f a b c d & args])
areduce
Reduces an expression across an array a, using an index named idx, and return value named ret, initialized to init, sett...
macro
([a idx ret init expr])
array
Creates a new javascript array. @param {...*} var_args
macro
([var-args])
array-chunk
function
([arr] [arr off] [arr off end])
array-index-of
function
([arr k])
array-iter
function
([x])
array-list
function
([])
array-map
keyval => key val Returns a new array map with supplied mappings.
macro
([& keyvals])
array-seq
Create a seq from a JavaScript array.
function
([array] [array i])
array?
Returns true if x is a JavaScript array.
function
([x])
as->
Binds name to expr, evaluates the first form in the lexical context of that binding, then binds name to that result, rep...
macro
([expr name & forms])
aset
Sets the value at the index/indices. Works on JavaScript arrays. Returns val.
macro
([array idx val] [array idx idx2 & idxv])
assert
Evaluates expr and throws an exception if it does not evaluate to logical true.
macro
([x] [x message])
assoc
assoc[iate]. When applied to a map, returns a new map of the same (hashed/sorted) type, that contains the mapping of key...
function
([coll k v] [coll k v & kvs])
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 i...
function
([tcoll key val] [tcoll key val & kvs])
assoc-in
Associates a value in a nested associative structure, where ks is a sequence of keys and v is the new value and returns ...
function
([m [k & ks] v])
associative?
Returns true if coll implements IAssociative
function
([x])
atom
Creates and returns an Atom with an initial value of x and zero or more options (in any order): :meta metadata-map :va...
function
([x] [x & {:keys [meta validator]}])

B

BitmapIndexedNode
value
([edit bitmap arr])
BitmapIndexedNode.EMPTY
value
BlackNode
value
([key val left right __hash])
Box
value
([val])
bases
Returns the immediate prototype of c
function
([c])
binding
binding => var-symbol init-expr Creates new bindings for the (already-existing) vars, with the supplied initial values,...
macro
([bindings & body])
bit-and
Bitwise and
macro
([x y] [x y & more])
bit-and-not
Bitwise and with complement
macro
([x y] [x y & more])
bit-clear
Clear bit at index n
macro
([x n])
bit-count
Counts the number of bits set in n
function
([v])
bit-flip
Flip bit at index n
macro
([x n])
bit-not
Bitwise complement
macro
([x])
bit-or
Bitwise or
macro
([x y] [x y & more])
bit-set
Set bit at index n
macro
([x n])
bit-shift-left
Bitwise shift left
macro
([x n])
bit-shift-right
Bitwise shift right
macro
([x n])
bit-shift-right-zero-fill
DEPRECATED: Bitwise shift right with zero fill
macro
([x n])
bit-test
Test bit at index n
macro
([x n])
bit-xor
Bitwise exclusive or
macro
([x y] [x y & more])
bitpos
macro
([hash shift])
boolean
Coerce to boolean
function
([x])
boolean?
Return true if x is a Boolean
function
([x])
booleans
function
([x])
bounded-count
If coll is counted? returns its count, else will count at most the first n elements of coll using its seq
function
([n coll])
butlast
Return a seq of all but the last item in coll, in linear time
function
([s])
byte
macro
([x])
bytes
function
([x])

C

CHAR_MAP
value
ChunkBuffer
value
([buf end])
ChunkedCons
value
([chunk more meta __hash])
ChunkedSeq
value
([vec node i off meta __hash])
Cons
value
([meta first rest __hash])
Cycle
value
([meta all prev current _next])
caching-hash
macro
([coll hash-fn hash-key])
case
Takes an expression, and a set of clauses. Each clause can take the form of either: test-constant result-expr (test-c...
macro
([e & clauses])
case*
special-form
cat
A transducer which concatenates the contents of each input, which must be a collection, into the reduction.
function
([rf])
catch
catch-clause => (catch classname name expr*) finally-clause => (finally expr*) Catches and handles JavaScript exceptions...
special-form
([classname name expr*])
char
Coerce to char
function
([x])
char?
Returns true if x is a JavaScript string of length one.
function
([x])
chars
function
([x])
check-string-hash-cache
function
([k])
chunk
function
([b])
chunk-append
function
([b x])
chunk-buffer
function
([capacity])
chunk-cons
function
([chunk rest])
chunk-first
function
([s])
chunk-next
function
([s])
chunk-rest
function
([s])
chunked-seq
function
([vec i off] [vec node i off] [vec node i off meta])
chunked-seq?
Return true if x satisfies IChunkedSeq.
function
([x])
clj->js
Recursively transforms ClojureScript values to JavaScript. sets/vectors/lists become Arrays, Keywords and Symbol become ...
function
([x & {:keys [keyword-fn], :or {keyword-fn name}, :as options}])
clone
Clone the supplied value which must implement ICloneable.
function
([value])
cloneable?
Return true if x implements ICloneable protocol.
function
([value])
coercive-=
macro
([x y])
coercive-boolean
macro
([x])
coercive-not
macro
([x])
coercive-not=
macro
([x y])
coll?
Returns true if x satisfies ICollection
function
([x])
comment
Ignores body, yields nil
macro
([& body])
comp
Takes a set of functions and returns a fn that is the composition of those fns. The returned fn takes a variable number...
function
([] [f] [f g] [f g h] [f1 f2 f3 & fs])
comparator
Returns an JavaScript compatible comparator based upon pred.
function
([pred])
compare
Comparator. Returns a negative number, zero, or a positive number when x is logically 'less than', 'equal to', or 'grea...
function
([x y])
compare-and-set!
Atomically sets the value of atom to newval if and only if the current value of the atom is equal to oldval. Returns tru...
function
([a oldval newval])
complement
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...
function
([f])
completing
Takes a reducing function f of 2 args and returns a fn suitable for transduce by adding an arity-1 signature that calls ...
function
([f] [f cf])
concat
Returns a lazy seq representing the concatenation of the elements in the supplied colls.
function
([] [x] [x y] [x y & zs])
cond
Takes a set of test/expr pairs. It evaluates each test one at a time. If a test returns logical true, cond evaluates an...
macro
([& clauses])
cond->
Takes an expression and a set of test/form pairs. Threads expr (via ->) through each form for which the corresponding te...
macro
([expr & clauses])
cond->>
Takes an expression and a set of test/form pairs. Threads expr (via ->>) through each form for which the corresponding t...
macro
([expr & clauses])
condp
Takes a binary predicate, an expression, and a set of clauses. Each clause can take the form of either: test-expr resul...
macro
([pred expr & clauses])
conj
conj[oin]. Returns a new collection with the xs 'added'. (conj nil item) returns (item). (conj coll) returns coll. (conj...
function
([] [coll] [coll x] [coll x & xs])
conj!
Adds val to the transient collection, and return tcoll. The 'addition' may happen at different 'places' depending on the...
function
([] [tcoll] [tcoll val] [tcoll val & vals])
cons
Returns a new seq where x is the first element and coll is the rest.
function
([x coll])
constantly
Returns a function that takes any number of arguments and returns x.
function
([x])
contains?
Returns true if key is present in the given collection, otherwise returns false. Note that for numerically indexed coll...
function
([coll v])
copy-arguments
macro
([dest])
count
Returns the number of items in the collection. (count nil) returns 0. Also works on strings, arrays, and Maps
function
([coll])
counted?
Returns true if coll implements count in constant time
function
([x])
create-ns
Create a new namespace named by the symbol. Bootstrap only.
function
([sym] [sym ns-obj])
cycle
Returns a lazy (infinite!) sequence of repetitions of the items in coll.
function
([coll])

D

DEMUNGE_MAP
value
DEMUNGE_PATTERN
value
Delay
value
([f value])
dec
Returns a number one less than num.
macro
([x])
declare
defs the supplied var names with no bindings, useful for making forward declarations.
macro
([& names])
dedupe
Returns a lazy sequence removing consecutive duplicates in coll. Returns a transducer when no collection is provided.
function
([] [coll])
def
Creates and interns a global var with the name of symbol in the current namespace (*ns*) or locates such a var if it alr...
special-form
([symbol doc-string? init?])
default-dispatch-val
Given a multimethod, return its default-dispatch-val.
function
([multifn])
defmacro
Like defn, but the resulting function name is declared as a macro and will be used as a macro by the compiler when it is...
macro
([name doc-string? attr-map? [params*] body] [name doc-string? attr-map? ([params*] body) + attr-map?])
defmethod
Creates and installs a new method of multimethod associated with dispatch-value.
macro
([multifn dispatch-val & fn-tail])
defmulti
Creates a new multimethod with the associated dispatch function. The docstring and attribute-map are optional. Options ...
macro
([name docstring? attr-map? dispatch-fn & options])
defn
Same as (def name (core/fn [params* ] exprs*)) or (def name (core/fn ([params* ] exprs*)+)) with any doc-string or attr...
macro
defn-
same as defn, yielding non-public def
macro
([name & decls])
defonce
defs name to have the root value of init iff the named var has no root value, else init is unevaluated
macro
([x init])
defprotocol
A protocol is a named set of named methods and their signatures: (defprotocol AProtocolName ;optional doc string "A...
macro
([psym & doc+methods])
defrecord
(defrecord name [fields*] options* specs*) Currently there are no options. Each spec consists of a protocol or interf...
macro
([rsym fields & impls])
defrecord*
special-form
deftype
(deftype name [fields*] options* specs*) Currently there are no options. Each spec consists of a protocol or interfac...
macro
([t fields & impls])
deftype*
special-form
delay
Takes a body of expressions and yields a Delay object that will invoke the body only the first time it is forced (with f...
macro
([& body])
delay?
returns true if x is a Delay created with delay
function
([x])
demunge
function
([name])
deref
Also reader macro: @var/@atom/@delay. Returns the most-recently-committed value of ref. When applied to a var or atom, r...
function
([o])
derive
Establishes a parent/child relationship between parent and tag. Parent must be a namespace-qualified symbol or keyword a...
function
([tag parent] [h tag parent])
descendants
Returns the immediate and indirect children of tag, through a relationship established via derive. h must be a hierarchy...
function
([tag] [h tag])
disj
disj[oin]. Returns a new set of the same (hashed/sorted) type, that does not contain key(s).
function
([coll] [coll k] [coll k & ks])
disj!
disj[oin]. Returns a transient set of the same (hashed/sorted) type, that does not contain key(s).
function
([tcoll val] [tcoll val & vals])
dispatch-fn
Given a multimethod, return its dispatch-fn.
function
([multifn])
dissoc
dissoc[iate]. Returns a new map of the same (hashed/sorted) type, that does not contain a mapping for key(s).
function
([coll] [coll k] [coll k & ks])
dissoc!
Returns a transient map that doesn't contain a mapping for key(s).
function
([tcoll key] [tcoll key & ks])
distinct
Returns a lazy sequence of the elements of coll with duplicates removed. Returns a stateful transducer when no collectio...
function
([] [coll])
distinct?
Returns true if no two of the arguments are =
function
([x] [x y] [x y & more])
divide
macro
([x] [x y] [x y & more])
do
Evaluates the expressions in order and returns the value of the last. If no expressions are supplied, returns nil.
special-form
([exprs*])
doall
When lazy sequences are produced via functions that have side effects, any effects other than those needed to produce th...
function
([coll] [n coll])
dorun
When lazy sequences are produced via functions that have side effects, any effects other than those needed to produce th...
function
([coll] [n coll])
doseq
Repeatedly executes body (presumably for side-effects) with bindings and filtering as provided by "for". Does not retai...
macro
([seq-exprs & body])
dotimes
bindings => name n Repeatedly executes body (presumably for side-effects) with name bound to integers from 0 through n-...
macro
([bindings & body])
doto
Evaluates x then calls all of the methods and functions with the value of x supplied at the front of the given arguments...
macro
([x & forms])
double
macro
([x])
double-array
Creates an array of doubles. Does not coerce array, provided for compatibility with Clojure.
function
([size-or-seq] [size init-val-or-seq])
double?
Returns true for JavaScript numbers, false otherwise.
function
([x])
doubles
function
([x])
drop
Returns a laziness-preserving sequence of all but the first n items in coll. Returns a stateful transducer when no colle...
function
([n] [n coll])
drop-last
Return a lazy sequence of all but the last n (default 1) items in coll
function
([s] [n s])
drop-while
Returns a lazy sequence of the items in coll starting from the first item for which (pred item) returns logical false. ...
function
([pred] [pred coll])

E

ES6EntriesIterator
value
([s])
ES6Iterator
value
([s])
ES6IteratorSeq
value
([value iter _rest])
ES6SetEntriesIterator
value
([s])
Eduction
value
([xform coll])
Empty
value
([])
EmptyList
value
([meta])
EntriesIterator
value
([s])
ExceptionInfo
value
([message data cause])
eduction
Returns a reducible/iterable application of the transducers to the items in coll. Transducers are applied in order as if...
function
([xform* coll])
empty
Returns an empty collection of the same category as coll, or nil
function
([coll])
empty?
Returns true if coll has no items. To check the emptiness of a seq, please use the idiom (seq x) rather than (not (empty...
function
([coll])
enable-console-print!
Set *print-fn* to console.log
function
([])
ensure-reduced
If x is already reduced?, returns it, else returns (reduced x)
function
([x])
entries-iterator
function
([coll])
equiv-map
Test map equivalence. Returns true if x equals y, otherwise returns false.
function
([x y])
es6-entries-iterator
function
([coll])
es6-iterable
macro
([ty])
es6-iterator
Return a ES2015+ compatible iterator for coll.
function
([coll])
es6-iterator-seq
Given an ES2015+ compatible iterator return a seq.
function
([iter])
es6-set-entries-iterator
function
([coll])
eval
Evaluates the form data structure (not text!) and returns the result. Delegates to cljs.core/*eval*. Intended for use in...
function
([form])
even?
Returns true if n is even, throws an exception if n is not an integer
function
([n])
every-pred
Takes a set of predicates and returns a function f that returns true if all of its composing predicates return a logical...
function
([p] [p1 p2] [p1 p2 p3] [p1 p2 p3 & ps])
every?
Returns true if (pred x) is logical true for every x in coll, else false.
function
([pred coll])
ex-cause
Returns exception cause (an Error / ExceptionInfo) if ex is an ExceptionInfo. Otherwise returns nil.
function
([ex])
ex-data
Returns exception data (a map) if ex is an ExceptionInfo. Otherwise returns nil.
function
([ex])
ex-info
Create an instance of ExceptionInfo, an Error type that carries a map of additional data.
function
([msg data] [msg data cause])
ex-message
Returns the message attached to the given Error / ExceptionInfo object. For non-Errors returns nil.
function
([ex])
exists?
Return true if argument exists, analogous to usage of typeof operator in JavaScript.
macro
([x])
extend-protocol
Useful when you want to provide several implementations of the same protocol all at once. Takes a single protocol and th...
macro
([p & specs])
extend-type
Extend a type to a series of protocols. Useful when you are supplying the definitions explicitly inline. Propagates the ...
macro
([type-sym & impls])

F

Fn
Marker protocol
protocol
false?
Returns true if x is the value false, false otherwise.
macro
([x])
ffirst
Same as (first (first x))
function
([coll])
filter
Returns a lazy sequence of the items in coll for which (pred item) returns logical true. pred must be free of side-effec...
function
([pred] [pred coll])
filterv
Returns a vector of the items in coll for which (pred item) returns logical true. pred must be free of side-effects.
function
([pred coll])
finally
catch-clause => (catch classname name expr*) finally-clause => (finally expr*) Catches and handles JavaScript exceptions...
special-form
([expr*])
find
Returns the map entry for key, or nil if key not present.
function
([coll k])
find-macros-ns
Returns the macros namespace named by the symbol or nil if it doesn't exist. Bootstrap only.
function
([ns])
find-ns
Returns the namespace named by the symbol or nil if it doesn't exist. Bootstrap only.
function
([ns])
find-ns-obj
Bootstrap only.
function
([ns])
first
Returns the first item in the collection. Calls seq on its argument. If coll is nil, returns nil.
function
([coll])
flatmap
maps f over coll and concatenates the results. Thus function f should return a collection. Returns a transducer when n...
function
([f] [f coll])
flatten
Takes any nested combination of sequential things (lists, vectors, etc.) and returns their contents as a single, flat se...
function
([x])
float
macro
([x])
float?
Returns true for JavaScript numbers, false otherwise.
function
([x])
floats
function
([x])
flush
function
([])
fn
params => positional-params* , or positional-params* & next-param positional-param => binding-form next-param => binding...
macro
([& sigs])
fn*
special-form
fn?
Return true if f is a JavaScript function or satisfies the Fn protocol.
function
([f])
fnext
Same as (first (next x))
function
([coll])
fnil
Takes a function f, and returns a function that calls f, replacing a nil first argument to f with the supplied value x. ...
function
([f x] [f x y] [f x y z])
for
List comprehension. Takes a vector of one or more binding-form/collection-expr pairs, each followed by zero or more mo...
macro
([seq-exprs body-expr])
force
If x is a Delay, returns the (possibly cached) value of its expression, else returns x
function
([x])
format
Formats a string using goog.string.format.
function
([fmt & args])
frequencies
Returns a map from distinct items in coll to the number of times they appear.
function
([coll])

G

gen-apply-to
macro
([])
gen-apply-to-simple
macro
([f num-args args])
gensym
Returns a new symbol with a unique name. If a prefix string is supplied, the name is prefix# where # is some unique numb...
function
([] [prefix-string])
gensym_counter
value
get
Returns the value mapped to key, not-found or nil if key not present in associative collection, set, string, array, or I...
function
([o k] [o k not-found])
get-in
Returns the value in a nested associative structure, where ks is a sequence of keys. Returns nil if the key is not prese...
function
([m ks] [m ks not-found])
get-method
Given a multimethod and a dispatch value, returns the dispatch fn that would apply to that value, or nil if none apply a...
function
([multifn dispatch-val])
get-validator
Gets the validator-fn for a var/ref/agent/atom.
function
([iref])
goog-define
Defines a var using `goog.define`. Passed default value must be string, number or boolean. Default value can be overrid...
macro
([sym default])
group-by
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 o...
function
([f coll])

H

HashCollisionNode
value
([edit collision-hash cnt arr])
HashMap
value
([meta count hashobj __hash])
HashMap.EMPTY
value
HashMap.fromArrays
function
([ks vs])
HashMapIter
value
([nil-val root-iter seen])
HashMapLite
value
([meta count hashobj __hash])
HashSetIter
value
([iter])
halt-when
Returns a transducer that ends transduction when pred returns true for an input. When retf is supplied it must be a fn o...
function
([pred] [pred retf])
hash
Returns the hash code of its argument. Note this is the hash code consistent with =.
function
([o])
hash-combine
function
([seed hash])
hash-double
function
([f])
hash-keyword
function
([k])
hash-long
function
([high low])
hash-map
keyval => key val Returns a new hash map with supplied mappings.
macro
([& keyvals])
hash-map-lite
:lite-mode version of hash-map, not intended to be used directly.
function
([& keyvals])
hash-ordered-coll
Returns the hash code, consistent with =, for an external ordered collection implementing Iterable. See http://clojure.o...
function
([coll])
hash-set
Returns a new hash set with supplied keys. Any equal keys are handled as if by repeated uses of conj.
macro
([] [& keys])
hash-string
function
([k])
hash-string*
function
([s])
hash-unordered-coll
Returns the hash code, consistent with =, for an external unordered collection implementing Iterable. For maps, the iter...
function
([coll])

I

IAssociative
Protocol for adding associativity to collections.
protocol
IAtom
Marker protocol indicating an atom.
protocol
IChunk
Protocol for accessing the items of a chunk.
protocol
IChunkedNext
Protocol for accessing the chunks of a collection.
protocol
IChunkedSeq
Protocol for accessing a collection as sequential chunks.
protocol
ICloneable
Protocol for cloning a value.
protocol
ICollection
Protocol for adding to a collection.
protocol
IComparable
Protocol for values that can be compared.
protocol
ICounted
Protocol for adding the ability to count a collection in constant time.
protocol
IDeref
Protocol for adding dereference functionality to a reference.
protocol
IDerefWithTimeout
protocol
IDrop
Protocol for persistent or algorithmically defined collections to provide a means of dropping N items that is more eff...
protocol
IEditableCollection
Protocol for collections which can transformed to transients.
protocol
IEmptyableCollection
Protocol for creating an empty collection.
protocol
IEncodeClojure
protocol
IEncodeJS
protocol
IEquiv
Protocol for adding value comparison functionality to a type.
protocol
IFind
Protocol for implementing entry finding in collections.
protocol
IFn
Protocol for adding the ability to invoke an object as a function. For example, a vector can also be used to look up a...
protocol
IHash
Protocol for adding hashing functionality to a type.
protocol
IIndexed
Protocol for collections to provide indexed-based access to their items.
protocol
IIterable
Protocol for iterating over a collection.
protocol
IKVReduce
Protocol for associative types that can reduce themselves via a function of key and val. Called by cljs.core/reduce-kv...
protocol
IList
Marker interface indicating a persistent list
protocol
ILookup
Protocol for looking up a value in a data structure.
protocol
IMap
Protocol for adding mapping functionality to collections.
protocol
IMapEntry
Protocol for examining a map entry.
protocol
IMeta
Protocol for accessing the metadata of an object.
protocol
IMultiFn
protocol
INamed
Protocol for adding a name.
protocol
INext
Protocol for accessing the next items of a collection.
protocol
IPending
Protocol for types which can have a deferred realization. Currently only implemented by Delay and LazySeq.
protocol
IPrintWithWriter
The old IPrintable protocol's implementation consisted of building a giant list of strings to concatenate. This invo...
protocol
IPrintable
Do not use this. It is kept for backwards compatibility with existing user code that depends on it, but it has been ...
protocol
IRecord
Marker interface indicating a record object
protocol
IReduce
Protocol for seq types that can reduce themselves. Called by cljs.core/reduce.
protocol
IReset
Protocol for adding resetting functionality.
protocol
IReversible
Protocol for reversing a seq.
protocol
ISeq
Protocol for collections to provide access to their items as sequences.
protocol
ISeqable
Protocol for adding the ability to a type to be transformed into a sequence.
protocol
ISequential
Marker interface indicating a persistent collection of sequential items
protocol
ISet
Protocol for adding set functionality to a collection.
protocol
ISorted
Protocol for a collection which can represent their items in a sorted manner.
protocol
IStack
Protocol for collections to provide access to their items as stacks. The top of the stack should be accessed in the mo...
protocol
ISwap
Protocol for adding swapping functionality.
protocol
ITransientAssociative
Protocol for adding associativity to transient collections.
protocol
ITransientCollection
Protocol for adding basic functionality to transient collections.
protocol
ITransientMap
Protocol for adding mapping functionality to transient collections.
protocol
ITransientSet
Protocol for adding set functionality to a transient collection.
protocol
ITransientVector
Protocol for adding vector functionality to transient collections.
protocol
IUUID
A marker protocol for UUIDs
protocol
IVector
Protocol for adding vector functionality to collections.
protocol
IVolatile
Protocol for adding volatile functionality.
protocol
IWatchable
Protocol for types that can be watched. Currently only implemented by Atom.
protocol
IWithMeta
Protocol for adding metadata to an object.
protocol
IWriter
Protocol for writing. Currently only implemented by StringBufferWriter.
protocol
IndexedSeq
value
([arr i meta])
IndexedSeqIterator
value
([arr i])
Inst
protocol
IntegerRange
value
([meta start end step cnt __hash])
IntegerRangeChunk
value
([start step count])
Iterate
value
([meta f prev-seed seed next])
Iteration
value
([xform coll])
Iterator
value
([s])
ident?
Return true if x is a symbol or keyword
function
([x])
identical?
Tests if 2 arguments are the same object
macro
([x y])
identity
Returns its argument.
function
([x])
if
Evaluates test. If not the singular values nil or false, evaluates and yields then, otherwise, evaluates and yields else...
special-form
([test then else?])
if-let
bindings => binding-form test If test is true, evaluates then with binding-form bound to the value of test, if not, yi...
macro
([bindings then] [bindings then else & oldform])
if-not
Evaluates test. If logical false, evaluates and returns then expr, otherwise else expr, if supplied, else nil.
macro
([test then] [test then else])
if-some
bindings => binding-form test If test is not nil, evaluates then with binding-form bound to the value of test, if not, ...
macro
([bindings then] [bindings then else & oldform])
ifind?
Returns true if coll implements IFind
function
([x])
ifn?
Returns true if f returns true for fn? or satisfies IFn.
function
([f])
implements?
EXPERIMENTAL
macro
([psym x])
import
import-list => (closure-namespace constructor-name-symbols*) For each name in constructor-name-symbols, adds a mapping ...
macro
([& import-symbols-or-lists])
import-macros
macro
([ns [& vars]])
in-ns
Sets *cljs-ns* to the namespace named by the symbol, creating it if needed.
special-form
([name])
inc
Returns a number one greater than num.
macro
([x])
indexed?
Returns true if coll implements nth in constant time
function
([x])
infinite?
Returns true for Infinity and -Infinity values.
function
([x])
inst-ms
Return the number of milliseconds since January 1, 1970, 00:00:00 GMT
function
([inst])
inst?
Return true if x satisfies Inst
function
([x])
instance?
Evaluates x and tests if it is an instance of the type c. Returns true or false
macro
([c x])
int
Coerce to int.
macro
([x])
int-array
Creates an array of ints. Does not coerce array, provided for compatibility with Clojure.
function
([size-or-seq] [size init-val-or-seq])
int-rotate-left
function
([x n])
int?
Return true if x satisfies integer? or is an instance of goog.math.Integer or goog.math.Long.
function
([x])
integer?
Returns true if n is a JavaScript number with no decimal part.
function
([n])
interleave
Returns a lazy seq of the first item in each coll, then the second etc.
function
([] [c1] [c1 c2] [c1 c2 & colls])
interpose
Returns a lazy seq of the elements of coll separated by sep. Returns a stateful transducer when no collection is provide...
function
([sep] [sep coll])
into
Returns a new coll consisting of to-coll with all of the items of from-coll conjoined. A transducer may be supplied.
function
([] [to] [to from] [to xform from])
into-array
Returns an array with components set to the values in aseq. Optional type argument accepted for compatibility with Cloju...
function
([aseq] [type aseq])
ints
function
([x])
is_proto_
function
([x])
isa?
Returns true if (= child parent), or child is directly or indirectly derived from parent, either via a JavaScript type i...
function
([child parent] [h child parent])
iter
function
([coll])
iterable?
Return true if x implements IIterable protocol.
function
([x])
iterate
Returns a lazy sequence of x, (f x), (f (f x)) etc. f must be free of side-effects
function
([f x])
iteration
Creates a seqable/reducible via repeated calls to step, a function of some (continuation token) 'k'. The first call to s...
function
([step & {:keys [somef vf kf initk], :or {vf identity, kf identity, somef some?, initk nil}}])
iterator
function
([coll])

J

js*
special-form
js->clj
Recursively transforms JavaScript arrays into ClojureScript vectors, and JavaScript objects into ClojureScript maps. Wi...
function
([x] [x & opts])
js-arguments
macro
([])
js-comment
Emit a top-level JavaScript multi-line comment. New lines will create a new comment line. Comment block will be preceded...
macro
([comment])
js-debugger
Emit JavaScript "debugger;" statement
macro
([])
js-delete
Delete a property from a JavaScript object. Returns true upon success, false otherwise.
macro
([obj key])
js-fn?
macro
([x])
js-in
macro
([key obj])
js-inline-comment
Emit an inline JavaScript comment.
macro
([comment])
js-invoke
Invoke JavaScript object method via string. Needed when the string is not a valid unquoted property name.
function
([obj s & args])
js-iterable?
Return true if x has a JavaScript iterator property
function
([x])
js-keys
Return the JavaScript keys for an object.
function
([obj])
js-mod
Modulus of num and div with original javascript behavior. i.e. bug for negative numbers
macro
([n d])
js-obj
Create JavaSript object from an even number arguments representing interleaved keys and values.
macro
([] [& keyvals])
js-reserved
value
js-str
macro
([s])
js-symbol?
Returns true if x is an instance of Symbol
function
([x])
juxt
Takes a set of functions and returns a fn that is the juxtaposition of those fns. The returned fn takes a variable numb...
function
([f] [f g] [f g h] [f g h & fs])

K

KeySeq
value
([mseq _meta])
Keyword
value
([ns name fqn _hash])
keep
Returns a lazy sequence of the non-nil results of (f item). Note, this means false return values will be included. f mu...
function
([f] [f coll])
keep-indexed
Returns a lazy sequence of the non-nil results of (f index item). Note, this means false return values will be included....
function
([f] [f coll])
key
Returns the key of the map entry.
function
([map-entry])
key->js
function
([k] [k primitive-fn])
key-test
function
([key other])
keys
Returns a sequence of the map's keys, in the same order as (seq map).
function
([map])
keyword
Returns a Keyword with the given namespace and name. Do not use : in the keyword strings, it will be added automaticall...
function
([name] [ns name])
keyword-identical?
Efficient test to determine that two keywords are identical.
function
([x y])
keyword?
Return true if x is a Keyword
macro
([x])

L

LITE_MODE
Boolean flag for LITE_MODE
value
LazySeq
value
([meta fn s __hash])
LazyTransformer
value
([stepper first rest meta])
LazyTransformer.create
function
([xform coll])
LazyTransformer.createMulti
function
([xform colls])
List
value
([meta first rest count __hash])
List.EMPTY
value
LongImpl
INTERNAL: do not use
value
last
Return the last item in coll, in linear time
function
([s])
lazy-cat
Expands to code which yields a lazy sequence of the concatenation of the supplied colls. Each coll expr is not evaluate...
macro
([& colls])
lazy-seq
Takes a body of expressions that returns an ISeq or nil, and yields a ISeqable object that will invoke the body only the...
macro
([& body])
lazy-transformer
function
([stepper])
let
binding => binding-form init-expr binding-form => name, or destructuring-form destructuring-form => map-destructure-form...
macro
([bindings & body])
let*
special-form
letfn
fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+) Takes a vector of function specs and a body, and gener...
macro
([fnspecs & body])
letfn*
special-form
list
Creates a new list containing the items.
macro
([& xs])
list*
Creates a new list containing the items prepended to the rest, the last of which will be treated as a sequence.
function
([args] [a args] [a b args] [a b c args] [a b c d & more])
list?
Returns true if x implements IList
function
([x])
load
Loads Clojure code from resources in classpath. A path is interpreted as classpath-relative if it begins with a slash or...
special-form
([& paths])
load-file
Sequentially read and evaluate the set of forms contained in the file.
special-form
([name])
load-file*
macro
([f])
load-namespace
special-form
locking
macro
([x & forms])
long
Coerce to long. Identical to `int'.
function
([x])
long-array
Creates an array of longs. Does not coerce array, provided for compatibility with Clojure.
function
([size-or-seq] [size init-val-or-seq])
longs
function
([x])
loop
Evaluates the exprs in a lexical context in which the symbols in the binding-forms are bound to their respective init-ex...
macro
([bindings & body])
loop*
special-form

M

MODULE_INFOS
value
MODULE_URIS
value
Many
value
([vals])
MapEntry
value
([key val __hash])
MetaFn
value
([afn meta])
MultiFn
value
([name dispatch-fn default-dispatch-val hierarchy method-table prefer-table method-cache cached-hierarchy])
MultiIterator
value
([iters])
MultiStepper
value
([xform iters nexts])
m3-C1
value
m3-C2
value
m3-fmix
function
([h1 len])
m3-hash-int
function
([in])
m3-hash-unencoded-chars
function
([in])
m3-mix-H1
function
([h1 k1])
m3-mix-K1
function
([k1])
m3-seed
value
macroexpand
Repeatedly calls macroexpand-1 on form until it no longer represents a macro form, then returns it. Note neither macroe...
macro
([quoted])
macroexpand-1
If form represents a macro form, returns its expansion, else returns form.
macro
([quoted])
make-array
Construct a JavaScript array of the specified dimensions. Accepts ignored type argument for compatibility with Clojure. ...
macro
([size] [type size] [type size & more-sizes])
make-hierarchy
Creates a hierarchy object for use with derive, isa? etc.
function
([])
map
Returns a lazy sequence consisting of the result of applying f to the set of first items of each coll, followed by apply...
function
([f] [f coll] [f c1 c2] [f c1 c2 c3] [f c1 c2 c3 & colls])
map-entry?
Returns true if x satisfies IMapEntry
function
([x])
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 t...
function
([f] [f coll])
map?
Return true if x satisfies IMap
function
([x])
mapcat
Returns the result of applying concat to the result of applying map to f and colls. Thus function f should return a col...
function
([f] [f & colls])
mapv
Returns a vector consisting of the result of applying f to the set of first items of each coll, followed by applying f t...
function
([f coll] [f c1 c2] [f c1 c2 c3] [f c1 c2 c3 & colls])
mask
macro
([hash shift])
max
Returns the greatest of the nums.
function
([x] [x y] [x y & more])
max-key
Returns the x for which (k x), a number, is greatest. If there are multiple such xs, the last one is returned.
function
([k x] [k x y] [k x y & more])
memfn
Expands into code that creates a fn that expects to be passed an object and any args and calls the named instance method...
macro
([name & args])
memoize
Returns a memoized version of a referentially transparent function. The memoized version of the function keeps a cache o...
function
([f])
merge
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 m...
function
([& maps])
merge-with
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 m...
function
([f & maps])
meta
Returns the metadata of obj, returns nil if there is no metadata.
function
([o])
methods
Given a multimethod, returns a map of dispatch values -> dispatch fns
function
([multifn])
min
Returns the least of the nums.
function
([x] [x y] [x y & more])
min-key
Returns the x for which (k x), a number, is least. If there are multiple such xs, the last one is returned.
function
([k x] [k x y] [k x y & more])
missing-protocol
function
([proto obj])
mix-collection-hash
Mix final collection hash for ordered or unordered collections. hash-basis is the combined collection hash, count is the...
function
([hash-basis count])
mk-bound-fn
function
([sc test key])
mod
Modulus of num and div. Truncates toward negative infinity.
function
([n d])
multi-stepper
function
([xform iters] [xform iters nexts])
munge
Munge symbol or string `name` for safe use in JavaScript. - Replaces '..' with '_DOT__DOT_'. - Appends '$' to JavaScrip...
function
([name])
munge-str
Munge string `name` without considering `..` or JavaScript reserved keywords.
function
([name])

N

NS_CACHE
Bootstrap only.
value
NaN?
Returns true if num is NaN, else false
function
([val])
Namespace
value
([obj name])
NeverEquiv
value
([])
NodeIterator
value
([arr i next-entry next-iter])
NodeSeq
value
([meta nodes i s __hash])
name
Returns the name String of a string, symbol or keyword.
function
([x])
namespace
Returns the namespace String of a symbol or keyword, or nil if not present.
function
([x])
nat-int?
Return true if x satisfies int? and is a natural integer value.
function
([x])
neg-int?
Return true if x satisfies int? and is negative.
function
([x])
neg?
Returns true if num is less than zero, else false
macro
([x])
new
The args, if any, are evaluated from left to right, and passed to the JavaScript constructor. The constructed object is ...
special-form
([Constructor. args*] [Constructor args*])
newline
Prints a newline using *print-fn*
function
([] [opts])
next
Returns a seq of the items after the first. Calls seq on its argument. If there are no more items, returns nil
function
([coll])
nfirst
Same as (next (first x))
function
([coll])
nil-iter
function
([])
nil?
Returns true if x is nil, false otherwise.
macro
([x])
nnext
Same as (next (next x))
function
([coll])
not
Returns true if x is logical false, false otherwise.
function
([x])
not-any?
Returns false if (pred x) is logical true for any x in coll, else true.
function
([pred coll])
not-empty
If coll is empty, returns nil, else coll
function
([coll])
not-every?
Returns false if (pred x) is logical true for every x in coll, else true.
function
([pred coll])
not-native
value
not=
Same as (not (= obj1 obj2))
function
([x] [x y] [x y & more])
ns
You must currently use the ns form only with the following caveats * You must use the :only form of :use * :require...
special-form
([name docstring? attr-map? references*])
ns*
special-form
ns-imports
Returns a map of the import mappings for the namespace.
macro
([quoted-ns])
ns-interns
Returns a map of the intern mappings for the namespace.
macro
([quoted-ns])
ns-interns*
Returns a map of the intern mappings for the namespace. Bootstrap only.
function
([sym])
ns-name
Returns the name of the namespace, a Namespace object. Bootstrap only.
function
([ns-obj])
ns-publics
Returns a map of the public intern mappings for the namespace.
macro
([quoted-ns])
ns-unmap
Removes the mappings for the symbol from the namespace.
macro
([quoted-ns quoted-sym])
nth
Returns the value at the index. get returns nil if index out of bounds, nth throws an exception unless not-found is supp...
function
([coll n] [coll n not-found])
nthnext
Returns the nth next of coll, (seq coll) when n is 0.
function
([coll n])
nthrest
Returns the nth rest of coll, coll when n is 0.
function
([coll n])
number?
Returns true if x is a JavaScript number.
macro
([x])

O

ObjMap
value
([meta strkeys strobj __hash])
ObjMap.EMPTY
value
ObjMap.HASHMAP_THRESHOLD
value
ObjMap.fromObject
function
([ks obj])
ObjMapIterator
value
([strkeys strobj i])
obj-map
:lite-mode simple key hash-map, not intended to be used directly.
function
([& keyvals])
object-array
Creates an array of objects. Does not coerce array, provided for compatibility with Clojure.
function
([size-or-seq] [size init-val-or-seq])
object?
Returns true if x's constructor is Object
function
([x])
odd?
Returns true if n is odd, throws an exception if n is not an integer
function
([n])
or
Evaluates exprs one at a time, from left to right. If a form returns a logical true value, or returns that value and doe...
macro
([] [x] [x & next])

P

PROTOCOL_SENTINEL
value
PersistentArrayMap
value
([meta cnt arr __hash])
PersistentArrayMap.EMPTY
value
PersistentArrayMap.HASHMAP-THRESHOLD
value
PersistentArrayMap.HASHMAP_THRESHOLD
value
PersistentArrayMap.createAsIfByAssoc
function
([init])
PersistentArrayMap.createAsIfByAssocComplexPath
function
([init has-trailing?])
PersistentArrayMap.createWithCheck
function
([arr])
PersistentArrayMap.fromArray
function
([arr no-clone no-check])
PersistentArrayMap.fromArrays
function
([ks vs])
PersistentArrayMapIterator
value
([arr i cnt])
PersistentArrayMapSeq
value
([arr i _meta])
PersistentHashMap
value
([meta cnt root has-nil? nil-val __hash])
PersistentHashMap.EMPTY
value
PersistentHashMap.createWithCheck
function
([arr])
PersistentHashMap.fromArray
function
([arr no-clone])
PersistentHashMap.fromArrays
function
([ks vs])
PersistentHashSet
value
([meta hash-map __hash])
PersistentHashSet.EMPTY
value
PersistentHashSet.createAsIfByAssoc
function
([items])
PersistentHashSet.createWithCheck
function
([items])
PersistentHashSet.fromArray
function
([items no-clone])
PersistentQueue
value
([meta count front rear __hash])
PersistentQueue.EMPTY
value
PersistentQueueIter
value
([fseq riter])
PersistentQueueSeq
value
([meta front rear __hash])
PersistentTreeMap
value
([comp tree cnt meta __hash])
PersistentTreeMap.EMPTY
value
PersistentTreeMapSeq
value
([meta stack ascending? cnt __hash])
PersistentTreeSet
value
([meta tree-map __hash])
PersistentTreeSet.EMPTY
value
PersistentVector
value
([meta cnt shift root tail __hash])
PersistentVector.EMPTY
value
PersistentVector.EMPTY-NODE
value
PersistentVector.EMPTY_NODE
value
PersistentVector.fromArray
function
([xs no-clone])
parents
Returns the immediate parents of tag, either via a JavaScript type inheritance relationship or a relationship establishe...
function
([tag] [h tag])
parse-boolean
Parse strings "true" or "false" and return a boolean, or nil if invalid. Note that this explicitly excludes strings with...
function
([s])
parse-double
Parse string with floating point components and return a floating point value, or nil if parse fails. Grammar: https://d...
function
([s])
parse-long
Parse string of decimal digits with optional leading -/+ and return an integer value, or nil if parse fails
function
([s])
parse-uuid
Parse a string representing a UUID and return a UUID instance, or nil if parse fails. Grammar: https://docs.oracle.com/j...
function
([s])
partial
Takes a function f and fewer than the normal arguments to f, and returns a fn that takes a variable number of additional...
function
([f] [f arg1] [f arg1 arg2] [f arg1 arg2 arg3] [f arg1 arg2 arg3 & more])
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. th...
function
([n coll] [n step coll] [n step pad coll])
partition-all
Returns a lazy sequence of lists like partition, but may include partitions with fewer than n items at the end. Returns...
function
([n] [n coll] [n step coll])
partition-by
Applies f to each value in coll, splitting it each time f returns a new value. Returns a lazy seq of partitions. Retur...
function
([f] [f coll])
partitionv
Returns a lazy sequence of vectors of n items each, at offsets step apart. If step is not supplied, defaults to n, i.e. ...
function
([n coll] [n step coll] [n step pad coll])
partitionv-all
Returns a lazy sequence of vector partitions, but may include partitions with fewer than n items at the end. Returns a s...
function
([n] [n coll] [n step coll])
peek
For a list or queue, same as first, for a vector, same as, but much more efficient than, last. If the collection is empt...
function
([coll])
persistent!
Returns a new, persistent version of the transient collection, in constant time. The transient collection cannot be used...
function
([tcoll])
persistent-array-map-seq
function
([arr i _meta])
pop
For a list or queue, returns a new list/queue without the first item, for a vector, returns a new vector without the las...
function
([coll])
pop!
Removes the last item from a transient vector. If the collection is empty, throws an exception. Returns tcoll
function
([tcoll])
pos-int?
Return true if x satisfies int? and is positive.
function
([x])
pos?
Returns true if num is greater than zero, else false
macro
([x])
pr
Prints the object(s) using string-print. Prints the object(s), separated by spaces if there is more than one. By defaul...
function
([& objs])
pr-seq-writer
function
([objs writer opts])
pr-sequential
Do not use this. It is kept for backwards compatibility with the old IPrintable protocol.
function
([print-one begin sep end opts coll])
pr-sequential-writer
function
([writer print-one begin sep end opts coll])
pr-str
pr to a string, returning it. Fundamental entrypoint to IPrintWithWriter.
function
([& objs])
pr-str*
Support so that collections can implement toString without loading all the printing machinery.
function
([obj])
pr-str-with-opts
Prints a sequence of objects to a string, observing all the options given in opts
function
([objs opts])
pr-with-opts
Prints a sequence of objects using string-print, observing all the options given in opts
function
([objs opts])
prefer-method
Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y when there is a conflict
function
([multifn dispatch-val-x dispatch-val-y])
prefers
Given a multimethod, returns a map of preferred value -> set of other values
function
([multifn])
prim-seq
Create seq from a primitive JavaScript Array-like.
function
([prim] [prim i])
print
Prints the object(s) using string-print. print and println produce output for human consumption.
function
print-map
function
([m print-one writer opts])
print-meta?
function
([opts obj])
print-prefix-map
function
([prefix m print-one writer opts])
print-str
print to a string, returning it
function
([& objs])
printf
Prints formatted output, as per format
function
([fmt & args])
println
Same as print followed by (newline)
function
([& objs])
println-str
println to a string, returning it
function
([& objs])
prn
Same as pr followed by (newline).
function
([& objs])
prn-str
Same as pr-str followed by (newline)
function
([& objs])
prn-str-with-opts
Same as pr-str-with-opts followed by (newline)
function
([objs opts])

Q

qualified-ident?
Return true if x is a symbol or keyword with a namespace
function
([x])
qualified-keyword?
Return true if x is a keyword with a namespace
function
([x])
qualified-symbol?
Return true if x is a symbol with a namespace
function
([x])
quot
quot[ient] of dividing numerator by denominator.
function
([n d])
quote
Yields the unevaluated form.
special-form
([form])

R

RSeq
value
([ci i meta])
Range
value
([meta start end step chunk chunk-next __hash])
RangeChunk
value
([start step count])
RangeIterator
value
([i end step])
RangedIterator
value
([i base arr v start end])
RecordIter
value
([i record base-count fields ext-map-iter])
RedNode
value
([key val left right __hash])
Reduced
value
([val])
Repeat
value
([meta count val next __hash])
rand
Returns a random floating point number between 0 (inclusive) and n (default 1) (exclusive).
function
([] [n])
rand-int
Returns a random integer between 0 (inclusive) and n (exclusive).
function
([n])
rand-nth
Return a random element of the (sequential) collection. Will have the same performance characteristics as nth for the gi...
function
([coll])
random-sample
Returns items from coll with random probability of prob (0.0 - 1.0). Returns a transducer when no collection is provide...
function
([prob] [prob coll])
random-uuid
Returns a pseudo-randomly generated UUID instance (i.e. type 4).
function
([])
range
Returns a lazy seq of nums from start (inclusive) to end (exclusive), by step, where start defaults to 0, step to 1, and...
function
([] [end] [start end] [start end step])
ranged-iterator
function
([v start end])
re-find
Returns the first regex match, if any, of s to re, using re.exec(s). Returns a vector, containing first the matching sub...
function
([re s])
re-matches
Returns the result of (re-find re s) if re fully matches s.
function
([re s])
re-pattern
Returns an instance of RegExp which has compiled the provided string.
function
([s])
re-seq
Returns a lazy sequence of successive matches of re in s.
function
([re s])
realized?
Returns true if a value has been produced for a delay or lazy sequence.
function
([x])
record?
Return true if x satisfies IRecord
function
([x])
recur
Evaluates the exprs in order, then, in parallel, rebinds the bindings of the recursion point to the values of the exprs....
special-form
([exprs*])
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 ...
function
([f coll] [f val coll])
reduce-kv
Reduces an associative collection. f should be a function of 3 arguments. Returns the result of applying f to init, the ...
function
([f init coll])
reduceable?
Returns true if coll satisfies IReduce
function
([x])
reduced
Wraps x in a way such that a reduce will terminate with the value x
function
([x])
reduced?
Returns true if x is the result of a call to reduced
function
([r])
reductions
Returns a lazy seq of the intermediate values of the reduction (as per reduce) of coll by f, starting with init.
function
([f coll] [f init coll])
refer-clojure
Refers to all the public vars of `cljs.core`, subject to filters. Filters can include at most one each of: :exclude lis...
macro
([& args])
refer-global
Refer global js vars. Supports renaming via :rename. (refer-global :only '[Date Symbol] :rename '{Symbol Sym})
macro
([& args])
regexp?
Returns true if x is a JavaScript RegExp instance.
function
([x])
reify
reify creates an object implementing a protocol. reify is a macro with the following structure: (reify options* specs*...
macro
([& impls])
rem
remainder of dividing numerator by denominator.
function
([n d])
remove
Returns a lazy sequence of the items in coll for which (pred item) returns logical false. pred must be free of side-effe...
function
([pred] [pred coll])
remove-all-methods
Removes all of the methods of multimethod.
function
([multifn])
remove-method
Removes the method of multimethod associated with dispatch-value.
function
([multifn dispatch-val])
remove-tap
Remove f from the tap set.
function
([f])
remove-watch
Removes a watch (set by add-watch) from a reference
function
([iref key])
repeat
Returns a lazy (infinite!, or length n if supplied) sequence of xs.
function
([x] [n x])
repeatedly
Takes a function of no args, presumably with side effects, and returns an infinite (or length n if supplied) lazy sequen...
function
([f] [n f])
replace
Given a map of replacement pairs and a vector/collection, returns a vector/seq with any elements = a key in smap replace...
function
([smap] [smap coll])
replicate
DEPRECATED: Use 'repeat' instead. Returns a lazy seq of n xs.
function
([n x])
require
Loads libs, skipping any that are already loaded. Each argument is either a libspec that identifies a lib or a flag that...
macro
([& args])
require-global
Require libraries in the global JS environment. (require-global '[SomeLib :as lib :refer [foo]])
macro
([& args])
require-macros
Similar to require but only for macros.
macro
([& args])
reset!
Sets the value of atom to newval without regard for the current value. Returns new-value.
function
([a new-value])
reset-meta!
Atomically resets the metadata for an atom
function
([iref m])
reset-vals!
Sets the value of atom to newval. Returns [old new], the value of the atom before and after the reset.
function
([a new-value])
resolve
Returns the var to which a symbol will be resolved in the namespace else nil.
macro
([quoted-sym])
rest
Returns a possibly empty seq of the items after the first. Calls seq on its argument.
function
([coll])
reverse
Returns a seq of the items in coll in reverse order. Not lazy.
function
([coll])
reversible?
Returns true if coll satisfies? IReversible.
function
([coll])
rseq
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 ...
function
([rev])
rsubseq
sc must be a sorted collection, test(s) one of <, <=, > or >=. Returns a reverse seq of those entries with keys ek for w...
function
([sc test key] [sc start-test start-key end-test end-key])
run!
Runs the supplied procedure (via reduce), for purposes of side effects, on successive items in the collection. Returns n...
function
([proc coll])

S

SeqIter
value
([_seq _next])
Set
value
([meta hash-map __hash])
Set.EMPTY
value
SetEntriesIterator
value
([s])
SetLite
value
([meta hash-map __hash])
Single
value
([val])
Stepper
value
([xform iter])
StringBufferWriter
value
([sb])
StringIter
value
([s i])
Subvec
value
([meta v start end __hash])
Symbol
value
([ns name str _hash _meta])
satisfies?
Returns true if x satisfies the protocol
macro
([psym x])
second
Same as (first (next x))
function
([coll])
select-keys
Returns a map containing only those entries in map whose key is in keys
function
([map keyseq])
seq
Returns a seq on the collection. If the collection is empty, returns nil. (seq nil) returns nil. seq also works on Stri...
function
([coll])
seq-iter
function
([coll])
seq-to-map-for-destructuring
Builds a map from a seq as described in https://clojure.org/reference/special_forms#keyword-arguments
function
([s])
seq?
Return true if s satisfies ISeq
function
([s])
seqable?
Return true if the seq function is supported for s
function
([s])
sequence
Coerces coll to a (possibly empty) sequence, if it is not already one. Will not force a lazy seq. (sequence nil) yields ...
function
([coll] [xform coll] [xform coll & colls])
sequential?
Returns true if coll satisfies ISequential
function
([x])
set
Returns a set of the distinct elements of coll.
function
([coll])
set!
Used to set vars and JavaScript object fields
special-form
([var-symbol expr] [(.- instance-expr instanceFieldName-symbol) expr])
set-entries-iterator
function
([coll])
set-from-indexed-seq
function
([iseq])
set-lite
:lite-mode version of set, not intended ot be used directly.
function
([coll])
set-print-err-fn!
Set *print-err-fn* to f.
function
([f])
set-print-fn!
Set *print-fn* to f.
function
([f])
set-validator!
Sets the validator-fn for an atom. validator-fn must be nil or a side-effect-free fn of one argument, which will be pass...
function
([iref val])
set?
Returns true if x satisfies ISet
function
([x])
short
macro
([x])
shorts
function
([x])
shuffle
Return a random permutation of coll
function
([coll])
simple-benchmark
Runs expr iterations times in the context of a let expression with the given bindings, then prints out the bindings and ...
macro
([bindings expr iterations & {:keys [print-fn], :or {print-fn (quote println)}}])
simple-hash-map
keyval => key val Returns a new hash map with supplied mappings.
function
([& keyvals])
simple-ident?
Return true if x is a symbol or keyword without a namespace
function
([x])
simple-keyword?
Return true if x is a keyword without a namespace
function
([x])
simple-set
function
([coll])
simple-symbol?
Return true if x is a symbol without a namespace
function
([x])
simple-vec
function
([coll])
simple-vector
function
([& args])
some
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,...
function
([pred coll])
some->
When expr is not nil, threads it into the first form (via ->), and when that result is not nil, through the next etc
macro
([expr & forms])
some->>
When expr is not nil, threads it into the first form (via ->>), and when that result is not nil, through the next etc
macro
([expr & forms])
some-fn
Takes a set of predicates and returns a function f that returns the first logical true value returned by one of its comp...
function
([p] [p1 p2] [p1 p2 p3] [p1 p2 p3 & ps])
some?
Returns true if x is not nil, false otherwise.
macro
([x])
sort
Returns a sorted sequence of the items in coll. Comp can be boolean-valued comparison function, or a -/0/+ valued compar...
function
([coll] [comp coll])
sort-by
Returns a sorted sequence of the items in coll, where the sort order is determined by comparing (keyfn item). Comp can ...
function
([keyfn coll] [keyfn comp coll])
sorted-map
keyval => key val Returns a new sorted map with supplied mappings.
function
([& keyvals])
sorted-map-by
keyval => key val Returns a new sorted map with supplied mappings, using the supplied comparator.
function
([comparator & keyvals])
sorted-set
Returns a new sorted set with supplied keys.
function
([& keys])
sorted-set-by
Returns a new sorted set with supplied keys, using the supplied comparator.
function
([comparator & keys])
sorted?
Returns true if coll satisfies ISorted
function
([x])
special-symbol?
Returns true if x names a special form
function
([x])
specify
Identical to specify! but does not mutate its first argument. The first argument must be an ICloneable instance.
macro
([expr & impls])
specify!
Identical to reify but mutates its first argument.
macro
([expr & impls])
split-at
Returns a vector of [(take n coll) (drop n coll)]
function
([n coll])
split-with
Returns a vector of [(take-while pred coll) (drop-while pred coll)]
function
([pred coll])
splitv-at
Returns a vector of [(into [] (take n) coll) (drop n coll)]
function
([n coll])
spread
function
([arglist])
stepper
function
([xform iter])
str
With no args, returns the empty string. With one arg x, returns x.toString(). (str nil) returns the empty string. With ...
macro
([] [x] [x & ys])
str_
macro
([] [x] [x & ys])
string-hash-cache
value
string-hash-cache-count
value
string-iter
function
([x])
string-print
function
([x])
string?
Returns true if x is a JavaScript string.
macro
([x])
subs
Returns the substring of s beginning at start inclusive, and ending at end (defaults to length of string), exclusive.
function
([s start] [s start end])
subseq
sc must be a sorted collection, test(s) one of <, <=, > or >=. Returns a seq of those entries with keys ek for which (te...
function
([sc test key] [sc start-test start-key end-test end-key])
subvec
Returns a persistent vector of the items in vector from start (inclusive) to end (exclusive). If end is not supplied, d...
function
([v start] [v start end])
supers
Returns the immediate and indirect prototypes of c, if any
function
([c])
swap!
Atomically swaps the value of atom to be: (apply f current-value-of-atom args). Note that f may be called multiple times...
function
([a f] [a f x] [a f x y] [a f x y & more])
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...
function
([a f] [a f x] [a f x y] [a f x y & more])
symbol
Returns a Symbol with the given namespace and name. Arity-1 works on strings, keywords, and vars.
function
([name] [ns name])
symbol-identical?
Efficient test to determine that two symbols are identical.
function
([x y])
symbol?
Return true if x is a Symbol
macro
([x])
system-time
Returns highest resolution time offered by host in milliseconds.
function
([])

T

TaggedLiteral
value
([tag form])
Throwable->map
Constructs a data representation for an Error with keys: :cause - root cause message :phase - error phase :via - caus...
function
([o])
TransformerIterator
value
([buffer _next completed xf sourceIter multi])
TransformerIterator.create
function
([xform source])
TransformerIterator.createMulti
function
([xform sources])
TransientArrayMap
value
([editable? len arr])
TransientHashMap
value
([edit root count has-nil? nil-val])
TransientHashSet
value
([transient-map])
TransientVector
value
([cnt shift root tail])
tagged-literal
Construct a data representation of a tagged literal from a tag symbol and a form.
function
([tag form])
tagged-literal?
Return true if the value is the data representation of a tagged literal
function
([value])
take
Returns a lazy sequence of the first n items in coll, or all items if there are fewer than n. Returns a stateful transd...
function
([n] [n coll])
take-last
Returns a seq of the last n items in coll. Depending on the type of coll may be no better than linear time. For vector...
function
([n coll])
take-nth
Returns a lazy seq of every nth item in coll. Returns a stateful transducer when no collection is provided.
function
([n] [n coll])
take-while
Returns a lazy sequence of successive items from coll while (pred item) returns logical true. pred must be free of side-...
function
([pred] [pred coll])
tap>
Sends x to any taps. Returns the result of *exec-tap-fn*, a Boolean value.
function
([x])
test
test [v] - if var, finds fn at key :test in var metadata, if function, finds special test property. Calls it, presuming ...
function
([v])
this-as
Defines a scope where JavaScript's implicit "this" is bound to the name provided.
macro
([name & body])
throw
The expr is evaluated and thrown.
special-form
([expr])
time
Evaluates expr and prints the time it took. Returns the value of expr.
macro
([expr])
to-array
Returns an array containing the contents of coll.
function
([coll])
to-array-2d
Returns a (potentially-ragged) 2-dimensional array containing the contents of coll.
function
([coll])
trampoline
trampoline can be used to convert algorithms requiring mutual recursion without stack consumption. Calls f with supplied...
function
([f] [f & args])
transduce
reduce with a transformation of f (xf). If init is not supplied, (f) will be called to produce it. f should be a reducin...
function
([xform f coll] [xform f init coll])
transformer-iterator
function
([xform sourceIter multi])
transient
Returns a new, transient version of the collection, in constant time.
function
([coll])
tree-seq
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 tru...
function
([branch? children root])
true?
Returns true if x is the value true, false otherwise.
macro
([x])
truth_
macro
([x])
try
catch-clause => (catch classname name expr*) finally-clause => (finally expr*) Catches and handles JavaScript exceptions...
special-form
([expr* catch-clause* finally-clause?])
try*
special-form
type
Return x's constructor.
function
([x])
type->str
function
([ty])

U

UUID
value
([uuid __hash])
unchecked-add
Returns the sum of nums. (+) returns 0.
macro
([] [x] [x y] [x y & more])
unchecked-add-int
Returns the sum of nums. (+) returns 0.
macro
([] [x] [x y] [x y & more])
unchecked-byte
macro
([x])
unchecked-char
macro
([x])
unchecked-dec
Returns a number one less than x, an int.
macro
([x])
unchecked-dec-int
Returns a number one less than x, an int.
macro
([x])
unchecked-divide-int
If no denominators are supplied, returns 1/numerator, else returns numerator divided by all of the denominators.
macro
([x] [x y] [x y & more])
unchecked-double
macro
([x])
unchecked-float
macro
([x])
unchecked-get
INTERNAL. Compiles to JavaScript property access using bracket notation. Does not distinguish between object and array t...
macro
([obj key])
unchecked-inc
macro
([x])
unchecked-inc-int
macro
([x])
unchecked-int
Coerce to int.
function
([x])
unchecked-long
Coerce to long. Identical to `int'.
function
([x])
unchecked-max
macro
([x] [x y] [x y & more])
unchecked-min
macro
([x] [x y] [x y & more])
unchecked-multiply
Returns the product of nums. (*) returns 1.
macro
([] [x] [x y] [x y & more])
unchecked-multiply-int
Returns the product of nums. (*) returns 1.
macro
([] [x] [x y] [x y & more])
unchecked-negate
macro
([x])
unchecked-negate-int
macro
([x])
unchecked-remainder-int
macro
([x n])
unchecked-set
INTERNAL. Compiles to JavaScript property access using bracket notation. Does not distinguish between object and array t...
macro
([obj key val])
unchecked-short
macro
([x])
unchecked-substract
If no ys are supplied, returns the negation of x, else subtracts the ys from x and returns the result.
function
([x] [x y] [x y & more])
unchecked-substract-int
If no ys are supplied, returns the negation of x, else subtracts the ys from x and returns the result.
function
([x] [x y] [x y & more])
unchecked-subtract
If no ys are supplied, returns the negation of x, else subtracts the ys from x and returns the result.
macro
([x] [x y] [x y & more])
unchecked-subtract-int
If no ys are supplied, returns the negation of x, else subtracts the ys from x and returns the result.
macro
([x] [x y] [x y & more])
undefined?
Returns true if x identical to the JavaScript undefined value.
macro
([x])
underive
Removes a parent/child relationship between parent and tag. h must be a hierarchy obtained from make-hierarchy, if not s...
function
([tag parent] [h tag parent])
unreduced
If x is reduced?, returns (deref x), else returns x
function
([x])
unsafe-bit-and
macro
([x y] [x y & more])
unsafe-cast
EXPERIMENTAL: Subject to change. Unsafely cast a value to a different type.
macro
([t x])
unsigned-bit-shift-right
Bitwise shift right with zero fill
macro
([x n])
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...
function
([m k f] [m k f x] [m k f x y] [m k f x y z] [m k f x y z & more])
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 t...
function
([m [k & ks] f] [m [k & ks] f a] [m [k & ks] f a b] [m [k & ks] f a b c] [m [k & ks] f a b c & args])
update-keys
m f => {(f k) v ...} Given a map m and a function f of 1-argument, returns a new map whose keys are the result of applyi...
function
([m f])
update-vals
m f => {k (f v) ...} Given a map m and a function f of 1-argument, returns a new map where the keys of m are mapped to r...
function
([m f])
uri?
Returns true x is a goog.Uri instance.
function
([x])
use
Like require, but referring vars specified by the mandatory :only option. Example: The following would load the librar...
macro
([& args])
use-macros
Similar to use but only for macros.
macro
([& args])
uuid
Returns a UUID consistent with the string s.
function
([s])
uuid?
Return true if x is a UUID.
function
([x])

V

ValSeq
value
([mseq _meta])
Var
value
([val sym _meta])
Vector
value
([meta array __hash])
Vector.EMPTY
value
Vector.fromArray
function
([xs])
VectorIterator
value
([arr i])
VectorLite
value
([meta array __hash])
VectorLiteIterator
value
([arr i])
VectorNode
value
([edit arr])
Volatile
value
([state])
val
Returns the value in the map entry.
function
([map-entry])
vals
Returns a sequence of the map's values, in the same order as (seq map).
function
([map])
var
The symbol must resolve to a var, and the Var object itself (not its value) is returned. The reader macro #'x expands to...
special-form
([symbol])
var?
Returns true if v is of type cljs.core.Var
function
([v])
vary-meta
Returns an object of the same type and value as obj, with (apply f (meta obj) args) as its metadata.
function
([obj f] [obj f a] [obj f a b] [obj f a b c] [obj f a b c d] [obj f a b c d & args])
vec
Creates a new vector containing the contents of coll. JavaScript arrays will be aliased and should not be modified.
function
([coll])
vec-lite
:lite-mode version of vec, not intended to be used directly.
function
([coll])
vector
Creates a new vector containing the args.
macro
([& args])
vector-lite
:lite-mode version of vector, not intended to be used directly.
function
([& args])
vector-seq
function
([v offset])
vector?
Return true if x satisfies IVector
function
([x])
volatile!
Creates and returns a Volatile with an initial value of val.
function
([val])
volatile?
Returns true if x is a volatile.
function
([x])
vreset!
Sets the value of volatile to newval without regard for the current value. Returns newval.
function
([vol newval])
vswap!
Non-atomically swaps the value of the volatile as if: (apply f current-value-of-vol args). Returns the value that was sw...
macro
([vol f & args])

W

when
Evaluates test. If logical true, evaluates body in an implicit do.
macro
([test & body])
when-first
bindings => x xs Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once
macro
([bindings & body])
when-let
bindings => binding-form test When test is true, evaluates body with binding-form bound to the value of test
macro
([bindings & body])
when-not
Evaluates test. If logical false, evaluates body in an implicit do.
macro
([test & body])
when-some
bindings => binding-form test When test is not nil, evaluates body with binding-form bound to the value of test
macro
([bindings & body])
while
Repeatedly executes body while test expression is true. Presumes some side-effect will cause test to become false/nil. R...
macro
([test & body])
with-meta
Returns an object of the same type and value as obj, with map m as its metadata.
function
([o meta])
with-out-str
Evaluates exprs in a context in which *print-fn* is bound to .append on a fresh StringBuffer. Returns the string create...
macro
([& body])
with-redefs
binding => var-symbol temp-value-expr Temporarily redefines vars while executing the body. The temp-value-exprs will b...
macro
([bindings & body])
write-all
function
([writer & ss])

Z

zero?
Returns true if num is zero, else false
macro
([x])
zipmap
Returns a map with the keys mapped to the corresponding vals.
function
([keys vals])