ArrayChunk

Eduction

Vec

VecNode

VecSeq

&

Syntax for use with fn.Please seehttps://clojure.org/reference/special_forms#fn

*

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

Returns the product of nums. (*) returns 1. Does not auto-promotelongs, 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: *

*1

bound in a repl thread to the most recent value printed

*2

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

*3

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

*agent*

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

*assert*

When set to logical false, 'assert' will omit assertion checks incompiled code. Defaults to true.

*clojure-version*

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"

*command-line-args*

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

*compile-files*

Set to true when compiling files, false otherwise.

*compile-path*

Specifies the directory where 'compile' will write out .classfiles. This directory must be in the classpath for 'compile' towork.Defaults to "classes"

*compiler-options*

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:direct-linking - set to true to use direct static invocation of functions, rather than vars  Note that call sites compiled with direct linking will not be affected by var redefinition.  Use ^:redef (or ^:dynamic) on a var to prevent direct linking and allow redefinition.Seehttps://clojure.org/reference/compilation for more information.

*data-readers*

Map from reader tag symbols to data reader Vars.When Clojure starts, it searches for files named 'data_readers.clj'and 'data_readers.cljc' at the root of the classpath. Each such filemust 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 bythe Clojure reader. The second symbol in the pair is thefully-qualified name of a Var which will be invoked by the reader toparse the form following the tag. For example, given thedata_readers.clj file above, the Clojure reader would parse thisform:    #foo/bar [1 2 3]by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. Thedata reader function is invoked on the form AFTER it has been readas a normal Clojure data structure by the reader.Reader tags without namespace qualifiers are reserved forClojure. Default reader tags are defined inclojure.core/default-data-readers but may be overridden indata_readers.clj, data_readers.cljc, or by rebinding this Var.

*default-data-reader-fn*

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 (thedefault), an exception will be thrown for the unknown tag.

*e

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

*err*

A java.io.Writer object representing standard error for print operations.Defaults to System/err, wrapped in a PrintWriter

*file*

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.

*flush-on-newline*

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

*in*

A java.io.Reader object representing standard input for read operations.Defaults to System/in, wrapped in a LineNumberingPushbackReader

*ns*

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

*out*

A java.io.Writer object representing standard output for print operations.Defaults to System/out, wrapped in an OutputStreamWriter

*print-dup*

When set to logical true, objects will be printed in a way that preservestheir type when read in later.Defaults to false.

*print-length*

*print-length* controls how many items of each collection theprinter will print. If it is bound to logical false, there is nolimit. Otherwise, it must be bound to an integer indicating the maximumnumber of items of each collection to print. If a collection containsmore items, the printer will print items up to the limit followed by'...' to represent the remaining items. The root binding is nilindicating no limit.

*print-level*

*print-level* controls how many levels deep the printer willprint nested objects. If it is bound to logical false, there is nolimit. Otherwise, it must be bound to an integer indicating the maximumlevel to print. Each argument to print is at level 0; if an argument is acollection, its items are at level 1; and so on. If an object is acollection and is at a level greater than or equal to the value bound to*print-level*, the printer prints '#' to represent it. The root bindingis nil indicating no limit.

*print-meta*

If set to logical true, when printing an object, its metadata will alsobe printed in a form that can be read back by the reader.Defaults to false.

*print-namespace-maps*

*print-namespace-maps* controls whether the printer will printnamespace map literal syntax. It defaults to false, but the REPL bindsto true.

*print-readably*

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

*read-eval*

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 beused 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 linelike 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 bindingis :unknown and all reads will fail in contexts where *read-eval*has not been explicitly bound to either true or false. This settingcan be a useful diagnostic tool to ensure that all of your readsoccur in considered contexts. You can also accomplish this in aparticular scope by binding *read-eval* to :unknown

*repl*

Bound to true in a repl thread

*unchecked-math*

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

*warn-on-reflection*

When set to true, the compiler will emit warnings when reflection isneeded 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-promotelongs, 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 subtractsthe ys from x and returns the result. Does not auto-promotelongs, will throw on overflow. See also: -'

-'

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

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

->

Usage: (-> x & forms)

Threads the expr through the forms. Inserts x as thesecond item in the first form, making a list of it if it is not alist already. If there are more forms, inserts the first form as thesecond item in second form, etc.

->>

Usage: (->> x & forms)

Threads the expr through the forms. Inserts x as thelast item in the first form, making a list of it if it is not alist already. If there are more forms, inserts the first form as thelast item in second form, etc.

->ArrayChunk

Usage: (->ArrayChunk am arr off end)

Positional factory function for class clojure.core.ArrayChunk.

->Eduction

Usage: (->Eduction xform coll)

Positional factory function for class clojure.core.Eduction.

->Vec

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

Positional factory function for class clojure.core.Vec.

->VecNode

Usage: (->VecNode edit arr)

Positional factory function for class clojure.core.VecNode.

->VecSeq

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

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 seehttps://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 firstargument, followed by the next member on the result, etc. Forinstance:(.. 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)

Equality. Returns true if x equals y, false if not. Same asJava x.equals(y) except it also works for nil, and comparesnumbers and collections in a type-independent manner.  Clojure's immutable datastructures define equals() (and thus =) as a value, not an identity,comparison.

==

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

Returns non-nil if nums all have the equivalentvalue (type-independent), otherwise false

>

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.

NaN?

Usage: (NaN? num)

Returns true if num is NaN, else false

PrintWriter-on

Usage: (PrintWriter-on flush-fn close-fn)       (PrintWriter-on flush-fn close-fn autoflush?)

implements java.io.PrintWriter given flush-fn, which will be calledwhen .flush() is called, with a string built up since the last call to .flush().if not nil, close-fn will be called with no arguments when .close is called.autoflush? determines if the PrintWriter will autoflush, false by default.

StackTraceElement->vec

Usage: (StackTraceElement->vec o)

Constructs a data representation for a StackTraceElement: [class method file line]

Throwable->map

Usage: (Throwable->map o)

Constructs a data representation for a Throwable with keys::cause - root cause message:phase - error phase:via - cause chain, with cause keys:         :type - exception class symbol         :message - exception message         :data - ex-data         :at - top stack element:trace - root cause stack elements

abs

Usage: (abs a)

Returns the absolute value of a.If a is Long/MIN_VALUE => Long/MIN_VALUEIf a is a double and zero => +0.0If a is a double and ##Inf or ##-Inf => ##InfIf a is a double and ##NaN => ##NaN

accessor

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. Thereturned function should be (slightly) more efficient than usingget, but such use of accessors should be limited to knownperformance-critical areas.

aclone

Usage: (aclone array)

Returns a clone of the Java array. Works on arrays of knowntypes.

add-classpath

Usage: (add-classpath url)

DEPRECATED Adds the url (String or URL object) to the classpath perURLClassLoader.addURL

add-tap

Usage: (add-tap f)

adds f, a fn of one argument, to the tap set. This function will be called with anything sent via tap>.This function may (briefly) block (e.g. for streams), and will never impede calls to tap>,but blocking indefinitely may cause tap values to be dropped.Remember f in order to remove-tap

add-watch

Usage: (add-watch reference key fn)

Adds a watch function to an agent/atom/var/ref reference. The watchfn must be a fn of 4 args: a key, the reference, its old-state, itsnew-state. Whenever the reference's state might have been changed,any registered watches will have their functions called. The watch fnwill be called synchronously, on the agent's thread if an agent,before any pending sends if agent or ref. Note that an atom's orref's state may have changed again prior to the fn call, so useold/new-state rather than derefing the reference. Note also that watchfns may be called from multiple threads simultaneously. Var watchersare triggered only by root binding changes, not thread-localset!s. Keys must be unique per reference, and can be used to removethe watch with remove-watch, but are otherwise considered opaque bythe watch mechanism.

agent

Usage: (agent state & options)

Creates and returns an agent with an initial value of state andzero or more options (in any order)::meta metadata-map:validator validate-fn:error-handler handler-fn:error-mode mode-keywordIf metadata-map is supplied, it will become the metadata on theagent. validate-fn must be nil or a side-effect-free fn of oneargument, which will be passed the intended new state on any statechange. If the new state is unacceptable, the validate-fn shouldreturn false or throw an exception.  handler-fn is called if anaction 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 (thedefault if no error-handler is given) -- see set-error-mode! fordetails.

agent-error

Usage: (agent-error a)

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

agent-errors

Usage: (agent-errors a)

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

aget

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

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

alength

Usage: (alength array)

Returns the length of the Java array. Works on arrays of alltypes.

alias

Usage: (alias alias namespace-sym)

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

all-ns

Usage: (all-ns)

Returns a sequence of all namespaces.

alter

Usage: (alter ref fun & args)

Must be called in a transaction. Sets the in-transaction-value ofref to:(apply fun in-transaction-value-of-ref args)and returns the in-transaction-value of ref.

alter-meta!

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

alter-var-root

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

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

amap

Usage: (amap a idx ret expr)

Maps an expression across an array a, using an index named idx, andreturn 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

Usage: (ancestors tag)       (ancestors h tag)

Returns the immediate and indirect parents of tag, either via a Java typeinheritance relationship or a relationship established via derive. hmust be a hierarchy obtained from make-hierarchy, if not supplieddefaults to the global hierarchy

and

Usage: (and)       (and x)       (and x & next)

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

any?

Usage: (any? x)

Returns true given any argument.

apply

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.

areduce

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.

array-map

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

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

as->

Usage: (as-> expr name & forms)

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

aset

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

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

aset-boolean

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.

aset-byte

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.

aset-char

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.

aset-double

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.

aset-float

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.

aset-int

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.

aset-long

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.

aset-short

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.

assert

Usage: (assert x)       (assert x message)

Evaluates expression x and throws an AssertionError with optionalmessage if x does not evaluate to logical true.Assertion checks are omitted from compiled code if '*assert*' isfalse.

assoc

Usage: (assoc map key val)       (assoc map key val & kvs)

assoc[iate]. When applied to a map, returns a new map of thesame (hashed/sorted) type, that contains the mapping of key(s) toval(s). When applied to a vector, returns a new vector thatcontains val at index. Note - index must be <= (count vector).

assoc!

Usage: (assoc! coll key val)       (assoc! coll key val & kvs)

When applied to a transient map, adds mapping of key(s) toval(s). When applied to a transient vector, sets the val at index.Note - index must be <= (count vector). Returns coll.

assoc-in

Usage: (assoc-in m [k & ks] v)

Associates a value in a nested associative structure, where ks is asequence 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?

Usage: (associative? coll)

Returns true if coll implements Associative

atom

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

Creates and returns an Atom with an initial value of x and zero ormore options (in any order)::meta metadata-map:validator validate-fnIf metadata-map is supplied, it will become the metadata on theatom. validate-fn must be nil or a side-effect-free fn of oneargument, which will be passed the intended new state on any statechange. If the new state is unacceptable, the validate-fn shouldreturn false or throw an exception.

await

Usage: (await & agents)

Blocks the current thread (indefinitely!) until all actionsdispatched thus far, from this thread or agent, to the agent(s) haveoccurred.  Will block on failed agents.  Will never return ifa failed agent is restarted with :clear-actions true or shutdown-agents was called.

await-for

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

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

bases

Usage: (bases c)

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

bean

Usage: (bean x)

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

bigdec

Usage: (bigdec x)

Coerce to BigDecimal

bigint

Usage: (bigint x)

Coerce to BigInt

biginteger

Usage: (biginteger x)

Coerce to BigInteger

binding

Usage: (binding bindings & body)

binding => var-symbol init-exprCreates new bindings for the (already-existing) vars, with thesupplied initial values, executes the exprs in an implicit do, thenre-establishes the bindings that existed before.  The new bindingsare made in parallel (unlike let); all init-exprs are evaluatedbefore the vars are bound to their new values.

bit-and

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

Bitwise and

bit-and-not

Usage: (bit-and-not x y)       (bit-and-not x y & more)

Bitwise and with complement

bit-clear

Usage: (bit-clear x n)

Clear bit at index n

bit-flip

Usage: (bit-flip x n)

Flip bit at index n

bit-not

Usage: (bit-not x)

Bitwise complement

bit-or

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

Bitwise or

bit-set

Usage: (bit-set x n)

Set bit at index n

bit-shift-left

Usage: (bit-shift-left x n)

Bitwise shift left

bit-shift-right

Usage: (bit-shift-right x n)

Bitwise shift right

bit-test

Usage: (bit-test x n)

Test bit at index n

bit-xor

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

Bitwise exclusive or

boolean

Usage: (boolean x)

Coerce to boolean

boolean-array

Usage: (boolean-array size-or-seq)       (boolean-array size init-val-or-seq)

Creates an array of booleans

boolean?

Usage: (boolean? x)

Return true if x is a Boolean

booleans

Usage: (booleans xs)

Casts to boolean[]

bound-fn

Usage: (bound-fn & fntail)

Returns a function defined by the given fntail, which will install thesame bindings in effect as in the thread at the time bound-fn was called.This may be used to define a helper function which runs on a differentthread, but needs the same bindings in place.

bound-fn*

Usage: (bound-fn* f)

Returns a function, which will install the same bindings in effect as inthe thread at the time bound-fn* was called and then call f with any givenarguments. This may be used to define a helper function which runs on adifferent thread, but needs the same bindings in place.

bound?

Usage: (bound? & vars)

Returns true if all of the vars provided as arguments have any bound value, root or thread-local.Implies that deref'ing the provided vars will succeed. Returns true if no vars are provided.

bounded-count

Usage: (bounded-count n coll)

If coll is counted? returns its count, else will count at most the first nelements of coll using its seq

butlast

Usage: (butlast coll)

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

byte

Usage: (byte x)

Coerce to byte

byte-array

Usage: (byte-array size-or-seq)       (byte-array size init-val-or-seq)

Creates an array of bytes

bytes

Usage: (bytes xs)

Casts to bytes[]

bytes?

Usage: (bytes? x)

Return true if x is a byte array

case

Usage: (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-exprThe test-constants are not evaluated. They must be compile-timeliterals, and need not be quoted.  If the expression is equal to atest-constant, the corresponding result-expr is returned. A singledefault expression can follow the clauses, and its value will bereturned if no clause matches. If no default expression is providedand no clause matches, an IllegalArgumentException is thrown.Unlike cond and condp, case does a constant-time dispatch, theclauses are not considered sequentially.  All manner of constantexpressions are acceptable in case, including numbers, strings,symbols, keywords, and (Clojure) composites thereof. Note that sincelists are used to group multiple constants that map to the sameexpression, a vector can be used to match a list if needed. Thetest-constants need not be all of the same type.

cast

Usage: (cast c x)

Throws a ClassCastException if x is not a c, else returns x.

cat

Usage: (cat rf)

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

catch

Syntax for use with try.Please seehttps://clojure.org/reference/special_forms#try

char

Usage: (char x)

Coerce to char

char-array

Usage: (char-array size-or-seq)       (char-array size init-val-or-seq)

Creates an array of chars

char-escape-string

Returns escape string for char or nil if none

char-name-string

Returns name string for char or nil if none

char?

Usage: (char? x)

Return true if x is a Character

chars

Usage: (chars xs)

Casts to chars[]

class

Usage: (class x)

Returns the Class of x

class?

Usage: (class? x)

Returns true if x is an instance of Class

clear-agent-errors

Usage: (clear-agent-errors a)

DEPRECATED: Use 'restart-agent' instead.Clears any exceptions thrown during asynchronous actions of theagent, allowing subsequent actions to occur.

clojure-version

Usage: (clojure-version)

Returns clojure version as a printable string.

coll?

Usage: (coll? x)

Returns true if x implements IPersistentCollection

comment

Usage: (comment & body)

Ignores body, yields nil

commute

Usage: (commute ref fun & args)

Must be called in a transaction. Sets the in-transaction-value ofref to:(apply fun in-transaction-value-of-ref args)and returns the in-transaction-value of ref.At the commit point of the transaction, sets the value of ref to be:(apply fun most-recently-committed-value-of-ref args)Thus fun should be commutative, or, failing that, you must acceptlast-one-in-wins behavior.  commute allows for more concurrency thanref-set.

comp

Usage: (comp)       (comp f)       (comp f g)       (comp f g & fs)

Takes a set of functions and returns a fn that is the compositionof those fns.  The returned fn takes a variable number of args,applies the rightmost of fns to the args, the nextfn (right-to-left) to the result, etc.

comparator

Usage: (comparator pred)

Returns an implementation of java.util.Comparator based upon pred.

compare

Usage: (compare x y)

Comparator. Returns a negative number, zero, or a positive numberwhen x is logically 'less than', 'equal to', or 'greater than'y. Same as Java x.compareTo(y) except it also works for nil, andcompares numbers and collections in a type-independent manner. xmust implement Comparable

compare-and-set!

Usage: (compare-and-set! atom oldval newval)

Atomically sets the value of atom to newval if and only if thecurrent value of the atom is identical to oldval. Returns true ifset happened, else false

compile

Usage: (compile lib)

Compiles the namespace named by the symbol lib into a set ofclassfiles. The source for the lib must be in a properclasspath-relative directory. The output files will go into thedirectory specified by *compile-path*, and that directory too mustbe in the classpath.

complement

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

Usage: (completing f)       (completing f cf)

Takes a reducing function f of 2 args and returns a fn suitable fortransduce by adding an arity-1 signature that calls cf (default -identity) on the result argument.

concat

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

Usage: (cond & clauses)

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

cond->

Usage: (cond-> expr & clauses)

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

cond->>

Usage: (cond->> expr & clauses)

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

condp

Usage: (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-exprtest-expr :>> result-fnNote :>> is an ordinary keyword.For each clause, (pred test-expr expr) is evaluated. If it returnslogical true, the clause is a match. If a binary clause matches, theresult-expr is returned, if a ternary clause matches, its result-fn,which must be a unary function, is called with the result of thepredicate as its argument, the result of that call being the returnvalue of condp. A single default expression can follow the clauses,and its value will be returned if no clause matches. If no defaultexpression is provided and no clause matches, anIllegalArgumentException is thrown.

conj

Usage: (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).(conj coll) returns coll. (conj) returns [].The 'addition' may happen at different 'places' dependingon the concrete type.

conj!

Usage: (conj!)       (conj! coll)       (conj! coll x)

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

cons

Usage: (cons x seq)

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

constantly

Usage: (constantly x)

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

construct-proxy

Usage: (construct-proxy c & ctor-args)

Takes a proxy class and any arguments for its superclass ctor andcreates and returns an instance of the proxy.

contains?

Usage: (contains? coll key)

Returns true if key is present in the given collection, otherwisereturns false.  Note that for numerically indexed collections likevectors and Java arrays, this tests if the numeric key is within therange of indexes. 'contains?' operates constant or logarithmic time;it will not perform a linear search for a value.  See also 'some'.

count

Usage: (count coll)

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

counted?

Usage: (counted? coll)

Returns true if coll implements count in constant time

create-ns

Usage: (create-ns sym)

Create a new namespace named by the symbol if one doesn't alreadyexist, returns it or the already-existing namespace of the samename.

create-struct

Usage: (create-struct & keys)

Returns a structure basis object.

cycle

Usage: (cycle coll)

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

dec

Usage: (dec x)

Returns a number one less than num. Does not auto-promotelongs, will throw on overflow. See also: dec'

dec'

Usage: (dec' x)

Returns a number one less than num. Supports arbitrary precision.See also: dec

decimal?

Usage: (decimal? n)

Returns true if n is a BigDecimal

declare

Usage: (declare & names)

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

dedupe

Usage: (dedupe)       (dedupe coll)

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

def

Usage: (def symbol doc-string? init?)

Creates and interns a global var with the nameof symbol in the current namespace (*ns*) or locates such a var ifit already exists.  If init is supplied, it is evaluated, and theroot binding of the var is set to the resulting value.  If init isnot supplied, the root binding of the var is unaffected.Please seehttps://clojure.org/reference/special_forms#def

default-data-readers

Default map of data reader functions provided by Clojure. May beoverridden by binding *data-readers*.

definline

Usage: (definline name & decl)

Experimental - like defmacro, except defines a named function whosebody is the expansion, calls to which may be expanded inline as ifit were a macro. Cannot be used with variadic (&) args.

definterface

Usage: (definterface name & sigs)

Creates a new Java interface with the given name and method sigs.The method return types and parameter types may be specified with type hints,defaulting to Object if omitted.(definterface MyInterface  (^int method1 [x])  (^Bar method2 [^Baz b ^Quux q]))

defmacro

Usage: (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 amacro and will be used as a macro by the compiler when it iscalled.

defmethod

Usage: (defmethod multifn dispatch-val & fn-tail)

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

defmulti

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

Creates a new multimethod with the associated dispatch function.The docstring and attr-map are optional.Options are key-value pairs and may be one of::defaultThe default dispatch value, defaults to :default:hierarchyThe value used for hierarchical dispatch (e.g. ::square is-a ::shape)Hierarchies are type-like relationships that do not depend upon typeinheritance. By default Clojure's multimethods dispatch off of aglobal hierarchy map.  However, a hierarchy relationship can becreated with the derive function used to augment the root ancestorcreated with make-hierarchy.Multimethods expect the value of the hierarchy option to be supplied asa reference type e.g. a var (i.e. via the Var-quote dispatch macro #'or the var special form).

defn

Usage: (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 (fn [params* ] exprs*)) or (defname (fn ([params* ] exprs*)+)) with any doc-string or attrs addedto the var metadata. prepost-map defines a map with optional keys:pre and :post that contain collections of pre or post conditions.

Specs:  Args: (fspec          :args          :clojure.core.specs.alpha/defn-args          :ret          any?          :fn          nil)  Ret:  (fspec          :args          :clojure.core.specs.alpha/defn-args          :ret          any?          :fn          nil)

defn-

Usage: (defn- name & decls)

same as defn, yielding non-public def

Specs:  Args: (fspec          :args          :clojure.core.specs.alpha/defn-args          :ret          any?          :fn          nil)  Ret:  (fspec          :args          :clojure.core.specs.alpha/defn-args          :ret          any?          :fn          nil)

defonce

Usage: (defonce name expr)

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

defprotocol

Usage: (defprotocol name & opts+sigs)

A protocol is a named set of named methods and their signatures:(defprotocol AProtocolName  ;optional doc string  "A doc string for AProtocol abstraction" ;options :extend-via-metadata true;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 theprotocol overall and for each method. The above yields a set ofpolymorphic functions and a protocol object. All arenamespace-qualified by the ns enclosing the definition The resultingfunctions dispatch on the type of their first argument, which isrequired and corresponds to the implicit target object ('this' in Java parlance). defprotocol is dynamic, has no special compile-time effect, and defines no new types or classes. Implementations of the protocol methods can be provided using extend.When :extend-via-metadata is true, values can extend protocols byadding metadata where keys are fully-qualified protocol functionsymbols and values are function implementations. Protocolimplementations are checked first for direct definitions (defrecord,deftype, reify), then metadata definitions, then externalextensions (extend, extend-type, extend-protocol)defprotocol will automatically generate a corresponding interface,with the same name as the protocol, i.e. given a protocol:my.ns/Protocol, an interface: my.ns.Protocol. The interface willhave methods corresponding to the protocol functions, and theprotocol will automatically work with instances of the interface.Note that you should not use this interface with deftype orreify, as they support the protocol directly:(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

Usage: (defrecord name [& fields] & opts+specs)

(defrecord name [fields*]  options* specs*)Options are expressed as sequential keywords and arguments (in any order).Supported options::load-ns - if true, importing the record class will cause the           namespace in which the record was defined to be loaded.           Defaults to false.Each spec consists of a protocol or interface name followed by zeroor more method bodies:protocol-or-interface-or-Object(methodName [args*] body)*Dynamically generates compiled bytecode for class with the givenname, in a package with the same name as the current namespace, thegiven fields, and, optionally, methods for protocols and/orinterfaces.The class will have the (immutable) fields named byfields, which can have type hints. Protocols/interfaces and methodsare optional. The only methods that can be supplied are thosedeclared in the protocols/interfaces.  Note that method bodies arenot 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 andmethodname symbols. If not supplied, they will be inferred, so typehints should be reserved for disambiguation.Methods should be supplied for all methods of the desiredprotocol(s) and interface(s). You can also define overrides formethods of Object. Note that a parameter must be supplied tocorrespond to the target object ('this' in Java parlance). Thusmethods for interfaces will take one more argument than do theinterface declarations. Note also that recur calls to the methodhead should *not* pass the target object, it will be suppliedautomatically and can not be substituted.In the method bodies, the (unqualified) name can be used to name theclass (for calls to new, instance? etc).The class will have implementations of several (clojure.lang)interfaces generated automatically: IObj (metadata support) andIPersistentMap, and all of their superinterfaces.In addition, defrecord will define type-and-value-based =,and will defined Java .hashCode and .equals consistent with thecontract for java.util.Map.When AOT compiling, generates compiled bytecode for a class with thegiven name (a symbol), prepends the current ns as the package, andwrites the .class file to the *compile-path* directory.Two constructors will be defined, one taking the designated fieldsfollowed by a metadata map (nil for none) and an extension fieldmap (nil for none), and one taking only the fields (using nil formeta and extension fields). Note that the field names __meta,__extmap, __hash and __hasheq are currently reserved and should notbe used when defining your own records.Given (defrecord TypeName ...), two factory functions will bedefined: ->TypeName, taking positional parameters for the fields,and map->TypeName, taking a map of keywords to field values.

defstruct

Usage: (defstruct name & keys)

Same as (def name (create-struct keys...))

deftype

Usage: (deftype name [& fields] & opts+specs)

(deftype name [fields*]  options* specs*)Options are expressed as sequential keywords and arguments (in any order).Supported options::load-ns - if true, importing the type class will cause the           namespace in which the type was defined to be loaded.           Defaults to false.Each spec consists of a protocol or interface name followed by zeroor more method bodies:protocol-or-interface-or-Object(methodName [args*] body)*Dynamically generates compiled bytecode for class with the givenname, in a package with the same name as the current namespace, thegiven fields, and, optionally, methods for protocols and/orinterfaces. The class will have the (by default, immutable) fields named byfields, which can have type hints. Protocols/interfaces and methodsare optional. The only methods that can be supplied are thosedeclared in the protocols/interfaces.  Note that method bodies arenot closures, the local environment includes only the named fields,and those fields can be accessed directly. Fields can be qualifiedwith the metadata :volatile-mutable true or :unsynchronized-mutabletrue, at which point (set! afield aval) will be supported in methodbodies. Note well that mutable fields are extremely difficult to usecorrectly, and are present only to facilitate the building of higherlevel constructs, such as Clojure's reference types, in Clojureitself. They are for experts only - if the semantics andimplications of :volatile-mutable or :unsynchronized-mutable are notimmediately 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 andmethodname symbols. If not supplied, they will be inferred, so typehints should be reserved for disambiguation.Methods should be supplied for all methods of the desiredprotocol(s) and interface(s). You can also define overrides formethods of Object. Note that a parameter must be supplied tocorrespond to the target object ('this' in Java parlance). Thusmethods for interfaces will take one more argument than do theinterface declarations. Note also that recur calls to the methodhead should *not* pass the target object, it will be suppliedautomatically and can not be substituted.In the method bodies, the (unqualified) name can be used to name theclass (for calls to new, instance? etc).When AOT compiling, generates compiled bytecode for a class with thegiven name (a symbol), prepends the current ns as the package, andwrites the .class file to the *compile-path* directory.One constructor will be defined, taking the designated fields.  Notethat the field names __meta, __extmap, __hash and __hasheq are currentlyreserved and should not be used when defining your own types.Given (deftype TypeName ...), a factory function called ->TypeNamewill be defined, taking positional parameters for the fields

delay

Usage: (delay & body)

Takes a body of expressions and yields a Delay object that willinvoke the body only the first time it is forced (with force or deref/@), andwill cache the result and return it on all subsequent forcecalls. See also - realized?

delay?

Usage: (delay? x)

returns true if x is a Delay created with delay

deliver

Usage: (deliver promise val)

Delivers the supplied value to the promise, releasing any pendingderefs. A subsequent call to deliver on a promise will have no effect.

denominator

Usage: (denominator r)

Returns the denominator part of a Ratio.

deref

Usage: (deref ref)       (deref ref timeout-ms timeout-val)

Also reader macro: @ref/@agent/@var/@atom/@delay/@future/@promise. Within a transaction,returns the in-transaction-value of ref, else returns themost-recently-committed value of ref. When applied to a var, agentor atom, returns its current state. When applied to a delay, forcesit if not already forced. When applied to a future, will block ifcomputation not complete. When applied to a promise, will blockuntil a value is delivered.  The variant taking a timeout can beused for blocking references (futures and promises), and will returntimeout-val if the timeout (in milliseconds) is reached before avalue is available. See also - realized?.

derive

Usage: (derive tag parent)       (derive h tag parent)

Establishes a parent/child relationship between parent andtag. Parent must be a namespace-qualified symbol or keyword andchild can be either a namespace-qualified symbol or keyword or aclass. h must be a hierarchy obtained from make-hierarchy, if notsupplied defaults to, and modifies, the global hierarchy.

descendants

Usage: (descendants tag)       (descendants h tag)

Returns the immediate and indirect children of tag, through arelationship established via derive. h must be a hierarchy obtainedfrom make-hierarchy, if not supplied defaults to the globalhierarchy. Note: does not work on Java type inheritancerelationships.

disj

Usage: (disj set)       (disj set key)       (disj set key & ks)

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

disj!

Usage: (disj! set)       (disj! set key)       (disj! set key & ks)

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

dissoc

Usage: (dissoc map)       (dissoc map key)       (dissoc map key & ks)

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

dissoc!

Usage: (dissoc! map key)       (dissoc! map key & ks)

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

distinct

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

Usage: (distinct? x)       (distinct? x y)       (distinct? x y & more)

Returns true if no two of the arguments are =

do

Usage: (do exprs*)

Evaluates the expressions in order and returns the value ofthe last. If no expressions are supplied, returns nil.Please seehttps://clojure.org/reference/special_forms#do

doall

Usage: (doall coll)       (doall n coll)

When lazy sequences are produced via functions that have sideeffects, any effects other than those needed to produce the firstelement in the seq do not occur until the seq is consumed. doall canbe used to force any effects. Walks through the successive nexts ofthe seq, retains the head and returns it, thus causing the entireseq to reside in memory at one time.

dorun

Usage: (dorun coll)       (dorun n coll)

When lazy sequences are produced via functions that have sideeffects, any effects other than those needed to produce the firstelement in the seq do not occur until the seq is consumed. dorun canbe used to force any effects. Walks through the successive nexts ofthe seq, does not retain the head and returns nil.

doseq

Usage: (doseq seq-exprs & body)

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

dosync

Usage: (dosync & exprs)

Runs the exprs (in an implicit do) in a transaction that encompassesexprs and any nested calls.  Starts a transaction if none is alreadyrunning on this thread. Any uncaught exception will abort thetransaction and flow out of dosync. The exprs may be run more thanonce, but any effects on Refs will be atomic.

dotimes

Usage: (dotimes bindings & body)

bindings => name nRepeatedly executes body (presumably for side-effects) with namebound to integers from 0 through n-1.

doto

Usage: (doto x & forms)

Evaluates x then calls all of the methods and functions with thevalue of x supplied at the front of the given arguments.  The formsare evaluated in order.  Returns x.(doto (new java.util.HashMap) (.put "a" 1) (.put "b" 2))

double

Usage: (double x)

Coerce to double

double-array

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

Creates an array of doubles

double?

Usage: (double? x)

Return true if x is a Double

doubles

Usage: (doubles xs)

Casts to double[]

drop

Usage: (drop n)       (drop n coll)

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

drop-last

Usage: (drop-last coll)       (drop-last n coll)

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

drop-while

Usage: (drop-while pred)       (drop-while pred coll)

Returns a lazy sequence of the items in coll starting from thefirst item for which (pred item) returns logical false.  Returns astateful transducer when no collection is provided.

eduction

Usage: (eduction xform* coll)

Returns a reducible/iterable application of the transducersto the items in coll. Transducers are applied in order as ifcombined with comp. Note that these applications will beperformed every time reduce/iterator is called.

empty

Usage: (empty coll)

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

empty?

Usage: (empty? coll)

Returns true if coll has no items. To check the emptiness of a seq,please use the idiom (seq x) rather than (not (empty? x))

ensure

Usage: (ensure ref)

Must be called in a transaction. Protects the ref from modificationby other transactions.  Returns the in-transaction-value ofref. Allows for more concurrency than (ref-set ref @ref)

ensure-reduced

Usage: (ensure-reduced x)

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

enumeration-seq

Usage: (enumeration-seq e)

Returns a seq on a java.util.Enumeration

error-handler

Usage: (error-handler a)

Returns the error-handler of agent a, or nil if there is none.See set-error-handler!

error-mode

Usage: (error-mode a)

Returns the error-mode of agent a.  See set-error-mode!

eval

Usage: (eval form)

Evaluates the form data structure (not text!) and returns the result.

even?

Usage: (even? n)

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

every-pred

Usage: (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 itscomposing predicates return a logical true value against all of its arguments, else it returnsfalse. Note that f is short-circuiting in that it will stop execution on the firstargument that triggers a logical false result against the original predicates.

every?

Usage: (every? pred coll)

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

ex-cause

Usage: (ex-cause ex)

Returns the cause of ex if ex is a Throwable.Otherwise returns nil.

ex-data

Usage: (ex-data ex)

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

ex-info

Usage: (ex-info msg map)       (ex-info msg map cause)

Create an instance of ExceptionInfo, a RuntimeException subclassthat carries a map of additional data.

ex-message

Usage: (ex-message ex)

Returns the message attached to ex if ex is a Throwable.Otherwise returns nil.

extend

Usage: (extend atype & proto+mmaps)

Implementations of protocol methods can be provided using the extend construct: (extend AType   AProtocol    {:foo an-existing-fn     :bar (fn [a b] ...)     :baz (fn ([a]...) ([a b] ...)...)}   BProtocol      {...}    ...) extend takes a type/class (or interface, see below), and one or more protocol + method map pairs. It will extend the polymorphism of the protocol's methods to call the supplied methods when an AType is provided as the first argument.  Method maps are maps of the keyword-ized method names to ordinary fns. This facilitates easy reuse of existing fns and fn maps, for code reuse/mixins without derivation or composition. You can extend an interface to a protocol. This is primarily to facilitate interop with the host (e.g. Java) but opens the door to incidental multiple inheritance of implementation since a class can inherit from more than one interface, both of which extend the protocol. It is TBD how to specify which impl to use. You can extend a protocol on nil. If you are supplying the definitions explicitly (i.e. not reusing exsting functions or mixin maps), you may find it more convenient to use the extend-type or extend-protocol macros. Note that multiple independent extend clauses can exist for the same type, not all protocols need be defined in a single extend call. See also: extends?, satisfies?, extenders

extend-protocol

Usage: (extend-protocol p & specs)

Useful when you want to provide several implementations of the sameprotocol all at once. Takes a single protocol and the implementationof that protocol for one or more types. Expands into calls toextend-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

Usage: (extend-type t & specs)

A macro that expands into an extend call. Useful when you aresupplying the definitions explicitly inline, extend-typeautomatically creates the maps required by extend.  Propagates theclass as a type hint on the first argument of all fns.(extend-type MyType   Countable    (cnt [c] ...)  Foo    (bar [x y] ...)    (baz ([x] ...) ([x y & zs] ...)))expands into:(extend MyType Countable   {:cnt (fn [c] ...)} Foo   {:baz (fn ([x] ...) ([x y & zs] ...))    :bar (fn [x y] ...)})

extenders

Usage: (extenders protocol)

Returns a collection of the types explicitly extending protocol

extends?

Usage: (extends? protocol atype)

Returns true if atype extends protocol

false?

Usage: (false? x)

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

ffirst

Usage: (ffirst x)

Same as (first (first x))

file-seq

Usage: (file-seq dir)

A tree seq on java.io.Files

filter

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

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

finally

Syntax for use with try.Please seehttps://clojure.org/reference/special_forms#try

find

Usage: (find map key)

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

find-keyword

Usage: (find-keyword name)       (find-keyword ns name)

Returns a Keyword with the given namespace and name if one alreadyexists.  This function will not intern a new keyword. If the keywordhas not already been interned, it will return nil.  Do not use :in the keyword strings, it will be added automatically.

find-ns

Usage: (find-ns sym)

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

find-var

Usage: (find-var sym)

Returns the global var named by the namespace-qualified symbol, ornil if no var with that name.

first

Usage: (first coll)

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

flatten

Usage: (flatten x)

Takes any nested combination of sequential things (lists, vectors,etc.) and returns their contents as a single, flat lazy sequence.(flatten nil) returns an empty sequence.

float

Usage: (float x)

Coerce to float

float-array

Usage: (float-array size-or-seq)       (float-array size init-val-or-seq)

Creates an array of floats

float?

Usage: (float? n)

Returns true if n is a floating point number

floats

Usage: (floats xs)

Casts to float[]

flush

Usage: (flush)

Flushes the output stream that is the current value of*out*

fn

Usage: (fn name? [params*] exprs*)       (fn name? ([params*] exprs*) +)

params => positional-params*, or positional-params* & rest-parampositional-param => binding-formrest-param => binding-formbinding-form => name, or destructuring-formDefines a function.Seehttps://clojure.org/reference/special_forms#fn for more information

Specs:  Args: (fspec          :args          (cat           :fn-name (? simple-symbol?)           :fn-tail (alt                     :arity-1 :clojure.core.specs.alpha/params+body                     :arity-n (+                                (spec                                  :clojure.core.specs.alpha/params+body))))          :ret          any?          :fn          nil)  Ret:  (fspec          :args          (cat           :fn-name (? simple-symbol?)           :fn-tail (alt                     :arity-1 :clojure.core.specs.alpha/params+body                     :arity-n (+                                (spec                                  :clojure.core.specs.alpha/params+body))))          :ret          any?          :fn          nil)

fn?

Usage: (fn? x)

Returns true if x implements Fn, i.e. is an object created via fn.

fnext

Usage: (fnext x)

Same as (first (next x))

fnil

Usage: (fnil f x)       (fnil f x y)       (fnil f x y z)

Takes a function f, and returns a function that calls f, replacinga nil first argument to f with the supplied value x. Higher arityversions can replace arguments in the second and thirdpositions (y, z). Note that the function f can take any number ofarguments, not just the one(s) being nil-patched.

for

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

Usage: (force x)

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

format

Usage: (format fmt & args)

Formats a string using java.lang.String.format, see java.util.Formatter for formatstring syntax

frequencies

Usage: (frequencies coll)

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

future

Usage: (future & body)

Takes a body of expressions and yields a future object that willinvoke the body in another thread, and will cache the result andreturn it on all subsequent calls to deref/@. If the computation hasnot yet finished, calls to deref/@ will block, unless the variant ofderef with timeout is used. See also - realized?.

future-call

Usage: (future-call f)

Takes a function of no args and yields a future object that willinvoke the function in another thread, and will cache the result andreturn it on all subsequent calls to deref/@. If the computation hasnot yet finished, calls to deref/@ will block, unless the variantof deref with timeout is used. See also - realized?.

future-cancel

Usage: (future-cancel f)

Cancels the future, if possible.

future-cancelled?

Usage: (future-cancelled? f)

Returns true if future f is cancelled

future-done?

Usage: (future-done? f)

Returns true if future f is done

future?

Usage: (future? x)

Returns true if x is a future

gen-class

Usage: (gen-class & options)

When compiling, generates compiled bytecode for a class with thegiven package-qualified :name (which, as all names in theseparameters, can be a string or symbol), and writes the .class fileto the *compile-path* directory.  When not compiling, doesnothing. The gen-class construct contains no implementation, as theimplementation will be dynamically sought by the generated class infunctions in an implementing Clojure namespace. Given a generatedclass org.mydomain.MyClass with a method named mymethod, gen-classwill generate an implementation that looks for a function named by (str prefix mymethod) (default prefix: "-") in aClojure namespace specified by :impl-ns(defaults to the current namespace). All inherited methods,generated methods, and init and main functions (see :methods, :init,and :main below) will be found similarly prefixed. By default, thestatic initializer for the generated class will attempt to load theClojure support code for the class as a resource from the classpath,e.g. in the example case, ``org/mydomain/MyClass__init.class``. Thisbehavior can be controlled by :load-impl-nsNote that methods with a maximum of 18 parameters are supported.In all subsequent sections taking types, the primitive types can bereferred to by their Java names (int, float etc), and classes in thejava.lang package can be used without a package qualifier. All otherclasses must be fully qualified.Options should be a set of key/value pairs, all except for :name are optional::name anameThe package-qualified name of the class to be generated:extends aclassSpecifies the superclass, the non-private methods of which will beoverridden by the class. If not provided, defaults to Object.:implements [interface ...]One or more interfaces, the methods of which will be implemented by the class.:init nameIf supplied, names a function that will be called with the argumentsto the constructor. Must return [ [superclass-constructor-args] state] If not supplied, the constructor args are passed directly tothe superclass constructor and the state will be nil:constructors {[param-types] [super-param-types], ...}By default, constructors are created for the generated class whichmatch the signature(s) of the constructors for the superclass. Thisparameter may be used to explicitly specify constructors, each entryproviding a mapping from a constructor signature to a superclassconstructor signature. When you supply this, you must supply an :initspecifier. :post-init nameIf supplied, names a function that will be called with the object asthe first argument, followed by the arguments to the constructor.It will be called every time an object of this class is created,immediately after all the inherited constructors have completed.Its return value is ignored.:methods [ [name [param-types] return-type], ...]The generated class automatically defines all of the non-privatemethods of its superclasses/interfaces. This parameter can be usedto specify the signatures of additional methods of the generatedclass. Static methods can be specified with ^{:static true} in thesignature's metadata. Do not repeat superclass/interface signatureshere.:main booleanIf supplied and true, a static public main function will be generated. It willpass each string of the String[] argument as a separate argument toa function called (str prefix main).:factory nameIf supplied, a (set of) public static factory function(s) will becreated with the given name, and the same signature(s) as theconstructor(s).:state nameIf supplied, a public final instance field with the given name will becreated. You must supply an :init function in order to provide avalue for the state. Note that, though final, the state can be a refor agent, supporting the creation of Java objects with transactionalor asynchronous mutation semantics.:exposes {protected-field-name {:get name :set name}, ...}Since the implementations of the methods of the generated classoccur in Clojure functions, they have no access to the inheritedprotected fields of the superclass. This parameter can be used togenerate public getter/setter methods exposing the protected field(s)for use in the implementation.:exposes-methods {super-method-name exposed-name, ...}It is sometimes necessary to call the superclass' implementation of anoverridden method.  Those methods may be exposed and referred in the new method implementation by a local name.:prefix stringDefault: "-" Methods called e.g. Foo will be looked up in vars calledprefixFoo in the implementing ns.:impl-ns nameDefault: the name of the current ns. Implementations of methods will be looked up in this namespace.:load-impl-ns booleanDefault: true. Causes the static initializer for the generated classto reference the load code for the implementing namespace. Should betrue when implementing-ns is the default, false if you intend toload the code via some other method.

gen-interface

Usage: (gen-interface & options)

When compiling, generates compiled bytecode for an interface with the given package-qualified :name (which, as all names in these parameters, can be a string or symbol), and writes the .class file to the *compile-path* directory.  When not compiling, does nothing. In all subsequent sections taking types, the primitive types can be referred to by their Java names (int, float etc), and classes in the java.lang package can be used without a package qualifier. All other classes must be fully qualified. Options should be a set of key/value pairs, all except for :name are optional: :name aname The package-qualified name of the class to be generated :extends [interface ...] One or more interfaces, which will be extended by this interface. :methods [ [name [param-types] return-type], ...] This parameter is used to specify the signatures of the methods of the generated interface.  Do not repeat superinterface signatures here.

gensym

Usage: (gensym)       (gensym prefix-string)

Returns a new symbol with a unique name. If a prefix string issupplied, the name is prefix# where # is some unique number. Ifprefix is not supplied, the prefix is 'G__'.

get

Usage: (get map key)       (get map key not-found)

Returns the value mapped to key, not-found or nil if key not presentin associative collection, set, string, array, or ILookup instance.

get-in

Usage: (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 keyis not present, or the not-found value if supplied.

get-method

Usage: (get-method multifn dispatch-val)

Given a multimethod and a dispatch value, returns the dispatch fnthat would apply to that value, or nil if none apply and no default

get-proxy-class

Usage: (get-proxy-class & bases)

Takes an optional single class followed by zero or moreinterfaces. If not supplied class defaults to Object.  Creates anreturns an instance of a proxy class derived from the suppliedclasses. The resulting value is cached and used for any subsequentrequests for the same class set. Returns a Class object.

get-thread-bindings

Usage: (get-thread-bindings)

Get a map with the Var/value pairs which is currently in effect for thecurrent thread.

get-validator

Usage: (get-validator iref)

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

group-by

Usage: (group-by f coll)

Returns a map of the elements of coll keyed by the result off on each element. The value at each key will be a vector of thecorresponding elements, in the order they appeared in coll.

halt-when

Usage: (halt-when pred)       (halt-when pred retf)

Returns a transducer that ends transduction when pred returns truefor 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 thattriggered the predicate, and its return value (if it does not throwan exception) will be the return value of the transducer. If retfis not supplied, the input that triggered the predicate will bereturned. If the predicate never returns true the transduction isunaffected.

hash

Usage: (hash x)

Returns the hash code of its argument. Note this is the hash codeconsistent with =, and thus is different than .hashCode for Integer,Short, Byte and Clojure collections.

hash-map

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

keyval => key valReturns a new hash map with supplied mappings.  If any keys areequal, they are handled as if by repeated uses of assoc.

hash-ordered-coll

Usage: (hash-ordered-coll coll)

Returns the hash code, consistent with =, for an external orderedcollection implementing Iterable.Seehttp://clojure.org/data_structures#hash for full algorithms.

hash-set

Usage: (hash-set)       (hash-set & keys)

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

hash-unordered-coll

Usage: (hash-unordered-coll coll)

Returns the hash code, consistent with =, for an external unorderedcollection implementing Iterable. For maps, the iterator shouldreturn map entries whose hash is computed as  (hash-ordered-coll [k v]).Seehttp://clojure.org/data_structures#hash for full algorithms.

ident?

Usage: (ident? x)

Return true if x is a symbol or keyword

identical?

Usage: (identical? x y)

Tests if 2 arguments are the same object

identity

Usage: (identity x)

Returns its argument.

if

Usage: (if test then else?)

Evaluates test. If not the singular values nil or false,evaluates and yields then, otherwise, evaluates and yields else. Ifelse is not supplied it defaults to nil.Please seehttps://clojure.org/reference/special_forms#if

if-let

Usage: (if-let bindings then)       (if-let bindings then else & oldform)

bindings => binding-form testIf test is true, evaluates then with binding-form bound to the value of test, if not, yields else

Specs:  Args: (fspec          :args          (cat           :bindings (and vector? :clojure.core.specs.alpha/binding)           :then any?           :else (? any?))          :ret          any?          :fn          nil)  Ret:  (fspec          :args          (cat           :bindings (and vector? :clojure.core.specs.alpha/binding)           :then any?           :else (? any?))          :ret          any?          :fn          nil)

if-not

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

Usage: (if-some bindings then)       (if-some bindings then else & oldform)

bindings => binding-form testIf test is not nil, evaluates then with binding-form bound to thevalue of test, if not, yields else

ifn?

Usage: (ifn? x)

Returns true if x implements IFn. Note that many data structures(e.g. sets and maps) implement IFn

import

Usage: (import & import-symbols-or-lists)

import-list => (package-symbol class-name-symbols*)For each name in class-name-symbols, adds a mapping from name to theclass named by package.name to the current namespace. Use :import in the nsmacro in preference to calling this directly.

Specs:  Args: (fspec          :args          :clojure.core.specs.alpha/quotable-import-list          :ret          any?          :fn          nil)  Ret:  (fspec          :args          :clojure.core.specs.alpha/quotable-import-list          :ret          any?          :fn          nil)

in-ns

Usage: (in-ns name)

Sets *ns* to the namespace named by the symbol, creating it if needed.

inc

Usage: (inc x)

Returns a number one greater than num. Does not auto-promotelongs, will throw on overflow. See also: inc'

inc'

Usage: (inc' x)

Returns a number one greater than num. Supports arbitrary precision.See also: inc

indexed?

Usage: (indexed? coll)

Return true if coll implements Indexed, indicating efficient lookup by index

infinite?

Usage: (infinite? num)

Returns true if num is negative or positive infinity, else false

init-proxy

Usage: (init-proxy proxy mappings)

Takes a proxy instance and a map of strings (which mustcorrespond to methods of the proxy superclass/superinterfaces) tofns (which must take arguments matching the corresponding method,plus an additional (explicit) first arg corresponding to this, andsets the proxy's fn map.  Returns the proxy.

inst-ms

Usage: (inst-ms inst)

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

inst?

Usage: (inst? x)

Return true if x satisfies Inst

instance?

Usage: (instance? c x)

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

int

Usage: (int x)

Coerce to int

int-array

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

Creates an array of ints

int?

Usage: (int? x)

Return true if x is a fixed precision integer

integer?

Usage: (integer? n)

Returns true if n is an integer

interleave

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

intern

Usage: (intern ns name)       (intern ns name val)

Finds or creates a var named by the symbol name in the namespacens (which can be a symbol or a namespace), setting its root bindingto val if supplied. The namespace must exist. The var will adopt anymetadata from the name symbol.  Returns the var.

interpose

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

Usage: (into)       (into to)       (into to from)       (into to xform from)

Returns a new coll consisting of to with all of the items offrom conjoined. A transducer may be supplied.(into x) returns x. (into) returns [].

into-array

Usage: (into-array aseq)       (into-array type aseq)

Returns an array with components set to the values in aseq. The array'scomponent type is type if provided, or the type of the first value inaseq if present, or Object. All values in aseq must be compatible withthe component type. Class objects for the primitive types can be obtainedusing, e.g., Integer/TYPE.

ints

Usage: (ints xs)

Casts to int[]

io!

Usage: (io! & body)

If an io! block occurs in a transaction, throws anIllegalStateException, else runs body in an implicit do. If thefirst expression in body is a literal string, will use that as theexception message.

isa?

Usage: (isa? child parent)       (isa? h child parent)

Returns true if (= child parent), or child is directly or indirectly derived fromparent, either via a Java type inheritance relationship or arelationship established via derive. h must be a hierarchy obtainedfrom make-hierarchy, if not supplied defaults to the globalhierarchy

iterate

Usage: (iterate f x)

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

iteration

Usage: (iteration step & {:keys [somef vf kf initk], :or {vf identity, kf identity, somef some?, initk nil}})

Creates a seqable/reducible via repeated calls to step,a function of some (continuation token) 'k'. The first call to stepwill be passed initk, returning 'ret'. Iff (somef ret) is true,(vf ret) will be included in the iteration, else iteration willterminate and vf/kf will not be called. If (kf ret) is non-nil itwill be passed to the next step call, else iteration will terminate.This can be used e.g. to consume APIs that return paginated or batched data. step - (possibly impure) fn of 'k' -> 'ret' :somef - fn of 'ret' -> logical true/false, default 'some?' :vf - fn of 'ret' -> 'v', a value produced by the iteration, default 'identity' :kf - fn of 'ret' -> 'next-k' or nil (signaling 'do not continue'), default 'identity' :initk - the first value passed to step, default 'nil'It is presumed that step with non-initk is unreproducible/non-idempotent.If step with initk is unreproducible it is on the consumer to not consume twice.

iterator-seq

Usage: (iterator-seq iter)

Returns a seq on a java.util.Iterator. Note that most collectionsproviding iterators implement Iterable and thus support seq directly.Seqs cache values, thus iterator-seq should not be used on anyiterator that repeatedly returns the same mutable object.

juxt

Usage: (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 juxtapositionof those fns.  The returned fn takes a variable number of args, andreturns a vector containing the result of applying each fn to theargs (left-to-right).((juxt a b c) x) => [(a x) (b x) (c x)]

keep

Usage: (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 ofside-effects.  Returns a transducer when no collection is provided.

keep-indexed

Usage: (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 ofside-effects.  Returns a stateful transducer when no collection isprovided.

key

Usage: (key e)

Returns the key of the map entry.

keys

Usage: (keys map)

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

keyword

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

Usage: (keyword? x)

Return true if x is a Keyword

last

Usage: (last coll)

Return the last item in coll, in linear time

lazy-cat

Usage: (lazy-cat & colls)

Expands to code which yields a lazy sequence of the concatenationof the supplied colls.  Each coll expr is not evaluated until it isneeded. (lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))

lazy-seq

Usage: (lazy-seq & body)

Takes a body of expressions that returns an ISeq or nil, and yieldsa Seqable object that will invoke the body only the first time seqis called, and will cache the result and return it on all subsequentseq calls. See also - realized?

let

Usage: (let [bindings*] exprs*)

binding => binding-form init-exprbinding-form => name, or destructuring-formdestructuring-form => map-destructure-form, or seq-destructure-formEvaluates the exprs in a lexical context in which the symbols inthe binding-forms are bound to their respective init-exprs or partstherein.Seehttps://clojure.org/reference/special_forms#binding-forms formore information about destructuring.

Specs:  Args: (fspec          :args          (cat           :bindings :clojure.core.specs.alpha/bindings           :body (* any?))          :ret          any?          :fn          nil)  Ret:  (fspec          :args          (cat           :bindings :clojure.core.specs.alpha/bindings           :body (* any?))          :ret          any?          :fn          nil)

letfn

Usage: (letfn [fnspecs*] exprs*)

fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+)Takes a vector of function specs and a body, and generates a set ofbindings of functions to their names. All of the names are availablein all of the definitions of the functions, as well as the body.

line-seq

Usage: (line-seq rdr)

Returns the lines of text from rdr as a lazy sequence of strings.rdr must implement java.io.BufferedReader.

list

Usage: (list & items)

Creates a new list containing the items.

list*

Usage: (list* args)       (list* a args)       (list* a b args)       (list* a b c args)       (list* a b c d & more)

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

list?

Usage: (list? x)

Returns true if x implements IPersistentList

load

Usage: (load & paths)

Loads Clojure code from resources in classpath. A path is interpreted asclasspath-relative if it begins with a slash or relative to the rootdirectory for the current namespace otherwise.

load-file

Usage: (load-file name)

Sequentially read and evaluate the set of forms contained in the file.

load-reader

Usage: (load-reader rdr)

Sequentially read and evaluate the set of forms contained in thestream/file

load-string

Usage: (load-string s)

Sequentially read and evaluate the set of forms contained in thestring

loaded-libs

Usage: (loaded-libs)

Returns a sorted set of symbols naming the currently loaded libs

locking

Usage: (locking x & body)

Executes exprs in an implicit do, while holding the monitor of x.Will release the monitor of x in all circumstances.

long

Usage: (long x)

Coerce to long

long-array

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

Creates an array of longs

longs

Usage: (longs xs)

Casts to long[]

loop

Usage: (loop [bindings*] exprs*)

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

macroexpand

Usage: (macroexpand form)

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

macroexpand-1

Usage: (macroexpand-1 form)

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

make-array

Usage: (make-array type len)       (make-array type dim & more-dims)

Creates and returns an array of instances of the specified class ofthe specified dimension(s).  Note that a class object is required.Class objects can be obtained by using their imported orfully-qualified name.  Class objects for the primitive types can beobtained using, e.g., Integer/TYPE.

make-hierarchy

Usage: (make-hierarchy)

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

map

Usage: (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 tothe set of first items of each coll, followed by applying f to theset of second items in each coll, until any one of the colls isexhausted.  Any remaining items in other colls are ignored. Functionf should accept number-of-colls arguments. Returns a transducer whenno collection is provided.

map-entry?

Usage: (map-entry? x)

Return true if x is a map entry

map-indexed

Usage: (map-indexed f)       (map-indexed f coll)

Returns a lazy sequence consisting of the result of applying f to 0and the first item of coll, followed by applying f to 1 and the seconditem in coll, etc, until coll is exhausted. Thus function f shouldaccept 2 arguments, index and item. Returns a stateful transducer whenno collection is provided.

map?

Usage: (map? x)

Return true if x implements IPersistentMap

mapcat

Usage: (mapcat f)       (mapcat f & colls)

Returns the result of applying concat to the result of applying mapto f and colls.  Thus function f should return a collection. Returnsa transducer when no collections are provided

mapv

Usage: (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 theset of first items of each coll, followed by applying f to the setof second items in each coll, until any one of the colls isexhausted.  Any remaining items in other colls are ignored. Functionf should accept number-of-colls arguments.

max

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

Returns the greatest of the nums.

max-key

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

Usage: (memfn name & args)

Expands into code that creates a fn that expects to be passed anobject and any args and calls the named instance method on theobject passing the args. Use when you want to treat a Java method asa first-class fn. name may be type-hinted with the method receiver'stype in order to avoid reflective calls.

memoize

Usage: (memoize f)

Returns a memoized version of a referentially transparent function. Thememoized version of the function keeps a cache of the mapping from argumentsto results and, when calls with the same arguments are repeated often, hashigher performance at the expense of higher memory use.

merge

Usage: (merge & maps)

Returns a map that consists of the rest of the maps conj-ed ontothe first.  If a key occurs in more than one map, the mapping fromthe latter (left-to-right) will be the mapping in the result.

merge-with

Usage: (merge-with f & maps)

Returns a map that consists of the rest of the maps conj-ed ontothe 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 inthe result by calling (f val-in-result val-in-latter).

meta

Usage: (meta obj)

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

methods

Usage: (methods multifn)

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

min

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

Returns the least of the nums.

min-key

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

mix-collection-hash

Usage: (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 numberof elements included in the basis. Note this is the hash codeconsistent with =, different from .hashCode.Seehttp://clojure.org/data_structures#hash for full algorithms.

mod

Usage: (mod num div)

Modulus of num and div. Truncates toward negative infinity.

monitor-enter

Usage: (monitor-enter x)

Synchronization primitive that should be avoidedin user code. Use the 'locking' macro.Please seehttps://clojure.org/reference/special_forms#monitor-enter

monitor-exit

Usage: (monitor-exit x)

Synchronization primitive that should be avoidedin user code. Use the 'locking' macro.Please seehttps://clojure.org/reference/special_forms#monitor-exit

name

Usage: (name x)

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

namespace

Usage: (namespace x)

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

namespace-munge

Usage: (namespace-munge ns)

Convert a Clojure namespace name to a legal Java package name.

nat-int?

Usage: (nat-int? x)

Return true if x is a non-negative fixed precision integer

neg-int?

Usage: (neg-int? x)

Return true if x is a negative fixed precision integer

neg?

Usage: (neg? num)

Returns true if num is less than zero, else false

new

Usage: (Classname. args*)       (new Classname args*)

The args, if any, are evaluated from left to right, andpassed to the constructor of the class named by Classname. Theconstructed object is returned.Please seehttps://clojure.org/java_interop#new

newline

Usage: (newline)

Writes a platform-specific newline to *out*

next

Usage: (next coll)

Returns a seq of the items after the first. Calls seq on itsargument.  If there are no more items, returns nil.

nfirst

Usage: (nfirst x)

Same as (next (first x))

nil?

Usage: (nil? x)

Returns true if x is nil, false otherwise.

nnext

Usage: (nnext x)

Same as (next (next x))

not

Usage: (not x)

Returns true if x is logical false, false otherwise.

not-any?

Usage: (not-any? pred coll)

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

not-empty

Usage: (not-empty coll)

If coll is empty, returns nil, else coll

not-every?

Usage: (not-every? pred coll)

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

not=

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

Same as (not (= obj1 obj2))

ns

Usage: (ns name docstring? attr-map? references*)

Sets *ns* to the namespace named by name (unevaluated), creating itif needed.  references can be zero or more of: (:refer-clojure ...)(:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)with the syntax of refer-clojure/require/use/import/load/gen-classrespectively, except the arguments are unevaluated and need not bequoted. (:gen-class ...), when supplied, defaults to :namecorresponding to the ns name, :main true, :impl-ns same as ns, and:init-impl-ns true. All options of gen-class aresupported. The :gen-class directive is ignored when notcompiling. If :gen-class is not supplied, when compiled only annsname__init.class will be generated. If :refer-clojure is not used, adefault (refer 'clojure.core) is used.  Use of ns is preferred toindividual calls to in-ns/require/use/import:(ns foo.bar  (:refer-clojure :exclude [ancestors printf])  (:require (clojure.contrib sql combinatorics))  (:use (my.lib this that))  (:import (java.util Date Timer Random)           (java.sql Connection Statement)))

Specs:  Args: (fspec          :args          :clojure.core.specs.alpha/ns-form          :ret          any?          :fn          nil)  Ret:  (fspec          :args          :clojure.core.specs.alpha/ns-form          :ret          any?          :fn          nil)

ns-aliases

Usage: (ns-aliases ns)

Returns a map of the aliases for the namespace.

ns-imports

Usage: (ns-imports ns)

Returns a map of the import mappings for the namespace.

ns-interns

Usage: (ns-interns ns)

Returns a map of the intern mappings for the namespace.

ns-map

Usage: (ns-map ns)

Returns a map of all the mappings for the namespace.

ns-name

Usage: (ns-name ns)

Returns the name of the namespace, a symbol.

ns-publics

Usage: (ns-publics ns)

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

ns-refers

Usage: (ns-refers ns)

Returns a map of the refer mappings for the namespace.

ns-resolve

Usage: (ns-resolve ns sym)       (ns-resolve ns env sym)

Returns the var or Class to which a symbol will be resolved in thenamespace (unless found in the environment), else nil.  Note thatif the symbol is fully qualified, the var/Class to which it resolvesneed not be present in the namespace.

ns-unalias

Usage: (ns-unalias ns sym)

Removes the alias for the symbol from the namespace.

ns-unmap

Usage: (ns-unmap ns sym)

Removes the mappings for the symbol from the namespace.

nth

Usage: (nth coll index)       (nth coll index not-found)

Returns the value at the index. get returns nil if index out ofbounds, nth throws an exception unless not-found is supplied.  nthalso works for strings, Java arrays, regex Matchers and Lists, and,in O(n) time, for sequences.

nthnext

Usage: (nthnext coll n)

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

nthrest

Usage: (nthrest coll n)

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

num

Usage: (num x)

Coerce to Number

number?

Usage: (number? x)

Returns true if x is a Number

numerator

Usage: (numerator r)

Returns the numerator part of a Ratio.

object-array

Usage: (object-array size-or-seq)

Creates an array of objects

odd?

Usage: (odd? n)

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

or

Usage: (or)       (or x)       (or x & next)

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

parents

Usage: (parents tag)       (parents h tag)

Returns the immediate parents of tag, either via a Java typeinheritance relationship or a relationship established via derive. hmust be a hierarchy obtained from make-hierarchy, if not supplieddefaults to the global hierarchy

parse-boolean

Usage: (parse-boolean s)

Parse strings "true" or "false" and return a boolean, or nil if invalid

parse-double

Usage: (parse-double s)

Parse string with floating point components and return a Double value,or nil if parse fails.Grammar:https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-

parse-long

Usage: (parse-long s)

Parse string of decimal digits with optional leading -/+ and return aLong value, or nil if parse fails

parse-uuid

Usage: (parse-uuid s)

Parse a string representing a UUID and return a java.util.UUID instance,or nil if parse fails.Grammar:https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--

partial

Usage: (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, andreturns a fn that takes a variable number of additional args. Whencalled, the returned function calls f with args + additional args.

partition

Usage: (partition n coll)       (partition n step coll)       (partition n step pad coll)

Returns a lazy sequence of lists of n items each, at offsets stepapart. If step is not supplied, defaults to n, i.e. the partitionsdo not overlap. If a pad collection is supplied, use its elements asnecessary to complete last partition upto n items. In case there arenot enough padding elements, return a partition with less than n items.

partition-all

Usage: (partition-all n)       (partition-all n coll)       (partition-all n step coll)

Returns a lazy sequence of lists like partition, but may includepartitions with fewer than n items at the end.  Returns a statefultransducer when no collection is provided.

partition-by

Usage: (partition-by f)       (partition-by f coll)

Applies f to each value in coll, splitting it each time f returns anew value.  Returns a lazy seq of partitions.  Returns a statefultransducer when no collection is provided.

partitionv

Usage: (partitionv n coll)       (partitionv n step coll)       (partitionv n step pad coll)

Returns a lazy sequence of vectors of n items each, at offsets stepapart. If step is not supplied, defaults to n, i.e. the partitionsdo not overlap. If a pad collection is supplied, use its elements asnecessary to complete last partition upto n items. In case there arenot enough padding elements, return a partition with less than n items.

partitionv-all

Usage: (partitionv-all n)       (partitionv-all n coll)       (partitionv-all n step coll)

Returns a lazy sequence of vector partitions, but may includepartitions with fewer than n items at the end.Returns a stateful transducer when no collection is provided.

pcalls

Usage: (pcalls & fns)

Executes the no-arg fns in parallel, returning a lazy sequence oftheir values

peek

Usage: (peek coll)

For a list or queue, same as first, for a vector, same as, but muchmore efficient than, last. If the collection is empty, returns nil.

persistent!

Usage: (persistent! coll)

Returns a new, persistent version of the transient collection, inconstant time. The transient collection cannot be used after thiscall, any such use will throw an exception.

pmap

Usage: (pmap f coll)       (pmap f coll & colls)

Like map, except f is applied in parallel. Semi-lazy in that theparallel computation stays ahead of the consumption, but doesn'trealize the entire result unless required. Only useful forcomputationally intensive functions where the time of f dominatesthe coordination overhead.

pop

Usage: (pop coll)

For a list or queue, returns a new list/queue without the firstitem, for a vector, returns a new vector without the last item. Ifthe collection is empty, throws an exception.  Note - not the sameas next/butlast.

pop!

Usage: (pop! coll)

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

pop-thread-bindings

Usage: (pop-thread-bindings)

Pop one set of bindings pushed with push-binding before. It is an error topop bindings without pushing before.

pos-int?

Usage: (pos-int? x)

Return true if x is a positive fixed precision integer

pos?

Usage: (pos? num)

Returns true if num is greater than zero, else false

pr

Usage: (pr)       (pr x)       (pr x & more)

Prints the object(s) to the output stream that is the current valueof *out*.  Prints the object(s), separated by spaces if there ismore than one.  By default, pr and prn print in a way that objectscan be read by the reader

pr-str

Usage: (pr-str & xs)

pr to a string, returning it

prefer-method

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

Usage: (prefers multifn)

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

print

Usage: (print & more)

Prints the object(s) to the output stream that is the current valueof *out*.  print and println produce output for human consumption.

print-str

Usage: (print-str & xs)

print to a string, returning it

printf

Usage: (printf fmt & args)

Prints formatted output, as per format

println

Usage: (println & more)

Same as print followed by (newline)

println-str

Usage: (println-str & xs)

println to a string, returning it

prn

Usage: (prn & more)

Same as pr followed by (newline). Observes *flush-on-newline*

prn-str

Usage: (prn-str & xs)

prn to a string, returning it

promise

Usage: (promise)

Returns a promise object that can be read with deref/@, and set,once only, with deliver. Calls to deref/@ prior to delivery willblock, unless the variant of deref with timeout is used. Allsubsequent derefs will return the same delivered value withoutblocking. See also - realized?.

proxy

Usage: (proxy class-and-interfaces args & fs)

class-and-interfaces - a vector of class namesargs - a (possibly empty) vector of arguments to the superclassconstructor.f => (name [params*] body) or(name ([params*] body) ([params+] body) ...)Expands to code which creates a instance of a proxy class thatimplements the named class/interface(s) by calling the suppliedfns. A single class, if provided, must be first. If not provided itdefaults to Object.The interfaces names must be valid interface types. If a method fnis not provided for a class method, the superclass method will becalled. If a method fn is not provided for an interface method, anUnsupportedOperationException will be thrown should it becalled. Method fns are closures and can capture the environment inwhich proxy is called. Each method fn takes an additional implicitfirst arg, which is bound to 'this. Note that while method fns canbe provided to override protected methods, they have no other accessto protected members, nor to super, as these capabilities cannot beproxied.

proxy-mappings

Usage: (proxy-mappings proxy)

Takes a proxy instance and returns the proxy's fn map.

proxy-super

Usage: (proxy-super meth & args)

Use to call a superclass method in the body of a proxy method. Note, expansion captures 'this

push-thread-bindings

Usage: (push-thread-bindings bindings)

WARNING: This is a low-level function. Prefer high-level macros likebinding where ever possible.Takes a map of Var/value pairs. Binds each Var to the associated value forthe current thread. Each call *MUST* be accompanied by a matching call topop-thread-bindings wrapped in a try-finally!    (push-thread-bindings bindings)    (try      ...      (finally        (pop-thread-bindings)))

pvalues

Usage: (pvalues & exprs)

Returns a lazy sequence of the values of the exprs, which areevaluated in parallel

qualified-ident?

Usage: (qualified-ident? x)

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

qualified-keyword?

Usage: (qualified-keyword? x)

Return true if x is a keyword with a namespace

qualified-symbol?

Usage: (qualified-symbol? x)

Return true if x is a symbol with a namespace

quot

Usage: (quot num div)

quot[ient] of dividing numerator by denominator.

quote

Usage: (quote form)

Yields the unevaluated form.Please seehttps://clojure.org/reference/special_forms#quote

rand

Usage: (rand)       (rand n)

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

rand-int

Usage: (rand-int n)

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

rand-nth

Usage: (rand-nth coll)

Return a random element of the (sequential) collection. Will havethe same performance characteristics as nth for the givencollection.

random-sample

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

Usage: (random-uuid)

Returns a pseudo-randomly generated java.util.UUID instance (i.e. type 4).See:https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--

range

Usage: (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 toinfinity. When step is equal to 0, returns an infinite sequence ofstart. When start is equal to end, returns empty list.

ratio?

Usage: (ratio? n)

Returns true if n is a Ratio

rational?

Usage: (rational? n)

Returns true if n is a rational number

rationalize

Usage: (rationalize num)

returns the rational value of num

re-find

Usage: (re-find m)       (re-find re s)

Returns the next regex match, if any, of string to pattern, usingjava.util.regex.Matcher.find().  Uses re-groups to return thegroups.

re-groups

Usage: (re-groups m)

Returns the groups from the most recent match/find. If there are nonested groups, returns a string of the entire match. If there arenested groups, returns a vector of the groups, the first elementbeing the entire match.

re-matcher

Usage: (re-matcher re s)

Returns an instance of java.util.regex.Matcher, for use, e.g. inre-find.

re-matches

Usage: (re-matches re s)

Returns the match, if any, of string to pattern, usingjava.util.regex.Matcher.matches().  Uses re-groups to return thegroups.

re-pattern

Usage: (re-pattern s)

Returns an instance of java.util.regex.Pattern, for use, e.g. inre-matcher.

re-seq

Usage: (re-seq re s)

Returns a lazy sequence of successive matches of pattern in string,using java.util.regex.Matcher.find(), each such match processed withre-groups.

read

Usage: (read)       (read stream)       (read stream eof-error? eof-value)       (read stream eof-error? eof-value recursive?)       (read opts stream)

Reads the next object from stream, which must be an instance ofjava.io.PushbackReader or some derivee.  stream defaults to thecurrent value of *in*.Opts is a persistent map with valid keys:  :read-cond - :allow to process reader conditionals, or               :preserve to keep all branches  :features - persistent set of feature keywords for reader conditionals  :eof - on eof, return value unless :eofthrow, then throw.         if not specified, will throwNote that read can execute code (controlled by *read-eval*),and as such should be used only with trusted sources.For data structure interop use clojure.edn/read

read+string

Usage: (read+string)       (read+string stream)       (read+string stream eof-error? eof-value)       (read+string stream eof-error? eof-value recursive?)       (read+string opts stream)

Like read, and taking the same args. stream must be a LineNumberingPushbackReader.Returns a vector containing the object read and the (whitespace-trimmed) string read.

read-line

Usage: (read-line)

Reads the next line from stream that is the current value of *in* .

read-string

Usage: (read-string s)       (read-string opts s)

Reads one object from the string s. Optionally include readeroptions, as specified in read.Note that read-string can execute code (controlled by *read-eval*),and as such should be used only with trusted sources.For data structure interop use clojure.edn/read-string

reader-conditional

Usage: (reader-conditional form splicing?)

Construct a data representation of a reader conditional.If true, splicing? indicates read-cond-splicing.

reader-conditional?

Usage: (reader-conditional? value)

Return true if the value is the data representation of a reader conditional

realized?

Usage: (realized? x)

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

record?

Usage: (record? x)

Returns true if x is a record

recur

Usage: (recur exprs*)

Evaluates the exprs in order, then, in parallel, rebindsthe bindings of the recursion point to the values of the exprs.Execution then jumps back to the recursion point, a loop or fn method.Please seehttps://clojure.org/reference/special_forms#recur

reduce

Usage: (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, thenapplying f to that result and the 3rd item, etc. If coll contains noitems, f must accept no arguments as well, and reduce returns theresult of calling f with no arguments.  If coll has only 1 item, itis returned and f is not called.  If val is supplied, returns theresult of applying f to val and the first item in coll, thenapplying f to that result and the 2nd item, etc. If coll contains noitems, returns val and f is not called.

reduce-kv

Usage: (reduce-kv f init coll)

Reduces an associative collection. f should be a function of 3arguments. Returns the result of applying f to init, the first keyand the first value in coll, then applying f to that result and the2nd key and value, etc. If coll contains no entries, returns initand f is not called. Note that reduce-kv is supported on vectors,where the keys will be the ordinals.

reduced

Usage: (reduced x)

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

reduced?

Usage: (reduced? x)

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

reductions

Usage: (reductions f coll)       (reductions f init coll)

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

ref

Usage: (ref x)       (ref x & options)

Creates and returns a Ref with an initial value of x and zero ormore options (in any order)::meta metadata-map:validator validate-fn:min-history (default 0):max-history (default 10)If metadata-map is supplied, it will become the metadata on theref. validate-fn must be nil or a side-effect-free fn of oneargument, which will be passed the intended new state on any statechange. If the new state is unacceptable, the validate-fn shouldreturn false or throw an exception. validate-fn will be called ontransaction commit, when all refs have their final values.Normally refs accumulate history dynamically as needed to deal withread demands. If you know in advance you will need history you canset :min-history to ensure it will be available when first needed (insteadof after a read fault). History is limited, and the limit can be setwith :max-history.

ref-history-count

Usage: (ref-history-count ref)

Returns the history count of a ref

ref-max-history

Usage: (ref-max-history ref)       (ref-max-history ref n)

Gets the max-history of a ref, or sets it and returns the ref

ref-min-history

Usage: (ref-min-history ref)       (ref-min-history ref n)

Gets the min-history of a ref, or sets it and returns the ref

ref-set

Usage: (ref-set ref val)

Must be called in a transaction. Sets the value of ref.Returns val.

refer

Usage: (refer ns-sym & filters)

refers to all public vars of ns, subject to filters.filters can include at most one each of::exclude list-of-symbols:only list-of-symbols:rename map-of-fromsymbol-tosymbolFor each public interned var in the namespace named by the symbol,adds a mapping from the name of the var to the var to the currentnamespace.  Throws an exception if name is already mapped tosomething else in the current namespace. Filters can be used toselect a subset, via inclusion or exclusion, or to provide a mappingto a symbol different from the var's name, in order to preventclashes. Use :use in the ns macro in preference to calling this directly.

refer-clojure

Usage: (refer-clojure & filters)

Same as (refer 'clojure.core <filters>)

Specs:  Args: (fspec          :args          (*            (alt             :exclude (cat                       :op (quotable #{:exclude})                       :arg (quotable                              :clojure.core.specs.alpha/exclude))             :only (cat                    :op (quotable #{:only})                    :arg (quotable :clojure.core.specs.alpha/only))             :rename (cat                      :op (quotable #{:rename})                      :arg (quotable                             :clojure.core.specs.alpha/rename))))          :ret          any?          :fn          nil)  Ret:  (fspec          :args          (*            (alt             :exclude (cat                       :op (quotable #{:exclude})                       :arg (quotable                              :clojure.core.specs.alpha/exclude))             :only (cat                    :op (quotable #{:only})                    :arg (quotable :clojure.core.specs.alpha/only))             :rename (cat                      :op (quotable #{:rename})                      :arg (quotable                             :clojure.core.specs.alpha/rename))))          :ret          any?          :fn          nil)

reify

Usage: (reify & opts+specs)

reify creates an object implementing a protocol or interface. reify is a macro with the following structure:(reify options* specs*)  Currently there are no options. Each spec consists of the protocol or interface name followed by zero or more method bodies: protocol-or-interface-or-Object (methodName [args+] body)* Methods should be supplied for all methods of the desired protocol(s) and interface(s). You can also define overrides for methods of Object. Note that the first parameter must be supplied to correspond to the target object ('this' in Java parlance). Thus methods for interfaces will take one more argument than do the interface declarations.  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. The return type can be indicated by a type hint on the method name, and arg types can be indicated by a type hint on arg names. If you leave out all hints, reify will try to match on same name/arity method in the protocol(s)/interface(s) - this is preferred. If you supply any hints at all, no inference is done, so all hints (or default of Object) must be correct, for both arguments and return type. If a method is overloaded in a protocol/interface, multiple independent method definitions must be supplied.  If overloaded with same arity in an interface you must specify complete hints to disambiguate - a missing hint implies Object. Method heads are recursion points for recur, as in a fn. 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 clojure.lang.Seqable          (seq [this] (seq f))))) == (\f \o \o)  reify always implements clojure.lang.IObj and transfers meta data of the form to the created object.  (meta ^{:k :v} (reify Object (toString [this] "foo"))) == {:k :v}

release-pending-sends

Usage: (release-pending-sends)

Normally, actions sent directly or indirectly during another actionare held until the action completes (changes the agent'sstate). This function can be used to dispatch any pending sentactions immediately. This has no impact on actions sent during atransaction, which are still held until commit. If no action isoccurring, does nothing. Returns the number of actions dispatched.

rem

Usage: (rem num div)

remainder of dividing numerator by denominator.