; Copyright (c) Rich Hickey. All rights reserved.

; The use and distribution terms for this software are covered by the

; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)

; which can be found in the file epl-v10.html at the root of this distribution.

; By using this software in any fashion, you are agreeing to be bound by

; the terms of this license.

; You must not remove this notice, or any other, from this software.

(ns ^{:doc "The core Clojure language."

:author "Rich Hickey"}

clojure.core)

(def unquote)

(def unquote-splicing)

(def

^{:arglists '([& items])

:doc "Creates a new list containing the items."

:added "1.0"}

list (. clojure.lang.PersistentList creator))

(def

^{:arglists '([x seq])

:doc "Returns a new seq where x is the first element and seq is

the rest."

:added "1.0"

:static true}

cons (fn* ^:static cons [x seq] (. clojure.lang.RT (cons x seq))))

;during bootstrap we don't have destructuring let, loop or fn, will redefine later

(def

^{:macro true

:added "1.0"}

let (fn* let [&form &env & decl] (cons 'let* decl)))

(def

^{:macro true

:added "1.0"}

loop (fn* loop [&form &env & decl] (cons 'loop* decl)))

(def

^{:macro true

:added "1.0"}

fn (fn* fn [&form &env & decl]

(.withMeta ^clojure.lang.IObj (cons 'fn* decl)

(.meta ^clojure.lang.IMeta &form))))

(def

^{:arglists '([coll])

:doc "Returns the first item in the collection. Calls seq on its

argument. If coll is nil, returns nil."

:added "1.0"

:static true}

first (fn ^:static first [coll] (. clojure.lang.RT (first coll))))

(def

^{:arglists '([coll])

:tag clojure.lang.ISeq

:doc "Returns a seq of the items after the first. Calls seq on its

argument. If there are no more items, returns nil."

:added "1.0"

:static true}

next (fn ^:static next [x] (. clojure.lang.RT (next x))))

(def

^{:arglists '([coll])

:tag clojure.lang.ISeq

:doc "Returns a possibly empty seq of the items after the first. Calls seq on its

argument."

:added "1.0"

:static true}

rest (fn ^:static rest [x] (. clojure.lang.RT (more x))))

(def

^{:arglists '([coll x] [coll x & xs])

:doc "conj[oin]. Returns a new collection with the xs

'added'. (conj nil item) returns (item). The 'addition' may

happen at different 'places' depending on the concrete type."

:added "1.0"

:static true}

conj (fn ^:static conj

([coll x] (. clojure.lang.RT (conj coll x)))

([coll x & xs]

(if xs

(recur (conj coll x) (first xs) (next xs))

(conj coll x)))))

(def

^{:doc "Same as (first (next x))"

:arglists '([x])

:added "1.0"

:static true}

second (fn ^:static second [x] (first (next x))))

(def

^{:doc "Same as (first (first x))"

:arglists '([x])

:added "1.0"

:static true}

ffirst (fn ^:static ffirst [x] (first (first x))))

(def

^{:doc "Same as (next (first x))"

:arglists '([x])

:added "1.0"

:static true}

nfirst (fn ^:static nfirst [x] (next (first x))))

(def

^{:doc "Same as (first (next x))"

:arglists '([x])

:added "1.0"

:static true}

fnext (fn ^:static fnext [x] (first (next x))))

(def

^{:doc "Same as (next (next x))"

:arglists '([x])

:added "1.0"

:static true}

nnext (fn ^:static nnext [x] (next (next x))))

(def

^{:arglists '(^clojure.lang.ISeq [coll])

:doc "Returns a seq on the collection. If the collection is

empty, returns nil. (seq nil) returns nil. seq also works on

Strings, native Java arrays (of reference types) and any objects

that implement Iterable."

:tag clojure.lang.ISeq

:added "1.0"

:static true}

seq (fn ^:static seq ^clojure.lang.ISeq [coll] (. clojure.lang.RT (seq coll))))

(def

^{:arglists '([^Class c x])

:doc "Evaluates x and tests if it is an instance of the class

c. Returns true or false"

:added "1.0"}

instance? (fn instance? [^Class c x] (. c (isInstance x))))

(def

^{:arglists '([x])

:doc "Return true if x implements ISeq"

:added "1.0"

:static true}

seq? (fn ^:static seq? [x] (instance? clojure.lang.ISeq x)))

(def

^{:arglists '([x])

:doc "Return true if x is a Character"

:added "1.0"

:static true}

char? (fn ^:static char? [x] (instance? Character x)))

(def

^{:arglists '([x])

:doc "Return true if x is a String"

:added "1.0"

:static true}

string? (fn ^:static string? [x] (instance? String x)))

(def

^{:arglists '([x])

:doc "Return true if x implements IPersistentMap"

:added "1.0"

:static true}

map? (fn ^:static map? [x] (instance? clojure.lang.IPersistentMap x)))

(def

^{:arglists '([x])

:doc "Return true if x implements IPersistentVector"

:added "1.0"

:static true}

vector? (fn ^:static vector? [x] (instance? clojure.lang.IPersistentVector x)))

(def

^{:arglists '([map key val] [map key val & kvs])

:doc "assoc[iate]. When applied to a map, returns a new map of the

same (hashed/sorted) type, that contains the mapping of key(s) to

val(s). When applied to a vector, returns a new vector that

contains val at index. Note - index must be <= (count vector)."

:added "1.0"

:static true}

assoc

(fn ^:static assoc

([map key val] (. clojure.lang.RT (assoc map key val)))

([map key val & kvs]

(let [ret (assoc map key val)]

(if kvs

(recur ret (first kvs) (second kvs) (nnext kvs))

ret)))))

;;;;;;;;;;;;;;;;; metadata ;;;;;;;;;;;;;;;;;;;;;;;;;;;

(def

^{:arglists '([obj])

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

:added "1.0"

:static true}

meta (fn ^:static meta [x]

(if (instance? clojure.lang.IMeta x)

(. ^clojure.lang.IMeta x (meta)))))

(def

^{:arglists '([^clojure.lang.IObj obj m])

:doc "Returns an object of the same type and value as obj, with

map m as its metadata."

:added "1.0"

:static true}

with-meta (fn ^:static with-meta [^clojure.lang.IObj x m]

(. x (withMeta m))))

(def ^{:private true :dynamic true}

assert-valid-fdecl (fn [fdecl]))

(def

^{:private true}

sigs

(fn [fdecl]

(assert-valid-fdecl fdecl)

(let [asig

(fn [fdecl]

(let [arglist (first fdecl)

;elide implicit macro args

arglist (if (clojure.lang.Util/equals '&form (first arglist))

(clojure.lang.RT/subvec arglist 2 (clojure.lang.RT/count arglist))

arglist)

body (next fdecl)]

(if (map? (first body))

(if (next body)

(with-meta arglist (conj (if (meta arglist) (meta arglist) {}) (first body)))

arglist)

arglist)))]

(if (seq? (first fdecl))

(loop [ret [] fdecls fdecl]

(if fdecls

(recur (conj ret (asig (first fdecls))) (next fdecls))

(seq ret)))

(list (asig fdecl))))))

(def

^{:arglists '([coll])

:doc "Return the last item in coll, in linear time"

:added "1.0"

:static true}

last (fn ^:static last [s]

(if (next s)

(recur (next s))

(first s))))

(def

^{:arglists '([coll])

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

:added "1.0"

:static true}

butlast (fn ^:static butlast [s]

(loop [ret [] s s]

(if (next s)

(recur (conj ret (first s)) (next s))

(seq ret)))))

(def

^{:doc "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."

:arglists '([name doc-string? attr-map? [params*] prepost-map? body]

[name doc-string? attr-map? ([params*] prepost-map? body)+ attr-map?])

:added "1.0"}

defn (fn defn [&form &env name & fdecl]

(let [m (if (string? (first fdecl))

{:doc (first fdecl)}

{})

fdecl (if (string? (first fdecl))

(next fdecl)

fdecl)

m (if (map? (first fdecl))

(conj m (first fdecl))

m)

fdecl (if (map? (first fdecl))

(next fdecl)

fdecl)

fdecl (if (vector? (first fdecl))

(list fdecl)

fdecl)

m (if (map? (last fdecl))

(conj m (last fdecl))

m)

fdecl (if (map? (last fdecl))

(butlast fdecl)

fdecl)

m (conj {:arglists (list 'quote (sigs fdecl))} m)

m (let [inline (:inline m)

ifn (first inline)

iname (second inline)]

;; same as: (if (and (= 'fn ifn) (not (symbol? iname))) ...)

(if (if (clojure.lang.Util/equiv 'fn ifn)

(if (instance? clojure.lang.Symbol iname) false true))

;; inserts the same fn name to the inline fn if it does not have one

(assoc m :inline (cons ifn (cons (clojure.lang.Symbol/intern (.concat (.getName ^clojure.lang.Symbol name) "__inliner"))

(next inline))))

m))

m (conj (if (meta name) (meta name) {}) m)]

(list 'def (with-meta name m)

;;todo - restore propagation of fn name

;;must figure out how to convey primitive hints to self calls first

(cons `fn fdecl) ))))

(. (var defn) (setMacro))

(defn cast

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

{:added "1.0"

:static true}

[^Class c x]

(. c (cast x)))

(defn to-array

"Returns an array of Objects containing the contents of coll, which

can be any Collection. Maps to java.util.Collection.toArray()."

{:tag "[Ljava.lang.Object;"

:added "1.0"

:static true}

[coll] (. clojure.lang.RT (toArray coll)))

(defn vector

"Creates a new vector containing the args."

{:added "1.0"

:static true}

([] [])

([a] [a])

([a b] [a b])

([a b c] [a b c])

([a b c d] [a b c d])

([a b c d & args]

(. clojure.lang.LazilyPersistentVector (create (cons a (cons b (cons c (cons d args))))))))

(defn vec

"Creates a new vector containing the contents of coll."

{:added "1.0"

:static true}

([coll]

(if (instance? java.util.Collection coll)

(clojure.lang.LazilyPersistentVector/create coll)

(. clojure.lang.LazilyPersistentVector (createOwning (to-array coll))))))

(defn hash-map

"keyval => key val

Returns a new hash map with supplied mappings."

{:added "1.0"

:static true}

([] {})

([& keyvals]

(. clojure.lang.PersistentHashMap (createWithCheck keyvals))))

(defn hash-set

"Returns a new hash set with supplied keys."

{:added "1.0"

:static true}

([] #{})

([& keys]

(clojure.lang.PersistentHashSet/createWithCheck keys)))

(defn sorted-map

"keyval => key val

Returns a new sorted map with supplied mappings."

{:added "1.0"

:static true}

([& keyvals]

(clojure.lang.PersistentTreeMap/create keyvals)))

(defn sorted-map-by

"keyval => key val

Returns a new sorted map with supplied mappings, using the supplied comparator."

{:added "1.0"

:static true}

([comparator & keyvals]

(clojure.lang.PersistentTreeMap/create comparator keyvals)))

(defn sorted-set

"Returns a new sorted set with supplied keys."

{:added "1.0"

:static true}

([& keys]

(clojure.lang.PersistentTreeSet/create keys)))

(defn sorted-set-by

"Returns a new sorted set with supplied keys, using the supplied comparator."

{:added "1.1"

:static true}

([comparator & keys]

(clojure.lang.PersistentTreeSet/create comparator keys)))

;;;;;;;;;;;;;;;;;;;;

(defn nil?

"Returns true if x is nil, false otherwise."

{:tag Boolean

:added "1.0"

:static true

:inline (fn [x] (list 'clojure.lang.Util/identical x nil))}

[x] (clojure.lang.Util/identical x nil))

(def

^{:doc "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."

:arglists '([name doc-string? attr-map? [params*] body]

[name doc-string? attr-map? ([params*] body)+ attr-map?])

:added "1.0"}

defmacro (fn [&form &env

name & args]

(let [prefix (loop [p (list name) args args]

(let [f (first args)]

(if (string? f)

(recur (cons f p) (next args))

(if (map? f)

(recur (cons f p) (next args))

p))))

fdecl (loop [fd args]

(if (string? (first fd))

(recur (next fd))

(if (map? (first fd))

(recur (next fd))

fd)))

fdecl (if (vector? (first fdecl))

(list fdecl)

fdecl)

add-implicit-args (fn [fd]

(let [args (first fd)]

(cons (vec (cons '&form (cons '&env args))) (next fd))))

add-args (fn [acc ds]

(if (nil? ds)

acc

(let [d (first ds)]

(if (map? d)

(conj acc d)

(recur (conj acc (add-implicit-args d)) (next ds))))))

fdecl (seq (add-args [] fdecl))

decl (loop [p prefix d fdecl]

(if p

(recur (next p) (cons (first p) d))

d))]

(list 'do

(cons `defn decl)

(list '. (list 'var name) '(setMacro))

(list 'var name)))))

(. (var defmacro) (setMacro))

(defmacro when

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

{:added "1.0"}

[test & body]

(list 'if test (cons 'do body)))

(defmacro when-not

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

{:added "1.0"}

[test & body]

(list 'if test nil (cons 'do body)))

(defn false?

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

{:tag Boolean,

:added "1.0"

:static true}

[x] (clojure.lang.Util/identical x false))

(defn true?

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

{:tag Boolean,

:added "1.0"

:static true}

[x] (clojure.lang.Util/identical x true))

(defn not

"Returns true if x is logical false, false otherwise."

{:tag Boolean

:added "1.0"

:static true}

[x] (if x false true))

(defn str

"With no args, returns the empty string. With one arg x, returns

x.toString(). (str nil) returns the empty string. With more than

one arg, returns the concatenation of the str values of the args."

{:tag String

:added "1.0"

:static true}

(^String [] "")

(^String [^Object x]

(if (nil? x) "" (. x (toString))))

(^String [x & ys]

((fn [^StringBuilder sb more]

(if more

(recur (. sb (append (str (first more)))) (next more))

(str sb)))

(new StringBuilder (str x)) ys)))

(defn symbol?

"Return true if x is a Symbol"

{:added "1.0"

:static true}

[x] (instance? clojure.lang.Symbol x))

(defn keyword?

"Return true if x is a Keyword"

{:added "1.0"

:static true}

[x] (instance? clojure.lang.Keyword x))

(defn symbol

"Returns a Symbol with the given namespace and name."

{:tag clojure.lang.Symbol

:added "1.0"

:static true}

([name] (if (symbol? name) name (clojure.lang.Symbol/intern name)))

([ns name] (clojure.lang.Symbol/intern ns name)))

(defn gensym

"Returns a new symbol with a unique name. If a prefix string is

supplied, the name is prefix# where # is some unique number. If

prefix is not supplied, the prefix is 'G__'."

{:added "1.0"

:static true}

([] (gensym "G__"))

([prefix-string] (. clojure.lang.Symbol (intern (str prefix-string (str (. clojure.lang.RT (nextID))))))))

(defmacro cond

"Takes a set of test/expr pairs. It evaluates each test one at a

time. If a test returns logical true, cond evaluates and returns

the value of the corresponding expr and doesn't evaluate any of the

other tests or exprs. (cond) returns nil."

{:added "1.0"}

[& clauses]

(when clauses

(list 'if (first clauses)

(if (next clauses)

(second clauses)

(throw (IllegalArgumentException.

"cond requires an even number of forms")))

(cons 'clojure.core/cond (next (next clauses))))))

(defn keyword

"Returns a Keyword with the given namespace and name. Do not use :

in the keyword strings, it will be added automatically."

{:tag clojure.lang.Keyword

:added "1.0"

:static true}

([name] (cond (keyword? name) name

(symbol? name) (clojure.lang.Keyword/intern ^clojure.lang.Symbol name)

(string? name) (clojure.lang.Keyword/intern ^String name)))

([ns name] (clojure.lang.Keyword/intern ns name)))

(defn find-keyword

"Returns a Keyword with the given namespace and name if one already

exists. This function will not intern a new keyword. If the keyword

has not already been interned, it will return nil. Do not use :

in the keyword strings, it will be added automatically."

{:tag clojure.lang.Keyword

:added "1.3"

:static true}

([name] (cond (keyword? name) name

(symbol? name) (clojure.lang.Keyword/find ^clojure.lang.Symbol name)

(string? name) (clojure.lang.Keyword/find ^String name)))

([ns name] (clojure.lang.Keyword/find ns name)))

(defn spread

{:private true

:static true}

[arglist]

(cond

(nil? arglist) nil

(nil? (next arglist)) (seq (first arglist))

:else (cons (first arglist) (spread (next arglist)))))

(defn list*

"Creates a new list containing the items prepended to the rest, the

last of which will be treated as a sequence."

{:added "1.0"

:static true}

([args] (seq args))

([a args] (cons a args))

([a b args] (cons a (cons b args)))

([a b c args] (cons a (cons b (cons c args))))

([a b c d & more]

(cons a (cons b (cons c (cons d (spread more)))))))

(defn apply

"Applies fn f to the argument list formed by prepending intervening arguments to args."

{:added "1.0"

:static true}

([^clojure.lang.IFn f args]

(. f (applyTo (seq args))))

([^clojure.lang.IFn f x args]

(. f (applyTo (list* x args))))

([^clojure.lang.IFn f x y args]

(. f (applyTo (list* x y args))))

([^clojure.lang.IFn f x y z args]

(. f (applyTo (list* x y z args))))

([^clojure.lang.IFn f a b c d & args]

(. f (applyTo (cons a (cons b (cons c (cons d (spread args)))))))))

(defn vary-meta

"Returns an object of the same type and value as obj, with

(apply f (meta obj) args) as its metadata."

{:added "1.0"

:static true}

[obj f & args]

(with-meta obj (apply f (meta obj) args)))

(defmacro lazy-seq

"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 "1.0"}

[& body]

(list 'new 'clojure.lang.LazySeq (list* '^{:once true} fn* [] body)))

(defn ^:static ^clojure.lang.ChunkBuffer chunk-buffer ^clojure.lang.ChunkBuffer [capacity]

(clojure.lang.ChunkBuffer. capacity))

(defn ^:static chunk-append [^clojure.lang.ChunkBuffer b x]

(.add b x))

(defn ^:static ^clojure.lang.IChunk chunk [^clojure.lang.ChunkBuffer b]

(.chunk b))

(defn ^:static ^clojure.lang.IChunk chunk-first ^clojure.lang.IChunk [^clojure.lang.IChunkedSeq s]

(.chunkedFirst s))

(defn ^:static ^clojure.lang.ISeq chunk-rest ^clojure.lang.ISeq [^clojure.lang.IChunkedSeq s]

(.chunkedMore s))

(defn ^:static ^clojure.lang.ISeq chunk-next ^clojure.lang.ISeq [^clojure.lang.IChunkedSeq s]

(.chunkedNext s))

(defn ^:static chunk-cons [chunk rest]

(if (clojure.lang.Numbers/isZero (clojure.lang.RT/count chunk))

rest

(clojure.lang.ChunkedCons. chunk rest)))

(defn ^:static chunked-seq? [s]

(instance? clojure.lang.IChunkedSeq s))

(defn concat

"Returns a lazy seq representing the concatenation of the elements in the supplied colls."

{:added "1.0"

:static true}

([] (lazy-seq nil))

([x] (lazy-seq x))

([x y]

(lazy-seq

(let [s (seq x)]

(if s

(if (chunked-seq? s)

(chunk-cons (chunk-first s) (concat (chunk-rest s) y))

(cons (first s) (concat (rest s) y)))

y))))

([x y & zs]

(let [cat (fn cat [xys zs]

(lazy-seq

(let [xys (seq xys)]

(if xys

(if (chunked-seq? xys)

(chunk-cons (chunk-first xys)

(cat (chunk-rest xys) zs))

(cons (first xys) (cat (rest xys) zs)))

(when zs

(cat (first zs) (next zs)))))))]

(cat (concat x y) zs))))

;;;;;;;;;;;;;;;;at this point all the support for syntax-quote exists;;;;;;;;;;;;;;;;;;;;;;

(defmacro delay

"Takes a body of expressions and yields a Delay object that will

invoke the body only the first time it is forced (with force or deref/@), and

will cache the result and return it on all subsequent force

calls. See also - realized?"

{:added "1.0"}

[& body]

(list 'new 'clojure.lang.Delay (list* `^{:once true} fn* [] body)))

(defn delay?

"returns true if x is a Delay created with delay"

{:added "1.0"

:static true}

[x] (instance? clojure.lang.Delay x))

(defn force

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

{:added "1.0"

:static true}

[x] (. clojure.lang.Delay (force x)))

(defmacro if-not

"Evaluates test. If logical false, evaluates and returns then expr,

otherwise else expr, if supplied, else nil."

{:added "1.0"}

([test then] `(if-not ~test ~then nil))

([test then else]

`(if (not ~test) ~then ~else)))

(defn identical?

"Tests if 2 arguments are the same object"

{:inline (fn [x y] `(. clojure.lang.Util identical ~x ~y))

:inline-arities #{2}

:added "1.0"}

([x y] (clojure.lang.Util/identical x y)))

;equiv-based

(defn =

"Equality. Returns true if x equals y, false if not. Same as

Java x.equals(y) except it also works for nil, and compares

numbers and collections in a type-independent manner. Clojure's immutable data

structures define equals() (and thus =) as a value, not an identity,

comparison."

{:inline (fn [x y] `(. clojure.lang.Util equiv ~x ~y))

:inline-arities #{2}

:added "1.0"}

([x] true)

([x y] (clojure.lang.Util/equiv x y))

([x y & more]

(if (clojure.lang.Util/equiv x y)

(if (next more)

(recur y (first more) (next more))

(clojure.lang.Util/equiv y (first more)))

false)))

;equals-based

#_(defn =

"Equality. Returns true if x equals y, false if not. Same as Java

x.equals(y) except it also works for nil. Boxed numbers must have

same type. Clojure's immutable data structures define equals() (and

thus =) as a value, not an identity, comparison."

{:inline (fn [x y] `(. clojure.lang.Util equals ~x ~y))

:inline-arities #{2}

:added "1.0"}

([x] true)

([x y] (clojure.lang.Util/equals x y))

([x y & more]

(if (= x y)

(if (next more)

(recur y (first more) (next more))

(= y (first more)))

false)))

(defn not=

"Same as (not (= obj1 obj2))"

{:tag Boolean

:added "1.0"

:static true}

([x] false)

([x y] (not (= x y)))

([x y & more]

(not (apply = x y more))))

(defn compare

"Comparator. Returns a negative number, zero, or a positive number

when x is logically 'less than', 'equal to', or 'greater than'

y. Same as Java x.compareTo(y) except it also works for nil, and

compares numbers and collections in a type-independent manner. x

must implement Comparable"

{

:inline (fn [x y] `(. clojure.lang.Util compare ~x ~y))

:added "1.0"}

[x y] (. clojure.lang.Util (compare x y)))

(defmacro and

"Evaluates exprs one at a time, from left to right. If a form

returns logical false (nil or false), and returns that value and

doesn't evaluate any of the other expressions, otherwise it returns

the value of the last expr. (and) returns true."

{:added "1.0"}

([] true)

([x] x)

([x & next]

`(let [and# ~x]

(if and# (and ~@next) and#))))

(defmacro or

"Evaluates exprs one at a time, from left to right. If a form

returns a logical true value, or returns that value and doesn't

evaluate any of the other expressions, otherwise it returns the

value of the last expression. (or) returns nil."

{:added "1.0"}

([] nil)

([x] x)

([x & next]

`(let [or# ~x]

(if or# or# (or ~@next)))))

;;;;;;;;;;;;;;;;;;; sequence fns ;;;;;;;;;;;;;;;;;;;;;;;

(defn zero?

"Returns true if num is zero, else false"

{

:inline (fn [x] `(. clojure.lang.Numbers (isZero ~x)))

:added "1.0"}

[x] (. clojure.lang.Numbers (isZero x)))

(defn count

"Returns the number of items in the collection. (count nil) returns

0. Also works on strings, arrays, and Java Collections and Maps"

{

:inline (fn [x] `(. clojure.lang.RT (count ~x)))

:added "1.0"}

[coll] (clojure.lang.RT/count coll))

(defn int

"Coerce to int"

{

:inline (fn [x] `(. clojure.lang.RT (~(if *unchecked-math* 'uncheckedIntCast 'intCast) ~x)))

:added "1.0"}

[x] (. clojure.lang.RT (intCast x)))

(defn nth

"Returns the value at the index. get returns nil if index out of

bounds, nth throws an exception unless not-found is supplied. nth

also works for strings, Java arrays, regex Matchers and Lists, and,

in O(n) time, for sequences."

{:inline (fn [c i & nf] `(. clojure.lang.RT (nth ~c ~i ~@nf)))

:inline-arities #{2 3}

:added "1.0"}

([coll index] (. clojure.lang.RT (nth coll index)))

([coll index not-found] (. clojure.lang.RT (nth coll index not-found))))

(defn <

"Returns non-nil if nums are in monotonically increasing order,

otherwise false."

{:inline (fn [x y] `(. clojure.lang.Numbers (lt ~x ~y)))

:inline-arities #{2}

:added "1.0"}

([x] true)

([x y] (. clojure.lang.Numbers (lt x y)))

([x y & more]

(if (< x y)

(if (next more)

(recur y (first more) (next more))

(< y (first more)))

false)))

(defn inc'

"Returns a number one greater than num. Supports arbitrary precision.

See also: inc"

{:inline (fn [x] `(. clojure.lang.Numbers (incP ~x)))

:added "1.0"}

[x] (. clojure.lang.Numbers (incP x)))

(defn inc

"Returns a number one greater than num. Does not auto-promote

longs, will throw on overflow. See also: inc'"

{:inline (fn [x] `(. clojure.lang.Numbers (~(if *unchecked-math* 'unchecked_inc 'inc) ~x)))

:added "1.2"}

[x] (. clojure.lang.Numbers (inc x)))

;; reduce is defined again later after InternalReduce loads

(defn ^:private ^:static

reduce1

([f coll]

(let [s (seq coll)]

(if s

(reduce1 f (first s) (next s))

(f))))

([f val coll]

(let [s (seq coll)]

(if s

(if (chunked-seq? s)

(recur f

(.reduce (chunk-first s) f val)

(chunk-next s))

(recur f (f val (first s)) (next s)))

val))))

(defn reverse

"Returns a seq of the items in coll in reverse order. Not lazy."

{:added "1.0"

:static true}

[coll]

(reduce1 conj () coll))

;;math stuff

(defn ^:private nary-inline

([op] (nary-inline op op))

([op unchecked-op]

(fn

([x] (let [op (if *unchecked-math* unchecked-op op)]

`(. clojure.lang.Numbers (~op ~x))))

([x y] (let [op (if *unchecked-math* unchecked-op op)]

`(. clojure.lang.Numbers (~op ~x ~y))))

([x y & more]

(let [op (if *unchecked-math* unchecked-op op)]

(reduce1

(fn [a b] `(. clojure.lang.Numbers (~op ~a ~b)))

`(. clojure.lang.Numbers (~op ~x ~y)) more))))))

(defn ^:private >1? [n] (clojure.lang.Numbers/gt n 1))

(defn ^:private >0? [n] (clojure.lang.Numbers/gt n 0))

(defn +'

"Returns the sum of nums. (+) returns 0. Supports arbitrary precision.

See also: +"

{:inline (nary-inline 'addP)

:inline-arities >1?

:added "1.0"}

([] 0)

([x] (cast Number x))

([x y] (. clojure.lang.Numbers (addP x y)))

([x y & more]

(reduce1 +' (+' x y) more)))

(defn +

"Returns the sum of nums. (+) returns 0. Does not auto-promote

longs, will throw on overflow. See also: +'"

{:inline (nary-inline 'add 'unchecked_add)

:inline-arities >1?

:added "1.2"}

([] 0)

([x] (cast Number x))

([x y] (. clojure.lang.Numbers (add x y)))

([x y & more]

(reduce1 + (+ x y) more)))

(defn *'

"Returns the product of nums. (*) returns 1. Supports arbitrary precision.

See also: *"

{:inline (nary-inline 'multiplyP)

:inline-arities >1?

:added "1.0"}

([] 1)

([x] (cast Number x))

([x y] (. clojure.lang.Numbers (multiplyP x y)))

([x y & more]

(reduce1 *' (*' x y) more)))

(defn *

"Returns the product of nums. (*) returns 1. Does not auto-promote

longs, will throw on overflow. See also: *'"

{:inline (nary-inline 'multiply 'unchecked_multiply)

:inline-arities >1?

:added "1.2"}

([] 1)

([x] (cast Number x))

([x y] (. clojure.lang.Numbers (multiply x y)))

([x y & more]

(reduce1 * (* x y) more)))

(defn /

"If no denominators are supplied, returns 1/numerator,

else returns numerator divided by all of the denominators."

{:inline (nary-inline 'divide)

:inline-arities >1?

:added "1.0"}

([x] (/ 1 x))

([x y] (. clojure.lang.Numbers (divide x y)))

([x y & more]

(reduce1 / (/ x y) more)))

(defn -'

"If no ys are supplied, returns the negation of x, else subtracts

the ys from x and returns the result. Supports arbitrary precision.

See also: -"

{:inline (nary-inline 'minusP)

:inline-arities >0?

:added "1.0"}

([x] (. clojure.lang.Numbers (minusP x)))

([x y] (. clojure.lang.Numbers (minusP x y)))

([x y & more]

(reduce1 -' (-' x y) more)))

(defn -

"If no ys are supplied, returns the negation of x, else subtracts

the ys from x and returns the result. Does not auto-promote

longs, will throw on overflow. See also: -'"

{:inline (nary-inline 'minus 'unchecked_minus)

:inline-arities >0?

:added "1.2"}

([x] (. clojure.lang.Numbers (minus x)))

([x y] (. clojure.lang.Numbers (minus x y)))

([x y & more]

(reduce1 - (- x y) more)))

(defn <=

"Returns non-nil if nums are in monotonically non-decreasing order,

otherwise false."

{:inline (fn [x y] `(. clojure.lang.Numbers (lte ~x ~y)))

:inline-arities #{2}

:added "1.0"}

([x] true)

([x y] (. clojure.lang.Numbers (lte x y)))

([x y & more]

(if (<= x y)