clojure.core - Clojure v1.12.0 API documentation (original) (raw)

Public Variables and Functions

&

special syntax

Syntax for use with fn.

Please see https://clojure.org/reference/special_forms#fn

Added in Clojure version 1.0

*

function

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

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

Added in Clojure version 1.2
Source

*'

function

compiler-options

var

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. See https://clojure.org/reference/compilation for more information.

Added in Clojure version 1.4

data-readers

dynamic var

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 file must contain a literal map of symbols, like this:

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

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

#foo/bar [1 2 3]

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

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

Added in Clojure version 1.4
Source

default-data-reader-fn

dynamic var

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

Added in Clojure version 1.5
Source

var

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

Added in Clojure version 1.0

out

var

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

Defaults to System/out, wrapped in an OutputStreamWriter

Added in Clojure version 1.0

print-dup

var

read-eval

var

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

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

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

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

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

Added in Clojure version 1.0

repl

dynamic var

Bound to true in a repl thread

Added in Clojure version 1.12
Source

function

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

Positional factory function for class clojure.core.VecSeq.

Source

.

special form

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

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

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

Added in Clojure version 1.0

..

macro

Usage: (.. x form) (.. x form & more)

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

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

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

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.

Added in Clojure version 1.0
Source

assert

macro

Returns escape string for char or nil if none

Added in Clojure version 1.0
Source

function

Usage: (clojure-version)

Returns clojure version as a printable string.

Added in Clojure version 1.0
Source

coll?

function

Usage: (coll? x)

Returns true if x implements IPersistentCollection

Added in Clojure version 1.0
Source

macro

Usage: (comment & body)

Ignores body, yields nil

Added in Clojure version 1.0
Source

commute

function

Usage: (commute ref fun & args)

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

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

and returns the in-transaction-value of ref.

macro

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-expr

macro

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

Added in Clojure version 1.2
Source

defmacro

macro

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 a macro and will be used as a macro by the compiler when it is called.

Added in Clojure version 1.0
Source

defmethod

macro

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

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

Added in Clojure version 1.0
Source

defmulti

macro

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:

:default

The default dispatch value, defaults to :default

:hierarchy

The value used for hierarchical dispatch (e.g. ::square is-a ::shape)

Hierarchies are type-like relationships that do not depend upon type inheritance. By default Clojure's multimethods dispatch off of a global hierarchy map. However, a hierarchy relationship can be created with the derive function used to augment the root ancestor created with make-hierarchy.

Multimethods expect the value of the hierarchy option to be supplied as a reference type e.g. a var (i.e. via the Var-quote dispatch macro #' or the var special form).

Added in Clojure version 1.0
Source

defn

macro

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

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)

Added in Clojure version 1.0
Source

defn-

macro

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)

Added in Clojure version 1.0
Source

defonce

macro

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

Added in Clojure version 1.0
Source

defprotocol

macro

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 the protocol overall and for each method. The above yields a set of polymorphic functions and a protocol object. All are namespace-qualified by the ns enclosing the definition The resulting functions dispatch on the type of their first argument, which is required and corresponds to the implicit target object ('this' in 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 by adding metadata where keys are fully-qualified protocol function symbols and values are function implementations. Protocol implementations are checked first for direct definitions (defrecord, deftype, reify), then metadata definitions, then external extensions (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 will have methods corresponding to the protocol functions, and the protocol will automatically work with instances of the interface.

Note that you should not use this interface with deftype or reify, 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

Added in Clojure version 1.2
Source

defrecord

macro

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 zero or more method bodies:

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

Dynamically generates compiled bytecode for class with the given name, in a package with the same name as the current namespace, the given fields, and, optionally, methods for protocols and/or interfaces.

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

Method definitions take the form:

(methodname [args*] body)

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

Methods should be supplied for all methods of the desired protocol(s) and interface(s). You can also define overrides for methods of Object. Note that a parameter must be supplied to correspond to the target object ('this' in 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.

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

The class will have implementations of several (clojure.lang) interfaces generated automatically: IObj (metadata support) and IPersistentMap, and all of their superinterfaces.

In addition, defrecord will define type-and-value-based =, and will defined Java .hashCode and .equals consistent with the contract for java.util.Map.

When AOT compiling, generates compiled bytecode for a class with the given name (a symbol), prepends the current ns as the package, and writes the .class file to the compile-path directory.

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

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

Added in Clojure version 1.2
Source

defstruct

macro

Usage: (defstruct name & keys)

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

Added in Clojure version 1.0
Source

deftype

macro

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 zero or more method bodies:

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

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

Method definitions take the form:

(methodname [args*] body)

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

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

special form

Usage: (do exprs*)

Evaluates the expressions in order and returns the value of the last. If no expressions are supplied, returns nil.

Please see https://clojure.org/reference/special_forms#do

Added in Clojure version 1.0

doall

function

Usage: (doall coll) (doall n coll)

When lazy sequences are produced via functions that have side effects, any effects other than those needed to produce the first element in the seq do not occur until the seq is consumed. doall can be used to force any effects. Walks through the successive nexts of the seq, retains the head and returns it, thus causing the entire seq to reside in memory at one time.

Added in Clojure version 1.0
Source

dorun

function

Usage: (dorun coll) (dorun n coll)

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

Added in Clojure version 1.0
Source

doseq

macro

Usage: (doseq seq-exprs & body)

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

Added in Clojure version 1.0
Source

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

Added in Clojure version 1.2
Source

extend-protocol

macro

Usage: (extend-protocol p & specs)

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

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

expands into:

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

Added in Clojure version 1.2
Source

extend-type

macro

Usage: (extend-type t & specs)

A macro that expands into an extend call. Useful when you are supplying the definitions explicitly inline, extend-type automatically creates the maps required by extend. Propagates the class as a type hint on the first argument of all fns.

special form

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

params => positional-params*, or positional-params* & rest-param positional-param => binding-form rest-param => binding-form binding-form => name, or destructuring-form

Defines a function.

See https://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)

Added in Clojure version 1.0
Source

fn?

function

Usage: (fn? x)

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

Added in Clojure version 1.0
Source

fnext

function

Usage: (fnext x)

Same as (first (next x))

Added in Clojure version 1.0
Source

fnil

function

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

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

Added in Clojure version 1.2
Source

for

macro

macro

Usage: (gen-class & options)

When compiling, generates compiled bytecode for a class 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. The gen-class construct contains no implementation, as the implementation will be dynamically sought by the generated class in functions in an implementing Clojure namespace. Given a generated class org.mydomain.MyClass with a method named mymethod, gen-class will generate an implementation that looks for a function named by (str prefix mymethod) (default prefix: "-") in a Clojure 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, the static initializer for the generated class will attempt to load the Clojure support code for the class as a resource from the classpath, e.g. in the example case, org/mydomain/MyClass__init.class. This behavior can be controlled by :load-impl-ns

Note that methods with a maximum of 18 parameters are supported.

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 aclass

Specifies the superclass, the non-private methods of which will be overridden 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 name

If supplied, names a function that will be called with the arguments to the constructor. Must return [ [superclass-constructor-args] state] If not supplied, the constructor args are passed directly to the superclass constructor and the state will be nil

:constructors {[param-types] [super-param-types], ...}

By default, constructors are created for the generated class which match the signature(s) of the constructors for the superclass. This parameter may be used to explicitly specify constructors, each entry providing a mapping from a constructor signature to a superclass constructor signature. When you supply this, you must supply an :init specifier.

:post-init name

If supplied, names a function that will be called with the object as the 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-private methods of its superclasses/interfaces. This parameter can be used to specify the signatures of additional methods of the generated class. Static methods can be specified with ^{:static true} in the signature's metadata. Do not repeat superclass/interface signatures here.

:main boolean

If supplied and true, a static public main function will be generated. It will pass each string of the String[] argument as a separate argument to a function called (str prefix main).

:factory name

If supplied, a (set of) public static factory function(s) will be created with the given name, and the same signature(s) as the constructor(s).

:state name

If supplied, a public final instance field with the given name will be created. You must supply an :init function in order to provide a value for the state. Note that, though final, the state can be a ref or agent, supporting the creation of Java objects with transactional or asynchronous mutation semantics.

:exposes {protected-field-name {:get name :set name}, ...}

Since the implementations of the methods of the generated class occur in Clojure functions, they have no access to the inherited protected fields of the superclass. This parameter can be used to generate 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 an overridden method. Those methods may be exposed and referred in the new method implementation by a local name.

:prefix string

Default: "-" Methods called e.g. Foo will be looked up in vars called prefixFoo in the implementing ns.

:impl-ns name

Default: the name of the current ns. Implementations of methods will be looked up in this namespace.

:load-impl-ns boolean

Default: true. Causes the static initializer for the generated class to reference the load code for the implementing namespace. Should be true when implementing-ns is the default, false if you intend to load the code via some other method.

Added in Clojure version 1.0
Source

gen-interface

macro

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.

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

special form

Usage: (if test then else?)

Evaluates test. If not the singular values nil or false, evaluates and yields then, otherwise, evaluates and yields else. If else is not supplied it defaults to nil.

Please see https://clojure.org/reference/special_forms#if

Added in Clojure version 1.0

if-let

macro

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

bindings => binding-form test

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

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)

Added in Clojure version 1.0
Source

if-not

macro

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.

Added in Clojure version 1.0
Source

if-some

macro

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

bindings => binding-form test

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

Added in Clojure version 1.6
Source

ifn?

function

Usage: (ifn? x)

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

Added in Clojure version 1.0
Source

import

macro

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

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

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

Added in Clojure version 1.0
Source

lazy-seq

macro

Usage: (lazy-seq & body)

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

Added in Clojure version 1.0
Source

let

special form

Usage: (let [bindings*] exprs*)

binding => binding-form init-expr binding-form => name, or destructuring-form destructuring-form => map-destructure-form, or seq-destructure-form

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

See https://clojure.org/reference/special_forms#binding-forms for more 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)

Added in Clojure version 1.0
Source

letfn

special form

function

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.

Added in Clojure version 1.0
Source

memfn

macro

Usage: (memfn name & args)

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

Added in Clojure version 1.0
Source

memoize

function

Usage: (memoize f)

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

Added in Clojure version 1.0
Source

merge

function

Usage: (merge & maps)

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

Added in Clojure version 1.0
Source

merge-with

function

Usage: (merge-with f & maps)

Returns a map that consists of the rest of the maps conj-ed onto the first. If a key occurs in more than one map, the mapping(s) from the latter (left-to-right) will be combined with the mapping in the result by calling (f val-in-result val-in-latter).

Added in Clojure version 1.0
Source

function

Usage: (meta obj)

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

Added in Clojure version 1.0
Source

methods

function

Usage: (methods multifn)

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

Added in Clojure version 1.0
Source

newline

function

Usage: (newline)

Writes a platform-specific newline to out

Added in Clojure version 1.0
Source

Grammar: https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-

Added in Clojure version 1.11
Source

parse-long

function

Usage: (parse-long s)

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

Added in Clojure version 1.11
Source

parse-uuid

function

macro

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

class-and-interfaces - a vector of class names

args - a (possibly empty) vector of arguments to the superclass constructor.

f => (name [params*] body) or (name ([params*] body) ([params+] body) ...)

Expands to code which creates a instance of a proxy class that implements the named class/interface(s) by calling the supplied fns. A single class, if provided, must be first. If not provided it defaults to Object.

The interfaces names must be valid interface types. If a method fn is not provided for a class method, the superclass method will be called. If a method fn is not provided for an interface method, an UnsupportedOperationException will be thrown should it be called. Method fns are closures and can capture the environment in which proxy is called. Each method fn takes an additional implicit first arg, which is bound to 'this. Note that while method fns can be provided to override protected methods, they have no other access to protected members, nor to super, as these capabilities cannot be proxied.

Added in Clojure version 1.0
Source

proxy-mappings

function

Usage: (proxy-mappings proxy)

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

Added in Clojure version 1.0
Source

proxy-super

macro

Usage: (proxy-super meth & args)

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

Added in Clojure version 1.0
Source

push-thread-bindings

function

Usage: (push-thread-bindings bindings)

WARNING: This is a low-level function. Prefer high-level macros like binding where ever possible.

Takes a map of Var/value pairs. Binds each Var to the associated value for the current thread. Each call MUST be accompanied by a matching call to pop-thread-bindings wrapped in a try-finally!

(push-thread-bindings bindings)
(try
  ...
  (finally
    (pop-thread-bindings)))

Please see https://clojure.org/reference/special_forms#quote

Added in Clojure version 1.0

rand

function

Usage: (rand) (rand n)

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

Added in Clojure version 1.0
Source

rand-int

function

Usage: (rand-int n)

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

Added in Clojure version 1.0
Source

rand-nth

function

Usage: (rand-nth coll)

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

Added in Clojure version 1.2
Source

random-sample

function

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.

Added in Clojure version 1.7
Source

random-uuid

function

For data structure interop use clojure.edn/read

Added in Clojure version 1.0
Source

read+string

function

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.

Added in Clojure version 1.10
Source

read-line

function

Usage: (read-line)

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

Added in Clojure version 1.0
Source

read-string

function

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

For 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 current namespace. Throws an exception if name is already mapped to something else in the current namespace. Filters can be used to select a subset, via inclusion or exclusion, or to provide a mapping to a symbol different from the var's name, in order to prevent clashes. Use :use in the ns macro in preference to calling this directly.

Added in Clojure version 1.0
Source

refer-clojure

macro

Usage: (refer-clojure & filters)

Same as (refer 'clojure.core )

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)

Added in Clojure version 1.0
Source

reify

macro

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"

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

Libspecs

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

Recognized options: :as takes a symbol as its argument and makes that symbol an alias to the lib's namespace in the current namespace. :as-alias takes a symbol as its argument and aliases like :as, however the lib will not be loaded. If the lib has not been loaded, a new empty namespace will be created (as with create-ns). :refer takes a list of symbols to refer from the namespace or the :all keyword to bring in all public vars.

Prefix Lists

It's common for Clojure code to depend on several libs whose names have the same prefix. When specifying libs, prefix lists can be used to reduce repetition. A prefix list contains the shared prefix followed by libspecs with the shared prefix removed from the lib names. After removing the prefix, the names that remain must not contain any periods.

Flags

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

Example:

The following would load the libraries clojure.zip and clojure.set abbreviated as 's'.

(require '(clojure zip [set :as s]))

Added in Clojure version 1.0
Source

requiring-resolve

function

Usage: (requiring-resolve sym)

Resolves namespace-qualified sym per 'resolve'. If initial resolve fails, attempts to require sym's namespace and retries.

Added in Clojure version 1.10
Source

reset!

function

Usage: (reset! atom newval)

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

Added in Clojure version 1.0
Source

function

Usage: (rseq rev)

Returns, in constant time, a seq of the items in rev (which can be a vector or sorted-map), in reverse order. If rev is empty returns nil

Added in Clojure version 1.0
Source

rsubseq

function

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

sc must be a sorted collection, test(s) one of <, <=, > or

=. Returns a reverse seq of those entries with keys ek for which (test (.. sc comparator (compare ek key)) 0) is true

Added in Clojure version 1.0
Source

run!

function

Usage: (run! proc coll)

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

Added in Clojure version 1.7
Source

satisfies?

function

Usage: (satisfies? protocol x)

Returns true if x satisfies the protocol

Added in Clojure version 1.2
Source

second

function

Usage: (second x)

Same as (first (next x))

Added in Clojure version 1.0
Source

special form

Usage: (set! var-symbol expr) (set! (. instance-expr instanceFieldName-symbol) expr) (set! (. Classname-symbol staticFieldName-symbol) expr)

Used to set thread-local-bound vars, Java object instance fields, and Java class static fields.

Please see https://clojure.org/vars#set

Added in Clojure version 1.0

set-agent-send-executor!

function

Usage: (set-agent-send-executor! executor)

Sets the ExecutorService to be used by send

Added in Clojure version 1.5
Source

set-agent-send-off-executor!

function

Usage: (set-agent-send-off-executor! executor)

Sets the ExecutorService to be used by send-off

Added in Clojure version 1.5
Source

set-error-handler!

function

Usage: (set-error-handler! a handler-fn)

Sets the error-handler of agent a to handler-fn. If an action being run by the agent throws an exception or doesn't pass the validator fn, handler-fn will be called with two arguments: the agent and the exception.

Added in Clojure version 1.2
Source

set-error-mode!

function

function

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

sc must be a sorted collection, test(s) one of <, <=, > or

=. Returns a seq of those entries with keys ek for which (test (.. sc comparator (compare ek key)) 0) is true

Added in Clojure version 1.0
Source

sync

macro

Note in particular that transients are not designed to be bashed in-place. You must capture and use the return value in the next call. In this way, they support the same code structure as the functional persistent code they replace.

Added in Clojure version 1.1
Source

tree-seq

function

Usage: (tree-seq branch? children root)

Returns a lazy sequence of the nodes in a tree, via a depth-first walk. branch? must be a fn of one arg that returns true if passed a node that can have children (but may not). children must be a fn of one arg that returns a sequence of the children. Will only be called on nodes for which branch? returns true. Root is the root node of the tree.

Added in Clojure version 1.0
Source

true?

function

Usage: (true? x)

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

Added in Clojure version 1.0
Source

try

special form

Usage: (try expr* catch-clause* finally-clause?)

function

Usage: (val e)

Returns the value in the map entry.

Added in Clojure version 1.0
Source

vals

function

Usage: (vals map)

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

Added in Clojure version 1.0
Source

var

special form

Usage: (var symbol)

The symbol must resolve to a var, and the Var object itself (not its value) is returned. The reader macro #'x expands to (var x).

Please see https://clojure.org/reference/special_forms#var

Added in Clojure version 1.0

var-get

function

Usage: (var-get x)

Gets the value in the var object

Added in Clojure version 1.0
Source

var-set

function

Usage: (var-set x val)

Sets the value in the var object to val. The var must be thread-locally bound.

Added in Clojure version 1.0
Source

var?

function

Usage: (var? v)

Returns true if v is of type clojure.lang.Var

Added in Clojure version 1.0
Source

function

Usage: (vary-meta obj f & args)

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

Added in Clojure version 1.0
Source

vec

function

Usage: (vec coll)

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

Added in Clojure version 1.0
Source

vector

function

Usage: (vector) (vector a) (vector a b) (vector a b c) (vector a b c d) (vector a b c d e) (vector a b c d e f) (vector a b c d e f & args)

Creates a new vector containing the args.

Added in Clojure version 1.0
Source

vector-of

function

when-let

macro

Usage: (when-let bindings & body)

bindings => binding-form test

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

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

Added in Clojure version 1.0
Source

when-not

macro

Usage: (when-not test & body)

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

Added in Clojure version 1.0
Source

when-some

macro

with-out-str

macro

Usage: (with-out-str & body)

Evaluates exprs in a context in which out is bound to a fresh StringWriter. Returns the string created by any nested printing calls.

Added in Clojure version 1.0
Source

with-precision

macro

Usage: (with-precision precision & exprs)

Sets the precision and rounding mode to be used for BigDecimal operations.

Usage: (with-precision 10 (/ 1M 3)) or: (with-precision 10 :rounding HALF_DOWN (/ 1M 3))

The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN, HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP.

Added in Clojure version 1.0
Source

with-redefs

macro

Usage: (with-redefs bindings & body)

binding => var-symbol temp-value-expr

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

Added in Clojure version 1.3
Source

with-redefs-fn

function

Usage: (with-redefs-fn binding-map func)

Temporarily redefines Vars during a call to func. Each val of binding-map will replace the root value of its key which must be a Var. After func is called with no args, the root values of all the Vars will be set back to their old values. These temporary changes will be visible in all threads. Useful for mocking out functions during testing.

Added in Clojure version 1.3
Source

xml-seq

function

Usage: (xml-seq root)

A tree seq on the xml elements as per xml/parse

Added in Clojure version 1.0
Source

zero?

function

Usage: (zero? num)

Returns true if num is zero, else false

Added in Clojure version 1.0
Source

zipmap

function

Usage: (zipmap keys vals)

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

Added in Clojure version 1.0
Source

clojure.core - Clojure v1.12.0 API documentation (original) (raw)

Public Variables and Functions

&

*

*'

*1

*2

*3

*agent*

*assert*

*clojure-version*

*command-line-args*

*compile-files*

*compile-path*

*compiler-options*

*data-readers*

*default-data-reader-fn*

*e

*err*

*file*

*flush-on-newline*

*in*

*ns*

*out*

*print-dup*

*print-length*

*print-level*

*print-namespace-maps*

*print-readably*

*read-eval*

*repl*

*unchecked-math*

*warn-on-reflection*

+

+'

-

-'

->

->>

->ArrayChunk

->Eduction

->Vec

->VecNode

->VecSeq

.

..

/

<

<=

=

==

>

>=

NaN?

PrintWriter-on

StackTraceElement->vec

Throwable->map

abs

accessor

aclone

add-classpath

add-tap

add-watch

agent

agent-error

agent-errors

aget

alength

alias

all-ns

alter

alter-var-root

amap

ancestors

and

any?

apply

areduce

array-map

as->

agent

assert

clojure-version

command-line-args

compile-files

compile-path

compiler-options

data-readers

default-data-reader-fn

err

file

flush-on-newline

in

ns

out

print-dup

print-length

print-level

print-namespace-maps

print-readably

read-eval

repl

unchecked-math

warn-on-reflection