clojure.core

Fundamental library of the Clojure language

Syntax for use with fn.

Please see http://clojure.org/special_forms#fn

Usage: (*)
       (* x)
       (* x y)
       (* x y & more)

Returns the product of nums. (*) returns 1. Does not auto-promote
longs, will throw on overflow. See also: *'

Usage: (*')
       (*' x)
       (*' x y)
       (*' x y & more)

Returns the product of nums. (*') returns 1. Supports arbitrary precision.
See also: *

bound in a repl thread to the most recent value printed

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

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

The agent currently running an action on this thread, else nil

The version info for Clojure core, as a map containing :major :minor 
:incremental and :qualifier keys. Feature releases may increment 
:minor and/or :major, bugfix releases will increment :incremental. 
Possible values of :qualifier include "GA", "SNAPSHOT", "RC-x" "BETA-x"

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

Set to true when compiling files, false otherwise.

Specifies the directory where 'compile' will write out .class
files. This directory must be in the classpath for 'compile' to
work.

Defaults to "classes"

A map of keys to options.
Note, when binding dynamically make sure to merge with previous value.
Supported options:
:elide-meta - a collection of metadata keys to elide during compilation.
:disable-locals-clearing - set to true to disable clearing, useful for using a debugger
Alpha, subject to change.

Map from reader tag symbols to data reader Vars.

When Clojure starts, it searches for files named 'data_readers.clj'
at the root of the classpath. Each such file must contain a literal
map of symbols, like this:

    {foo/bar my.project.foo/bar
     foo/baz my.project/baz}

The first symbol in each pair is a tag that will be recognized by
the Clojure reader. The second symbol in the pair is the
fully-qualified name of a Var which will be invoked by the reader to
parse the form following the tag. For example, given the
data_readers.clj file above, the Clojure reader would parse this
form:

    #foo/bar [1 2 3]

by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. The
data reader function is invoked on the form AFTER it has been read
as a normal Clojure data structure by the reader.

Reader tags without namespace qualifiers are reserved for
Clojure. Default reader tags are defined in
clojure.core/default-data-readers but may be overridden in
data_readers.clj or by rebinding this Var.

When no data reader is found for a tag and *default-data-reader-fn*
is non-nil, it will be called with two arguments,
the tag and the value.  If *default-data-reader-fn* is nil (the
default), an exception will be thrown for the unknown tag.

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

A java.io.Writer object representing standard error for print operations.

Defaults to System/err, wrapped in a PrintWriter

The path of the file being evaluated, as a String.

When there is no file, e.g. in the REPL, the value is not defined.

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

Defaults to true.

A java.io.Reader object representing standard input for read operations.

Defaults to System/in, wrapped in a LineNumberingPushbackReader

A clojure.lang.Namespace object representing the current namespace.

A java.io.Writer object representing standard output for print operations.

Defaults to System/out, wrapped in an OutputStreamWriter

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

Defaults to false.

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

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.

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

Defaults to true

Defaults to true (or value specified by system property, see below)
***This setting implies that the full power of the reader is in play,
including syntax that can cause code to execute. It should never be
used with untrusted sources. See also: clojure.edn/read.***

When set to logical false in the thread-local binding,
the eval reader (#=) and record/type literal syntax are disabled in read/load.
Example (will fail): (binding [*read-eval* false] (read-string "#=(* 2 21)"))

The default binding can be controlled by the system property
'clojure.read.eval' System properties can be set on the command line
like this:

java -Dclojure.read.eval=false ...

The system property can also be set to 'unknown' via
-Dclojure.read.eval=unknown, in which case the default binding
is :unknown and all reads will fail in contexts where *read-eval*
has not been explicitly bound to either true or false. This setting
can be a useful diagnostic tool to ensure that all of your reads
occur in considered contexts. You can also accomplish this in a
particular scope by binding *read-eval* to :unknown

While bound to true, compilations of +, -, *, inc, dec and the
coercions will be done without overflow checks. While bound
to :warn-on-boxed, same behavior as true, and a warning is emitted
when compilation uses boxed math. Default: false.

When set to true, the compiler will emit warnings when reflection is
needed to resolve Java method calls or field accesses.

Defaults to false.

Usage: (+)
       (+ x)
       (+ x y)
       (+ x y & more)

Returns the sum of nums. (+) returns 0. Does not auto-promote
longs, will throw on overflow. See also: +'

Usage: (+')
       (+' x)
       (+' x y)
       (+' x y & more)

Returns the sum of nums. (+') returns 0. Supports arbitrary precision.
See also: +

Usage: (- x)
       (- x y)
       (- x y & more)

If no ys are supplied, returns the negation of x, else subtracts
the ys from x and returns the result. Does not auto-promote
longs, will throw on overflow. See also: -'

Usage: (-' x)
       (-' x y)
       (-' x y & more)

If no ys are supplied, returns the negation of x, else subtracts
the ys from x and returns the result. Supports arbitrary precision.
See also: -

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

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

Usage: (->ArrayChunk am arr off end)

Positional factory function for class clojure.core.ArrayChunk.

Usage: (->Eduction xform coll)

Positional factory function for class clojure.core.Eduction.

Usage: (->Vec am cnt shift root tail _meta)

Positional factory function for class clojure.core.Vec.

Usage: (->VecNode edit arr)

Positional factory function for class clojure.core.VecNode.

Usage: (->VecSeq am vec anode i offset)

Positional factory function for class clojure.core.VecSeq.

Usage: (.instanceMember instance args*)
       (.instanceMember Classname args*)
       (Classname/staticMethod args*)
       Classname/staticField

The instance member form works for both fields and methods.
They all expand into calls to the dot operator at macroexpansion time.

Please see http://clojure.org/java_interop#dot

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

Usage: (/ x)
       (/ x y)
       (/ x y & more)

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

Usage: (< x)
       (< x y)
       (< x y & more)

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

Usage: (<= x)
       (<= x y)
       (<= x y & more)

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

Usage: (= x)
       (= x y)
       (= x y & more)

Usage: (== x)
       (== x y)
       (== x y & more)

Returns non-nil if nums all have the equivalent
value (type-independent), otherwisefalse

Usage: (> x)
       (> x y)
       (> x y & more)

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

Usage: (>= x)
       (>= x y)
       (>= x y & more)

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

Usage: (Throwable->map o)

Constructs a data representation for a Throwable.

Usage: (accessor s key)

Returns a fn that, given an instance of a structmap with the basis,
returns the value at the key.  The key must be in the basis. The
returned function should be (slightly) more efficient than using
get, but such use of accessors should be limited to known
performance-critical areas.

Usage: (aclone array)

Returns a clone of the Java array. Works on arrays of known
types.

Usage: (add-classpath url)

DEPRECATED 

Adds the url (String or URL object) to the classpath per
URLClassLoader.addURL

Usage: (add-watch reference key fn)

Adds a watch function to an agent/atom/var/ref 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, on the agent's thread if an agent,
before any pending sends if agent or ref. Note that an atom's or
ref's state may have changed again prior to the fn call, so use
old/new-state rather than derefing the reference. Note also that watch
fns may be called from multiple threads simultaneously. Var watchers
are triggered only by root binding changes, not thread-local
set!s. 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.

Usage: (agent state & options)

Creates and returns an agent with an initial value of state and
zero or more options (in any order):

:meta metadata-map

:validator validate-fn

:error-handler handler-fn

:error-mode mode-keyword

If metadata-map is supplied, it will become the metadata on the
agent. 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 exception.  handler-fn is called if an
action throws an exception or if validate-fn rejects a new state --
see set-error-handler! for details.  The mode-keyword may be either
:continue (the default if an error-handler is given) or :fail (the
default if no error-handler is given) -- see set-error-mode! for
details.

Usage: (agent-error a)

Returns the exception thrown during an asynchronous action of the
agent if the agent is failed.  Returns nil if the agent is not
failed.

Usage: (agent-errors a)

DEPRECATED: Use 'agent-error' instead.
Returns a sequence of the exceptions thrown during asynchronous
actions of the agent.

Usage: (aget array idx)
       (aget array idx & idxs)

Returns the value at the index/indices. Works on Java arrays of all
types.

Usage: (alength array)

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

Usage: (alias alias namespace-sym)

Add an alias in the current namespace to another
namespace. Arguments are two symbols: the alias to be used, and
the symbolic name of the target namespace. Use :as in the ns macro in preference
to calling this directly.

Usage: (all-ns)

Returns a sequence of all namespaces.

Usage: (alter ref fun & args)

Must be called in a transaction. Sets the in-transaction-value of
ref to:

(apply fun in-transaction-value-of-ref args)

and returns the in-transaction-value of ref.

Usage: (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

Usage: (alter-var-root v f & args)

Atomically alters the root binding of var v by applying f to its
current value plus any args

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

Usage: (ancestors tag)
       (ancestors h tag)

Returns the immediate and indirect parents of tag, either via a Java 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

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

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

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

Usage: (array-map)
       (array-map & keyvals)

Constructs an array-map. If any keys are equal, they are handled as
if by repeated uses of assoc.

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

Usage: (aset array idx val)
       (aset array idx idx2 & idxv)

Sets the value at the index/indices. Works on Java arrays of
reference types. Returns val.

Usage: (aset-boolean array idx val)
       (aset-boolean array idx idx2 & idxv)

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

Usage: (aset-byte array idx val)
       (aset-byte array idx idx2 & idxv)

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

Usage: (aset-char array idx val)
       (aset-char array idx idx2 & idxv)

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

Usage: (aset-double array idx val)
       (aset-double array idx idx2 & idxv)

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

Usage: (aset-float array idx val)
       (aset-float array idx idx2 & idxv)

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

Usage: (aset-int array idx val)
       (aset-int array idx idx2 & idxv)

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

Usage: (aset-long array idx val)
       (aset-long array idx idx2 & idxv)

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

Usage: (aset-short array idx val)
       (aset-short array idx idx2 & idxv)

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

Usage: (assert x)
       (assert x message)

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

Usage: (assoc map key val)
       (assoc map key val & 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. Note - index must be <= (count vector).

Usage: (assoc! coll key val)
       (assoc! coll 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.

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

Usage: (associative? coll)

Returns true if coll implements Associative

Usage: (atom x)
       (atom x & options)

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

Usage: (await & agents)

Blocks the current thread (indefinitely!) until all actions
dispatched thus far, from this thread or agent, to the agent(s) have
occurred.  Will block on failed agents.  Will never return if
a failed agent is restarted with :clear-actions true.

Usage: (await-for timeout-ms & agents)

Blocks the current thread until all actions dispatched thus
far (from this thread or agent) to the agents have occurred, or the
timeout (in milliseconds) has elapsed. Returns logical false if
returning due to timeout, logical true otherwise.

Usage: (bases c)

Returns the immediate superclass and direct interfaces of c, if any

Usage: (bean x)

Takes a Java object and returns a read-only implementation of the
map abstraction based upon its JavaBean properties.

Usage: (bigdec x)

Coerce to BigDecimal