cljs.core — org.clojars.pmbauer/clojurescript_svced 1.0.0-SNAPSHOT

* clj/s≠

(*)

(* x)

(* x y)

(* x y & more)

cljs

Returns the product of nums. (*) returns 1.

*1 cljs

bound in a repl thread to the most recent value printed

*2 cljs

bound in a repl thread to the second most recent value printed

*3 cljs

bound in a repl thread to the third most recent value printed

*assert* cljs

*clojurescript-version* cljs

*command-line-args* cljs

A sequence of the supplied command line arguments, or nil if none were supplied

*e cljs

bound in a repl thread to the most recent exception caught by the repl

*eval* cljs

Runtime environments may provide a way to evaluate ClojureScript forms. Whatever function eval is bound to will be passed any forms which should be evaluated.

*exec-tap-fn* cljs

(*exec-tap-fn* f)

Arranges to have tap functions executed via the supplied f, a function of no arguments. Returns true if successful, false otherwise.

*flush-on-newline* cljs

When set to true, output will be flushed whenever a newline is printed.

Defaults to true.

*loaded-libs* cljs

*main-cli-fn* cljs

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

*ns* cljs

Var bound to the current namespace. Only used for bootstrapping.

*out* cljs

*print-dup* cljs

When set to logical true, objects will be printed in a way that preserves their type when read in later.

Defaults to false.

*print-err-fn* cljs

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.

*print-fn* cljs

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.

*print-fn-bodies* cljs

print-fns-bodies controls whether functions print their source or only their names.

*print-length* cljs

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.

*print-level* cljs

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.

*print-meta* cljs

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.

*print-namespace-maps* cljs

print-namespace-maps controls whether the printer will print namespace map literal syntax.

Defaults to false, but the REPL binds it to true.

*print-newline* cljs

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.

*print-readably* cljs

When set to logical false, strings and characters will be printed with non-alphanumeric characters converted to the appropriate escape sequences.

Defaults to true

*target* cljs

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.

*unchecked-arrays* cljs

*unchecked-if* cljs

*warn-on-infer* cljs

+ clj/s≠

(+)

(+ x)

(+ x y)

(+ x y & more)

cljs

Returns the sum of nums. (+) returns 0.

- clj/s≠

(- x)

(- x y)

(- x y & more)

cljs

If no ys are supplied, returns the negation of x, else subtracts the ys from x and returns the result.

-> clj macro

(-> x & forms)

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 list already. If there are more forms, inserts the first form as the second item in second form, etc.

->> clj 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 list already. If there are more forms, inserts the first form as the last item in second form, etc.

.. clj macro

(.. x form)

(.. x form & more)

form => fieldName-symbol or (instanceMethodName-symbol args*)

Expands into a member access (.) of the first member on the first argument, followed by the next member on the result, etc. For instance:

(.. System (getProperties) (get "os.name"))

expands to:

(. (. System (getProperties)) (get "os.name"))

but is easier to write, read, and understand.

/ clj/s≠

(/ x)

(/ x y)

(/ x y & more)

cljs

If no denominators are supplied, returns 1/numerator, else returns numerator divided by all of the denominators.

< clj/s≠

(< x)

(< x y)

(< x y & more)

cljs

Returns non-nil if nums are in monotonically increasing order, otherwise false.

<= clj/s≠

(<= x)

(<= x y)

(<= x y & more)

cljs

Returns non-nil if nums are in monotonically non-decreasing order, otherwise false.

= cljs

(= 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. Clojure's immutable data structures define -equiv (and thus =) as a value, not an identity, comparison.

== clj/s≠

(== x)

(== x y)

(== x y & more)

cljs

Returns non-nil if nums all have the equivalent value, otherwise false. Behavior on non nums is undefined.

> clj/s≠

(> x)

(> x y)

(> x y & more)

cljs

Returns non-nil if nums are in monotonically decreasing order, otherwise false.

>= clj/s≠

(>= x)

(>= x y)

(>= x y & more)

cljs

Returns non-nil if nums are in monotonically non-increasing order, otherwise false.

aclone cljs

(aclone arr)

Returns a javascript array, cloned from the passed in array

add-tap cljs

(add-tap f)

Adds f, a fn of one argument, to the tap set. This function will be called with anything sent via tap>. Remember f in order to remove-tap

add-to-string-hash-cache cljs

(add-to-string-hash-cache k)

add-watch cljs

(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 clj/s≠

(aget array idx)

(aget array idx & idxs)

cljs

Returns the value at the index/indices. Works on JavaScript arrays.

alength clj/s≠

clj

(alength a)

cljs

(alength array)

Returns the length of the array. Works on arrays of all types.

alter-meta! cljs

(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

amap clj macro

(amap a idx ret expr)

Maps an expression across an array a, using an index named idx, and return value named ret, initialized to a clone of a, then setting each element of ret to the evaluation of expr, returning the new array ret.

ancestors cljs

(ancestors tag)

(ancestors h tag)

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

and clj macro

(and)

(and x)

(and x & next)

Evaluates exprs one at a time, from left to right. If a form returns logical false (nil or false), and returns that value and doesn't evaluate any of the other expressions, otherwise it returns the value of the last expr. (and) returns true.

any? cljs

(any? x)

Returns true if given any argument.

APersistentVector cljs protocol

Marker protocol

apply cljs

(apply f args)

(apply f x args)

(apply f x y args)

(apply f x y z args)

(apply f a b c d & args)

Applies fn f to the argument list formed by prepending intervening arguments to args.

apply-to cljs

(apply-to f argc args)

areduce clj macro

(areduce a idx ret init expr)

Reduces an expression across an array a, using an index named idx, and return value named ret, initialized to init, setting ret to the evaluation of expr at each step, returning ret.

array clj/s≠

clj

(array & rest)

cljs

(array var-args)

Creates a new javascript array. @param {...*} var_args

array-chunk cljs

(array-chunk arr)

(array-chunk arr off)

(array-chunk arr off end)

array-index-of cljs

(array-index-of arr k)

array-iter cljs

(array-iter x)

array-list cljs

(array-list)

array-map clj/s≠

clj

(array-map)

(array-map & kvs)

cljs

(array-map & keyvals)

keyval => key val Returns a new array map with supplied mappings.

array-seq cljs

(array-seq array)

(array-seq array i)

Create a seq from a JavaScript array.

array? cljs

(array? x)

Returns true if x is a JavaScript array.

ArrayChunk cljs

ArrayIter cljs

ArrayList cljs

ArrayNode cljs

ArrayNodeIterator cljs

ArrayNodeSeq cljs

as-> clj macro

(as-> expr name & forms)

Binds name to expr, evaluates the first form in the lexical context of that binding, then binds name to that result, repeating for each successive form, returning the result of the last form.

ASeq cljs protocol

Marker protocol indicating an array sequence.

aset clj/s≠

(aset array idx val)

(aset array idx idx2 & idxv)

cljs

Sets the value at the index/indices. Works on JavaScript arrays. Returns val.

assert clj macro

(assert x)

(assert x message)

Evaluates expr and throws an exception if it does not evaluate to logical true.

assoc cljs

(assoc coll k v)

(assoc coll k v & kvs)

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! cljs

(assoc! tcoll key val)

(assoc! tcoll key val & kvs)

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 cljs

(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? cljs

(associative? x)

Returns true if coll implements IAssociative

atom cljs

(atom x)

(atom x & {:keys [meta validator]})

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 become 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.

Atom cljs

binding clj macro

(binding bindings & body)

binding => var-symbol init-expr

Creates new bindings for the (already-existing) vars, with the supplied initial values, executes the exprs in an implicit do, then re-establishes the bindings that existed before. The new bindings are made in parallel (unlike let); all init-exprs are evaluated before the vars are bound to their new values.

bit-and clj/s≠

(bit-and x y)

(bit-and x y & more)

cljs

Bitwise and

bit-and-not clj/s≠

(bit-and-not x y)

(bit-and-not x y & more)

cljs

Bitwise and with complement

bit-clear clj/s≠

(bit-clear x n)

cljs

Clear bit at index n

bit-count cljs

(bit-count v)

Counts the number of bits set in n

bit-flip clj/s≠

(bit-flip x n)

cljs

Flip bit at index n

bit-not clj/s≠

(bit-not x)

cljs

Bitwise complement

bit-or clj/s≠

(bit-or x y)

(bit-or x y & more)

cljs

Bitwise or

bit-set clj/s≠

(bit-set x n)

cljs

Set bit at index n

bit-shift-left clj/s≠

(bit-shift-left x n)

cljs

Bitwise shift left

bit-shift-right clj/s≠

(bit-shift-right x n)

cljs

Bitwise shift right

bit-shift-right-zero-fill clj/s≠

(bit-shift-right-zero-fill x n)

cljs

DEPRECATED: Bitwise shift right with zero fill

bit-test clj/s≠

(bit-test x n)

cljs

Test bit at index n

bit-xor clj/s≠

(bit-xor x y)

(bit-xor x y & more)

cljs

Bitwise exclusive or

BitmapIndexedNode cljs

bitpos clj macro

(bitpos hash shift)

BlackNode cljs

boolean cljs

(boolean x)

Coerce to boolean

boolean? cljs

(boolean? x)

Return true if x is a Boolean

booleans cljs

(booleans x)

bounded-count cljs

(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

Box cljs

butlast cljs

(butlast s)

Return a seq of all but the last item in coll, in linear time

byte clj/s

(byte x)

bytes cljs

(bytes x)

caching-hash clj macro

(caching-hash coll hash-fn hash-key)

case clj macro

(case e & clauses)

Takes an expression, and a set of clauses.

Each clause can take the form of either:

test-constant result-expr

(test-constant1 ... test-constantN) result-expr

The test-constants are not evaluated. They must be compile-time literals, and need not be quoted. If the expression is equal to a test-constant, the corresponding result-expr is returned. A single default expression can follow the clauses, and its value will be returned if no clause matches. If no default expression is provided and no clause matches, an Error is thrown.

Unlike cond and condp, case does a constant-time dispatch, the clauses are not considered sequentially. All manner of constant expressions are acceptable in case, including numbers, strings, symbols, keywords, and (ClojureScript) composites thereof. Note that since lists are used to group multiple constants that map to the same expression, a vector can be used to match a list if needed. The test-constants need not be all of the same type.

cat cljs

(cat rf)

A transducer which concatenates the contents of each input, which must be a collection, into the reduction.

char cljs

(char x)

Coerce to char

char? cljs

(char? x)

Returns true if x is a JavaScript string of length one.

CHAR_MAP cljs

chars cljs

(chars x)

chunk cljs

(chunk b)

chunk-append cljs

(chunk-append b x)

chunk-buffer cljs

(chunk-buffer capacity)

chunk-cons cljs

(chunk-cons chunk rest)

chunk-first cljs

(chunk-first s)

chunk-next cljs

(chunk-next s)

chunk-rest cljs

(chunk-rest s)

ChunkBuffer cljs

chunked-seq cljs

(chunked-seq vec i off)

(chunked-seq vec node i off)

(chunked-seq vec node i off meta)

chunked-seq? cljs

(chunked-seq? x)

Return true if x is satisfies IChunkedSeq.

ChunkedCons cljs

ChunkedSeq cljs

clj->js cljs

(clj->js x & {:keys [keyword-fn] :or {keyword-fn name} :as options})

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. Options is a key-value pair, where the only valid key is :keyword-fn, which should point to a single-argument function to be called on keyword keys. Default to name.

clone cljs

(clone value)

Clone the supplied value which must implement ICloneable.

cloneable? cljs

(cloneable? value)

Return true if x implements ICloneable protocol.

coercive-= clj macro

(coercive-= x y)

coercive-boolean clj macro

(coercive-boolean x)

coercive-not clj macro

(coercive-not x)

coercive-not= clj macro

(coercive-not= x y)

coll? cljs

(coll? x)

Returns true if x satisfies ICollection

comment clj macro

(comment & body)

Ignores body, yields nil

comp cljs

(comp)

(comp f)

(comp f g)

(comp f g h)

(comp f1 f2 f3 & fs)

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 cljs

(comparator pred)

Returns an JavaScript compatible comparator based upon pred.

compare cljs

(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! cljs

(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.

complement cljs

(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 cljs

(completing f)

(completing f cf)

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 cljs

(concat)

(concat x)

(concat x y)

(concat x y & zs)

Returns a lazy seq representing the concatenation of the elements in the supplied colls.

cond clj macro

(cond & clauses)

Takes a set of test/expr pairs. It evaluates each test one at a time. If a test returns logical true, cond evaluates and returns the value of the corresponding expr and doesn't evaluate any of the other tests or exprs. (cond) returns nil.

cond-> clj macro

(cond-> expr & clauses)

Takes an expression and a set of test/form pairs. Threads expr (via ->) through each form for which the corresponding test expression is true. Note that, unlike cond branching, cond-> threading does not short circuit after the first true test expression.

cond->> clj macro

(cond->> expr & clauses)

Takes an expression and a set of test/form pairs. Threads expr (via ->>) through each form for which the corresponding test expression is true. Note that, unlike cond branching, cond->> threading does not short circuit after the first true test expression.

condp clj macro

(condp pred expr & clauses)

Takes a binary predicate, an expression, and a set of clauses. Each clause can take the form of either:

test-expr result-expr

test-expr :>> result-fn

Note :>> is an ordinary keyword.

For each clause, (pred test-expr expr) is evaluated. If it returns logical true, the clause is a match. If a binary clause matches, the result-expr is returned, if a ternary clause matches, its result-fn, which must be a unary function, is called with the result of the predicate as its argument, the result of that call being the return value of condp. A single default expression can follow the clauses, and its value will be returned if no clause matches. If no default expression is provided and no clause matches, an Error is thrown.

conj cljs

(conj)

(conj coll)

(conj coll x)

(conj coll x & xs)

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! cljs

(conj!)

(conj! tcoll)

(conj! tcoll val)

(conj! tcoll val & vals)

Adds val to the transient collection, and return tcoll. The 'addition' may happen at different 'places' depending on the concrete type.

cons cljs

(cons x coll)

Returns a new seq where x is the first element and coll is the rest.

Cons cljs

constantly cljs

(constantly x)

Returns a function that takes any number of arguments and returns x.

contains? cljs

(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'.

copy-arguments clj macro

(copy-arguments dest)

count cljs

(count coll)

Returns the number of items in the collection. (count nil) returns 0. Also works on strings, arrays, and Maps

counted? cljs

(counted? x)

Returns true if coll implements count in constant time

create-ns cljs

(create-ns sym)

(create-ns sym ns-obj)

Create a new namespace named by the symbol. Bootstrap only.

Cycle cljs

cycle cljs

(cycle coll)

Returns a lazy (infinite!) sequence of repetitions of the items in coll.

dec clj/s≠

(dec x)

cljs

Returns a number one less than num.

declare clj macro

(declare & names)

defs the supplied var names with no bindings, useful for making forward declarations.

dedupe cljs

(dedupe)

(dedupe coll)

Returns a lazy sequence removing consecutive duplicates in coll. Returns a transducer when no collection is provided.

default-dispatch-val cljs

(default-dispatch-val multifn)

Given a multimethod, return it's default-dispatch-val.

defmacro clj macro

(defmacro name doc-string? attr-map? [params*] body)

(defmacro name doc-string? attr-map? ([params*] body) + attr-map?)

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 called.

defmethod clj macro

(defmethod multifn dispatch-val & fn-tail)

Creates and installs a new method of multimethod associated with dispatch-value.

defmulti clj macro

(defmulti name docstring? attr-map? dispatch-fn & options)

Creates a new multimethod with the associated dispatch function. The docstring and attribute-map are optional.

Options are key-value pairs and may be one of: :default the default dispatch value, defaults to :default :hierarchy the isa? hierarchy to use for dispatching defaults to the global hierarchy

defn clj macro

(defn name doc-string? attr-map? [params*] prepost-map? body)

(defn name doc-string? attr-map? ([params*] prepost-map? body) + attr-map?)

Same as (def name (core/fn [params* ] exprs*)) or (def name (core/fn ([params* ] exprs*)+)) with any doc-string or attrs added to the var metadata. prepost-map defines a map with optional keys :pre and :post that contain collections of pre or post conditions.

defn- clj macro

(defn- name & decls)

same as defn, yielding non-public def

defonce clj macro

(defonce x init)

defs name to have the root value of init iff the named var has no root value, else init is unevaluated

defprotocol clj macro

(defprotocol psym & doc+methods)

A protocol is a named set of named methods and their signatures:

(defprotocol AProtocolName ;optional doc string "A doc string for AProtocol abstraction"

;method signatures (bar [this a b] "bar docs") (baz [this a] [this a b] [this a b c] "baz docs"))

No implementations are provided. Docs can be specified for the protocol overall and for each method. The above yields a set of polymorphic functions and a protocol object. All are namespace-qualified by the ns enclosing the definition The resulting functions dispatch on the type of their first argument, which is required and corresponds to the implicit target object ('this' in JavaScript parlance). defprotocol is dynamic, has no special compile-time effect, and defines no new types.

(defprotocol P (foo [this]) (bar-me [this] [this y]))

(deftype Foo [a b c] P (foo [this] a) (bar-me [this] b) (bar-me [this y] (+ c y)))

(bar-me (Foo. 1 2 3) 42) => 45

(foo (let [x 42] (reify P (foo [this] 17) (bar-me [this] x) (bar-me [this y] x)))) => 17

defrecord clj macro

(defrecord rsym fields & impls)

(defrecord name [fields*] options* specs*)

Currently there are no options.

Each spec consists of a protocol or interface name followed by zero or more method bodies:

protocol-or-Object (methodName [args*] body)*

The record will have the (immutable) fields named by fields, which can have type hints. Protocols and methods are optional. The only methods that can be supplied are those declared in the protocols. Note that method bodies are not closures, the local environment includes only the named fields, and those fields can be accessed directly.

Method definitions take the form:

(methodname [args*] body)

The argument and return types can be hinted on the arg and methodname symbols. If not supplied, they will be inferred, so type hints should be reserved for disambiguation.

Methods should be supplied for all methods of the desired protocol(s). You can also define overrides for methods of Object. Note that a parameter must be supplied to correspond to the target object ('this' in JavaScript parlance). Note also that recur calls to the method head should not pass the target object, it will be supplied automatically and can not be substituted.

In the method bodies, the (unqualified) name can be used to name the class (for calls to new, instance? etc).

The type will have implementations of several ClojureScript protocol generated automatically: IMeta/IWithMeta (metadata support) and IMap, etc.

In addition, defrecord will define type-and-value-based =, and will define ClojureScript IHash and IEquiv.

Two constructors will be defined, one taking the designated fields followed by a metadata map (nil for none) and an extension field map (nil for none), and one taking only the fields (using nil for meta and extension fields). Note that the field names __meta and __extmap are currently reserved and should not be used when defining your own records.

Given (defrecord TypeName ...), two factory functions will be defined: ->TypeName, taking positional parameters for the fields, and map->TypeName, taking a map of keywords to field values.

deftype clj macro

(deftype t fields & impls)

(deftype name [fields*] options* specs*)

Currently there are no options.

Each spec consists of a protocol or interface name followed by zero or more method bodies:

protocol-or-Object (methodName [args*] body)*

The type will have the (by default, immutable) fields named by fields, which can have type hints. Protocols and methods are optional. The only methods that can be supplied are those declared in the protocols/interfaces. Note that method bodies are not closures, the local environment includes only the named fields, and those fields can be accessed directly. Fields can be qualified with the metadata :mutable true at which point (set! afield aval) will be supported in method bodies. Note well that mutable fields are extremely difficult to use correctly, and are present only to facilitate the building of higherlevel constructs, such as ClojureScript's reference types, in ClojureScript itself. They are for experts only - if the semantics and implications of :mutable are not immediately apparent to you, you should not be using them.

Method definitions take the form:

(methodname [args*] body)

The argument and return types can be hinted on the arg and methodname symbols. If not supplied, they will be inferred, so type hints should be reserved for disambiguation.

Methods should be supplied for all methods of the desired protocol(s). You can also define overrides for methods of Object. Note that a parameter must be supplied to correspond to the target object ('this' in JavaScript parlance). Note also that recur calls to the method head should not pass the target object, it will be supplied automatically and can not be substituted.

In the method bodies, the (unqualified) name can be used to name the class (for calls to new, instance? etc).

One constructor will be defined, taking the designated fields. Note that the field names __meta and __extmap are currently reserved and should not be used when defining your own types.

Given (deftype TypeName ...), a factory function called ->TypeName will be defined, taking positional parameters for the fields

Delay cljs

delay clj macro

(delay & body)

Takes a body of expressions and yields a Delay object that will invoke the body only the first time it is forced (with force or deref/@), and will cache the result and return it on all subsequent force calls.

delay? cljs

(delay? x)

returns true if x is a Delay created with delay

demunge cljs

(demunge name)

DEMUNGE_MAP cljs

DEMUNGE_PATTERN cljs

deref cljs

(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 cljs

(derive tag parent)

(derive h tag parent)

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 cljs

(descendants tag)

(descendants h tag)

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.

destructure clj

(destructure bindings)

disj cljs

(disj coll)

(disj coll k)

(disj coll k & ks)

disj[oin]. Returns a new set of the same (hashed/sorted) type, that does not contain key(s).

disj! cljs

(disj! tcoll val)

(disj! tcoll val & vals)

disj[oin]. Returns a transient set of the same (hashed/sorted) type, that does not contain key(s).

dispatch-fn cljs

(dispatch-fn multifn)

Given a multimethod, return it's dispatch-fn.

dissoc cljs

(dissoc coll)

(dissoc coll k)

(dissoc coll k & ks)

dissoc[iate]. Returns a new map of the same (hashed/sorted) type, that does not contain a mapping for key(s).

dissoc! cljs

(dissoc! tcoll key)

(dissoc! tcoll key & ks)

Returns a transient map that doesn't contain a mapping for key(s).

distinct cljs

(distinct)

(distinct coll)

Returns a lazy sequence of the elements of coll with duplicates removed. Returns a stateful transducer when no collection is provided.

distinct? cljs

(distinct? x)

(distinct? x y)

(distinct? x y & more)

Returns true if no two of the arguments are =

divide clj/s≠

clj

(divide x)

(divide x y)

(divide x y & more)

cljs

doall cljs

(doall coll)

(doall n coll)

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.

dorun cljs

(dorun coll)

(dorun n coll)

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.

doseq clj macro

(doseq seq-exprs & body)

Repeatedly executes body (presumably for side-effects) with bindings and filtering as provided by "for". Does not retain the head of the sequence. Returns nil.

dotimes clj macro

(dotimes bindings & body)

bindings => name n

Repeatedly executes body (presumably for side-effects) with name bound to integers from 0 through n-1.

doto clj macro

(doto x & forms)

Evaluates x then calls all of the methods and functions with the value of x supplied at the front of the given arguments. The forms are evaluated in order. Returns x.

(doto (new js/Map) (.set "a" 1) (.set "b" 2))

double clj/s

(double x)

double-array cljs

(double-array size-or-seq)

(double-array size init-val-or-seq)

Creates an array of doubles. Does not coerce array, provided for compatibility with Clojure.

double? cljs

(double? x)

Returns true for JavaScript numbers, false otherwise.

doubles cljs

(doubles x)

drop cljs

(drop n)

(drop n coll)

Returns a lazy sequence of all but the first n items in coll. Returns a stateful transducer when no collection is provided.

drop-last cljs

(drop-last s)

(drop-last n s)

Return a lazy sequence of all but the last n (default 1) items in coll

drop-while cljs

(drop-while pred)

(drop-while pred coll)

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.

dt->et clj

(dt->et type specs fields)

(dt->et type specs fields inline)

eduction cljs

(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.

Eduction cljs

Empty cljs

empty cljs

(empty coll)

Returns an empty collection of the same category as coll, or nil

empty? cljs

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

EmptyList cljs

enable-console-print! cljs

(enable-console-print!)

Set print-fn to console.log

ensure-reduced cljs

(ensure-reduced x)

If x is already reduced?, returns it, else returns (reduced x)

equiv-map cljs

(equiv-map x y)

Test map equivalence. Returns true if x equals y, otherwise returns false.

es6-entries-iterator cljs

(es6-entries-iterator coll)

es6-iterable clj macro

(es6-iterable ty)

es6-iterator cljs

(es6-iterator coll)

EXPERIMENTAL: Return a ES2015 compatible iterator for coll.

es6-iterator-seq cljs

(es6-iterator-seq iter)

EXPERIMENTAL: Given an ES2015 compatible iterator return a seq.

es6-set-entries-iterator cljs

(es6-set-entries-iterator coll)

ES6EntriesIterator cljs

ES6Iterator cljs

ES6IteratorSeq cljs

ES6SetEntriesIterator cljs

eval cljs

(eval form)

Evaluates the form data structure (not text!) and returns the result. Delegates to cljs.core/eval. Intended for use in self-hosted ClojureScript, which sets up an implementation of cljs.core/eval for that environment.

even? cljs

(even? n)

Returns true if n is even, throws an exception if n is not an integer

every-pred cljs

(every-pred p)

(every-pred p1 p2)

(every-pred p1 p2 p3)

(every-pred p1 p2 p3 & ps)

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? cljs

(every? pred coll)

Returns true if (pred x) is logical true for every x in coll, else false.

ex-cause cljs

(ex-cause ex)

Returns exception cause (an Error / ExceptionInfo) if ex is an ExceptionInfo. Otherwise returns nil.

ex-data cljs

(ex-data ex)

Returns exception data (a map) if ex is an ExceptionInfo. Otherwise returns nil.

ex-info cljs

(ex-info msg data)

(ex-info msg data cause)

Create an instance of ExceptionInfo, an Error type that carries a map of additional data.

ex-message cljs

(ex-message ex)

Returns the message attached to the given Error / ExceptionInfo object. For non-Errors returns nil.

ExceptionInfo cljs

(ExceptionInfo message data cause)

exists? clj macro

(exists? x)

Return true if argument exists, analogous to usage of typeof operator in JavaScript.

extend-protocol clj macro

(extend-protocol p & specs)

Useful when you want to provide several implementations of the same protocol all at once. Takes a single protocol and the implementation of that protocol for one or more types. Expands into calls to extend-type:

(extend-protocol Protocol AType (foo [x] ...) (bar [x y] ...) BType (foo [x] ...) (bar [x y] ...) AClass (foo [x] ...) (bar [x y] ...) nil (foo [x] ...) (bar [x y] ...))

expands into:

(do (clojure.core/extend-type AType Protocol (foo [x] ...) (bar [x y] ...)) (clojure.core/extend-type BType Protocol (foo [x] ...) (bar [x y] ...)) (clojure.core/extend-type AClass Protocol (foo [x] ...) (bar [x y] ...)) (clojure.core/extend-type nil Protocol (foo [x] ...) (bar [x y] ...)))

extend-type clj macro

(extend-type type-sym & impls)

Extend a type to a series of protocols. Useful when you are supplying the definitions explicitly inline. Propagates the type as a type hint on the first argument of all fns.

type-sym may be

• default, meaning the definitions will apply for any value, unless an extend-type exists for one of the more specific cases below.
• nil, meaning the definitions will apply for the nil value.
• any of object, boolean, number, string, array, or function, indicating the definitions will apply for values of the associated base JavaScript types. Note that, for example, string should be used instead of js/String.
• a JavaScript type not covered by the previous list, such as js/RegExp.
• a type defined by deftype or defrecord.

(extend-type MyType ICounted (-count [c] ...) Foo (bar [x y] ...) (baz ([x] ...) ([x y] ...) ...)

false? clj/s≠

(false? x)

cljs

Returns true if x is the value false, false otherwise.

fast-path-protocol-partitions-count clj

total number of partitions

fast-path-protocols clj

protocol fqn -> [partition number, bit]

ffirst cljs

(ffirst coll)

Same as (first (first x))

filter cljs

(filter pred)

(filter pred coll)

Returns a lazy sequence of the items in coll for which (pred item) returns logical true. pred must be free of side-effects. Returns a transducer when no collection is provided.

filterv cljs

(filterv pred coll)

Returns a vector of the items in coll for which (pred item) returns logical true. pred must be free of side-effects.

find cljs

(find coll k)

Returns the map entry for key, or nil if key not present.

find-macros-ns cljs

(find-macros-ns ns)

Returns the macros namespace named by the symbol or nil if it doesn't exist. Bootstrap only.

find-ns cljs

(find-ns ns)

Returns the namespace named by the symbol or nil if it doesn't exist. Bootstrap only.

find-ns-obj cljs

(find-ns-obj ns)

Bootstrap only.

first cljs

(first coll)

Returns the first item in the collection. Calls seq on its argument. If coll is nil, returns nil.

flatten cljs

(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.

float clj/s

(float x)

float? cljs

(float? x)

Returns true for JavaScript numbers, false otherwise.

floats cljs

(floats x)

flush cljs

(flush)

fn clj macro

(fn & sigs)

params => positional-params* , or positional-params* & next-param positional-param => binding-form next-param => binding-form name => symbol

Defines a function

Fn cljs protocol

Marker protocol

fn? cljs

(fn? f)

Return true if f is a JavaScript function or satisfies the Fn protocol.

fnext cljs

(fnext coll)

Same as (first (next x))

fnil cljs

(fnil f x)

(fnil f x y)

(fnil f x y z)

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.

for clj macro

(for seq-exprs body-expr)

List comprehension. Takes a vector of one or more binding-form/collection-expr pairs, each followed by zero or more modifiers, and yields a lazy sequence of evaluations of expr. Collections are iterated in a nested fashion, rightmost fastest, and nested coll-exprs can refer to bindings created in prior binding-forms. Supported modifiers are: :let [binding-form expr ...], :while test, :when test.

(take 100 (for [x (range 100000000) y (range 1000000) :while (< y x)] [x y]))

force cljs

(force x)

If x is a Delay, returns the (possibly cached) value of its expression, else returns x

frequencies cljs

(frequencies coll)

Returns a map from distinct items in coll to the number of times they appear.

gen-apply-to clj macro

(gen-apply-to)

gen-apply-to-simple clj macro

(gen-apply-to-simple f num-args args)

gensym cljs

(gensym)

(gensym prefix-string)

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__'.

gensym_counter cljs

get cljs

(get o k)

(get o k not-found)

Returns the value mapped to key, not-found or nil if key not present.

get-in cljs

(get-in m ks)

(get-in m ks not-found)

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 cljs

(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 cljs

(get-validator iref)

Gets the validator-fn for a var/ref/agent/atom.

goog-define clj macro

(goog-define sym default)

Defines a var using goog.define. Passed default value must be string, number or boolean.

Default value can be overridden at compile time using the compiler option :closure-defines.

Example: (ns your-app.core) (goog-define DEBUG! false) ;; can be overridden with :closure-defines {"your_app.core.DEBUG_BANG_" true} or :closure-defines {'your-app.core/DEBUG! true}

group-by cljs

(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 cljs

(halt-when pred)

(halt-when pred retf)

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 cljs

(hash o)

Returns the hash code of its argument. Note this is the hash code consistent with =.

hash-combine cljs

(hash-combine seed hash)

hash-keyword cljs

(hash-keyword k)

hash-map clj/s≠

clj

(hash-map)

(hash-map & kvs)

cljs

(hash-map & keyvals)

keyval => key val Returns a new hash map with supplied mappings.

hash-ordered-coll cljs

(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 clj/s≠

clj

(hash-set)

(hash-set & xs)

cljs

(hash-set)

(hash-set & keys)

Returns a new hash set with supplied keys. Any equal keys are handled as if by repeated uses of conj.

hash-string cljs

(hash-string k)

hash-string* cljs

(hash-string* s)

hash-unordered-coll cljs

(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.

HashCollisionNode cljs

HashMapIter cljs

HashSetIter cljs

IAssociative cljs protocol

Protocol for adding associativity to collections.

-assoc cljs

(-assoc coll k v)

Returns a new collection of coll with a mapping from key k to value v added to it.

-contains-key? cljs

(-contains-key? coll k)

Returns true if k is a key in coll.

IAtom cljs protocol

Marker protocol indicating an atom.

IChunk cljs protocol

Protocol for accessing the items of a chunk.

-drop-first cljs

(-drop-first coll)

Return a new chunk of coll with the first item removed.

IChunkedNext cljs protocol

Protocol for accessing the chunks of a collection.

-chunked-next cljs

(-chunked-next coll)

Returns a new collection of coll without the first chunk.

IChunkedSeq cljs protocol

Protocol for accessing a collection as sequential chunks.

-chunked-rest cljs

(-chunked-rest coll)

Return a new collection of coll with the first chunk removed.

-chunked-first cljs

(-chunked-first coll)

Returns the first chunk in coll.

ICloneable cljs protocol

Protocol for cloning a value.

-clone cljs

(-clone value)

Creates a clone of value.

ICollection cljs protocol

Protocol for adding to a collection.

-conj cljs

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

IComparable cljs protocol

Protocol for values that can be compared.

-compare cljs

(-compare x y)

Returns a negative number, zero, or a positive number when x is logically 'less than', 'equal to', or 'greater than' y.

ICounted cljs protocol

Protocol for adding the ability to count a collection in constant time.

-count cljs

(-count coll)

Calculates the count of coll in constant time. Used by cljs.core/count.

ident? cljs

(ident? x)

Return true if x is a symbol or keyword

identical? clj/s≠

clj

(identical? a b)

cljs

(identical? x y)

Tests if 2 arguments are the same object

identity cljs

(identity x)

Returns its argument.

IDeref cljs protocol

Protocol for adding dereference functionality to a reference.

-deref cljs

(-deref o)

Returns the value of the reference o.

IDerefWithTimeout cljs protocol

-deref-with-timeout cljs

(-deref-with-timeout o msec timeout-val)

IEditableCollection cljs protocol

Protocol for collections which can transformed to transients.

-as-transient cljs

(-as-transient coll)

Returns a new, transient version of the collection, in constant time.

IEmptyableCollection cljs protocol

Protocol for creating an empty collection.

-empty cljs

(-empty coll)

Returns an empty collection of the same category as coll. Used by cljs.core/empty.

IEncodeClojure cljs protocol

-js->clj cljs

(-js->clj x options)

Transforms JavaScript values to Clojure

IEncodeJS cljs protocol

-clj->js cljs

(-clj->js x)

Recursively transforms clj values to JavaScript

-key->js cljs

(-key->js x)

Transforms map keys to valid JavaScript keys. Arbitrary keys are encoded to their string representation via (pr-str x)

IEquiv cljs protocol

Protocol for adding value comparison functionality to a type.

-equiv cljs

(-equiv o other)

Returns true if o and other are equal, false otherwise.

if-let clj macro

(if-let bindings then)

(if-let bindings then else & oldform)

bindings => binding-form test

If test is true, evaluates then with binding-form bound to the value of test, if not, yields else

if-not clj macro

(if-not test then)

(if-not test then else)

Evaluates test. If logical false, evaluates and returns then expr, otherwise else expr, if supplied, else nil.

if-some clj macro

(if-some bindings then)

(if-some bindings then else & oldform)

bindings => binding-form test

If test is not nil, evaluates then with binding-form bound to the value of test, if not, yields else

IFind cljs protocol

Protocol for implementing entry finding in collections.

-find cljs

(-find coll k)

Returns the map entry for key, or nil if key not present.

ifind? cljs

(ifind? x)

Returns true if coll implements IFind

IFn cljs 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 cljs

(-invoke this)

(-invoke this a)

(-invoke this a b)

(-invoke this a b c)

(-invoke this a b c d)

(-invoke this a b c d e)

(-invoke this a b c d e f)

(-invoke this a b c d e f g)

(-invoke this a b c d e f g h)

(-invoke this a b c d e f g h i)

(-invoke this a b c d e f g h i j)

(-invoke this a b c d e f g h i j k)

(-invoke this a b c d e f g h i j k l)

(-invoke this a b c d e f g h i j k l m)

(-invoke this a b c d e f g h i j k l m n)

(-invoke this a b c d e f g h i j k l m n o)

(-invoke this a b c d e f g h i j k l m n o p)

(-invoke this a b c d e f g h i j k l m n o p q)

(-invoke this a b c d e f g h i j k l m n o p q r)

(-invoke this a b c d e f g h i j k l m n o p q r s)

(-invoke this a b c d e f g h i j k l m n o p q r s t)

(-invoke this a b c d e f g h i j k l m n o p q r s t rest)

ifn? cljs

(ifn? f)

Returns true if f returns true for fn? or satisfies IFn.

IHash cljs protocol

Protocol for adding hashing functionality to a type.

-hash cljs

(-hash o)

Returns the hash code of o.

IIndexed cljs protocol

Protocol for collections to provide indexed-based access to their items.

-nth cljs

(-nth coll n)

(-nth coll n not-found)

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.

IIterable cljs protocol

Protocol for iterating over a collection.

-iterator cljs

(-iterator coll)

Returns an iterator for coll.

IKVReduce cljs protocol

Protocol for associative types that can reduce themselves via a function of key and val. Called by cljs.core/reduce-kv.

-kv-reduce cljs

(-kv-reduce coll f init)

Reduces an associative collection and returns the result. f should be a function that takes three arguments.

IList cljs protocol

Marker interface indicating a persistent list

ILookup cljs protocol

Protocol for looking up a value in a data structure.

-lookup cljs

(-lookup o k)

(-lookup o k not-found)

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.

IMap cljs protocol

Protocol for adding mapping functionality to collections.

-dissoc cljs

(-dissoc coll k)

Returns a new collection of coll without the mapping for key k.

IMapEntry cljs protocol

Protocol for examining a map entry.

-key cljs

(-key coll)

Returns the key of the map entry.

-val cljs

(-val coll)

Returns the value of the map entry.

IMeta cljs protocol

Protocol for accessing the metadata of an object.

-meta cljs

(-meta o)

Returns the metadata of object o.

implements? clj macro

(implements? psym x)

EXPERIMENTAL

import clj macro

(import & import-symbols-or-lists)

import-list => (closure-namespace constructor-name-symbols*)

For each name in constructor-name-symbols, adds a mapping from name to the constructor named by closure-namespace to the current namespace. Use :import in the ns macro in preference to calling this directly.

import-macros clj macro

(import-macros ns [& vars])

imul cljs

(imul a b)

IMultiFn cljs protocol

-prefer-method cljs

(-prefer-method mf dispatch-val dispatch-val-y)

-default-dispatch-val cljs

(-default-dispatch-val mf)

-remove-method cljs

(-remove-method mf dispatch-val)

-methods cljs

(-methods mf)

-prefers cljs

(-prefers mf)

-dispatch-fn cljs

(-dispatch-fn mf)

-add-method cljs

(-add-method mf dispatch-val method)

-reset cljs

(-reset mf)

-get-method cljs

(-get-method mf dispatch-val)

INamed cljs protocol

Protocol for adding a name.

-name cljs

(-name x)

Returns the name String of x.

-namespace cljs

(-namespace x)

Returns the namespace String of x.

inc clj/s≠

(inc x)

cljs

Returns a number one greater than num.

indexed? cljs

(indexed? x)

Returns true if coll implements nth in constant time

IndexedSeq cljs

IndexedSeqIterator cljs

INext cljs protocol

Protocol for accessing the next items of a collection.

-next cljs

(-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? cljs

(infinite? x)

Returns true for Infinity and -Infinity values.

INIT cljs

Inst cljs protocol

inst-ms* cljs

(inst-ms* inst)

inst-ms cljs

(inst-ms inst)

Return the number of milliseconds since January 1, 1970, 00:00:00 GMT

inst? cljs

(inst? x)

Return true if x satisfies Inst

instance? clj/s≠

(instance? c x)

cljs

Evaluates x and tests if it is an instance of the type c. Returns true or false

int clj/s≠

(int x)

cljs

Coerce to int by stripping decimal places.

int-array cljs

(int-array size-or-seq)

(int-array size init-val-or-seq)

Creates an array of ints. Does not coerce array, provided for compatibility with Clojure.

int-rotate-left cljs

(int-rotate-left x n)

int? cljs

(int? x)

Return true if x satisfies integer? or is an instance of goog.math.Integer or goog.math.Long.

integer? cljs

(integer? n)

Returns true if n is a JavaScript number with no decimal part.

interleave cljs

(interleave)

(interleave c1)

(interleave c1 c2)

(interleave c1 c2 & colls)

Returns a lazy seq of the first item in each coll, then the second etc.

interpose cljs

(interpose sep)

(interpose sep coll)

Returns a lazy seq of the elements of coll separated by sep. Returns a stateful transducer when no collection is provided.

into cljs

(into)

(into to)

(into to from)

(into to xform from)

Returns a new coll consisting of to-coll with all of the items of from-coll conjoined. A transducer may be supplied.

into-array cljs

(into-array aseq)

(into-array type aseq)

Returns an array with components set to the values in aseq. Optional type argument accepted for compatibility with Clojure.

ints cljs

(ints x)

IPending cljs protocol

Protocol for types which can have a deferred realization. Currently only implemented by Delay and LazySeq.

-realized? cljs

(-realized? x)

Returns true if a value for x has been produced, false otherwise.

IPrintWithWriter cljs 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 cljs

(-pr-writer o writer opts)

IRecord cljs protocol

Marker interface indicating a record object

IReduce cljs protocol

Protocol for seq types that can reduce themselves. Called by cljs.core/reduce.

-reduce cljs

(-reduce coll f)

(-reduce coll f start)

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.

IReset cljs protocol

Protocol for adding resetting functionality.

-reset! cljs

(-reset! o new-value)

Sets the value of o to new-value.

IReversible cljs protocol

Protocol for reversing a seq.

-rseq cljs

(-rseq coll)

Returns a seq of the items in coll in reversed order.

is_proto_ cljs

(is_proto_ x)

isa? cljs

(isa? child parent)

(isa? h child parent)

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

ISeq cljs protocol

Protocol for collections to provide access to their items as sequences.

-first cljs

(-first coll)

Returns the first item in the collection coll. Used by cljs.core/first.

-rest cljs

(-rest coll)

Returns a new collection of coll without the first item. It should always return a seq, e.g. (rest []) => () (rest nil) => ()

ISeqable cljs protocol

Protocol for adding the ability to a type to be transformed into a sequence.

-seq cljs

(-seq o)

Returns a seq of o, or nil if o is empty.

ISequential cljs protocol

Marker interface indicating a persistent collection of sequential items

ISet cljs protocol

Protocol for adding set functionality to a collection.

-disjoin cljs

(-disjoin coll v)

Returns a new collection of coll that does not contain v.

ISorted cljs protocol

Protocol for a collection which can represent their items in a sorted manner.

-sorted-seq-from cljs

(-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 cljs

(-sorted-seq coll ascending?)

Returns a sorted seq from coll in either ascending or descending order.

-comparator cljs

(-comparator coll)

Returns the comparator for coll.

-entry-key cljs

(-entry-key coll entry)

Returns the key for entry.

IStack cljs 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 cljs

(-pop coll)

Returns a new stack without the item on top of the stack. Is used by cljs.core/pop.

-peek cljs

(-peek coll)

Returns the item from the top of the stack. Is used by cljs.core/peek.

ISwap cljs protocol

Protocol for adding swapping functionality.

-swap! cljs

(-swap! o f)

(-swap! o f a)

(-swap! o f a b)

(-swap! o f a b xs)

Swaps the value of o to be (apply f current-value-of-atom args).

iter cljs

(iter coll)

ITER_SYMBOL cljs

iterable? cljs

(iterable? x)

Return true if x implements IIterable protocol.

iterate cljs

(iterate f x)

Returns a lazy sequence of x, (f x), (f (f x)) etc. f must be free of side-effects

Iterate cljs

ITransientAssociative cljs protocol

Protocol for adding associativity to transient collections.

-assoc! cljs

(-assoc! tcoll key val)

Returns a new transient collection of tcoll with a mapping from key to val added to it.

ITransientCollection cljs protocol

Protocol for adding basic functionality to transient collections.

-persistent! cljs

(-persistent! tcoll)

Creates a persistent data structure from tcoll and returns it.

-conj! cljs

(-conj! tcoll val)

Adds value val to tcoll and returns tcoll.

ITransientMap cljs protocol

Protocol for adding mapping functionality to transient collections.

-dissoc! cljs

(-dissoc! tcoll key)

Returns a new transient collection of tcoll without the mapping for key.

ITransientSet cljs protocol

Protocol for adding set functionality to a transient collection.

-disjoin! cljs

(-disjoin! tcoll v)

Returns tcoll without v.

ITransientVector cljs protocol

Protocol for adding vector functionality to transient collections.

-pop! cljs

(-pop! tcoll)

Returns tcoll with the last item removed from it.

-assoc-n! cljs

(-assoc-n! tcoll n val)

Returns tcoll with value val added at position n.

IUUID cljs protocol

A marker protocol for UUIDs

IVector cljs protocol

Protocol for adding vector functionality to collections.

-assoc-n cljs

(-assoc-n coll n val)

Returns a new vector with value val added at position n.

IVolatile cljs protocol

Protocol for adding volatile functionality.

-vreset! cljs

(-vreset! o new-value)

Sets the value of volatile o to new-value without regard for the current value. Returns new-value.

IWatchable cljs protocol

Protocol for types that can be watched. Currently only implemented by Atom.

-remove-watch cljs

(-remove-watch this key)

Removes watcher that corresponds to key from this.

-add-watch cljs

(-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 cljs

(-notify-watches this oldval newval)

Calls all watchers with this, oldval and newval.

IWithMeta cljs protocol

Protocol for adding metadata to an object.

-with-meta cljs

(-with-meta o meta)

Returns a new object with value of o and metadata meta added to it.

IWriter cljs protocol

Protocol for writing. Currently only implemented by StringBufferWriter.

-write cljs

(-write writer s)

Writes s with writer and returns the result.

-flush cljs

(-flush writer)

Flush writer.

js->clj cljs

(js->clj x)

(js->clj x & opts)

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-arguments clj macro

(js-arguments)

js-comment clj macro

(js-comment comment)

Emit a top-level JavaScript multi-line comment. New lines will create a new comment line. Comment block will be preceded and followed by a newline

js-debugger clj macro

(js-debugger)

Emit JavaScript "debugger;" statement

js-delete clj/s≠

(js-delete obj key)

cljs

Delete a property from a JavaScript object. Returns true upon success, false otherwise.

js-in clj macro

(js-in key obj)

js-inline-comment clj macro

(js-inline-comment comment)

Emit an inline JavaScript comment.

js-invoke cljs

(js-invoke obj s & args)

Invoke JavaScript object method via string. Needed when the string is not a valid unquoted property name.

js-keys cljs

(js-keys obj)

Return the JavaScript keys for an object.

js-mod clj/s≠

clj

(js-mod num div)

cljs

(js-mod n d)

Modulus of num and div with original javascript behavior. i.e. bug for negative numbers

js-obj clj/s≠

clj

(js-obj & rest)

cljs

(js-obj)

(js-obj & keyvals)

Create JavaSript object from an even number arguments representing interleaved keys and values.

js-reserved cljs

js-str clj macro

(js-str s)

juxt cljs

(juxt f)

(juxt f g)

(juxt f g h)

(juxt f g h & fs)

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 cljs

(keep f)

(keep f coll)

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 cljs

(keep-indexed f)

(keep-indexed f coll)

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 cljs

(key map-entry)

Returns the key of the map entry.

key->js cljs

(key->js k)

(key->js k primitive-fn)

key-test cljs

(key-test key other)

keys cljs

(keys map)

Returns a sequence of the map's keys, in the same order as (seq map).

KeySeq cljs

keyword cljs

(keyword name)

(keyword ns name)

Returns a Keyword with the given namespace and name. Do not use : in the keyword strings, it will be added automatically.

Keyword cljs

keyword-identical? cljs

(keyword-identical? x y)

Efficient test to determine that two keywords are identical.

keyword? clj/s≠

(keyword? x)

cljs

Return true if x is a Keyword

last cljs

(last s)

Return the last item in coll, in linear time

lazy-cat clj macro

(lazy-cat & colls)

Expands to code which yields a lazy sequence of the concatenation of the supplied colls. Each coll expr is not evaluated until it is needed.

(lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))

lazy-seq clj macro

(lazy-seq & body)

Takes a body of expressions that returns an ISeq or nil, and yields a ISeqable object that will invoke the body only the first time seq is called, and will cache the result and return it on all subsequent seq calls.

LazySeq cljs

let clj macro

(let bindings & body)

binding => binding-form init-expr

Evaluates the exprs in a lexical context in which the symbols in the binding-forms are bound to their respective init-exprs or parts therein.

letfn clj macro

(letfn fnspecs & body)

fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+)

Takes a vector of function specs and a body, and generates a set of bindings of functions to their names. All of the names are available in all of the definitions of the functions, as well as the body.

list clj/s≠

clj

(list)

(list x)

(list x & xs)

cljs

(list & xs)

Creates a new list containing the items.

List cljs

list* cljs

(list* args)

(list* a args)

(list* a b args)

(list* a b c args)

(list* a b c d & more)

Creates a new list containing the items prepended to the rest, the last of which will be treated as a sequence.

list? cljs

(list? x)

Returns true if x implements IList

load-file cljs

(load-file file)

load-file* clj macro

(load-file* f)

locking clj macro

(locking x & forms)

long cljs

(long x)

Coerce to long by stripping decimal places. Identical to `int'.

long-array cljs

(long-array size-or-seq)

(long-array size init-val-or-seq)

Creates an array of longs. Does not coerce array, provided for compatibility with Clojure.

longs cljs

(longs x)

loop clj macro

(loop bindings & body)

Evaluates the exprs in a lexical context in which the symbols in the binding-forms are bound to their respective init-exprs or parts therein. Acts as a recur target.

m3-C1 cljs

m3-C2 cljs

m3-fmix cljs

(m3-fmix h1 len)

m3-hash-int cljs

(m3-hash-int in)

m3-hash-unencoded-chars cljs

(m3-hash-unencoded-chars in)

m3-mix-H1 cljs

(m3-mix-H1 h1 k1)

m3-mix-K1 cljs

(m3-mix-K1 k1)

m3-seed cljs

macroexpand clj macro

(macroexpand quoted)

Repeatedly calls macroexpand-1 on form until it no longer represents a macro form, then returns it. Note neither macroexpand-1 nor macroexpand expand macros in subforms.

macroexpand-1 clj macro

(macroexpand-1 quoted)

If form represents a macro form, returns its expansion, else returns form.

make-array clj/s≠

(make-array size)

(make-array type size)

(make-array type size & more-sizes)

cljs

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 cljs

(make-hierarchy)

Creates a hierarchy object for use with derive, isa? etc.

Many cljs

map cljs

(map f)

(map f coll)

(map f c1 c2)

(map f c1 c2 c3)

(map f c1 c2 c3 & colls)

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-entry? cljs

(map-entry? x)

Returns true if x satisfies IMapEntry

map-indexed cljs

(map-indexed f)

(map-indexed f coll)

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? cljs

(map? x)

Return true if x satisfies IMap

mapcat cljs

(mapcat f)

(mapcat f & colls)

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

MapEntry cljs

mapv cljs

(mapv f coll)

(mapv f c1 c2)

(mapv f c1 c2 c3)

(mapv f c1 c2 c3 & colls)

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.

mask clj macro

(mask hash shift)

max clj/s≠

(max x)

(max x y)

(max x y & more)

cljs

Returns the greatest of the nums.

max-key cljs

(max-key k x)

(max-key k x y)

(max-key k x y & more)

Returns the x for which (k x), a number, is greatest.

If there are multiple such xs, the last one is returned.

memfn clj macro

(memfn name & args)

Expands into code that creates a fn that expects to be passed an object and any args and calls the named instance method on the object passing the args. Use when you want to treat a JavaScript method as a first-class fn.

memoize cljs

(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 cljs

(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 cljs

(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 cljs

(meta o)

Returns the metadata of obj, returns nil if there is no metadata.

MetaFn cljs

methods cljs

(methods multifn)

Given a multimethod, returns a map of dispatch values -> dispatch fns

min clj/s≠

(min x)

(min x y)

(min x y & more)

cljs

Returns the least of the nums.

min-key cljs

(min-key k x)

(min-key k x y)

(min-key k x y & more)

Returns the x for which (k x), a number, is least.

If there are multiple such xs, the last one is returned.

missing-protocol cljs

(missing-protocol proto obj)

mix-collection-hash cljs

(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 cljs

(mk-bound-fn sc test key)

mod cljs

(mod n d)

Modulus of num and div. Truncates toward negative infinity.

MODULE_INFOS cljs

MODULE_URIS cljs

MultiFn cljs

MultiIterator cljs

munge cljs

(munge name)

name cljs

(name x)

Returns the name String of a string, symbol or keyword.

Namespace cljs

namespace cljs

(namespace x)

Returns the namespace String of a symbol or keyword, or nil if not present.

nat-int? cljs

(nat-int? x)

Return true if x satisfies int? and is a natural integer value.

native-satisfies? cljs

(native-satisfies? p x)

Internal - do not use!

neg-int? cljs

(neg-int? x)

Return true if x satisfies int? and is negative.

neg? clj/s≠

(neg? x)

cljs

Returns true if num is less than zero, else false

NeverEquiv cljs

newline cljs

(newline)

(newline opts)

Prints a newline using print-fn

next cljs

(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 cljs

(nfirst coll)

Same as (next (first x))

nil-iter cljs

(nil-iter)

nil? clj/s≠

(nil? x)

cljs

Returns true if x is nil, false otherwise.

nnext cljs

(nnext coll)

Same as (next (next x))

NodeIterator cljs

NodeSeq cljs

not cljs

(not x)

Returns true if x is logical false, false otherwise.

not-any? cljs

(not-any? pred coll)

Returns false if (pred x) is logical true for any x in coll, else true.

not-empty cljs

(not-empty coll)

If coll is empty, returns nil, else coll

not-every? cljs

(not-every? pred coll)

Returns false if (pred x) is logical true for every x in coll, else true.

not-native cljs

not= cljs

(not= x)

(not= x y)

(not= x y & more)

Same as (not (= obj1 obj2))

ns-imports clj macro

(ns-imports quoted-ns)

Returns a map of the import mappings for the namespace.

ns-interns clj macro

(ns-interns quoted-ns)

Returns a map of the intern mappings for the namespace.

ns-interns* cljs

(ns-interns* sym)

Returns a map of the intern mappings for the namespace. Bootstrap only.

ns-name cljs

(ns-name ns-obj)

Returns the name of the namespace, a Namespace object. Bootstrap only.

ns-publics clj macro

(ns-publics quoted-ns)

Returns a map of the public intern mappings for the namespace.

ns-unmap clj macro

(ns-unmap quoted-ns quoted-sym)

Removes the mappings for the symbol from the namespace.

NS_CACHE cljs

Bootstrap only.

nth cljs

(nth coll n)

(nth coll n not-found)

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 cljs

(nthnext coll n)

Returns the nth next of coll, (seq coll) when n is 0.

nthrest cljs

(nthrest coll n)

Returns the nth rest of coll, coll when n is 0.

number? clj/s≠

(number? x)

cljs

Returns true if x is a JavaScript number.

obj-map cljs

(obj-map & keyvals)

keyval => key val Returns a new object map with supplied mappings.

object-array cljs

(object-array size-or-seq)

(object-array size init-val-or-seq)

Creates an array of objects. Does not coerce array, provided for compatibility with Clojure.

object? cljs

(object? x)

Returns true if x's constructor is Object

ObjMap cljs

odd? cljs

(odd? n)

Returns true if n is odd, throws an exception if n is not an integer

or clj macro

(or)

(or x)

(or x & next)

Evaluates exprs one at a time, from left to right. If a form returns a logical true value, or returns that value and doesn't evaluate any of the other expressions, otherwise it returns the value of the last expression. (or) returns nil.

parents cljs

(parents tag)

(parents h tag)

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 cljs

(partial f)

(partial f arg1)

(partial f arg1 arg2)

(partial f arg1 arg2 arg3)

(partial f arg1 arg2 arg3 & more)

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 cljs

(partition n coll)

(partition n step coll)

(partition n step pad coll)

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 cljs

(partition-all n)

(partition-all n coll)

(partition-all n step coll)

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 cljs

(partition-by f)

(partition-by f coll)

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 cljs

(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! cljs

(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 cljs

(persistent-array-map-seq arr i _meta)

PersistentArrayMap cljs

PersistentArrayMapIterator cljs

PersistentArrayMapSeq cljs

PersistentHashMap cljs

PersistentHashSet cljs

PersistentQueue cljs

PersistentQueueIter cljs

PersistentQueueSeq cljs

PersistentTreeMap cljs

PersistentTreeMapSeq cljs

PersistentTreeSet cljs

PersistentVector cljs

pop cljs

(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! cljs

(pop! tcoll)

Removes the last item from a transient vector. If the collection is empty, throws an exception. Returns tcoll

pos-int? cljs

(pos-int? x)

Return true if x satisfies int? and is positive.

pos? clj/s≠

(pos? x)

cljs

Returns true if num is greater than zero, else false

pr cljs

(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

pr-seq-writer cljs

(pr-seq-writer objs writer opts)

pr-sequential-writer cljs

(pr-sequential-writer writer print-one begin sep end opts coll)

pr-str cljs

(pr-str & objs)

pr to a string, returning it. Fundamental entrypoint to IPrintWithWriter.

pr-str* cljs

(pr-str* obj)

Support so that collections can implement toString without loading all the printing machinery.

pr-str-with-opts cljs

(pr-str-with-opts objs opts)

Prints a sequence of objects to a string, observing all the options given in opts

prefer-method cljs

(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 cljs

(prefers multifn)

Given a multimethod, returns a map of preferred value -> set of other values

prim-seq cljs

(prim-seq prim)

(prim-seq prim i)

Create seq from a primitive JavaScript Array-like.

print cljs

Prints the object(s) using string-print. print and println produce output for human consumption.

print-map cljs

(print-map m print-one writer opts)

print-meta? cljs

(print-meta? opts obj)

print-prefix-map cljs

(print-prefix-map prefix m print-one writer opts)

print-str cljs

(print-str & objs)

print to a string, returning it

println cljs

(println & objs)

Same as print followed by (newline)

println-str cljs

(println-str & objs)

println to a string, returning it

prn cljs

(prn & objs)

Same as pr followed by (newline).

prn-str cljs

(prn-str & objs)

Same as pr-str followed by (newline)

prn-str-with-opts cljs

(prn-str-with-opts objs opts)

Same as pr-str-with-opts followed by (newline)

PROTOCOL_SENTINEL cljs

qualified-ident? cljs

(qualified-ident? x)

Return true if x is a symbol or keyword with a namespace

qualified-keyword? cljs

(qualified-keyword? x)

Return true if x is a keyword with a namespace

qualified-symbol? cljs

(qualified-symbol? x)

Return true if x is a symbol with a namespace

quot cljs

(quot n d)

quot[ient] of dividing numerator by denominator.

rand cljs

(rand)

(rand n)

Returns a random floating point number between 0 (inclusive) and n (default 1) (exclusive).

rand-int cljs

(rand-int n)

Returns a random integer between 0 (inclusive) and n (exclusive).

rand-nth cljs

(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 cljs

(random-sample prob)

(random-sample prob coll)

Returns items from coll with random probability of prob (0.0 - 1.0). Returns a transducer when no collection is provided.

random-uuid cljs

(random-uuid)

range cljs

(range)

(range end)

(range start end)

(range start end step)

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.

Range cljs

RangeChunk cljs

ranged-iterator cljs

(ranged-iterator v start end)

RangedIterator cljs

RangeIterator cljs

re-find cljs

(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 cljs

(re-matches re s)

Returns the result of (re-find re s) if re fully matches s.

re-pattern cljs

(re-pattern s)

Returns an instance of RegExp which has compiled the provided string.

re-seq cljs

(re-seq re s)

Returns a lazy sequence of successive matches of re in s.

realized? cljs

(realized? x)

Returns true if a value has been produced for a delay or lazy sequence.

record? cljs

(record? x)

Return true if x satisfies IRecord

RecordIter cljs

RedNode cljs

reduce cljs

(reduce f coll)

(reduce f val coll)

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 cljs

(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? cljs

(reduceable? x)

Returns true if coll satisfies IReduce

Reduced cljs

reduced cljs

(reduced x)

Wraps x in a way such that a reduce will terminate with the value x

reduced? cljs

(reduced? r)

Returns true if x is the result of a call to reduced

reductions cljs

(reductions f coll)

(reductions f init coll)

Returns a lazy seq of the intermediate values of the reduction (as per reduce) of coll by f, starting with init.

refer-clojure clj macro

(refer-clojure & args)

Refers to all the public vars of cljs.core, subject to filters. Filters can include at most one each of:

:exclude list-of-symbols :rename map-of-fromsymbol-tosymbol

Filters can be used to select a subset, via exclusion, or to provide a mapping to a symbol different from the var's name, in order to prevent clashes.

regexp? cljs

(regexp? x)

Returns true if x is a JavaScript RegExp instance.

reify clj macro

(reify & impls)

reify is a macro with the following structure:

(reify options* specs*)

Currently there are no options.

Each spec consists of the protocol name followed by zero or more method bodies:

protocol (methodName [args+] body)*

Methods should be supplied for all methods of the desired protocol(s). You can also define overrides for Object methods. Note that the first parameter must be supplied to correspond to the target object ('this' in JavaScript parlance). Note also that recur calls to the method head should not pass the target object, it will be supplied automatically and can not be substituted.

recur works to method heads The method bodies of reify are lexical closures, and can refer to the surrounding local scope:

(str (let [f "foo"] (reify Object (toString [this] f)))) == "foo"

(seq (let [f "foo"] (reify ISeqable (-seq [this] (seq f))))) == ("f" "o" "o"))

reify always implements IMeta and IWithMeta and transfers meta data of the form to the created object.

(meta ^{:k :v} (reify Object (toString [this] "foo"))) == {:k :v}

rem cljs

(rem n d)

remainder of dividing numerator by denominator.

remove cljs

(remove pred)

(remove pred coll)

Returns a lazy sequence of the items in coll for which (pred item) returns logical false. pred must be free of side-effects. Returns a transducer when no collection is provided.

remove-all-methods cljs

(remove-all-methods multifn)

Removes all of the methods of multimethod.

remove-method cljs

(remove-method multifn dispatch-val)

Removes the method of multimethod associated with dispatch-value.

remove-tap cljs

(remove-tap f)

Remove f from the tap set.

remove-watch cljs

(remove-watch iref key)

Removes a watch (set by add-watch) from a reference

repeat cljs

(repeat x)

(repeat n x)

Returns a lazy (infinite!, or length n if supplied) sequence of xs.

Repeat cljs

repeatedly cljs

(repeatedly f)

(repeatedly n f)

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 cljs

(replace smap)

(replace smap coll)

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 cljs

(replicate n x)

DEPRECATED: Use 'repeat' instead. Returns a lazy seq of n xs.

require clj macro

(require & args)

Loads libs, skipping any that are already loaded. Each argument is either a libspec that identifies a lib or a flag that modifies how all the identified libs are loaded. Use :require in the ns macro in preference to calling this directly.

Libs

A 'lib' is a named set of resources in classpath whose contents define a library of ClojureScript code. Lib names are symbols and each lib is associated with a ClojureScript namespace. A lib's name also locates its root directory within classpath using Java's package name to classpath-relative path mapping. All resources in a lib should be contained in the directory structure under its root directory. All definitions a lib makes should be in its associated namespace.

'require loads a lib by loading its root resource. The root resource path is derived from the lib name in the following manner: Consider a lib named by the symbol 'x.y.z; it has the root directory <classpath>/x/y/, and its root resource is <classpath>/x/y/z.clj. The root resource should contain code to create the lib's namespace (usually by using the ns macro) and load any additional lib resources.

Libspecs

A libspec is a lib name or a vector containing a lib name followed by options expressed as sequential keywords and arguments.

Recognized options: :as takes a symbol as its argument and makes that symbol an alias to the lib's namespace in the current namespace. :refer takes a list of symbols to refer from the namespace. :refer-macros takes a list of macro symbols to refer from the namespace. :include-macros true causes macros from the namespace to be required. :rename specifies a map from referred var names to different symbols (and can be used to prevent clashes)

Flags

A flag is a keyword. Recognized flags: :reload, :reload-all, :verbose :reload forces loading of all the identified libs even if they are already loaded :reload-all implies :reload and also forces loading of all libs that the identified libs directly or indirectly load via require or use :verbose triggers printing information about each load, alias, and refer

Example:

The following would load the library clojure.string :as string.

(require '[clojure.string :as string])

require-macros clj macro

(require-macros & args)

Similar to require but only for macros.

reset! cljs

(reset! a new-value)

Sets the value of atom to newval without regard for the current value. Returns new-value.

reset-meta! cljs

(reset-meta! iref m)

Atomically resets the metadata for an atom

reset-vals! cljs

(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.

resolve clj macro

(resolve quoted-sym)

Returns the var to which a symbol will be resolved in the namespace else nil.

rest cljs

(rest coll)

Returns a possibly empty seq of the items after the first. Calls seq on its argument.

reverse cljs

(reverse coll)

Returns a seq of the items in coll in reverse order. Not lazy.

reversible? cljs

(reversible? coll)

Returns true if coll satisfies? IReversible.

rseq cljs

(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

RSeq cljs

rsubseq cljs

(rsubseq sc test key)

(rsubseq sc start-test start-key end-test end-key)

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! cljs

(run! proc coll)

Runs the supplied procedure (via reduce), for purposes of side effects, on successive items in the collection. Returns nil

satisfies? clj macro

(satisfies? psym x)

Returns true if x satisfies the protocol

second cljs

(second coll)

Same as (first (next x))

select-keys cljs

(select-keys map keyseq)

Returns a map containing only those entries in map whose key is in keys

seq cljs

(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 cljs

(seq-iter coll)

seq? cljs

(seq? s)

Return true if s satisfies ISeq

seqable? cljs

(seqable? s)

Return true if the seq function is supported for s

SeqIter cljs

sequence cljs

(sequence coll)

(sequence xform coll)

(sequence xform coll & colls)

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? cljs

(sequential? x)

Returns true if coll satisfies ISequential

set cljs

(set coll)

Returns a set of the distinct elements of coll.

set-from-indexed-seq cljs

(set-from-indexed-seq iseq)

set-print-err-fn! cljs

(set-print-err-fn! f)

Set print-err-fn to f.

set-print-fn! cljs

(set-print-fn! f)

Set print-fn to f.

set-validator! cljs

(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? cljs

(set? x)

Returns true if x satisfies ISet

short clj/s

(short x)

shorts cljs

(shorts x)

shuffle cljs

(shuffle coll)

Return a random permutation of coll

simple-benchmark clj macro

(simple-benchmark bindings
                  expr
                  iterations
                  &
                  {:keys [print-fn] :or {print-fn (quote println)}})

Runs expr iterations times in the context of a let expression with the given bindings, then prints out the bindings and the expr followed by number of iterations and total time. The optional argument print-fn, defaulting to println, sets function used to print the result. expr's string representation will be produced using pr-str in any case.

simple-ident? cljs

(simple-ident? x)

Return true if x is a symbol or keyword without a namespace

simple-keyword? cljs

(simple-keyword? x)

Return true if x is a keyword without a namespace

simple-symbol? cljs

(simple-symbol? x)

Return true if x is a symbol without a namespace

Single cljs

some cljs

(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-> clj macro

(some-> expr & forms)

When expr is not nil, threads it into the first form (via ->), and when that result is not nil, through the next etc

some->> clj macro

(some->> expr & forms)

When expr is not nil, threads it into the first form (via ->>), and when that result is not nil, through the next etc

some-fn cljs

(some-fn p)

(some-fn p1 p2)

(some-fn p1 p2 p3)

(some-fn p1 p2 p3 & ps)

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? clj/s≠

(some? x)

cljs

Returns true if x is not nil, false otherwise.

sort cljs

(sort coll)

(sort comp coll)

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 cljs

(sort-by keyfn coll)

(sort-by keyfn comp coll)

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 function, or a -/0/+ valued comparator. Comp defaults to compare.

sorted-map cljs

(sorted-map & keyvals)

keyval => key val Returns a new sorted map with supplied mappings.

sorted-map-by cljs

(sorted-map-by comparator & keyvals)

keyval => key val Returns a new sorted map with supplied mappings, using the supplied comparator.

sorted-set cljs

(sorted-set & keys)

Returns a new sorted set with supplied keys.

sorted-set-by cljs

(sorted-set-by comparator & keys)

Returns a new sorted set with supplied keys, using the supplied comparator.

sorted? cljs

(sorted? x)

Returns true if coll satisfies ISorted

special-symbol? cljs

(special-symbol? x)

Returns true if x names a special form

specify clj macro

(specify expr & impls)

Identical to specify! but does not mutate its first argument. The first argument must be an ICloneable instance.

specify! clj macro

(specify! expr & impls)

Identical to reify but mutates its first argument.

split-at cljs

(split-at n coll)

Returns a vector of [(take n coll) (drop n coll)]

split-with cljs

(split-with pred coll)

Returns a vector of [(take-while pred coll) (drop-while pred coll)]

spread cljs

(spread arglist)

START cljs

str clj/s≠

(str)

(str x)

(str x & ys)

cljs

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-hash-cache cljs

string-hash-cache-count cljs

string-iter cljs

(string-iter x)

string-print cljs

(string-print x)

string? clj/s≠

(string? x)

cljs

Returns true if x is a JavaScript string.

StringBufferWriter cljs

StringIter cljs

subs cljs

(subs s start)

(subs s start end)

Returns the substring of s beginning at start inclusive, and ending at end (defaults to length of string), exclusive.

subseq cljs

(subseq sc test key)

(subseq sc start-test start-key end-test end-key)

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 cljs

subvec cljs

(subvec v start)

(subvec v start end)

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! cljs

(swap! a f)

(swap! a f x)

(swap! a f x y)

(swap! a f x y & more)

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.

swap-vals! cljs

(swap-vals! a f)

(swap-vals! a f x)

(swap-vals! a f x y)

(swap-vals! a f x y & more)

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 cljs

symbol cljs

(symbol name)

(symbol ns name)

Returns a Symbol with the given namespace and name. Arity-1 works on strings, keywords, and vars.

symbol-identical? cljs

(symbol-identical? x y)

Efficient test to determine that two symbols are identical.

symbol? clj/s≠

(symbol? x)

cljs

Return true if x is a Symbol

system-time cljs

(system-time)

Returns highest resolution time offered by host in milliseconds.

tagged-literal cljs

(tagged-literal tag form)

Construct a data representation of a tagged literal from a tag symbol and a form.

tagged-literal? cljs

(tagged-literal? value)

Return true if the value is the data representation of a tagged literal

TaggedLiteral cljs

take cljs

(take n)

(take n coll)

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 cljs

(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 cljs

(take-nth n)

(take-nth n coll)

Returns a lazy seq of every nth item in coll. Returns a stateful transducer when no collection is provided.

take-while cljs

(take-while pred)

(take-while pred coll)

Returns a lazy sequence of successive items from coll while (pred item) returns logical true. pred must be free of side-effects. Returns a transducer when no collection is provided.

tap> cljs

(tap> x)

Sends x to any taps. Returns the result of exec-tap-fn, a Boolean value.

test cljs

(test v)

test [v] finds fn at key :test in var metadata and calls it, presuming failure will throw exception

this-as clj macro

(this-as name & body)

Defines a scope where JavaScript's implicit "this" is bound to the name provided.

time clj macro

(time expr)

Evaluates expr and prints the time it took. Returns the value of expr.

to-array cljs

(to-array coll)

Returns an array containing the contents of coll.

to-array-2d cljs

(to-array-2d coll)

Returns a (potentially-ragged) 2-dimensional array containing the contents of coll.

trampoline cljs

(trampoline f)

(trampoline f & args)

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 cljs

(transduce xform f coll)

(transduce xform f init coll)

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 cljs

(transformer-iterator xform sourceIter multi)

TransformerIterator cljs

transient cljs

(transient coll)

Returns a new, transient version of the collection, in constant time.

TransientArrayMap cljs

TransientHashMap cljs

TransientHashSet cljs

TransientVector cljs

tree-seq cljs

(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? clj/s≠

(true? x)

cljs

Returns true if x is the value true, false otherwise.

truth_ clj/s≠

(truth_ x)

cljs

Internal - do not use!

type cljs

(type x)

Return x's constructor.

type->str cljs

(type->str ty)

unchecked-add clj/s≠

clj

(unchecked-add & xs)

cljs

(unchecked-add)

(unchecked-add x)

(unchecked-add x y)

(unchecked-add x y & more)

Returns the sum of nums. (+) returns 0.

unchecked-add-int clj/s≠

clj

(unchecked-add-int & xs)

cljs

(unchecked-add-int)

(unchecked-add-int x)

(unchecked-add-int x y)

(unchecked-add-int x y & more)

Returns the sum of nums. (+) returns 0.

unchecked-byte clj/s

(unchecked-byte x)

unchecked-char clj/s

(unchecked-char x)

unchecked-dec clj/s≠

(unchecked-dec x)

cljs

Returns a number one less than x, an int.

unchecked-dec-int clj/s≠

(unchecked-dec-int x)

cljs

Returns a number one less than x, an int.

unchecked-divide-int clj/s≠

clj

(unchecked-divide-int & xs)

cljs

(unchecked-divide-int x)

(unchecked-divide-int x y)

(unchecked-divide-int x y & more)

If no denominators are supplied, returns 1/numerator, else returns numerator divided by all of the denominators.

unchecked-double clj/s

(unchecked-double x)

unchecked-float clj/s

(unchecked-float x)

unchecked-get clj macro

(unchecked-get obj key)

INTERNAL. Compiles to JavaScript property access using bracket notation. Does not distinguish between object and array types and not subject to compiler static analysis.

unchecked-inc clj/s

(unchecked-inc x)

unchecked-inc-int clj/s

(unchecked-inc-int x)

unchecked-int cljs

(unchecked-int x)

Coerce to int by stripping decimal places.

unchecked-long cljs

(unchecked-long x)

Coerce to long by stripping decimal places. Identical to `int'.

unchecked-multiply clj/s≠

clj

(unchecked-multiply & xs)

cljs

(unchecked-multiply)

(unchecked-multiply x)

(unchecked-multiply x y)

(unchecked-multiply x y & more)

Returns the product of nums. (*) returns 1.

unchecked-multiply-int clj/s≠

clj

(unchecked-multiply-int & xs)

cljs

(unchecked-multiply-int)

(unchecked-multiply-int x)

(unchecked-multiply-int x y)

(unchecked-multiply-int x y & more)

Returns the product of nums. (*) returns 1.

unchecked-negate clj/s

(unchecked-negate x)

unchecked-negate-int clj/s

(unchecked-negate-int x)

unchecked-remainder-int clj/s

(unchecked-remainder-int x n)

unchecked-set clj macro

(unchecked-set obj key val)

INTERNAL. Compiles to JavaScript property access using bracket notation. Does not distinguish between object and array types and not subject to compiler static analysis.

unchecked-short clj/s

(unchecked-short x)

unchecked-subtract clj/s≠

clj

(unchecked-subtract & xs)

cljs

(unchecked-subtract x)

(unchecked-subtract x y)

(unchecked-subtract x y & more)

If no ys are supplied, returns the negation of x, else subtracts the ys from x and returns the result.

unchecked-subtract-int clj/s≠

clj

(unchecked-subtract-int & xs)

cljs

(unchecked-subtract-int x)

(unchecked-subtract-int x y)

(unchecked-subtract-int x y & more)

If no ys are supplied, returns the negation of x, else subtracts the ys from x and returns the result.

undefined? clj/s≠

(undefined? x)

clj

Return true if argument is identical to the JavaScript undefined value.

cljs

Returns true if x identical to the JavaScript undefined value.

underive cljs

(underive tag parent)

(underive h tag parent)

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 cljs

(unreduced x)

If x is reduced?, returns (deref x), else returns x

unsafe-bit-and clj macro

(unsafe-bit-and x y)

(unsafe-bit-and x y & more)

unsafe-cast clj macro

(unsafe-cast t x)

EXPERIMENTAL: Subject to change. Unsafely cast a value to a different type.

unsigned-bit-shift-right clj/s≠

(unsigned-bit-shift-right x n)

cljs

Bitwise shift right with zero fill

update cljs

(update m k f)

(update m k f x)

(update m k f x y)

(update m k f x y z)

(update m k f x y z & more)

'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 cljs

(update-in m [k & ks] f)

(update-in m [k & ks] f a)

(update-in m [k & ks] f a b)

(update-in m [k & ks] f a b c)

(update-in m [k & ks] f a b c & args)

'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? cljs

(uri? x)

Returns true x is a goog.Uri instance.

use clj macro

(use & args)

Like require, but referring vars specified by the mandatory :only option.

Example:

The following would load the library clojure.set while referring the intersection var.

(use '[clojure.set :only [intersection]])

use-macros clj macro

(use-macros & args)

Similar to use but only for macros.

uuid cljs

(uuid s)

UUID cljs

uuid? cljs

(uuid? x)

val cljs

(val map-entry)

Returns the value in the map entry.

vals cljs

(vals map)

Returns a sequence of the map's values, in the same order as (seq map).

ValSeq cljs

Var cljs

var? cljs

(var? v)

Returns true if v is of type cljs.core.Var

vary-meta cljs

(vary-meta obj f)

(vary-meta obj f a)

(vary-meta obj f a b)

(vary-meta obj f a b c)

(vary-meta obj f a b c d)

(vary-meta obj f a b c d & args)

Returns an object of the same type and value as obj, with (apply f (meta obj) args) as its metadata.

vec cljs

(vec coll)

Creates a new vector containing the contents of coll. JavaScript arrays will be aliased and should not be modified.

vector clj/s≠

clj

(vector)

(vector & xs)

cljs

(vector & args)

Creates a new vector containing the args.

vector? cljs

(vector? x)

Return true if x satisfies IVector

VectorNode cljs

Volatile cljs

volatile! cljs

(volatile! val)

Creates and returns a Volatile with an initial value of val.

volatile? cljs

(volatile? x)

Returns true if x is a volatile.

vreset! cljs

(vreset! vol newval)

Sets the value of volatile to newval without regard for the current value. Returns newval.

vswap! clj macro

(vswap! vol f & args)

Non-atomically swaps the value of the volatile as if: (apply f current-value-of-vol args). Returns the value that was swapped in.

when clj macro

(when test & body)

Evaluates test. If logical true, evaluates body in an implicit do.

when-first clj macro

(when-first bindings & body)

bindings => x xs

Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once

when-let clj macro

(when-let bindings & body)

bindings => binding-form test

When test is true, evaluates body with binding-form bound to the value of test

when-not clj macro

(when-not test & body)

Evaluates test. If logical false, evaluates body in an implicit do.

when-some clj macro

(when-some bindings & body)

bindings => binding-form test

When test is not nil, evaluates body with binding-form bound to the value of test

while clj macro

(while test & body)

Repeatedly executes body while test expression is true. Presumes some side-effect will cause test to become false/nil. Returns nil

with-meta cljs

(with-meta o meta)

Returns an object of the same type and value as obj, with map m as its metadata.

with-out-str clj macro

(with-out-str & body)

Evaluates exprs in a context in which print-fn is bound to .append on a fresh StringBuffer. Returns the string created by any nested printing calls.

with-redefs clj macro

(with-redefs bindings & body)

binding => var-symbol temp-value-expr

Temporarily redefines vars while executing the body. The temp-value-exprs will be evaluated and each resulting value will replace in parallel the root value of its var. After the body is executed, the root values of all the vars will be set back to their old values. Useful for mocking out functions during testing.

write-all cljs

(write-all writer & ss)

zero? clj/s≠

(zero? x)

cljs

Returns true if num is zero, else false

zipmap cljs

(zipmap keys vals)

Returns a map with the keys mapped to the corresponding vals.