ClojureDocs
Core Library
(1.11.1)
Quick Reference
Log In
Core Library
Overview
All The Vars
Namespaces
clojure.core
clojure.core.async
clojure.core.logic
clojure.core.logic.fd
clojure.core.logic.pldb
clojure.core.protocols
clojure.core.reducers
clojure.core.server
clojure.data
clojure.data.csv
clojure.datafy
clojure.edn
clojure.inspector
clojure.instant
clojure.java.browse
clojure.java.io
clojure.java.javadoc
clojure.java.shell
clojure.main
clojure.math
clojure.pprint
clojure.reflect
clojure.repl
clojure.set
clojure.spec.alpha
clojure.stacktrace
clojure.string
clojure.template
clojure.test
clojure.test.junit
clojure.test.tap
clojure.walk
clojure.xml
clojure.zip
ClojureDocs
Core Library
Quick Ref
Log In
ClojureDocs
Core Library
Quick Ref
Log In
Core Library
Overview
All Vars
Namespaces
clojure
core
async
logic
fd
pldb
protocols
reducers
server
data
csv
datafy
edn
inspector
instant
java
browse
io
javadoc
shell
main
math
pprint
reflect
repl
set
spec
alpha
stacktrace
string
template
test
junit
tap
walk
xml
zip
All Vars in Clojure's Core Library
clojure.core
*^%
.
+'
->Eduction
*print-namespace-maps*
=
<
*source-path*
..
*command-line-args*
-cache-protocol-fn
*read-eval*
*2
-reset-methods
*verbose-defrecords*
*print-level*
*suppress-read*
<=
-'
*
*print-length*
*file*
*use-context-classloader*
->
*err*
*default-data-reader-fn*
*allow-unresolved-vars*
*1
*print-meta*
>
->VecSeq
*compile-files*
*math-context*
-
*data-readers*
*e
*clojure-version*
*'
->Vec
*unchecked-math*
*out*
*warn-on-reflection*
*compile-path*
*in*
/
>=
->ArrayChunk
*3
+
->VecNode
*ns*
*assert*
*print-readably*
*flush-on-newline*
==
*agent*
*fn-loader*
*compiler-options*
*print-dup*
*reader-resolver*
->>
a
atom
aget
any?
aclone
aset-long
await
alength
aset-float
alter
alter-var-root
await1
areduce
add-tap
aset-double
as->
aset-boolean
associative?
aset-char
agent-errors
aset-short
amap
aset-byte
assoc!
assoc-in
alter-meta!
add-watch
agent-error
aset-int
agent
assert
add-classpath
accessor
ancestors
all-ns
array-map
alias
aset
abs
apply
assoc
and
await-for
b
bit-set
butlast
bit-shift-right
bound-fn
bases
boolean
bit-shift-left
boolean?
boolean-array
bit-xor
bean
booleans
biginteger
bound?
bit-and-not
bound-fn*
bigint
byte-array
bit-test
bit-and
bounded-count
bytes?
bit-or
bit-flip
binding
bit-clear
bigdec
bit-not
byte
bytes
c
catch
chunk-first
contains?
cond->>
chunk
compile
char?
char
comp
cons
cat
conj!
chunk-append
conj
compare-and-set!
cycle
chunk-rest
create-ns
construct-proxy
concat
cast
counted?
char-name-string
class?
cond->
clear-agent-errors
condp
cond
chunked-seq?
char-escape-string
chars
class
case
comment
count
clojure-version
chunk-cons
comparator
char-array
compare
complement
constantly
completing
create-struct
chunk-next
chunk-buffer
commute
coll?
d
def
do
decimal?
dec'
doall
dedupe
dissoc
dosync
dec
delay
dorun
disj
deliver
doseq
disj!
deftype
defstruct
doto
double
definline
definterface
double?
default-data-readers
double-array
defn
declare
dissoc!
defmethod
drop
dotimes
defonce
defn-
defprotocol
drop-last
distinct
descendants
derive
delay?
doubles
defmacro
distinct?
destructure
defmulti
deref
drop-while
defrecord
denominator
e
ensure
eduction
every?
enumeration-seq
ex-data
eval
error-mode
empty?
extend
even?
extends?
ex-cause
ex-message
extend-type
EMPTY-NODE
extend-protocol
ensure-reduced
empty
error-handler
ex-info
every-pred
extenders
f
finally
find-ns
first
fn?
find-var
future-call
future-done?
floats
fnil
find
float?
flush
format
find-protocol-impl
future
fn
filterv
force
float
ffirst
future?
future-cancelled?
file-seq
flatten
find-protocol-method
for
find-keyword
float-array
frequencies
filter
false?
future-cancel
fnext
g
get-thread-bindings
gen-class
gen-interface
get
group-by
gensym
get-method
get-proxy-class
get-validator
get-in
h
hash-ordered-coll
hash
hash-combine
hash-set
halt-when
hash-map
hash-unordered-coll
i
if
inst-ms
iterator-seq
iterate
import
isa?
inst?
if-not
int-array
inc'
if-some
interleave
identity
into
int
int?
inst-ms*
Inst
in-ns
indexed?
instance?
identical?
ident?
iteration
integer?
infinite?
intern
ifn?
inc
if-let
ints
io!
interpose
into-array
init-proxy
j
juxt
k
keep-indexed
keep
key
keyword?
keys
keyword
l
line-seq
last
load
lazy-seq
let
long
longs
load-reader
list*
loaded-libs
letfn
loop
long-array
load-string
load-file
locking
list
list?
lazy-cat
m
monitor-enter
monitor-exit
macroexpand
map
munge
make-hierarchy
mapcat
map-indexed
merge-with
min
map?
meta
method-sig
map-entry?
mod
macroexpand-1
memoize
memfn
mix-collection-hash
max-key
merge
mapv
min-key
methods
max
make-array
n
new
ns-unmap
newline
namespace
ns-publics
NaN?
nthrest
neg?
num
ns-unalias
nfirst
ns-aliases
not=
ns-resolve
ns-refers
namespace-munge
ns
name
nnext
not-every?
neg-int?
nth
nil?
not
ns-name
ns-map
not-empty
numerator
nat-int?
ns-interns
ns-imports
next
nthnext
number?
not-any?
o
or
object-array
odd?
p
primitives-classnames
proxy-mappings
println-str
prefers
print-method
peek
pvalues
pr
push-thread-bindings
PrintWriter-on
print-dup
pos?
pmap
pop!
prn-str
pop-thread-bindings
printf
pcalls
prn
promise
pr-str
pop
parse-double
println
persistent!
prefer-method
print
print-ctor
proxy-super
partition
partition-all
partition-by
print-simple
proxy-name
partial
pos-int?
proxy
parse-uuid
parents
parse-boolean
proxy-call-with-super
print-str
parse-long
q
quote
qualified-keyword?
quot
qualified-ident?
qualified-symbol?
r
recur
restart-agent
reduce
ref-min-history
reader-conditional
re-groups
read+string
remove-ns
random-uuid
rand-int
resultset-seq
rest
re-seq
remove-tap
reverse
range
rand-nth
refer
reduced?
repeatedly
reset-vals!
remove
re-pattern
reversible?
ref-set
reset-meta!
read
remove-all-methods
rand
replace
re-matcher
ref
rseq
reductions
ref-history-count
reduce-kv
reset!
requiring-resolve
require
rem
random-sample
reify
re-find
run!
record?
release-pending-sends
remove-method
read-line
reader-conditional?
ratio?
remove-watch
replicate
reduced
re-matches
rationalize
read-string
rsubseq
ref-max-history
rational?
realized?
resolve
repeat
refer-clojure
s
set!
sort-by
seq
subs
set
satisfies?
seq?
slurp
short-array
seq-to-map-for-destructuring
send-via
struct
set-error-mode!
set-agent-send-executor!
swap-vals!
some?
sort
spit
simple-symbol?
sequential?
shuffle
set?
StackTraceElement->vec
shutdown-agents
seque
short
string?
second
set-error-handler!
some->>
set-agent-send-off-executor!
symbol
sorted-set
simple-keyword?
some
struct-map
sorted?
split-at
select-keys
set-validator!
swap!
sorted-set-by
sync
special-symbol?
subseq
some->
subvec
send-off
split-with
str
some-fn
simple-ident?
supers
sorted-map-by
sorted-map
send
sequence
shorts
seqable?
symbol?
t
throw
try
tree-seq
take-last
take-nth
take
thread-bound?
test
take-while
transduce
trampoline
tagged-literal?
to-array-2d
tagged-literal
time
the-ns
type
tap>
true?
Throwable->map
to-array
transient
u
unchecked-remainder-int
unchecked-subtract-int
unchecked-long
unchecked-negate
unchecked-inc-int
unsigned-bit-shift-right
unchecked-float
update-vals
unchecked-add-int
unquote-splicing
unchecked-double
uri?
unchecked-multiply-int
unchecked-int
unchecked-multiply
unchecked-dec
use
unquote
unchecked-dec-int
update
update-in
unchecked-add
unreduced
unchecked-divide-int
unchecked-subtract
unchecked-byte
unchecked-short
uuid?
underive
update-keys
update-proxy
unchecked-negate-int
unchecked-inc
unchecked-char
v
var
vswap!
vector?
vreset!
var-set
vary-meta
volatile?
var?
vec
vector-of
val
vals
volatile!
vector
var-get
w
when-first
while
with-bindings*
with-loading-context
with-bindings
when-let
with-precision
when-not
when
with-open
with-meta
with-out-str
with-in-str
with-local-vars
with-redefs
with-redefs-fn
when-some
x
xml-seq
z
zipmap
zero?
clojure.core.async
*^%
>!!
>!
a
admix*
admix
alt!
alt!!
alts!
alts!!
b
buffer
c
close!
chan
d
dropping-buffer
defblockingop
do-alts
do-alt
f
filter<
filter>
fn-handler
g
go
go-loop
i
into
ioc-alts!
m
mix
map
Mux
mapcat>
muxch*
map>
Mult
merge
map<
Mix
mult
mapcat<
o
offer!
onto-chan!
onto-chan
onto-chan!!
p
Pub
pub
promise-chan
pipeline
pipe
partition
partition-by
poll!
pipeline-blocking
pipeline-async
put!
r
reduce
remove>
remove<
s
solo-mode*
solo-mode
sub
sub*
sliding-buffer
split
t
timeout
take
tap
transduce
to-chan
to-chan!
toggle
to-chan!!
tap*
thread
toggle*
thread-call
take!
u
unsub*
unmix*
unsub-all*
unique
untap-all
unmix
untap*
untap-all*
unsub-all
unmix-all*
unmix-all
untap
unsub
unblocking-buffer?
clojure.core.logic
*^%
-conjo
!=c
-predc
-reify*
*logic-dbs*
->Substitutions
->Pair
->LCons
-reify
->ConstraintStore
*locals*
->LVar
->AnswerCache
->Choice
->PMap
-fnm
->SubstValue
-featurec
-fixc
-run
-nafc
-inc
!=
==
->SuspendedStream
a
appendo
addcg
assoc-dom
and*
add-dom
assoc-meta
annotate
add-attr
answer-cache
all
add-var
b
bind*
bindable?
build
c
choice
conde
composeg*
cgoal
condu
constrain-tree
copy-term
conda
conso
conjo
composeg
d
dissoc-meta
defna
defnu
distincto
defnc
disunify
defne
distribute
dissoc-dom
defnm
e
empty-s
ext-run-csg
emptyo
enforce-constraints
ext
empty-f
enforceable-constrained
entailed?
everyg
env-locals
entangle
f
fnu
fk
fresh
fnc
fnm
fna
featurec
force-ans
fixc
fail
fne
firsto
fix-constraints
g
get-dom
get-attr
get-dom-fd
ground-term?
i
ientailed?
is
ifu*
ifa*
l
log
lcons?
lvar
llist
lcons
let-dom
lvaro
lvar?
lvars
m
master
matche
merge-with-root
matcha
mplus*
make-suspended-stream
member1o
map->PMap
membero
merge-doms
matchu
make-cs
map->SuspendedStream
map->SubstValue
n
nafc
normalize-store
nilo
nonlvaro
o
onceo
or*
occurs-check
p
partial-map
permuteo
pred
pair
predc
project
partial-map?
r
run-db*
rem-attr
recover-vars-from-term
recover-vars
reifyg
run-nc*
runcg
reify-lvar-name
reify-constraints
rembero
run
run-nc
run-constraints*
run-constraint
resto
run-constraints
rem-dom
remcg
run*
run-db
s
sort-by-member-count
seqc
s#
solutions
stopcg
sort-by-strategy
sync-eset
subst?
suspended-stream?
subst-val?
succeed
subst-val
t
to-subst-val
tabled-s
treec
to-stream
trace-s
tramp
tree-term?
tabled
trace-lvar
to-s
trace-lvars
u
unify-with-map*
unbound-rands
updatecg
unify
unify-with-pmap*
umi
unbound-names
update-pvars!
unify-with-sequential*
update-dom
u#
update-eset
uai
v
var-rands
verify-all-bound
w
waiting-stream-check
walk-record-term
walk*
waiting-stream?
clojure.core.logic.fd
*^%
->FiniteDomain
!=c
-member?
->MultiIntervalFD
<
->IntervalFD
-intervals
-intersection
<=
*
-drop-one
-distinct
<=c
>
-drop-before
-
-domc
-lb
==c
-disjoint?
>=
-distinctc
-difference
->fd
+
-ub
!=
==
*c
-keep-before
+c
b
bounded-listo
binops->fd
bounds
binops
d
domain
domc
dom
difference*
distinctc
disjoint?*
distinct
e
expand
ext-dom-fd
eq
eq-form
eq*
extend-to-fd
f
finite-domain?
g
get-dom
i
interval
interval?
in
intersection*
interval-<
IInterval
ISet
interval-<=
interval->=
interval->
ISortedDomain
IIntervals
l
list-sorted?
m
map-sum
multi-interval
n
normalize-intervals
p
process-dom
q
quot
r
resolve-storable-dom
s
singleton-dom?
sorted-set->domain
t
to-vals
u
unify-with-domain*
clojure.core.logic.pldb
c
contains-lvar?
d
db
db-facts
db-rel
db-retractions
db-fact
db-retraction
e
empty-db
f
facts-for
facts-using-index
g
ground?
i
index-for-query
indexed?
r
rel-key
rel-indexes
w
with-dbs
with-db
clojure.core.protocols
c
CollReduce
coll-reduce
d
Datafiable
datafy
i
IKVReduce
internal-reduce
InternalReduce
k
kv-reduce
n
Navigable
nav
clojure.core.reducers
*^%
->Cat
a
append!
c
cat
CollFold
coll-fold
d
drop
f
foldcat
folder
fold
flatten
filter
fjtask
m
map
mapcat
monoid
p
pool
r
reduce
reducer
remove
t
take
take-while
clojure.core.server
*^%
*session*
i
io-prepl
p
prepl
r
repl-init
repl-read
repl
remote-prepl
s
stop-server
start-server
start-servers
stop-servers
clojure.data
d
diff
diff-similar
Diff
e
equality-partition
EqualityPartition
clojure.data.csv
r
read-csv
Read-CSV-From
read-csv-from
w
write-csv
clojure.datafy
d
datafy
n
nav
clojure.edn
r
read
read-string
clojure.inspector
a
atom?
c
collection-tag
g
get-child-count
get-child
i
inspect-table
is-leaf
inspect
inspect-tree
l
list-provider
list-model
o
old-table-model
t
tree-model
table-model
clojure.instant
p
parse-timestamp
r
read-instant-timestamp
read-instant-calendar
read-instant-date
v
validated
clojure.java.browse
*^%
*open-url-script*
b
browse-url
clojure.java.io
a
as-relative-path
as-file
as-url
c
copy
Coercions
d
default-streams-impl
delete-file
f
file
i
input-stream
IOFactory
m
make-output-stream
make-parents
make-writer
make-reader
make-input-stream
o
output-stream
r
resource
reader
w
writer
clojure.java.javadoc
*^%
*core-java-api*
*feeling-lucky-url*
*local-javadocs*
*remote-javadocs*
*feeling-lucky*
a
add-local-javadoc
add-remote-javadoc
j
javadoc
clojure.java.shell
*^%
*sh-dir*
*sh-env*
s
sh
w
with-sh-dir
with-sh-env
clojure.main
d
demunge
e
err->msg
ex-str
ex-triage
l
load-script
m
main
r
repl-caught
repl-exception
repl-read
report-error
root-cause
repl-requires
renumbering-read
repl
repl-prompt
s
stack-element-str
skip-if-eol
skip-whitespace
w
with-bindings
with-read-known
clojure.math
a
acos
atan2
atan
add-exact
asin
c
ceil
cos
cbrt
cosh
copy-sign
d
decrement-exact
e
expm1
exp
E
f
floor
floor-mod
floor-div
g
get-exponent
h
hypot
i
IEEE-remainder
increment-exact
l
log
log10
log1p
m
multiply-exact
n
next-after
next-down
next-up
negate-exact
p
PI
pow
r
round
rint
random
s
sqrt
subtract-exact
scalb
sinh
sin
signum
t
to-radians
to-degrees
tanh
tan
u
ulp
clojure.pprint
*^%
*print-suppress-namespaces*
*print-pretty*
*print-pprint-dispatch*
*print-radix*
*print-miser-width*
*print-right-margin*
*print-base*
c
code-dispatch
cl-format
f
fresh-line
formatter-out
formatter
g
get-pretty-writer
p
pprint
pprint-newline
print-length-loop
pprint-tab
pprint-logical-block
print-table
pp
pprint-indent
s
simple-dispatch
set-pprint-dispatch
w
write
write-out
with-pprint-dispatch
clojure.reflect
*^%
->Field
->Method
->JavaReflector
->AsmReflector
->Constructor
c
ClassResolver
d
do-reflect
f
flag-descriptors
m
map->Field
map->Method
map->Constructor
r
reflect
resolve-class
Reflector
t
TypeReference
typename
type-reflect
clojure.repl
a
apropos
d
doc
dir
dir-fn
demunge
f
find-doc
p
pst
r
root-cause
s
source-fn
stack-element-str
source
set-break-handler!
t
thread-stopper
clojure.set
d
difference
i
intersection
index
j
join
m
map-invert
p
project
r
rename
rename-keys
s
select
superset?
subset?
u
union
clojure.spec.alpha
*^%
&
*recursion-limit*
*coll-error-limit*
*explain-out*
*
*fspec-iterations*
?
*coll-check-limit*
+
*compile-asserts*
a
alt-impl
assert*
and-spec-impl
alt
abbrev
assert
amp-impl
and
c
check-asserts
coll-of
cat
conform
conformer
cat-impl
conform*
check-asserts?
d
def-impl
describe*
double-in
describe
def
e
explain-printer
every
explain-data*
explain
every-kv
exercise-fn
exercise
explain-data
every-impl
explain-str
explain-out
explain*
f
form
fspec
fspec-impl
fdef
g
gen
gen*
get-spec
i
inst-in-range?
int-in
int-in-range?
invalid?
inst-in
k
keys*
keys
m
merge-spec-impl
map-spec-impl
multi-spec
multi-spec-impl
merge
map-of
maybe-impl
n
nilable-impl
nilable
nonconforming
o
or-spec-impl
or
r
regex-spec-impl
regex?
registry
rep+impl
rep-impl
s
Specize
Spec
spec?
spec
spec-impl
specize*
t
tuple-impl
tuple
u
unform
unform*
v
valid?
w
with-gen*
with-gen
clojure.stacktrace
e
e
p
print-stack-trace
print-trace-element
print-cause-trace
print-throwable
r
root-cause
clojure.string
b
blank?
c
capitalize
e
ends-with?
escape
i
includes?
index-of
j
join
l
last-index-of
lower-case
r
reverse
replace-first
re-quote-replacement
replace
s
starts-with?
split-lines
split
t
trim-newline
trimr
trim
triml
u
upper-case
clojure.template
a
apply-template
d
do-template
clojure.test
*^%
*stack-trace-depth*
*report-counters*
*load-tests*
*testing-contexts*
*testing-vars*
*test-out*
*initial-report-counters*
a
are
assert-any
assert-expr
assert-predicate
c
compose-fixtures
d
do-report
deftest
deftest-
f
file-position
function?
g
get-possibly-unbound-var
i
is
inc-report-counter
j
join-fixtures
r
run-all-tests
report
run-test-var
run-test
run-tests
s
set-test
successful?
t
test-all-vars
test-var
testing-contexts-str
testing
test-vars
try-expr
testing-vars-str
test-ns
u
use-fixtures
w
with-test
with-test-out
clojure.test.junit
*^%
*depth*
*var-context*
e
element-content
error-el
f
finish-suite
finish-element
failure-el
finish-case
i
indent
j
junit-report
m
message-el
p
package-class
s
start-case
suite-attrs
start-suite
start-element
t
test-name
w
with-junit-output
clojure.test.tap
p
print-tap-fail
print-tap-pass
print-diagnostics
print-tap-plan
print-tap-diagnostic
t
tap-report
w
with-tap-output
clojure.walk
k
keywordize-keys
m
macroexpand-all
p
postwalk
prewalk-replace
prewalk
postwalk-demo
prewalk-demo
postwalk-replace
s
stringify-keys
w
walk
clojure.xml
*^%
*sb*
*state*
*stack*
*current*
a
attrs
c
content
content-handler
d
disable-external-entities
e
element
emit
emit-element
p
parse
s
sax-parser
startparse-sax
startparse-sax-safe
t
tag
clojure.zip
a
append-child
b
branch?
c
children
d
down
e
end?
edit
i
insert-child
insert-right
insert-left
l
left
leftmost
lefts
m
make-node
n
node
next
p
path
prev
r
rightmost
remove
replace
rights
root
right
s
seq-zip
u
up
v
vector-zip
x
xml-zip
z
zipper