ports/lang/clojure/files/clj_completions

&
*
*'
*1
*2
*3
*agent*
*allow-unresolved-vars*
*assert*
*clojure-version*
*coll-check-limit*
*coll-error-limit*
*command-line-args*
*compile-asserts*
*compile-files*
*compile-path*
*compiler-options*
*data-readers*
*default-data-reader-fn*
*e
*err*
*explain-out*
*file*
*flush-on-newline*
*fn-loader*
*fspec-iterations*
*in*
*math-context*
*ns*
*out*
*print-dup*
*print-length*
*print-level*
*print-meta*
*print-namespace-maps*
*print-readably*
*read-eval*
*reader-resolver*
*recursion-limit*
*session*
*source-path*
*suppress-read*
*unchecked-math*
*use-context-classloader*
*verbose-defrecords*
*warn-on-reflection*
+
+'
-
-'
->
->>
->ArrayChunk
->Eduction
->Vec
->VecNode
->VecSeq
-cache-protocol-fn
-reset-methods
..
/
<
<=
=
==
>
>=
?
Coercions
CollReduce
Datafiable
EMPTY-NODE
IKVReduce
IOFactory
Inst
InternalReduce
Navigable
PrintWriter-on
Spec
Specize
StackTraceElement->vec
Throwable->map
abbrev
accessor
aclone
add-classpath
add-tap
add-watch
agent
agent-error
agent-errors
aget
alength
alias
all-ns
alt
alt-impl
alter
alter-meta!
alter-var-root
amap
amp-impl
ancestors
and
and-spec-impl
any
any-printable
any?
apply
areduce
array-map
as->
as-file
as-relative-path
as-url
aset
aset-boolean
aset-byte
aset-char
aset-double
aset-float
aset-int
aset-long
aset-short
assert
assert*
assoc
assoc!
assoc-in
associative?
atom
await
await-for
await1
bases
bean
bigdec
bigint
biginteger
bind
binding
bit-and
bit-and-not
bit-clear
bit-flip
bit-not
bit-or
bit-set
bit-shift-left
bit-shift-right
bit-test
bit-xor
blank?
boolean
boolean-array
boolean?
booleans
bound-fn
bound-fn*
bound?
bounded-count
butlast
byte
byte-array
bytes
bytes?
capitalize
case
cast
cat
cat-impl
char
char-alpha
char-alphanumeric
char-array
char-ascii
char-escape-string
char-name-string
char?
chars
check-asserts
check-asserts?
choose
chunk
chunk-append
chunk-buffer
chunk-cons
chunk-first
chunk-next
chunk-rest
chunked-seq?
class
class?
clear-agent-errors
clojure-version
coll-of
coll-reduce
coll?
comment
commute
comp
comparator
compare
compare-and-set!
compile
complement
completing
completions
concat
cond
cond->
cond->>
condp
conform
conform*
conformer
conj
conj!
cons
constantly
construct-proxy
contains?
copy
count
counted?
create-ns
create-struct
cycle
datafy
dec
dec'
decimal?
declare
dedupe
def
def-impl
default-data-readers
default-streams-impl
definline
definterface
defmacro
defmethod
defmulti
defn
defn-
defonce
defprotocol
defrecord
defstruct
deftype
delay
delay-impl
delay?
delete-file
deliver
demunge
denominator
deref
derive
descendants
describe
describe*
destructure
disj
disj!
dissoc
dissoc!
distinct
distinct?
doall
dorun
doseq
dosync
dotimes
doto
double
double*
double-array
double-in
double?
doubles
drop
drop-last
drop-while
eduction
elements
empty
empty?
ends-with?
ensure
ensure-reduced
enumeration-seq
err->msg
error-handler
error-mode
escape
eval
even?
every
every-impl
every-kv
every-pred
every?
ex-cause
ex-data
ex-info
ex-message
ex-str
ex-triage
exercise
exercise-fn
explain
explain*
explain-data
explain-data*
explain-out
explain-printer
explain-str
extend
extend-protocol
extend-type
extenders
extends?
false?
fdef
ffirst
file
file-seq
filter
filterv
find
find-keyword
find-ns
find-protocol-impl
find-protocol-method
find-var
first
flatten
float
float-array
float?
floats
flush
fmap
fn
fn?
fnext
fnil
for
for-all*
force
form
format
frequencies
frequency
fspec
fspec-impl
future
future-call
future-cancel
future-cancelled?
future-done?
future?
gen
gen*
gen-class
gen-for-name
gen-for-pred
gen-interface
generate
gensym
get
get-in
get-method
get-proxy-class
get-spec
get-thread-bindings
get-validator
group-by
halt-when
hash
hash-combine
hash-map
hash-ordered-coll
hash-set
hash-unordered-coll
ident?
identical?
identity
if-let
if-not
if-some
ifn?
import
in-ns
inc
inc'
includes?
index-of
indexed?
init-proxy
input-stream
inst-in
inst-in-range?
inst-ms
inst-ms*
inst?
instance?
int
int-array
int-in
int-in-range?
int?
integer?
interleave
intern
internal-reduce
interpose
into
into-array
ints
invalid?
io!
io-prepl
isa?
iterate
iterator-seq
join
juxt
keep
keep-indexed
key
keys
keys*
keyword
keyword-ns
keyword?
keywordize-keys
kv-reduce
large-integer
large-integer*
last
last-index-of
lazy-cat
lazy-combinator
lazy-combinators
lazy-prim
lazy-prims
lazy-seq
let
letfn
line-seq
list
list*
list?
load
load-file
load-reader
load-script
load-string
loaded-libs
locking
long
long-array
longs
loop
lower-case
macroexpand
macroexpand-1
macroexpand-all
main
make-array
make-hierarchy
make-input-stream
make-output-stream
make-parents
make-reader
make-writer
map
map-entry?
map-indexed
map-of
map-spec-impl
map?
mapcat
mapv
max
max-key
maybe-impl
memfn
memoize
merge
merge-spec-impl
merge-with
meta
method-sig
methods
min
min-key
mix-collection-hash
mod
multi-spec
multi-spec-impl
munge
name
namespace
namespace-munge
nat-int?
nav
neg-int?
neg?
newline
next
nfirst
nil?
nilable
nilable-impl
nnext
nonconforming
not
not-any?
not-empty
not-every?
not=
ns
ns-aliases
ns-imports
ns-interns
ns-map
ns-name
ns-publics
ns-refers
ns-resolve
ns-unalias
ns-unmap
nth
nthnext
nthrest
num
number?
numerator
object-array
odd?
one-of
or
or-spec-impl
output-stream
parents
parse-timestamp
partial
partition
partition-all
partition-by
pcalls
peek
persistent!
pmap
pop
pop!
pop-thread-bindings
pos-int?
pos?
postwalk
postwalk-demo
postwalk-replace
pr
pr-str
prefer-method
prefers
prepl
prewalk
prewalk-demo
prewalk-replace
primitives-classnames
print
print-ctor
print-dup
print-method
print-simple
print-str
printf
println
println-str
prn
prn-str
promise
proxy
proxy-call-with-super
proxy-mappings
proxy-name
proxy-super
push-thread-bindings
pvalues
qualified-ident?
qualified-keyword?
qualified-symbol?
quick-check
quot
rand
rand-int
rand-nth
random-sample
range
ratio
ratio?
rational?
rationalize
re-find
re-groups
re-matcher
re-matches
re-pattern
re-quote-replacement
re-seq
read
read+string
read-instant-calendar
read-instant-date
read-instant-timestamp
read-line
read-string
reader
reader-conditional
reader-conditional?
realized?
record?
reduce
reduce-kv
reduced
reduced?
reductions
ref
ref-history-count
ref-max-history
ref-min-history
ref-set
refer
refer-clojure
regex-spec-impl
regex?
registry
reify
release-pending-sends
rem
remote-prepl
remove
remove-all-methods
remove-method
remove-ns
remove-tap
remove-watch
renumbering-read
rep+impl
rep-impl
repeat
repeatedly
repl
repl-caught
repl-exception
repl-init
repl-prompt
repl-read
repl-requires
replace
replace-first
replicate
report-error
require
requiring-resolve
reset!
reset-meta!
reset-vals!
resolve
resource
rest
restart-agent
resultset-seq
return
reverse
reversible?
root-cause
rseq
rsubseq
run!
sample
satisfies?
second
select-keys
send
send-off
send-via
seq
seq?
seqable?
seque
sequence
sequential?
set
set-agent-send-executor!
set-agent-send-off-executor!
set-error-handler!
set-error-mode!
set-validator!
set?
short
short-array
shorts
shuffle
shutdown-agents
simple-ident?
simple-keyword?
simple-symbol?
simple-type
simple-type-printable
skip-if-eol
skip-whitespace
slurp
some
some->
some->>
some-fn
some?
sort
sort-by
sorted-map
sorted-map-by
sorted-set
sorted-set-by
sorted?
spec
spec-impl
spec?
special-symbol?
specize*
spit
split
split-at
split-lines
split-with
stack-element-str
start-server
start-servers
starts-with?
stop-server
stop-servers
str
string
string-alphanumeric
string-ascii
string?
stringify-keys
struct
struct-map
subs
subseq
subvec
such-that
supers
swap!
swap-vals!
symbol
symbol-ns
symbol?
sync
tagged-literal
tagged-literal?
take
take-last
take-nth
take-while
tap>
test
the-ns
thread-bound?
time
to-array
to-array-2d
trampoline
transduce
transient
tree-seq
trim
trim-newline
triml
trimr
true?
tuple
tuple-impl
type
unchecked-add
unchecked-add-int
unchecked-byte
unchecked-char
unchecked-dec
unchecked-dec-int
unchecked-divide-int
unchecked-double
unchecked-float
unchecked-inc
unchecked-inc-int
unchecked-int
unchecked-long
unchecked-multiply
unchecked-multiply-int
unchecked-negate
unchecked-negate-int
unchecked-remainder-int
unchecked-short
unchecked-subtract
unchecked-subtract-int
underive
unform
unform*
unquote
unquote-splicing
unreduced
unsigned-bit-shift-right
update
update-in
update-proxy
upper-case
uri?
use
uuid
uuid?
val
valid?
validated
vals
var-get
var-set
var?
vary-meta
vec
vector
vector-distinct
vector-of
vector?
volatile!
volatile?
vreset!
vswap!
walk
when
when-first
when-let
when-not
when-some
while
with-bindings
with-bindings*
with-gen
with-gen*
with-in-str
with-loading-context
with-local-vars
with-meta
with-open
with-out-str
with-precision
with-read-known
with-redefs
with-redefs-fn
writer
xml-seq
zero?
zipmap