corelib.org

*

*’

*1

*2

*3

agent

allow-unresolved-vars

assert

clojure-version

command-line-args

compile-files

compile-path

*e

err

file

flush-on-newline

fn-loader

in

math-context

ns

out

print-dup

print-length

print-level

print-meta

print-readably

read-eval

source-path

unchecked-math

does what?

use-context-classloader

verbose-defrecords

warn-on-reflection

+

+’

-

-’

->

->>

->ArrayChunk

->Vec

->VecNode

->VecSeq

-cache-protocol-fn

-reset-methods

..

/

<

<=

=

==

>

>=

EMPTY-NODE

accessor

aclone

add-classpath

add-watch

agent

agent-error

agent-errors

aget

alength

alias

all-ns

alter

alter-meta!

alter-var-root

amap

ancestors

and

apply

areduce

array-map

aset

aset-boolean

aset-byte

aset-char

aset-double

aset-float

aset-int

aset-long

aset-short

assert

assoc

assoc!

assoc-in

associative?

atom

await

await-for

await1

bases

bean

bigdec

bigint

biginteger

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

boolean

boolean-array

booleans

bound-fn

bound-fn*

bound?

butlast

byte

byte-array

bytes

case

cast

char

char-array

char-escape-string

char-name-string

char?

chars

chunk

chunk-append

chunk-buffer

chunk-cons

chunk-first

chunk-next

chunk-rest

chunked-seq?

class

class?

clear-agent-errors

clojure-version

coll?

comment

commute

comp

comparator

compare

compare-and-set!

compile

complement

concat

cond

condp

conj

conj!

cons

constantly

construct-proxy

contains?

count

counted?

create-ns

create-struct

cycle

dec

dec’

decimal?

declare

definline

definterface

defmacro

defmethod

defmulti

defn

defn-

defonce

defprotocol

defrecord

defstruct

deftype

delay

delay?

deliver

denominator

deref

derive

descendants

destructure

For macros only, uses clojure.core version

disj

disj!

dissoc

dissoc!

distinct

distinct?

doall

dorun

doseq

dosync

dotimes

doto

double

double-array

doubles

drop

drop-last

drop-while

empty

empty?

ensure

enumeration-seq

error-handler

error-mode

eval

even?

every-pred

every?

extend

maybe not?

extend-protocol

macro currently expands into extend call

extend-type

extenders

extends?

false?

ffirst

file-seq

filter

find

find-keyword

find-ns

find-protocol-impl

find-protocol-method

find-var

first

flatten

float

float-array

float?

floats

flush

fn

fn?

fnext

fnil

for

force

format

frequencies

future

future-call

future-cancel

future-cancelled?

future-done?

future?

gen-class

gen-interface

gensym

get

get-in

get-method

get-proxy-class

get-thread-bindings

get-validator

group-by

hash

hash-combine

hash-map

hash-set

identical?

identity

if-let

if-not

ifn?

import

in-ns

inc

inc’

init-proxy

instance?

does what?

int

int-array

integer?

interleave

intern

interpose

into

into-array

ints

io!

isa?

does what?

iterate

iterator-seq

juxt

keep

keep-indexed

key

keys

keyword

keyword?

last

lazy-cat

lazy-seq

let

letfn

needs compiler letfn*

line-seq

list

list*

list?

load

load-file

load-reader

load-string

loaded-libs

locking

long

long-array

longs

loop

macroexpand

macroexpand-1

make-array

make-hierarchy

map

map-indexed

map?

mapcat

max

max-key

memfn

memoize

merge

merge-with

meta

method-sig

methods

min

min-key

mod

munge

name

namespace

namespace-munge

neg?

newline

next

nfirst

nil?

nnext

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

num

number?

numerator

object-array

odd?

or

parents

partial

partition

partition-all

partition-by

pcalls

peek

persistent!

pmap

pop

pop!

pop-thread-bindings

pos?

pr

dunno about printing

pr-str

prefer-method

prefers

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

quot

rand

rand-int

rand-nth

range

ratio?

rational?

rationalize

re-find

dunno about regex

re-groups

re-matcher

re-matches

re-pattern

re-seq

read

read-line

read-string

realized?

reduce

reductions

ref

ref-history-count

ref-max-history

ref-min-history

ref-set

refer

refer-clojure

reify

specify - make a particular object extend a protocol

release-pending-sends

rem

remove

remove-all-methods

remove-method

remove-ns

remove-watch

repeat

repeatedly

replace

replicate

require

ticket #8

reset!

reset-meta!

resolve

rest

restart-agent

resultset-seq

reverse

reversible?

rseq

rsubseq

satisfies?

as macro

second

select-keys

send

send-off

seq

seq?

seque

sequence

sequential?

set

set-error-handler!

set-error-mode!

set-validator!

set?

short

short-array

shorts

shuffle

shutdown-agents

slurp

some

some-fn

sort

sort-by

sorted-map

sorted-map-by

sorted-set

sorted-set-by

sorted?

special-symbol?

spit

split-at

split-with

str

string?

struct

struct-map

subs

subseq

subvec

supers

swap!

symbol

symbol?

sync

take

take-last

take-nth

take-while

test

the-ns

thread-bound?

time

to-array

to-array-2d

trampoline

transient

tree-seq

true?

type - returns JS constructor

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

unquote

unquote-splicing

update-in

update-proxy

use

val

vals

var-get

var-set

var?

vary-meta

vec

vector

vector-of

vector?

when

when-first

when-let

when-not

while

with-bindings

with-bindings*

with-in-str

with-loading-context

with-local-vars

with-meta

with-open

with-out-str

with-precision

with-redefs

with-redefs-fn

xml-seq

zero?

zipmap