lasercutter: src/clojure/core.clj comparison

comparison src/clojure/core.clj @ 10:ef7dbbd6452c

added clojure source goodness

author	Robert McIntyre <rlm@mit.edu>
date	Sat, 21 Aug 2010 06:25:44 -0400
parents
children

comparison

equal deleted inserted replaced

-:35cf337adfcf
+:ef7dbbd6452c
+;   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 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"}
+cons (fn* 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"}
+first (fn 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"}
+next (fn 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"}
+rest (fn 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"}
+conj (fn 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"}
+second (fn second [x] (first (next x))))
+(def
+^{:doc "Same as (first (first x))"
+:arglists '([x])
+:added "1.0"}
+ffirst (fn ffirst [x] (first (first x))))
+(def
+^{:doc "Same as (next (first x))"
+:arglists '([x])
+:added "1.0"}
+nfirst (fn nfirst [x] (next (first x))))
+(def
+^{:doc "Same as (first (next x))"
+:arglists '([x])
+:added "1.0"}
+fnext (fn fnext [x] (first (next x))))
+(def
+^{:doc "Same as (next (next x))"
+:arglists '([x])
+:added "1.0"}
+nnext (fn nnext [x] (next (next x))))
+(def
+^{:arglists '([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"}
+seq (fn seq [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"}
+seq? (fn seq? [x] (instance? clojure.lang.ISeq x)))
+(def
+^{:arglists '([x])
+:doc "Return true if x is a Character"
+:added "1.0"}
+char? (fn char? [x] (instance? Character x)))
+(def
+^{:arglists '([x])
+:doc "Return true if x is a String"
+:added "1.0"}
+string? (fn string? [x] (instance? String x)))
+(def
+^{:arglists '([x])
+:doc "Return true if x implements IPersistentMap"
+:added "1.0"}
+map? (fn map? [x] (instance? clojure.lang.IPersistentMap x)))
+(def
+^{:arglists '([x])
+:doc "Return true if x implements IPersistentVector"
+:added "1.0"}
+vector? (fn 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"}
+assoc
+(fn 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"}
+meta (fn 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"}
+with-meta (fn 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"}
+last (fn 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"}
+butlast (fn 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"
+:arglists '([name doc-string? attr-map? [params*] body]
+[name doc-string? attr-map? ([params*] 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 name) "__inliner"))
+(next inline))))
+m))
+m (conj (if (meta name) (meta name) {}) m)]
+(list 'def (with-meta name m)
+(list '.withMeta (cons `fn (cons name fdecl)) (list '.meta (list 'var name)))))))
+(. (var defn) (setMacro))
+(defn cast
+"Throws a ClassCastException if x is not a c, else returns x."
+{:added "1.0"}
+[^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"}
+[coll] (. clojure.lang.RT (toArray coll)))
+(defn vector
+"Creates a new vector containing the args."
+{:added "1.0"}
+([] [])
+([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"}
+([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"}
+([] {})
+([& keyvals]
+(. clojure.lang.PersistentHashMap (createWithCheck keyvals))))
+(defn hash-set
+"Returns a new hash set with supplied keys."
+{:added "1.0"}
+([] #{})
+([& keys]
+(clojure.lang.PersistentHashSet/createWithCheck keys)))
+(defn sorted-map
+"keyval => key val
+Returns a new sorted map with supplied mappings."
+{:added "1.0"}
+([& 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"}
+([comparator & keyvals]
+(clojure.lang.PersistentTreeMap/create comparator keyvals)))
+(defn sorted-set
+"Returns a new sorted set with supplied keys."
+{:added "1.0"}
+([& 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"}
+([comparator & keys]
+(clojure.lang.PersistentTreeSet/create comparator keys)))
+;;;;;;;;;;;;;;;;;;;;
+(defn nil?
+"Returns true if x is nil, false otherwise."
+{:tag Boolean
+:added "1.0"}
+[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"}
+[x] (clojure.lang.Util/identical x false))
+(defn true?
+"Returns true if x is the value true, false otherwise."
+{:tag Boolean,
+:added "1.0"}
+[x] (clojure.lang.Util/identical x true))
+(defn not
+"Returns true if x is logical false, false otherwise."
+{:tag Boolean
+:added "1.0"}
+[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"}
+([] "")
+([^Object x]
+(if (nil? x) "" (. x (toString))))
+([x & ys]
+((fn [^StringBuilder sb more]
+(if more
+(recur (. sb  (append (str (first more)))) (next more))
+(str sb)))
+(new StringBuilder ^String (str x)) ys)))
+(defn symbol?
+"Return true if x is a Symbol"
+{:added "1.0"}
+[x] (instance? clojure.lang.Symbol x))
+(defn keyword?
+"Return true if x is a Keyword"
+{:added "1.0"}
+[x] (instance? clojure.lang.Keyword x))
+(defn symbol
+"Returns a Symbol with the given namespace and name."
+{:tag clojure.lang.Symbol
+:added "1.0"}
+([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"}
+([] (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"}
+([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 spread
+{:private 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"}
+([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 args to argseq."
+{:arglists '([f args* argseq])
+:added "1.0"}
+([^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"}
+[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."
+{:added "1.0"}
+[& body]
+(list 'new 'clojure.lang.LazySeq (list* '^{:once true} fn* [] body)))
+(defn ^clojure.lang.ChunkBuffer chunk-buffer [capacity]
+(clojure.lang.ChunkBuffer. capacity))
+(defn chunk-append [^clojure.lang.ChunkBuffer b x]
+(.add b x))
+(defn chunk [^clojure.lang.ChunkBuffer b]
+(.chunk b))
+(defn ^clojure.lang.IChunk chunk-first [^clojure.lang.IChunkedSeq s]
+(.chunkedFirst s))
+(defn ^clojure.lang.ISeq chunk-rest [^clojure.lang.IChunkedSeq s]
+(.chunkedMore s))
+(defn ^clojure.lang.ISeq chunk-next [^clojure.lang.IChunkedSeq s]
+(.chunkedNext s))
+(defn chunk-cons [chunk rest]
+(if (clojure.lang.Numbers/isZero (clojure.lang.RT/count chunk))
+rest
+(clojure.lang.ChunkedCons. chunk rest)))
+(defn 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"}
+([] (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."
+{: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"}
+[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"}
+[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)))
+(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 (= 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"}
+([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 (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."
+{:inline (fn [x] `(. clojure.lang.Numbers (inc ~x)))
+:added "1.0"}
+[x] (. clojure.lang.Numbers (inc x)))
+;; reduce is defined again later after InternalReduce loads
+(def
+^{:arglists '([f coll] [f val coll])
+:doc "f should be a function of 2 arguments. If val is not supplied,
+returns the result of applying f to the first 2 items in coll, then
+applying f to that result and the 3rd item, etc. If coll contains no
+items, f must accept no arguments as well, and reduce returns the
+result of calling f with no arguments.  If coll has only 1 item, it
+is returned and f is not called.  If val is supplied, returns the
+result of applying f to val and the first item in coll, then
+applying f to that result and the 2nd item, etc. If coll contains no
+items, returns val and f is not called."
+:added "1.0"}
+reduce
+(fn r
+([f coll]
+(let [s (seq coll)]
+(if s
+(r 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"}
+[coll]
+(reduce conj () coll))
+;;math stuff
+(defn +
+"Returns the sum of nums. (+) returns 0."
+{:inline (fn [x y] `(. clojure.lang.Numbers (add ~x ~y)))
+:inline-arities #{2}
+:added "1.0"}
+([] 0)
+([x] (cast Number x))
+([x y] (. clojure.lang.Numbers (add x y)))
+([x y & more]
+(reduce + (+ x y) more)))
+(defn *
+"Returns the product of nums. (*) returns 1."
+{:inline (fn [x y] `(. clojure.lang.Numbers (multiply ~x ~y)))
+:inline-arities #{2}
+:added "1.0"}
+([] 1)
+([x] (cast Number x))
+([x y] (. clojure.lang.Numbers (multiply x y)))
+([x y & more]
+(reduce * (* x y) more)))
+(defn /
+"If no denominators are supplied, returns 1/numerator,
+else returns numerator divided by all of the denominators."
+{:inline (fn [x y] `(. clojure.lang.Numbers (divide ~x ~y)))
+:inline-arities #{2}
+:added "1.0"}
+([x] (/ 1 x))
+([x y] (. clojure.lang.Numbers (divide x y)))
+([x y & more]
+(reduce / (/ x y) more)))
+(defn -
+"If no ys are supplied, returns the negation of x, else subtracts
+the ys from x and returns the result."
+{:inline (fn [& args] `(. clojure.lang.Numbers (minus ~@args)))
+:inline-arities #{1 2}
+:added "1.0"}
+([x] (. clojure.lang.Numbers (minus x)))
+([x y] (. clojure.lang.Numbers (minus x y)))
+([x y & more]
+(reduce - (- 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)
+(if (next more)
+(recur y (first more) (next more))
+(<= y (first more)))
+false)))
+(defn >
+"Returns non-nil if nums are in monotonically decreasing order,
+otherwise false."
+{:inline (fn [x y] `(. clojure.lang.Numbers (gt ~x ~y)))
+:inline-arities #{2}
+:added "1.0"}
+([x] true)
+([x y] (. clojure.lang.Numbers (gt x y)))
+([x y & more]
+(if (> x y)
+(if (next more)
+(recur y (first more) (next more))
+(> y (first more)))
+false)))
+(defn >=
+"Returns non-nil if nums are in monotonically non-increasing order,
+otherwise false."
+{:inline (fn [x y] `(. clojure.lang.Numbers (gte ~x ~y)))
+:inline-arities #{2}
+:added "1.0"}
+([x] true)
+([x y] (. clojure.lang.Numbers (gte x y)))
+([x y & more]
+(if (>= x y)
+(if (next more)
+(recur y (first more) (next more))
+(>= y (first more)))
+false)))
+(defn ==
+"Returns non-nil if nums all have the same value, otherwise false"
+{:inline (fn [x y] `(. clojure.lang.Numbers (equiv ~x ~y)))
+:inline-arities #{2}
+:added "1.0"}
+([x] true)
+([x y] (. clojure.lang.Numbers (equiv x y)))
+([x y & more]
+(if (== x y)
+(if (next more)
+(recur y (first more) (next more))
+(== y (first more)))
+false)))
+(defn max
+"Returns the greatest of the nums."
+{:added "1.0"}
+([x] x)
+([x y] (if (> x y) x y))
+([x y & more]
+(reduce max (max x y) more)))
+(defn min
+"Returns the least of the nums."
+{:added "1.0"}
+([x] x)
+([x y] (if (< x y) x y))
+([x y & more]
+(reduce min (min x y) more)))
+(defn dec
+"Returns a number one less than num."
+{:inline (fn [x] `(. clojure.lang.Numbers (dec ~x)))
+:added "1.0"}
+[x] (. clojure.lang.Numbers (dec x)))
+(defn unchecked-inc
+"Returns a number one greater than x, an int or long.
+Note - uses a primitive operator subject to overflow."
+{:inline (fn [x] `(. clojure.lang.Numbers (unchecked_inc ~x)))
+:added "1.0"}
+[x] (. clojure.lang.Numbers (unchecked_inc x)))
+(defn unchecked-dec
+"Returns a number one less than x, an int or long.
+Note - uses a primitive operator subject to overflow."
+{:inline (fn [x] `(. clojure.lang.Numbers (unchecked_dec ~x)))
+:added "1.0"}
+[x] (. clojure.lang.Numbers (unchecked_dec x)))
+(defn unchecked-negate
+"Returns the negation of x, an int or long.
+Note - uses a primitive operator subject to overflow."
+{:inline (fn [x] `(. clojure.lang.Numbers (unchecked_negate ~x)))
+:added "1.0"}
+[x] (. clojure.lang.Numbers (unchecked_negate x)))
+(defn unchecked-add
+"Returns the sum of x and y, both int or long.
+Note - uses a primitive operator subject to overflow."
+{:inline (fn [x y] `(. clojure.lang.Numbers (unchecked_add ~x ~y)))
+:added "1.0"}
+[x y] (. clojure.lang.Numbers (unchecked_add x y)))
+(defn unchecked-subtract
+"Returns the difference of x and y, both int or long.
+Note - uses a primitive operator subject to overflow."
+{:inline (fn [x y] `(. clojure.lang.Numbers (unchecked_subtract ~x ~y)))
+:added "1.0"}
+[x y] (. clojure.lang.Numbers (unchecked_subtract x y)))
+(defn unchecked-multiply
+"Returns the product of x and y, both int or long.
+Note - uses a primitive operator subject to overflow."
+{:inline (fn [x y] `(. clojure.lang.Numbers (unchecked_multiply ~x ~y)))
+:added "1.0"}
+[x y] (. clojure.lang.Numbers (unchecked_multiply x y)))
+(defn unchecked-divide
+"Returns the division of x by y, both int or long.
+Note - uses a primitive operator subject to truncation."
+{:inline (fn [x y] `(. clojure.lang.Numbers (unchecked_divide ~x ~y)))
+:added "1.0"}
+[x y] (. clojure.lang.Numbers (unchecked_divide x y)))
+(defn unchecked-remainder
+"Returns the remainder of division of x by y, both int or long.
+Note - uses a primitive operator subject to truncation."
+{:inline (fn [x y] `(. clojure.lang.Numbers (unchecked_remainder ~x ~y)))
+:added "1.0"}
+[x y] (. clojure.lang.Numbers (unchecked_remainder x y)))
+(defn pos?
+"Returns true if num is greater than zero, else false"
+{
+:inline (fn [x] `(. clojure.lang.Numbers (isPos ~x)))
+:added "1.0"}
+[x] (. clojure.lang.Numbers (isPos x)))
+(defn neg?
+"Returns true if num is less than zero, else false"
+{
+:inline (fn [x] `(. clojure.lang.Numbers (isNeg ~x)))
+:added "1.0"}
+[x] (. clojure.lang.Numbers (isNeg x)))
+(defn quot
+"quot[ient] of dividing numerator by denominator."
+{:added "1.0"}
+[num div]
+(. clojure.lang.Numbers (quotient num div)))
+(defn rem
+"remainder of dividing numerator by denominator."
+{:added "1.0"}
+[num div]
+(. clojure.lang.Numbers (remainder num div)))
+(defn rationalize
+"returns the rational value of num"
+{:added "1.0"}
+[num]
+(. clojure.lang.Numbers (rationalize num)))
+;;Bit ops
+(defn bit-not
+"Bitwise complement"
+{:inline (fn [x] `(. clojure.lang.Numbers (not ~x)))
+:added "1.0"}
+[x] (. clojure.lang.Numbers not x))
+(defn bit-and
+"Bitwise and"
+{:inline (fn [x y] `(. clojure.lang.Numbers (and ~x ~y)))
+:added "1.0"}
+[x y] (. clojure.lang.Numbers and x y))
+(defn bit-or
+"Bitwise or"
+{:inline (fn [x y] `(. clojure.lang.Numbers (or ~x ~y)))
+:added "1.0"}
+[x y] (. clojure.lang.Numbers or x y))
+(defn bit-xor
+"Bitwise exclusive or"
+{:inline (fn [x y] `(. clojure.lang.Numbers (xor ~x ~y)))
+:added "1.0"}
+[x y] (. clojure.lang.Numbers xor x y))
+(defn bit-and-not
+"Bitwise and with complement"
+{:added "1.0"}
+[x y] (. clojure.lang.Numbers andNot x y))
+(defn bit-clear
+"Clear bit at index n"
+{:added "1.0"}
+[x n] (. clojure.lang.Numbers clearBit x n))
+(defn bit-set
+"Set bit at index n"
+{:added "1.0"}
+[x n] (. clojure.lang.Numbers setBit x n))
+(defn bit-flip
+"Flip bit at index n"
+{:added "1.0"}
+[x n] (. clojure.lang.Numbers flipBit x n))
+(defn bit-test
+"Test bit at index n"
+{:added "1.0"}
+[x n] (. clojure.lang.Numbers testBit x n))
+(defn bit-shift-left
+"Bitwise shift left"
+{:inline (fn [x n] `(. clojure.lang.Numbers (shiftLeft ~x ~n)))
+:added "1.0"}
+[x n] (. clojure.lang.Numbers shiftLeft x n))
+(defn bit-shift-right
+"Bitwise shift right"
+{:inline (fn [x n] `(. clojure.lang.Numbers (shiftRight ~x ~n)))
+:added "1.0"}
+[x n] (. clojure.lang.Numbers shiftRight x n))
+(defn even?
+"Returns true if n is even, throws an exception if n is not an integer"
+{:added "1.0"}
+[n] (zero? (bit-and n 1)))
+(defn odd?
+"Returns true if n is odd, throws an exception if n is not an integer"
+{:added "1.0"}
+[n] (not (even? n)))
+;;
+(defn complement
+"Takes a fn f and returns a fn that takes the same arguments as f,
+has the same effects, if any, and returns the opposite truth value."
+{:added "1.0"}
+[f]
+(fn
+([] (not (f)))
+([x] (not (f x)))
+([x y] (not (f x y)))
+([x y & zs] (not (apply f x y zs)))))
+(defn constantly
+"Returns a function that takes any number of arguments and returns x."
+{:added "1.0"}
+[x] (fn [& args] x))
+(defn identity
+"Returns its argument."
+{:added "1.0"}
+[x] x)
+;;Collection stuff
+;;list stuff
+(defn peek
+"For a list or queue, same as first, for a vector, same as, but much
+more efficient than, last. If the collection is empty, returns nil."
+{:added "1.0"}
+[coll] (. clojure.lang.RT (peek coll)))
+(defn pop
+"For a list or queue, returns a new list/queue without the first
+item, for a vector, returns a new vector without the last item. If
+the collection is empty, throws an exception.  Note - not the same
+as next/butlast."
+{:added "1.0"}
+[coll] (. clojure.lang.RT (pop coll)))
+;;map stuff
+(defn contains?
+"Returns true if key is present in the given collection, otherwise
+returns false.  Note that for numerically indexed collections like
+vectors and Java arrays, this tests if the numeric key is within the
+range of indexes. 'contains?' operates constant or logarithmic time;
+it will not perform a linear search for a value.  See also 'some'."
+{:added "1.0"}
+[coll key] (. clojure.lang.RT (contains coll key)))
+(defn get
+"Returns the value mapped to key, not-found or nil if key not present."
+{:inline (fn  [m k & nf] `(. clojure.lang.RT (get ~m ~k ~@nf)))
+:inline-arities #{2 3}
+:added "1.0"}
+([map key]
+(. clojure.lang.RT (get map key)))
+([map key not-found]
+(. clojure.lang.RT (get map key not-found))))
+(defn dissoc
+"dissoc[iate]. Returns a new map of the same (hashed/sorted) type,
+that does not contain a mapping for key(s)."
+{:added "1.0"}
+([map] map)
+([map key]
+(. clojure.lang.RT (dissoc map key)))
+([map key & ks]
+(let [ret (dissoc map key)]
+(if ks
+(recur ret (first ks) (next ks))
+ret))))
+(defn disj
+"disj[oin]. Returns a new set of the same (hashed/sorted) type, that
+does not contain key(s)."
+{:added "1.0"}
+([set] set)
+([^clojure.lang.IPersistentSet set key]
+(when set
+(. set (disjoin key))))
+([set key & ks]
+(when set
+(let [ret (disj set key)]
+(if ks
+(recur ret (first ks) (next ks))
+ret)))))
+(defn find
+"Returns the map entry for key, or nil if key not present."
+{:added "1.0"}
+[map key] (. clojure.lang.RT (find map key)))
+(defn select-keys
+"Returns a map containing only those entries in map whose key is in keys"
+{:added "1.0"}
+[map keyseq]
+(loop [ret {} keys (seq keyseq)]
+(if keys
+(let [entry (. clojure.lang.RT (find map (first keys)))]
+(recur
+(if entry
+(conj ret entry)
+ret)
+(next keys)))
+ret)))
+(defn keys
+"Returns a sequence of the map's keys."
+{:added "1.0"}
+[map] (. clojure.lang.RT (keys map)))
+(defn vals
+"Returns a sequence of the map's values."
+{:added "1.0"}
+[map] (. clojure.lang.RT (vals map)))
+(defn key
+"Returns the key of the map entry."
+{:added "1.0"}
+[^java.util.Map$Entry e]
+(. e (getKey)))
+(defn val
+"Returns the value in the map entry."
+{:added "1.0"}
+[^java.util.Map$Entry e]
+(. e (getValue)))
+(defn rseq
+"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 "1.0"}
+[^clojure.lang.Reversible rev]
+(. rev (rseq)))
+(defn name
+"Returns the name String of a string, symbol or keyword."
+{:tag String
+:added "1.0"}
+[^clojure.lang.Named x]
+(if (string? x) x (. x (getName))))
+(defn namespace
+"Returns the namespace String of a symbol or keyword, or nil if not present."
+{:tag String
+:added "1.0"}
+[^clojure.lang.Named x]
+(. x (getNamespace)))
+(defmacro locking
+"Executes exprs in an implicit do, while holding the monitor of x.
+Will release the monitor of x in all circumstances."
+{:added "1.0"}
+[x & body]
+`(let [lockee# ~x]
+(try
+(monitor-enter lockee#)
+~@body
+(finally
+(monitor-exit lockee#)))))
+(defmacro ..
+"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\"))
+expands to:
+(. (. System (getProperties)) (get \"os.name\"))
+but is easier to write, read, and understand."
+{:added "1.0"}
+([x form] `(. ~x ~form))
+([x form & more] `(.. (. ~x ~form) ~@more)))
+(defmacro ->
+"Threads the expr through the forms. Inserts x as the
+second item in the first form, making a list of it if it is not a
+list already. If there are more forms, inserts the first form as the
+second item in second form, etc."
+{:added "1.0"}
+([x] x)
+([x form] (if (seq? form)
+(with-meta `(~(first form) ~x ~@(next form)) (meta form))
+(list form x)))
+([x form & more] `(-> (-> ~x ~form) ~@more)))
+(defmacro ->>
+"Threads the expr through the forms. Inserts x as the
+last item in the first form, making a list of it if it is not a
+list already. If there are more forms, inserts the first form as the
+last item in second form, etc."
+{:added "1.1"}
+([x form] (if (seq? form)
+(with-meta `(~(first form) ~@(next form)  ~x) (meta form))
+(list form x)))
+([x form & more] `(->> (->> ~x ~form) ~@more)))
+;;multimethods
+(def global-hierarchy)
+(defmacro defmulti
+"Creates a new multimethod with the associated dispatch function.
+The docstring and attribute-map are optional.
+Options are key-value pairs and may be one of:
+:default    the default dispatch value, defaults to :default
+:hierarchy  the isa? hierarchy to use for dispatching
+defaults to the global hierarchy"
+{:arglists '([name docstring? attr-map? dispatch-fn & options])
+:added "1.0"}
+[mm-name & options]
+(let [docstring   (if (string? (first options))
+(first options)
+nil)
+options     (if (string? (first options))
+(next options)
+options)
+m           (if (map? (first options))
+(first options)
+{})
+options     (if (map? (first options))
+(next options)
+options)
+dispatch-fn (first options)
+options     (next options)
+m           (assoc m :tag 'clojure.lang.MultiFn)
+m           (if docstring
+(assoc m :doc docstring)
+m)
+m           (if (meta mm-name)
+(conj (meta mm-name) m)
+m)]
+(when (= (count options) 1)
+(throw (Exception. "The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)")))
+(let [options   (apply hash-map options)
+default   (get options :default :default)
+hierarchy (get options :hierarchy #'global-hierarchy)]
+`(let [v# (def ~mm-name)]
+(when-not (and (.hasRoot v#) (instance? clojure.lang.MultiFn (deref v#)))
+(def ~(with-meta mm-name m)
+(new clojure.lang.MultiFn ~(name mm-name) ~dispatch-fn ~default ~hierarchy)))))))
+(defmacro defmethod
+"Creates and installs a new method of multimethod associated with dispatch-value. "
+{:added "1.0"}
+[multifn dispatch-val & fn-tail]
+`(. ~(with-meta multifn {:tag 'clojure.lang.MultiFn}) addMethod ~dispatch-val (fn ~@fn-tail)))
+(defn remove-all-methods
+"Removes all of the methods of multimethod."
+{:added "1.2"}
+[^clojure.lang.MultiFn multifn]
+(.reset multifn))
+(defn remove-method
+"Removes the method of multimethod associated with dispatch-value."
+{:added "1.0"}
+[^clojure.lang.MultiFn multifn dispatch-val]
+(. multifn removeMethod dispatch-val))
+(defn prefer-method
+"Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y
+when there is a conflict"
+{:added "1.0"}
+[^clojure.lang.MultiFn multifn dispatch-val-x dispatch-val-y]
+(. multifn preferMethod dispatch-val-x dispatch-val-y))
+(defn methods
+"Given a multimethod, returns a map of dispatch values -> dispatch fns"
+{:added "1.0"}
+[^clojure.lang.MultiFn multifn] (.getMethodTable multifn))
+(defn get-method
+"Given a multimethod and a dispatch value, returns the dispatch fn
+that would apply to that value, or nil if none apply and no default"
+{:added "1.0"}
+[^clojure.lang.MultiFn multifn dispatch-val] (.getMethod multifn dispatch-val))
+(defn prefers
+"Given a multimethod, returns a map of preferred value -> set of other values"
+{:added "1.0"}
+[^clojure.lang.MultiFn multifn] (.getPreferTable multifn))
+;;;;;;;;; var stuff
+(defmacro ^{:private true} assert-args [fnname & pairs]
+`(do (when-not ~(first pairs)
+(throw (IllegalArgumentException.
+~(str fnname " requires " (second pairs)))))
+~(let [more (nnext pairs)]
+(when more
+(list* `assert-args fnname more)))))
+(defmacro if-let
+"bindings => binding-form test
+If test is true, evaluates then with binding-form bound to the value of
+test, if not, yields else"
+{:added "1.0"}
+([bindings then]
+`(if-let ~bindings ~then nil))
+([bindings then else & oldform]
+(assert-args if-let
+(and (vector? bindings) (nil? oldform)) "a vector for its binding"
+(= 2 (count bindings)) "exactly 2 forms in binding vector")
+(let [form (bindings 0) tst (bindings 1)]
+`(let [temp# ~tst]
+(if temp#
+(let [~form temp#]
+~then)
+~else)))))
+(defmacro when-let
+"bindings => binding-form test
+When test is true, evaluates body with binding-form bound to the value of test"
+{:added "1.0"}
+[bindings & body]
+(assert-args when-let
+(vector? bindings) "a vector for its binding"
+(= 2 (count bindings)) "exactly 2 forms in binding vector")
+(let [form (bindings 0) tst (bindings 1)]
+`(let [temp# ~tst]
+(when temp#
+(let [~form temp#]
+~@body)))))
+(defn push-thread-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)))"
+{:added "1.1"}
+[bindings]
+(clojure.lang.Var/pushThreadBindings bindings))
+(defn pop-thread-bindings
+"Pop one set of bindings pushed with push-binding before. It is an error to
+pop bindings without pushing before."
+{:added "1.1"}
+[]
+(clojure.lang.Var/popThreadBindings))
+(defn get-thread-bindings
+"Get a map with the Var/value pairs which is currently in effect for the
+current thread."
+{:added "1.1"}
+[]
+(clojure.lang.Var/getThreadBindings))
+(defmacro binding
+"binding => var-symbol init-expr
+Creates new bindings for the (already-existing) vars, with the
+supplied initial values, executes the exprs in an implicit do, then
+re-establishes the bindings that existed before.  The new bindings
+are made in parallel (unlike let); all init-exprs are evaluated
+before the vars are bound to their new values."
+{:added "1.0"}
+[bindings & body]
+(assert-args binding
+(vector? bindings) "a vector for its binding"
+(even? (count bindings)) "an even number of forms in binding vector")
+(let [var-ize (fn [var-vals]
+(loop [ret [] vvs (seq var-vals)]
+(if vvs
+(recur  (conj (conj ret `(var ~(first vvs))) (second vvs))
+(next (next vvs)))
+(seq ret))))]
+`(let []
+(push-thread-bindings (hash-map ~@(var-ize bindings)))
+(try
+~@body
+(finally
+(pop-thread-bindings))))))
+(defn with-bindings*
+"Takes a map of Var/value pairs. Installs for the given Vars the associated
+values as thread-local bindings. Then calls f with the supplied arguments.
+Pops the installed bindings after f returned. Returns whatever f returns."
+{:added "1.1"}
+[binding-map f & args]
+(push-thread-bindings binding-map)
+(try
+(apply f args)
+(finally
+(pop-thread-bindings))))
+(defmacro with-bindings
+"Takes a map of Var/value pairs. Installs for the given Vars the associated
+values as thread-local bindings. The executes body. Pops the installed
+bindings after body was evaluated. Returns the value of body."
+{:added "1.1"}
+[binding-map & body]
+`(with-bindings* ~binding-map (fn [] ~@body)))
+(defn bound-fn*
+"Returns a function, which will install the same bindings in effect as in
+the thread at the time bound-fn* was called and then call f with any given
+arguments. This may be used to define a helper function which runs on a
+different thread, but needs the same bindings in place."
+{:added "1.1"}
+[f]
+(let [bindings (get-thread-bindings)]
+(fn [& args]
+(apply with-bindings* bindings f args))))
+(defmacro bound-fn
+"Returns a function defined by the given fntail, which will install the
+same bindings in effect as in the thread at the time bound-fn was called.
+This may be used to define a helper function which runs on a different
+thread, but needs the same bindings in place."
+{:added "1.1"}
+[& fntail]
+`(bound-fn* (fn ~@fntail)))
+(defn find-var
+"Returns the global var named by the namespace-qualified symbol, or
+nil if no var with that name."
+{:added "1.0"}
+[sym] (. clojure.lang.Var (find sym)))
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Refs ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(defn ^{:private true}
+setup-reference [^clojure.lang.ARef r options]
+(let [opts (apply hash-map options)]
+(when (:meta opts)
+(.resetMeta r (:meta opts)))
+(when (:validator opts)
+(.setValidator r (:validator opts)))
+r))
+(defn agent
+"Creates and returns an agent with an initial value of state and
+zero or more options (in any order):
+:meta metadata-map
+:validator validate-fn
+:error-handler handler-fn
+:error-mode mode-keyword
+If metadata-map is supplied, it will be come the metadata on the
+agent. validate-fn must be nil or a side-effect-free fn of one
+argument, which will be passed the intended new state on any state
+change. If the new state is unacceptable, the validate-fn should
+return false or throw an exception.  handler-fn is called if an
+action throws an exception or if validate-fn rejects a new state --
+see set-error-handler! for details.  The mode-keyword may be either
+:continue (the default if an error-handler is given) or :fail (the
+default if no error-handler is given) -- see set-error-mode! for
+details."
+{:added "1.0"}
+([state & options]
+(let [a (new clojure.lang.Agent state)
+opts (apply hash-map options)]
+(setup-reference a options)
+(when (:error-handler opts)
+(.setErrorHandler a (:error-handler opts)))
+(.setErrorMode a (or (:error-mode opts)
+(if (:error-handler opts) :continue :fail)))
+a)))
+(defn send
+"Dispatch an action to an agent. Returns the agent immediately.
+Subsequently, in a thread from a thread pool, the state of the agent
+will be set to the value of:
+(apply action-fn state-of-agent args)"
+{:added "1.0"}
+[^clojure.lang.Agent a f & args]
+(. a (dispatch f args false)))
+(defn send-off
+"Dispatch a potentially blocking action to an agent. Returns the
+agent immediately. Subsequently, in a separate thread, the state of
+the agent will be set to the value of:
+(apply action-fn state-of-agent args)"
+{:added "1.0"}
+[^clojure.lang.Agent a f & args]
+(. a (dispatch f args true)))
+(defn release-pending-sends
+"Normally, actions sent directly or indirectly during another action
+are held until the action completes (changes the agent's
+state). This function can be used to dispatch any pending sent
+actions immediately. This has no impact on actions sent during a
+transaction, which are still held until commit. If no action is
+occurring, does nothing. Returns the number of actions dispatched."
+{:added "1.0"}
+[] (clojure.lang.Agent/releasePendingSends))
+(defn add-watch
+"Alpha - subject to change.
+Adds a watch function to an agent/atom/var/ref reference. The watch
+fn must be a fn of 4 args: a key, the reference, its old-state, its
+new-state. Whenever the reference's state might have been changed,
+any registered watches will have their functions called. The watch fn
+will be called synchronously, on the agent's thread if an agent,
+before any pending sends if agent or ref. Note that an atom's or
+ref's state may have changed again prior to the fn call, so use
+old/new-state rather than derefing the reference. Note also that watch
+fns may be called from multiple threads simultaneously. Var watchers
+are triggered only by root binding changes, not thread-local
+set!s. Keys must be unique per reference, and can be used to remove
+the watch with remove-watch, but are otherwise considered opaque by
+the watch mechanism."
+{:added "1.0"}
+[^clojure.lang.IRef reference key fn] (.addWatch reference key fn))
+(defn remove-watch
+"Alpha - subject to change.
+Removes a watch (set by add-watch) from a reference"
+{:added "1.0"}
+[^clojure.lang.IRef reference key]
+(.removeWatch reference key))
+(defn agent-error
+"Returns the exception thrown during an asynchronous action of the
+agent if the agent is failed.  Returns nil if the agent is not
+failed."
+{:added "1.2"}
+[^clojure.lang.Agent a] (.getError a))
+(defn restart-agent
+"When an agent is failed, changes the agent state to new-state and
+then un-fails the agent so that sends are allowed again.  If
+a :clear-actions true option is given, any actions queued on the
+agent that were being held while it was failed will be discarded,
+otherwise those held actions will proceed.  The new-state must pass
+the validator if any, or restart will throw an exception and the
+agent will remain failed with its old state and error.  Watchers, if
+any, will NOT be notified of the new state.  Throws an exception if
+the agent is not failed."
+{:added "1.2"}
+[^clojure.lang.Agent a, new-state & options]
+(let [opts (apply hash-map options)]
+(.restart a new-state (if (:clear-actions opts) true false))))
+(defn set-error-handler!
+"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 "1.2"}
+[^clojure.lang.Agent a, handler-fn]
+(.setErrorHandler a handler-fn))
+(defn error-handler
+"Returns the error-handler of agent a, or nil if there is none.
+See set-error-handler!"
+{:added "1.2"}
+[^clojure.lang.Agent a]
+(.getErrorHandler a))
+(defn set-error-mode!
+"Sets the error-mode of agent a to mode-keyword, which must be
+either :fail or :continue.  If an action being run by the agent
+throws an exception or doesn't pass the validator fn, an
+error-handler may be called (see set-error-handler!), after which,
+if the mode is :continue, the agent will continue as if neither the
+action that caused the error nor the error itself ever happened.
+If the mode is :fail, the agent will become failed and will stop
+accepting new 'send' and 'send-off' actions, and any previously
+queued actions will be held until a 'restart-agent'.  Deref will
+still work, returning the state of the agent before the error."
+{:added "1.2"}
+[^clojure.lang.Agent a, mode-keyword]
+(.setErrorMode a mode-keyword))
+(defn error-mode
+"Returns the error-mode of agent a.  See set-error-mode!"
+{:added "1.2"}
+[^clojure.lang.Agent a]
+(.getErrorMode a))
+(defn agent-errors
+"DEPRECATED: Use 'agent-error' instead.
+Returns a sequence of the exceptions thrown during asynchronous
+actions of the agent."
+{:added "1.0"
+:deprecated "1.2"}
+[a]
+(when-let [e (agent-error a)]
+(list e)))
+(defn clear-agent-errors
+"DEPRECATED: Use 'restart-agent' instead.
+Clears any exceptions thrown during asynchronous actions of the
+agent, allowing subsequent actions to occur."
+{:added "1.0"
+:deprecated "1.2"}
+[^clojure.lang.Agent a] (restart-agent a (.deref a)))
+(defn shutdown-agents
+"Initiates a shutdown of the thread pools that back the agent
+system. Running actions will complete, but no new actions will be
+accepted"
+{:added "1.0"}
+[] (. clojure.lang.Agent shutdown))
+(defn ref
+"Creates and returns a Ref with an initial value of x and zero or
+more options (in any order):
+:meta metadata-map
+:validator validate-fn
+:min-history (default 0)
+:max-history (default 10)
+If metadata-map is supplied, it will be come the metadata on the
+ref. validate-fn must be nil or a side-effect-free fn of one
+argument, which will be passed the intended new state on any state
+change. If the new state is unacceptable, the validate-fn should
+return false or throw an exception. validate-fn will be called on
+transaction commit, when all refs have their final values.
+Normally refs accumulate history dynamically as needed to deal with
+read demands. If you know in advance you will need history you can
+set :min-history to ensure it will be available when first needed (instead
+of after a read fault). History is limited, and the limit can be set
+with :max-history."
+{:added "1.0"}
+([x] (new clojure.lang.Ref x))
+([x & options]
+(let [r  ^clojure.lang.Ref (setup-reference (ref x) options)
+opts (apply hash-map options)]
+(when (:max-history opts)
+(.setMaxHistory r (:max-history opts)))
+(when (:min-history opts)
+(.setMinHistory r (:min-history opts)))
+r)))
+(defn deref
+"Also reader macro: @ref/@agent/@var/@atom/@delay/@future. Within a transaction,
+returns the in-transaction-value of ref, else returns the
+most-recently-committed value of ref. When applied to a var, agent
+or atom, returns its current state. When applied to a delay, forces
+it if not already forced. When applied to a future, will block if
+computation not complete"
+{:added "1.0"}
+[^clojure.lang.IDeref ref] (.deref ref))
+(defn atom
+"Creates and returns an Atom with an initial value of x and zero or
+more options (in any order):
+:meta metadata-map
+:validator validate-fn
+If metadata-map is supplied, it will be come the metadata on the
+atom. validate-fn must be nil or a side-effect-free fn of one
+argument, which will be passed the intended new state on any state
+change. If the new state is unacceptable, the validate-fn should
+return false or throw an exception."
+{:added "1.0"}
+([x] (new clojure.lang.Atom x))
+([x & options] (setup-reference (atom x) options)))
+(defn swap!
+"Atomically swaps the value of atom to be:
+(apply f current-value-of-atom args). Note that f may be called
+multiple times, and thus should be free of side effects.  Returns
+the value that was swapped in."
+{:added "1.0"}
+([^clojure.lang.Atom atom f] (.swap atom f))
+([^clojure.lang.Atom atom f x] (.swap atom f x))
+([^clojure.lang.Atom atom f x y] (.swap atom f x y))
+([^clojure.lang.Atom atom f x y & args] (.swap atom f x y args)))
+(defn compare-and-set!
+"Atomically sets the value of atom to newval if and only if the
+current value of the atom is identical to oldval. Returns true if
+set happened, else false"
+{:added "1.0"}
+[^clojure.lang.Atom atom oldval newval] (.compareAndSet atom oldval newval))
+(defn reset!
+"Sets the value of atom to newval without regard for the
+current value. Returns newval."
+{:added "1.0"}
+[^clojure.lang.Atom atom newval] (.reset atom newval))
+(defn set-validator!
+"Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a
+side-effect-free fn of one argument, which will be passed the intended
+new state on any state change. If the new state is unacceptable, the
+validator-fn should return false or throw an exception. If the current state (root
+value if var) is not acceptable to the new validator, an exception
+will be thrown and the validator will not be changed."
+{:added "1.0"}
+[^clojure.lang.IRef iref validator-fn] (. iref (setValidator validator-fn)))
+(defn get-validator
+"Gets the validator-fn for a var/ref/agent/atom."
+{:added "1.0"}
+[^clojure.lang.IRef iref] (. iref (getValidator)))
+(defn alter-meta!
+"Atomically sets the metadata for a namespace/var/ref/agent/atom to be:
+(apply f its-current-meta args)
+f must be free of side-effects"
+{:added "1.0"}
+[^clojure.lang.IReference iref f & args] (.alterMeta iref f args))
+(defn reset-meta!
+"Atomically resets the metadata for a namespace/var/ref/agent/atom"
+{:added "1.0"}
+[^clojure.lang.IReference iref metadata-map] (.resetMeta iref metadata-map))
+(defn commute
+"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.
+At the commit point of the transaction, sets the value of ref to be:
+(apply fun most-recently-committed-value-of-ref args)
+Thus fun should be commutative, or, failing that, you must accept
+last-one-in-wins behavior.  commute allows for more concurrency than
+ref-set."
+{:added "1.0"}
+[^clojure.lang.Ref ref fun & args]
+(. ref (commute fun args)))
+(defn alter
+"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."
+{:added "1.0"}
+[^clojure.lang.Ref ref fun & args]
+(. ref (alter fun args)))
+(defn ref-set
+"Must be called in a transaction. Sets the value of ref.
+Returns val."
+{:added "1.0"}
+[^clojure.lang.Ref ref val]
+(. ref (set val)))
+(defn ref-history-count
+"Returns the history count of a ref"
+{:added "1.1"}
+[^clojure.lang.Ref ref]
+(.getHistoryCount ref))
+(defn ref-min-history
+"Gets the min-history of a ref, or sets it and returns the ref"
+{:added "1.1"}
+([^clojure.lang.Ref ref]
+(.getMinHistory ref))
+([^clojure.lang.Ref ref n]
+(.setMinHistory ref n)))
+(defn ref-max-history
+"Gets the max-history of a ref, or sets it and returns the ref"
+{:added "1.1"}
+([^clojure.lang.Ref ref]
+(.getMaxHistory ref))
+([^clojure.lang.Ref ref n]
+(.setMaxHistory ref n)))
+(defn ensure
+"Must be called in a transaction. Protects the ref from modification
+by other transactions.  Returns the in-transaction-value of
+ref. Allows for more concurrency than (ref-set ref @ref)"
+{:added "1.0"}
+[^clojure.lang.Ref ref]
+(. ref (touch))
+(. ref (deref)))
+(defmacro sync
+"transaction-flags => TBD, pass nil for now
+Runs the exprs (in an implicit do) in a transaction that encompasses
+exprs and any nested calls.  Starts a transaction if none is already
+running on this thread. Any uncaught exception will abort the
+transaction and flow out of sync. The exprs may be run more than
+once, but any effects on Refs will be atomic."
+{:added "1.0"}
+[flags-ignored-for-now & body]
+`(. clojure.lang.LockingTransaction
+(runInTransaction (fn [] ~@body))))
+(defmacro io!
+"If an io! block occurs in a transaction, throws an
+IllegalStateException, else runs body in an implicit do. If the
+first expression in body is a literal string, will use that as the
+exception message."
+{:added "1.0"}
+[& body]
+(let [message (when (string? (first body)) (first body))
+body (if message (next body) body)]
+`(if (clojure.lang.LockingTransaction/isRunning)
+(throw (new IllegalStateException ~(or message "I/O in transaction")))
+(do ~@body))))
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; fn stuff ;;;;;;;;;;;;;;;;
+(defn comp
+"Takes a set of functions and returns a fn that is the composition
+of those fns.  The returned fn takes a variable number of args,
+applies the rightmost of fns to the args, the next
+fn (right-to-left) to the result, etc."
+{:added "1.0"}
+([f] f)
+([f g]
+(fn
+([] (f (g)))
+([x] (f (g x)))
+([x y] (f (g x y)))
+([x y z] (f (g x y z)))
+([x y z & args] (f (apply g x y z args)))))
+([f g h]
+(fn
+([] (f (g (h))))
+([x] (f (g (h x))))
+([x y] (f (g (h x y))))
+([x y z] (f (g (h x y z))))
+([x y z & args] (f (g (apply h x y z args))))))
+([f1 f2 f3 & fs]
+(let [fs (reverse (list* f1 f2 f3 fs))]
+(fn [& args]
+(loop [ret (apply (first fs) args) fs (next fs)]
+(if fs
+(recur ((first fs) ret) (next fs))
+ret))))))
+(defn juxt
+"Alpha - name subject to change.
+Takes a set of functions and returns a fn that is the juxtaposition
+of those fns.  The returned fn takes a variable number of args, and
+returns a vector containing the result of applying each fn to the
+args (left-to-right).
+((juxt a b c) x) => [(a x) (b x) (c x)]"
+{:added "1.1"}
+([f]
+(fn
+([] [(f)])
+([x] [(f x)])
+([x y] [(f x y)])
+([x y z] [(f x y z)])
+([x y z & args] [(apply f x y z args)])))
+([f g]
+(fn
+([] [(f) (g)])
+([x] [(f x) (g x)])
+([x y] [(f x y) (g x y)])
+([x y z] [(f x y z) (g x y z)])
+([x y z & args] [(apply f x y z args) (apply g x y z args)])))
+([f g h]
+(fn
+([] [(f) (g) (h)])
+([x] [(f x) (g x) (h x)])
+([x y] [(f x y) (g x y) (h x y)])
+([x y z] [(f x y z) (g x y z) (h x y z)])
+([x y z & args] [(apply f x y z args) (apply g x y z args) (apply h x y z args)])))
+([f g h & fs]
+(let [fs (list* f g h fs)]
+(fn
+([] (reduce #(conj %1 (%2)) [] fs))
+([x] (reduce #(conj %1 (%2 x)) [] fs))
+([x y] (reduce #(conj %1 (%2 x y)) [] fs))
+([x y z] (reduce #(conj %1 (%2 x y z)) [] fs))
+([x y z & args] (reduce #(conj %1 (apply %2 x y z args)) [] fs))))))
+(defn partial
+"Takes a function f and fewer than the normal arguments to f, and
+returns a fn that takes a variable number of additional args. When
+called, the returned function calls f with args + additional args."
+{:added "1.0"}
+([f arg1]
+(fn [& args] (apply f arg1 args)))
+([f arg1 arg2]
+(fn [& args] (apply f arg1 arg2 args)))
+([f arg1 arg2 arg3]
+(fn [& args] (apply f arg1 arg2 arg3 args)))
+([f arg1 arg2 arg3 & more]
+(fn [& args] (apply f arg1 arg2 arg3 (concat more args)))))
+;;;;;;;;;;;;;;;;;;; sequence fns  ;;;;;;;;;;;;;;;;;;;;;;;
+(defn sequence
+"Coerces coll to a (possibly empty) sequence, if it is not already
+one. Will not force a lazy seq. (sequence nil) yields ()"
+{:added "1.0"}
+[coll]
+(if (seq? coll) coll
+(or (seq coll) ())))
+(defn every?
+"Returns true if (pred x) is logical true for every x in coll, else
+false."
+{:tag Boolean
+:added "1.0"}
+[pred coll]
+(cond
+(nil? (seq coll)) true
+(pred (first coll)) (recur pred (next coll))
+:else false))
+(def
+^{:tag Boolean
+:doc "Returns false if (pred x) is logical true for every x in
+coll, else true."
+:arglists '([pred coll])
+:added "1.0"}
+not-every? (comp not every?))
+(defn some
+"Returns the first logical true value of (pred x) for any x in coll,
+else nil.  One common idiom is to use a set as pred, for example
+this will return :fred if :fred is in the sequence, otherwise nil:
+(some #{:fred} coll)"
+{:added "1.0"}
+[pred coll]
+(when (seq coll)
+(or (pred (first coll)) (recur pred (next coll)))))
+(def
+^{:tag Boolean
+:doc "Returns false if (pred x) is logical true for any x in coll,
+else true."
+:arglists '([pred coll])
+:added "1.0"}
+not-any? (comp not some))
+;will be redefed later with arg checks
+(defmacro dotimes
+"bindings => name n
+Repeatedly executes body (presumably for side-effects) with name
+bound to integers from 0 through n-1."
+{:added "1.0"}
+[bindings & body]
+(let [i (first bindings)
+n (second bindings)]
+`(let [n# (int ~n)]
+(loop [~i (int 0)]
+(when (< ~i n#)
+~@body
+(recur (inc ~i)))))))
+(defn map
+"Returns a lazy sequence consisting of the result of applying f to the
+set of first items of each coll, followed by applying f to the set
+of second items in each coll, until any one of the colls is
+exhausted.  Any remaining items in other colls are ignored. Function
+f should accept number-of-colls arguments."
+{:added "1.0"}
+([f coll]
+(lazy-seq
+(when-let [s (seq coll)]
+(if (chunked-seq? s)
+(let [c (chunk-first s)
+size (int (count c))
+b (chunk-buffer size)]
+(dotimes [i size]
+(chunk-append b (f (.nth c i))))
+(chunk-cons (chunk b) (map f (chunk-rest s))))
+(cons (f (first s)) (map f (rest s)))))))
+([f c1 c2]
+(lazy-seq
+(let [s1 (seq c1) s2 (seq c2)]
+(when (and s1 s2)
+(cons (f (first s1) (first s2))
+(map f (rest s1) (rest s2)))))))
+([f c1 c2 c3]
+(lazy-seq
+(let [s1 (seq c1) s2 (seq c2) s3 (seq c3)]
+(when (and  s1 s2 s3)
+(cons (f (first s1) (first s2) (first s3))
+(map f (rest s1) (rest s2) (rest s3)))))))
+([f c1 c2 c3 & colls]
+(let [step (fn step [cs]
+(lazy-seq
+(let [ss (map seq cs)]
+(when (every? identity ss)
+(cons (map first ss) (step (map rest ss)))))))]
+(map #(apply f %) (step (conj colls c3 c2 c1))))))
+(defn mapcat
+"Returns the result of applying concat to the result of applying map
+to f and colls.  Thus function f should return a collection."
+{:added "1.0"}
+[f & colls]
+(apply concat (apply map f colls)))
+(defn filter
+"Returns a lazy sequence of the items in coll for which
+(pred item) returns true. pred must be free of side-effects."
+{:added "1.0"}
+([pred coll]
+(lazy-seq
+(when-let [s (seq coll)]
+(if (chunked-seq? s)
+(let [c (chunk-first s)
+size (count c)
+b (chunk-buffer size)]
+(dotimes [i size]
+(when (pred (.nth c i))
+(chunk-append b (.nth c i))))
+(chunk-cons (chunk b) (filter pred (chunk-rest s))))
+(let [f (first s) r (rest s)]
+(if (pred f)
+(cons f (filter pred r))
+(filter pred r))))))))
+(defn remove
+"Returns a lazy sequence of the items in coll for which
+(pred item) returns false. pred must be free of side-effects."
+{:added "1.0"}
+[pred coll]
+(filter (complement pred) coll))
+(defn take
+"Returns a lazy sequence of the first n items in coll, or all items if
+there are fewer than n."
+{:added "1.0"}
+[n coll]
+(lazy-seq
+(when (pos? n)
+(when-let [s (seq coll)]
+(cons (first s) (take (dec n) (rest s)))))))
+(defn take-while
+"Returns a lazy sequence of successive items from coll while
+(pred item) returns true. pred must be free of side-effects."
+{:added "1.0"}
+[pred coll]
+(lazy-seq
+(when-let [s (seq coll)]
+(when (pred (first s))
+(cons (first s) (take-while pred (rest s)))))))
+(defn drop
+"Returns a lazy sequence of all but the first n items in coll."
+{:added "1.0"}
+[n coll]
+(let [step (fn [n coll]
+(let [s (seq coll)]
+(if (and (pos? n) s)
+(recur (dec n) (rest s))
+s)))]
+(lazy-seq (step n coll))))
+(defn drop-last
+"Return a lazy sequence of all but the last n (default 1) items in coll"
+{:added "1.0"}
+([s] (drop-last 1 s))
+([n s] (map (fn [x _] x) s (drop n s))))
+(defn take-last
+"Returns a seq of the last n items in coll.  Depending on the type
+of coll may be no better than linear time.  For vectors, see also subvec."
+{:added "1.1"}
+[n coll]
+(loop [s (seq coll), lead (seq (drop n coll))]
+(if lead
+(recur (next s) (next lead))
+s)))
+(defn drop-while
+"Returns a lazy sequence of the items in coll starting from the first
+item for which (pred item) returns nil."
+{:added "1.0"}
+[pred coll]
+(let [step (fn [pred coll]
+(let [s (seq coll)]
+(if (and s (pred (first s)))
+(recur pred (rest s))
+s)))]
+(lazy-seq (step pred coll))))
+(defn cycle
+"Returns a lazy (infinite!) sequence of repetitions of the items in coll."
+{:added "1.0"}
+[coll] (lazy-seq
+(when-let [s (seq coll)]
+(concat s (cycle s)))))
+(defn split-at
+"Returns a vector of [(take n coll) (drop n coll)]"
+{:added "1.0"}
+[n coll]
+[(take n coll) (drop n coll)])
+(defn split-with
+"Returns a vector of [(take-while pred coll) (drop-while pred coll)]"
+{:added "1.0"}
+[pred coll]
+[(take-while pred coll) (drop-while pred coll)])
+(defn repeat
+"Returns a lazy (infinite!, or length n if supplied) sequence of xs."
+{:added "1.0"}
+([x] (lazy-seq (cons x (repeat x))))
+([n x] (take n (repeat x))))
+(defn replicate
+"Returns a lazy seq of n xs."
+{:added "1.0"}
+[n x] (take n (repeat x)))
+(defn iterate
+"Returns a lazy sequence of x, (f x), (f (f x)) etc. f must be free of side-effects"
+{:added "1.0"}
+[f x] (cons x (lazy-seq (iterate f (f x)))))
+(defn range
+"Returns a lazy seq of nums from start (inclusive) to end
+(exclusive), by step, where start defaults to 0, step to 1, and end
+to infinity."
+{:added "1.0"}
+([] (range 0 Double/POSITIVE_INFINITY 1))
+([end] (range 0 end 1))
+([start end] (range start end 1))
+([start end step]
+(lazy-seq
+(let [b (chunk-buffer 32)
+comp (if (pos? step) < >)]
+(loop [i start]
+(if (and (< (count b) 32)
+(comp i end))
+(do
+(chunk-append b i)
+(recur (+ i step)))
+(chunk-cons (chunk b)
+(when (comp i end)
+(range i end step)))))))))
+(defn merge
+"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 "1.0"}
+[& maps]
+(when (some identity maps)
+(reduce #(conj (or %1 {}) %2) maps)))
+(defn merge-with
+"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 "1.0"}
+[f & maps]
+(when (some identity maps)
+(let [merge-entry (fn [m e]
+			(let [k (key e) v (val e)]
+			  (if (contains? m k)
+			    (assoc m k (f (get m k) v))
+			    (assoc m k v))))
+merge2 (fn [m1 m2]
+		   (reduce merge-entry (or m1 {}) (seq m2)))]
+(reduce merge2 maps))))
+(defn zipmap
+"Returns a map with the keys mapped to the corresponding vals."
+{:added "1.0"}
+[keys vals]
+(loop [map {}
+ks (seq keys)
+vs (seq vals)]
+(if (and ks vs)
+(recur (assoc map (first ks) (first vs))
+(next ks)
+(next vs))
+map)))
+(defmacro declare
+"defs the supplied var names with no bindings, useful for making forward declarations."
+{:added "1.0"}
+[& names] `(do ~@(map #(list 'def (vary-meta % assoc :declared true)) names)))
+(defn line-seq
+"Returns the lines of text from rdr as a lazy sequence of strings.
+rdr must implement java.io.BufferedReader."
+{:added "1.0"}
+[^java.io.BufferedReader rdr]
+(when-let [line (.readLine rdr)]
+(cons line (lazy-seq (line-seq rdr)))))
+(defn comparator
+"Returns an implementation of java.util.Comparator based upon pred."
+{:added "1.0"}
+[pred]
+(fn [x y]
+(cond (pred x y) -1 (pred y x) 1 :else 0)))
+(defn sort
+"Returns a sorted sequence of the items in coll. If no comparator is
+supplied, uses compare. comparator must
+implement java.util.Comparator."
+{:added "1.0"}
+([coll]
+(sort compare coll))
+([^java.util.Comparator comp coll]
+(if (seq coll)
+(let [a (to-array coll)]
+(. java.util.Arrays (sort a comp))
+(seq a))
+())))
+(defn sort-by
+"Returns a sorted sequence of the items in coll, where the sort
+order is determined by comparing (keyfn item).  If no comparator is
+supplied, uses compare. comparator must
+implement java.util.Comparator."
+{:added "1.0"}
+([keyfn coll]
+(sort-by keyfn compare coll))
+([keyfn ^java.util.Comparator comp coll]
+(sort (fn [x y] (. comp (compare (keyfn x) (keyfn y)))) coll)))
+(defn partition
+"Returns a lazy sequence of lists of n items each, at offsets step
+apart. If step is not supplied, defaults to n, i.e. the partitions
+do not overlap. If a pad collection is supplied, use its elements as
+necessary to complete last partition upto n items. In case there are
+not enough padding elements, return a partition with less than n items."
+{:added "1.0"}
+([n coll]
+(partition n n coll))
+([n step coll]
+(lazy-seq
+(when-let [s (seq coll)]
+(let [p (take n s)]
+(when (= n (count p))
+(cons p (partition n step (drop step s))))))))
+([n step pad coll]
+(lazy-seq
+(when-let [s (seq coll)]
+(let [p (take n s)]
+(if (= n (count p))
+(cons p (partition n step pad (drop step s)))
+(list (take n (concat p pad)))))))))
+;; evaluation
+(defn eval
+"Evaluates the form data structure (not text!) and returns the result."
+{:added "1.0"}
+[form] (. clojure.lang.Compiler (eval form)))
+(defmacro doseq
+"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 "1.0"}
+[seq-exprs & body]
+(assert-args doseq
+(vector? seq-exprs) "a vector for its binding"
+(even? (count seq-exprs)) "an even number of forms in binding vector")
+(let [step (fn step [recform exprs]
+(if-not exprs
+[true `(do ~@body)]
+(let [k (first exprs)
+v (second exprs)]
+(if (keyword? k)
+(let [steppair (step recform (nnext exprs))
+needrec (steppair 0)
+subform (steppair 1)]
+(cond
+(= k :let) [needrec `(let ~v ~subform)]
+(= k :while) [false `(when ~v
+~subform
+~@(when needrec [recform]))]
+(= k :when) [false `(if ~v
+(do
+~subform
+~@(when needrec [recform]))
+~recform)]))
+(let [seq- (gensym "seq_")
+chunk- (with-meta (gensym "chunk_")
+{:tag 'clojure.lang.IChunk})
+count- (gensym "count_")
+i- (gensym "i_")
+recform `(recur (next ~seq-) nil (int 0) (int 0))
+steppair (step recform (nnext exprs))
+needrec (steppair 0)
+subform (steppair 1)
+recform-chunk
+`(recur ~seq- ~chunk- ~count- (unchecked-inc ~i-))
+steppair-chunk (step recform-chunk (nnext exprs))
+subform-chunk (steppair-chunk 1)]
+[true
+`(loop [~seq- (seq ~v), ~chunk- nil,
+~count- (int 0), ~i- (int 0)]
+(if (< ~i- ~count-)
+(let [~k (.nth ~chunk- ~i-)]
+~subform-chunk
+~@(when needrec [recform-chunk]))
+(when-let [~seq- (seq ~seq-)]
+(if (chunked-seq? ~seq-)
+(let [c# (chunk-first ~seq-)]
+(recur (chunk-rest ~seq-) c#
+(int (count c#)) (int 0)))
+(let [~k (first ~seq-)]
+~subform
+~@(when needrec [recform]))))))])))))]
+(nth (step nil (seq seq-exprs)) 1)))
+(defn dorun
+"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 "1.0"}
+([coll]
+(when (seq coll)
+(recur (next coll))))
+([n coll]
+(when (and (seq coll) (pos? n))
+(recur (dec n) (next coll)))))
+(defn doall
+"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 "1.0"}
+([coll]
+(dorun coll)
+coll)
+([n coll]
+(dorun n coll)
+coll))
+(defn await
+"Blocks the current thread (indefinitely!) until all actions
+dispatched thus far, from this thread or agent, to the agent(s) have
+occurred.  Will block on failed agents.  Will never return if
+a failed agent is restarted with :clear-actions true."
+{:added "1.0"}
+[& agents]
+(io! "await in transaction"
+(when *agent*
+(throw (new Exception "Can't await in agent action")))
+(let [latch (new java.util.concurrent.CountDownLatch (count agents))
+count-down (fn [agent] (. latch (countDown)) agent)]
+(doseq [agent agents]
+(send agent count-down))
+(. latch (await)))))
+(defn await1 [^clojure.lang.Agent a]
+(when (pos? (.getQueueCount a))
+(await a))
+a)
+(defn await-for
+"Blocks the current thread until all actions dispatched thus
+far (from this thread or agent) to the agents have occurred, or the
+timeout (in milliseconds) has elapsed. Returns nil if returning due
+to timeout, non-nil otherwise."
+{:added "1.0"}
+[timeout-ms & agents]
+(io! "await-for in transaction"
+(when *agent*
+(throw (new Exception "Can't await in agent action")))
+(let [latch (new java.util.concurrent.CountDownLatch (count agents))
+count-down (fn [agent] (. latch (countDown)) agent)]
+(doseq [agent agents]
+(send agent count-down))
+(. latch (await  timeout-ms (. java.util.concurrent.TimeUnit MILLISECONDS))))))
+(defmacro dotimes
+"bindings => name n
+Repeatedly executes body (presumably for side-effects) with name
+bound to integers from 0 through n-1."
+{:added "1.0"}
+[bindings & body]
+(assert-args dotimes
+(vector? bindings) "a vector for its binding"
+(= 2 (count bindings)) "exactly 2 forms in binding vector")
+(let [i (first bindings)
+n (second bindings)]
+`(let [n# (int ~n)]
+(loop [~i (int 0)]
+(when (< ~i n#)
+~@body
+(recur (unchecked-inc ~i)))))))
+#_(defn into
+"Returns a new coll consisting of to-coll with all of the items of
+from-coll conjoined."
+{:added "1.0"}
+[to from]
+(let [ret to items (seq from)]
+(if items
+(recur (conj ret (first items)) (next items))
+ret)))
+;;;;;;;;;;;;;;;;;;;;; editable collections ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(defn transient
+"Alpha - subject to change.
+Returns a new, transient version of the collection, in constant time."
+{:added "1.1"}
+[^clojure.lang.IEditableCollection coll]
+(.asTransient coll))
+(defn persistent!
+"Alpha - subject to change.
+Returns a new, persistent version of the transient collection, in
+constant time. The transient collection cannot be used after this
+call, any such use will throw an exception."
+{:added "1.1"}
+[^clojure.lang.ITransientCollection coll]
+(.persistent coll))
+(defn conj!
+"Alpha - subject to change.
+Adds x to the transient collection, and return coll. The 'addition'
+may happen at different 'places' depending on the concrete type."
+{:added "1.1"}
+[^clojure.lang.ITransientCollection coll x]
+(.conj coll x))
+(defn assoc!
+"Alpha - subject to change.
+When applied to a transient map, adds mapping of key(s) to
+val(s). When applied to a transient vector, sets the val at index.
+Note - index must be <= (count vector). Returns coll."
+{:added "1.1"}
+([^clojure.lang.ITransientAssociative coll key val] (.assoc coll key val))
+([^clojure.lang.ITransientAssociative coll key val & kvs]
+(let [ret (.assoc coll key val)]
+(if kvs
+(recur ret (first kvs) (second kvs) (nnext kvs))
+ret))))
+(defn dissoc!
+"Alpha - subject to change.
+Returns a transient map that doesn't contain a mapping for key(s)."
+{:added "1.1"}
+([^clojure.lang.ITransientMap map key] (.without map key))
+([^clojure.lang.ITransientMap map key & ks]
+(let [ret (.without map key)]
+(if ks
+(recur ret (first ks) (next ks))
+ret))))
+(defn pop!
+"Alpha - subject to change.
+Removes the last item from a transient vector. If
+the collection is empty, throws an exception. Returns coll"
+{:added "1.1"}
+[^clojure.lang.ITransientVector coll]
+(.pop coll))
+(defn disj!
+"Alpha - subject to change.
+disj[oin]. Returns a transient set of the same (hashed/sorted) type, that
+does not contain key(s)."
+{:added "1.1"}
+([set] set)
+([^clojure.lang.ITransientSet set key]
+(. set (disjoin key)))
+([set key & ks]
+(let [ret (disj set key)]
+(if ks
+(recur ret (first ks) (next ks))
+ret))))
+;redef into with batch support
+(defn into
+"Returns a new coll consisting of to-coll with all of the items of
+from-coll conjoined."
+{:added "1.0"}
+[to from]
+(if (instance? clojure.lang.IEditableCollection to)
+(persistent! (reduce conj! (transient to) from))
+(reduce conj to from)))
+(defmacro import
+"import-list => (package-symbol class-name-symbols*)
+For each name in class-name-symbols, adds a mapping from name to the
+class named by package.name to the current namespace. Use :import in the ns
+macro in preference to calling this directly."
+{:added "1.0"}
+[& import-symbols-or-lists]
+(let [specs (map #(if (and (seq? %) (= 'quote (first %))) (second %) %)
+import-symbols-or-lists)]
+`(do ~@(map #(list 'clojure.core/import* %)
+(reduce (fn [v spec]
+(if (symbol? spec)
+(conj v (name spec))
+(let [p (first spec) cs (rest spec)]
+(into v (map #(str p "." %) cs)))))
+[] specs)))))
+(defn into-array
+"Returns an array with components set to the values in aseq. The array's
+component type is type if provided, or the type of the first value in
+aseq if present, or Object. All values in aseq must be compatible with
+the component type. Class objects for the primitive types can be obtained
+using, e.g., Integer/TYPE."
+{:added "1.0"}
+([aseq]
+(clojure.lang.RT/seqToTypedArray (seq aseq)))
+([type aseq]
+(clojure.lang.RT/seqToTypedArray type (seq aseq))))
+(defn ^{:private true}
+array [& items]
+(into-array items))
+(defn ^Class class
+"Returns the Class of x"
+{:added "1.0"}
+[^Object x] (if (nil? x) x (. x (getClass))))
+(defn type
+"Returns the :type metadata of x, or its Class if none"
+{:added "1.0"}
+[x]
+(or (:type (meta x)) (class x)))
+(defn num
+"Coerce to Number"
+{:tag Number
+:inline (fn  [x] `(. clojure.lang.Numbers (num ~x)))
+:added "1.0"}
+[x] (. clojure.lang.Numbers (num x)))
+(defn long
+"Coerce to long"
+{:tag Long
+:inline (fn  [x] `(. clojure.lang.RT (longCast ~x)))
+:added "1.0"}
+[^Number x] (clojure.lang.RT/longCast x))
+(defn float
+"Coerce to float"
+{:tag Float
+:inline (fn  [x] `(. clojure.lang.RT (floatCast ~x)))
+:added "1.0"}
+[^Number x] (clojure.lang.RT/floatCast x))
+(defn double
+"Coerce to double"
+{:tag Double
+:inline (fn  [x] `(. clojure.lang.RT (doubleCast ~x)))
+:added "1.0"}
+[^Number x] (clojure.lang.RT/doubleCast x))
+(defn short
+"Coerce to short"
+{:tag Short
+:inline (fn  [x] `(. clojure.lang.RT (shortCast ~x)))
+:added "1.0"}
+[^Number x] (clojure.lang.RT/shortCast x))
+(defn byte
+"Coerce to byte"
+{:tag Byte
+:inline (fn  [x] `(. clojure.lang.RT (byteCast ~x)))
+:added "1.0"}
+[^Number x] (clojure.lang.RT/byteCast x))
+(defn char
+"Coerce to char"
+{:tag Character
+:inline (fn  [x] `(. clojure.lang.RT (charCast ~x)))
+:added "1.1"}
+[x] (. clojure.lang.RT (charCast x)))
+(defn boolean
+"Coerce to boolean"
+{
+:inline (fn  [x] `(. clojure.lang.RT (booleanCast ~x)))
+:added "1.0"}
+[x] (clojure.lang.RT/booleanCast x))
+(defn number?
+"Returns true if x is a Number"
+{:added "1.0"}
+[x]
+(instance? Number x))
+(defn integer?
+"Returns true if n is an integer"
+{:added "1.0"}
+[n]
+(or (instance? Integer n)
+(instance? Long n)
+(instance? BigInteger n)
+(instance? Short n)
+(instance? Byte n)))
+(defn mod
+"Modulus of num and div. Truncates toward negative infinity."
+{:added "1.0"}
+[num div]
+(let [m (rem num div)]
+(if (or (zero? m) (pos? (* num div)))
+m
+(+ m div))))
+(defn ratio?
+"Returns true if n is a Ratio"
+{:added "1.0"}
+[n] (instance? clojure.lang.Ratio n))
+(defn numerator
+"Returns the numerator part of a Ratio."
+{:tag BigInteger
+:added "1.2"}
+[r]
+(.numerator ^clojure.lang.Ratio r))
+(defn denominator
+"Returns the denominator part of a Ratio."
+{:tag BigInteger
+:added "1.2"}
+[r]
+(.denominator ^clojure.lang.Ratio r))
+(defn decimal?
+"Returns true if n is a BigDecimal"
+{:added "1.0"}
+[n] (instance? BigDecimal n))
+(defn float?
+"Returns true if n is a floating point number"
+{:added "1.0"}
+[n]
+(or (instance? Double n)
+(instance? Float n)))
+(defn rational? [n]
+"Returns true if n is a rational number"
+{:added "1.0"}
+(or (integer? n) (ratio? n) (decimal? n)))
+(defn bigint
+"Coerce to BigInteger"
+{:tag BigInteger
+:added "1.0"}
+[x] (cond
+(instance? BigInteger x) x
+(decimal? x) (.toBigInteger ^BigDecimal x)
+(ratio? x) (.bigIntegerValue ^clojure.lang.Ratio x)
+(number? x) (BigInteger/valueOf (long x))
+:else (BigInteger. x)))
+(defn bigdec
+"Coerce to BigDecimal"
+{:tag BigDecimal
+:added "1.0"}
+[x] (cond
+(decimal? x) x
+(float? x) (. BigDecimal valueOf (double x))
+(ratio? x) (/ (BigDecimal. (.numerator x)) (.denominator x))
+(instance? BigInteger x) (BigDecimal. ^BigInteger x)
+(number? x) (BigDecimal/valueOf (long x))
+:else (BigDecimal. x)))
+(def ^{:private true} print-initialized false)
+(defmulti print-method (fn [x writer] (type x)))
+(defmulti print-dup (fn [x writer] (class x)))
+(defn pr-on
+{:private true}
+[x w]
+(if *print-dup*
+(print-dup x w)
+(print-method x w))
+nil)
+(defn pr
+"Prints the object(s) to the output stream that is the current value
+of *out*.  Prints the object(s), separated by spaces if there is
+more than one.  By default, pr and prn print in a way that objects
+can be read by the reader"
+{:dynamic true
+:added "1.0"}
+([] nil)
+([x]
+(pr-on x *out*))
+([x & more]
+(pr x)
+(. *out* (append \space))
+(if-let [nmore (next more)]
+(recur (first more) nmore)
+(apply pr more))))
+(defn newline
+"Writes a newline to the output stream that is the current value of
+*out*"
+{:added "1.0"}
+[]
+(. *out* (append \newline))
+nil)
+(defn flush
+"Flushes the output stream that is the current value of
+*out*"
+{:added "1.0"}
+[]
+(. *out* (flush))
+nil)
+(defn prn
+"Same as pr followed by (newline). Observes *flush-on-newline*"
+{:added "1.0"}
+[& more]
+(apply pr more)
+(newline)
+(when *flush-on-newline*
+(flush)))
+(defn print
+"Prints the object(s) to the output stream that is the current value
+of *out*.  print and println produce output for human consumption."
+{:added "1.0"}
+[& more]
+(binding [*print-readably* nil]
+(apply pr more)))
+(defn println
+"Same as print followed by (newline)"
+{:added "1.0"}
+[& more]
+(binding [*print-readably* nil]
+(apply prn more)))
+(defn read
+"Reads the next object from stream, which must be an instance of
+java.io.PushbackReader or some derivee.  stream defaults to the
+current value of *in* ."
+{:added "1.0"}
+([]
+(read *in*))
+([stream]
+(read stream true nil))
+([stream eof-error? eof-value]
+(read stream eof-error? eof-value false))
+([stream eof-error? eof-value recursive?]
+(. clojure.lang.LispReader (read stream (boolean eof-error?) eof-value recursive?))))
+(defn read-line
+"Reads the next line from stream that is the current value of *in* ."
+{:added "1.0"}
+[]
+(if (instance? clojure.lang.LineNumberingPushbackReader *in*)
+(.readLine ^clojure.lang.LineNumberingPushbackReader *in*)
+(.readLine ^java.io.BufferedReader *in*)))
+(defn read-string
+"Reads one object from the string s"
+{:added "1.0"}
+[s] (clojure.lang.RT/readString s))
+(defn subvec
+"Returns a persistent vector of the items in vector from
+start (inclusive) to end (exclusive).  If end is not supplied,
+defaults to (count vector). This operation is O(1) and very fast, as
+the resulting vector shares structure with the original and no
+trimming is done."
+{:added "1.0"}
+([v start]
+(subvec v start (count v)))
+([v start end]
+(. clojure.lang.RT (subvec v start end))))
+(defmacro with-open
+"bindings => [name init ...]
+Evaluates body in a try expression with names bound to the values
+of the inits, and a finally clause that calls (.close name) on each
+name in reverse order."
+{:added "1.0"}
+[bindings & body]
+(assert-args with-open
+(vector? bindings) "a vector for its binding"
+(even? (count bindings)) "an even number of forms in binding vector")
+(cond
+(= (count bindings) 0) `(do ~@body)
+(symbol? (bindings 0)) `(let ~(subvec bindings 0 2)
+(try
+(with-open ~(subvec bindings 2) ~@body)
+(finally
+(. ~(bindings 0) close))))
+:else (throw (IllegalArgumentException.
+"with-open only allows Symbols in bindings"))))
+(defmacro doto
+"Evaluates x then calls all of the methods and functions with the
+value of x supplied at the front of the given arguments.  The forms
+are evaluated in order.  Returns x.
+(doto (new java.util.HashMap) (.put \"a\" 1) (.put \"b\" 2))"
+{:added "1.0"}
+[x & forms]
+(let [gx (gensym)]
+`(let [~gx ~x]
+~@(map (fn [f]
+(if (seq? f)
+`(~(first f) ~gx ~@(next f))
+`(~f ~gx)))
+forms)
+~gx)))
+(defmacro memfn
+"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."
+{:added "1.0"}
+[name & args]
+`(fn [target# ~@args]
+(. target# (~name ~@args))))
+(defmacro time
+"Evaluates expr and prints the time it took.  Returns the value of
+expr."
+{:added "1.0"}
+[expr]
+`(let [start# (. System (nanoTime))
+ret# ~expr]
+(prn (str "Elapsed time: " (/ (double (- (. System (nanoTime)) start#)) 1000000.0) " msecs"))
+ret#))
+(import '(java.lang.reflect Array))
+(defn alength
+"Returns the length of the Java array. Works on arrays of all
+types."
+{:inline (fn [a] `(. clojure.lang.RT (alength ~a)))
+:added "1.0"}
+[array] (. clojure.lang.RT (alength array)))
+(defn aclone
+"Returns a clone of the Java array. Works on arrays of known
+types."
+{:inline (fn [a] `(. clojure.lang.RT (aclone ~a)))
+:added "1.0"}
+[array] (. clojure.lang.RT (aclone array)))
+(defn aget
+"Returns the value at the index/indices. Works on Java arrays of all
+types."
+{:inline (fn [a i] `(. clojure.lang.RT (aget ~a (int ~i))))
+:inline-arities #{2}
+:added "1.0"}
+([array idx]
+(clojure.lang.Reflector/prepRet (. Array (get array idx))))
+([array idx & idxs]
+(apply aget (aget array idx) idxs)))
+(defn aset
+"Sets the value at the index/indices. Works on Java arrays of
+reference types. Returns val."
+{:inline (fn [a i v] `(. clojure.lang.RT (aset ~a (int ~i) ~v)))
+:inline-arities #{3}
+:added "1.0"}
+([array idx val]
+(. Array (set array idx val))
+val)
+([array idx idx2 & idxv]
+(apply aset (aget array idx) idx2 idxv)))
+(defmacro
+^{:private true}
+def-aset [name method coerce]
+`(defn ~name
+{:arglists '([~'array ~'idx ~'val] [~'array ~'idx ~'idx2 & ~'idxv])}
+([array# idx# val#]
+(. Array (~method array# idx# (~coerce val#)))
+val#)
+([array# idx# idx2# & idxv#]
+(apply ~name (aget array# idx#) idx2# idxv#))))
+(def-aset
+^{:doc "Sets the value at the index/indices. Works on arrays of int. Returns val."
+:added "1.0"}
+aset-int setInt int)
+(def-aset
+^{:doc "Sets the value at the index/indices. Works on arrays of long. Returns val."
+:added "1.0"}
+aset-long setLong long)
+(def-aset
+^{:doc "Sets the value at the index/indices. Works on arrays of boolean. Returns val."
+:added "1.0"}
+aset-boolean setBoolean boolean)
+(def-aset
+^{:doc "Sets the value at the index/indices. Works on arrays of float. Returns val."
+:added "1.0"}
+aset-float setFloat float)
+(def-aset
+^{:doc "Sets the value at the index/indices. Works on arrays of double. Returns val."
+:added "1.0"}
+aset-double setDouble double)
+(def-aset
+^{:doc "Sets the value at the index/indices. Works on arrays of short. Returns val."
+:added "1.0"}
+aset-short setShort short)
+(def-aset
+^{:doc "Sets the value at the index/indices. Works on arrays of byte. Returns val."
+:added "1.0"}
+aset-byte setByte byte)
+(def-aset
+^{:doc "Sets the value at the index/indices. Works on arrays of char. Returns val."
+:added "1.0"}
+aset-char setChar char)
+(defn make-array
+"Creates and returns an array of instances of the specified class of
+the specified dimension(s).  Note that a class object is required.
+Class objects can be obtained by using their imported or
+fully-qualified name.  Class objects for the primitive types can be
+obtained using, e.g., Integer/TYPE."
+{:added "1.0"}
+([^Class type len]
+(. Array (newInstance type (int len))))
+([^Class type dim & more-dims]
+(let [dims (cons dim more-dims)
+^"[I" dimarray (make-array (. Integer TYPE)  (count dims))]
+(dotimes [i (alength dimarray)]
+(aset-int dimarray i (nth dims i)))
+(. Array (newInstance type dimarray)))))
+(defn to-array-2d
+"Returns a (potentially-ragged) 2-dimensional array of Objects
+containing the contents of coll, which can be any Collection of any
+Collection."
+{:tag "[[Ljava.lang.Object;"
+:added "1.0"}
+[^java.util.Collection coll]
+(let [ret (make-array (. Class (forName "[Ljava.lang.Object;")) (. coll (size)))]
+(loop [i 0 xs (seq coll)]
+(when xs
+(aset ret i (to-array (first xs)))
+(recur (inc i) (next xs))))
+ret))
+(defn macroexpand-1
+"If form represents a macro form, returns its expansion,
+else returns form."
+{:added "1.0"}
+[form]
+(. clojure.lang.Compiler (macroexpand1 form)))
+(defn macroexpand
+"Repeatedly calls macroexpand-1 on form until it no longer
+represents a macro form, then returns it.  Note neither
+macroexpand-1 nor macroexpand expand macros in subforms."
+{:added "1.0"}
+[form]
+(let [ex (macroexpand-1 form)]
+(if (identical? ex form)
+form
+(macroexpand ex))))
+(defn create-struct
+"Returns a structure basis object."
+{:added "1.0"}
+[& keys]
+(. clojure.lang.PersistentStructMap (createSlotMap keys)))
+(defmacro defstruct
+"Same as (def name (create-struct keys...))"
+{:added "1.0"}
+[name & keys]
+`(def ~name (create-struct ~@keys)))
+(defn struct-map
+"Returns a new structmap instance with the keys of the
+structure-basis. keyvals may contain all, some or none of the basis
+keys - where values are not supplied they will default to nil.
+keyvals can also contain keys not in the basis."
+{:added "1.0"}
+[s & inits]
+(. clojure.lang.PersistentStructMap (create s inits)))
+(defn struct
+"Returns a new structmap instance with the keys of the
+structure-basis. vals must be supplied for basis keys in order -
+where values are not supplied they will default to nil."
+{:added "1.0"}
+[s & vals]
+(. clojure.lang.PersistentStructMap (construct s vals)))
+(defn accessor
+"Returns a fn that, given an instance of a structmap with the basis,
+returns the value at the key.  The key must be in the basis. The
+returned function should be (slightly) more efficient than using
+get, but such use of accessors should be limited to known
+performance-critical areas."
+{:added "1.0"}
+[s key]
+(. clojure.lang.PersistentStructMap (getAccessor s key)))
+(defn load-reader
+"Sequentially read and evaluate the set of forms contained in the
+stream/file"
+{:added "1.0"}
+[rdr] (. clojure.lang.Compiler (load rdr)))
+(defn load-string
+"Sequentially read and evaluate the set of forms contained in the
+string"
+{:added "1.0"}
+[s]
+(let [rdr (-> (java.io.StringReader. s)
+(clojure.lang.LineNumberingPushbackReader.))]
+(load-reader rdr)))
+(defn set
+"Returns a set of the distinct elements of coll."
+{:added "1.0"}
+[coll] (clojure.lang.PersistentHashSet/create ^clojure.lang.ISeq (seq coll)))
+(defn ^{:private true}
+filter-key [keyfn pred amap]
+(loop [ret {} es (seq amap)]
+(if es
+(if (pred (keyfn (first es)))
+(recur (assoc ret (key (first es)) (val (first es))) (next es))
+(recur ret (next es)))
+ret)))
+(defn find-ns
+"Returns the namespace named by the symbol or nil if it doesn't exist."
+{:added "1.0"}
+[sym] (clojure.lang.Namespace/find sym))
+(defn create-ns
+"Create a new namespace named by the symbol if one doesn't already
+exist, returns it or the already-existing namespace of the same
+name."
+{:added "1.0"}
+[sym] (clojure.lang.Namespace/findOrCreate sym))
+(defn remove-ns
+"Removes the namespace named by the symbol. Use with caution.
+Cannot be used to remove the clojure namespace."
+{:added "1.0"}
+[sym] (clojure.lang.Namespace/remove sym))
+(defn all-ns
+"Returns a sequence of all namespaces."
+{:added "1.0"}
+[] (clojure.lang.Namespace/all))
+(defn ^clojure.lang.Namespace the-ns
+"If passed a namespace, returns it. Else, when passed a symbol,
+returns the namespace named by it, throwing an exception if not
+found."
+{:added "1.0"}
+[x]
+(if (instance? clojure.lang.Namespace x)
+x
+(or (find-ns x) (throw (Exception. (str "No namespace: " x " found"))))))
+(defn ns-name
+"Returns the name of the namespace, a symbol."
+{:added "1.0"}
+[ns]
+(.getName (the-ns ns)))
+(defn ns-map
+"Returns a map of all the mappings for the namespace."
+{:added "1.0"}
+[ns]
+(.getMappings (the-ns ns)))
+(defn ns-unmap
+"Removes the mappings for the symbol from the namespace."
+{:added "1.0"}
+[ns sym]
+(.unmap (the-ns ns) sym))
+;(defn export [syms]
+;  (doseq [sym syms]
+;   (.. *ns* (intern sym) (setExported true))))
+(defn ns-publics
+"Returns a map of the public intern mappings for the namespace."
+{:added "1.0"}
+[ns]
+(let [ns (the-ns ns)]
+(filter-key val (fn [^clojure.lang.Var v] (and (instance? clojure.lang.Var v)
+(= ns (.ns v))
+(.isPublic v)))
+(ns-map ns))))
+(defn ns-imports
+"Returns a map of the import mappings for the namespace."
+{:added "1.0"}
+[ns]
+(filter-key val (partial instance? Class) (ns-map ns)))
+(defn ns-interns
+"Returns a map of the intern mappings for the namespace."
+{:added "1.0"}
+[ns]
+(let [ns (the-ns ns)]
+(filter-key val (fn [^clojure.lang.Var v] (and (instance? clojure.lang.Var v)
+(= ns (.ns v))))
+(ns-map ns))))
+(defn refer
+"refers to all public vars of ns, subject to filters.
+filters can include at most one each of:
+:exclude list-of-symbols
+:only list-of-symbols
+:rename map-of-fromsymbol-tosymbol
+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 "1.0"}
+[ns-sym & filters]
+(let [ns (or (find-ns ns-sym) (throw (new Exception (str "No namespace: " ns-sym))))
+fs (apply hash-map filters)
+nspublics (ns-publics ns)
+rename (or (:rename fs) {})
+exclude (set (:exclude fs))
+to-do (or (:only fs) (keys nspublics))]
+(doseq [sym to-do]
+(when-not (exclude sym)
+(let [v (nspublics sym)]
+(when-not v
+(throw (new java.lang.IllegalAccessError
+(if (get (ns-interns ns) sym)
+(str sym " is not public")
+(str sym " does not exist")))))
+(. *ns* (refer (or (rename sym) sym) v)))))))
+(defn ns-refers
+"Returns a map of the refer mappings for the namespace."
+{:added "1.0"}
+[ns]
+(let [ns (the-ns ns)]
+(filter-key val (fn [^clojure.lang.Var v] (and (instance? clojure.lang.Var v)
+(not= ns (.ns v))))
+(ns-map ns))))
+(defn alias
+"Add an alias in the current namespace to another
+namespace. Arguments are two symbols: the alias to be used, and
+the symbolic name of the target namespace. Use :as in the ns macro in preference
+to calling this directly."
+{:added "1.0"}
+[alias namespace-sym]
+(.addAlias *ns* alias (find-ns namespace-sym)))
+(defn ns-aliases
+"Returns a map of the aliases for the namespace."
+{:added "1.0"}
+[ns]
+(.getAliases (the-ns ns)))
+(defn ns-unalias
+"Removes the alias for the symbol from the namespace."
+{:added "1.0"}
+[ns sym]
+(.removeAlias (the-ns ns) sym))
+(defn take-nth
+"Returns a lazy seq of every nth item in coll."
+{:added "1.0"}
+[n coll]
+(lazy-seq
+(when-let [s (seq coll)]
+(cons (first s) (take-nth n (drop n s))))))
+(defn interleave
+"Returns a lazy seq of the first item in each coll, then the second etc."
+{:added "1.0"}
+([c1 c2]
+(lazy-seq
+(let [s1 (seq c1) s2 (seq c2)]
+(when (and s1 s2)
+(cons (first s1) (cons (first s2)
+(interleave (rest s1) (rest s2))))))))
+([c1 c2 & colls]
+(lazy-seq
+(let [ss (map seq (conj colls c2 c1))]
+(when (every? identity ss)
+(concat (map first ss) (apply interleave (map rest ss))))))))
+(defn var-get
+"Gets the value in the var object"
+{:added "1.0"}
+[^clojure.lang.Var x] (. x (get)))
+(defn var-set
+"Sets the value in the var object to val. The var must be
+thread-locally bound."
+{:added "1.0"}
+[^clojure.lang.Var x val] (. x (set val)))
+(defmacro with-local-vars
+"varbinding=> symbol init-expr
+Executes the exprs in a context in which the symbols are bound to
+vars with per-thread bindings to the init-exprs.  The symbols refer
+to the var objects themselves, and must be accessed with var-get and
+var-set"
+{:added "1.0"}
+[name-vals-vec & body]
+(assert-args with-local-vars
+(vector? name-vals-vec) "a vector for its binding"
+(even? (count name-vals-vec)) "an even number of forms in binding vector")
+`(let [~@(interleave (take-nth 2 name-vals-vec)
+(repeat '(. clojure.lang.Var (create))))]
+(. clojure.lang.Var (pushThreadBindings (hash-map ~@name-vals-vec)))
+(try
+~@body
+(finally (. clojure.lang.Var (popThreadBindings))))))
+(defn ns-resolve
+"Returns the var or Class to which a symbol will be resolved in the
+namespace, else nil.  Note that if the symbol is fully qualified,
+the var/Class to which it resolves need not be present in the
+namespace."
+{:added "1.0"}
+[ns sym]
+(clojure.lang.Compiler/maybeResolveIn (the-ns ns) sym))
+(defn resolve
+"same as (ns-resolve *ns* symbol)"
+{:added "1.0"}
+[sym] (ns-resolve *ns* sym))
+(defn array-map
+"Constructs an array-map."
+{:added "1.0"}
+([] (. clojure.lang.PersistentArrayMap EMPTY))
+([& keyvals] (clojure.lang.PersistentArrayMap/createWithCheck (to-array keyvals))))
+(defn nthnext
+"Returns the nth next of coll, (seq coll) when n is 0."
+{:added "1.0"}
+[coll n]
+(loop [n n xs (seq coll)]
+(if (and xs (pos? n))
+(recur (dec n) (next xs))
+xs)))
+;redefine let and loop  with destructuring
+(defn destructure [bindings]
+(let [bents (partition 2 bindings)
+pb (fn pb [bvec b v]
+(let [pvec
+(fn [bvec b val]
+(let [gvec (gensym "vec__")]
+(loop [ret (-> bvec (conj gvec) (conj val))
+n 0
+bs b
+seen-rest? false]
+(if (seq bs)
+(let [firstb (first bs)]
+(cond
+(= firstb '&) (recur (pb ret (second bs) (list `nthnext gvec n))
+n
+(nnext bs)
+true)
+(= firstb :as) (pb ret (second bs) gvec)
+:else (if seen-rest?
+(throw (new Exception "Unsupported binding form, only :as can follow & parameter"))
+(recur (pb ret firstb  (list `nth gvec n nil))
+(inc n)
+(next bs)
+seen-rest?))))
+ret))))
+pmap
+(fn [bvec b v]
+(let [gmap (or (:as b) (gensym "map__"))
+defaults (:or b)]
+(loop [ret (-> bvec (conj gmap) (conj v)
+(conj gmap) (conj `(if (seq? ~gmap) (apply hash-map ~gmap) ~gmap)))
+bes (reduce
+(fn [bes entry]
+(reduce #(assoc %1 %2 ((val entry) %2))
+(dissoc bes (key entry))
+((key entry) bes)))
+(dissoc b :as :or)
+{:keys #(keyword (str %)), :strs str, :syms #(list `quote %)})]
+(if (seq bes)
+(let [bb (key (first bes))
+bk (val (first bes))
+has-default (contains? defaults bb)]
+(recur (pb ret bb (if has-default
+(list `get gmap bk (defaults bb))
+(list `get gmap bk)))
+(next bes)))
+ret))))]
+(cond
+(symbol? b) (-> bvec (conj b) (conj v))
+(vector? b) (pvec bvec b v)
+(map? b) (pmap bvec b v)
+:else (throw (new Exception (str "Unsupported binding form: " b))))))
+process-entry (fn [bvec b] (pb bvec (first b) (second b)))]
+(if (every? symbol? (map first bents))
+bindings
+(reduce process-entry [] bents))))
+(defmacro let
+"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."
+{:added "1.0"}
+[bindings & body]
+(assert-args let
+(vector? bindings) "a vector for its binding"
+(even? (count bindings)) "an even number of forms in binding vector")
+`(let* ~(destructure bindings) ~@body))
+(defn ^{:private true}
+maybe-destructured
+[params body]
+(if (every? symbol? params)
+(cons params body)
+(loop [params params
+new-params []
+lets []]
+(if params
+(if (symbol? (first params))
+(recur (next params) (conj new-params (first params)) lets)
+(let [gparam (gensym "p__")]
+(recur (next params) (conj new-params gparam)
+(-> lets (conj (first params)) (conj gparam)))))
+`(~new-params
+(let ~lets
+~@body))))))
+;redefine fn with destructuring and pre/post conditions
+(defmacro fn
+"(fn name? [params* ] exprs*)
+(fn name? ([params* ] exprs*)+)
+params => positional-params* , or positional-params* & next-param
+positional-param => binding-form
+next-param => binding-form
+name => symbol
+Defines a function"
+{:added "1.0"}
+[& sigs]
+(let [name (if (symbol? (first sigs)) (first sigs) nil)
+sigs (if name (next sigs) sigs)
+sigs (if (vector? (first sigs)) (list sigs) sigs)
+psig (fn* [sig]
+(let [[params & body] sig
+conds (when (and (next body) (map? (first body)))
+(first body))
+body (if conds (next body) body)
+conds (or conds (meta params))
+pre (:pre conds)
+post (:post conds)
+body (if post
+`((let [~'% ~(if (< 1 (count body))
+`(do ~@body)
+(first body))]
+~@(map (fn* [c] `(assert ~c)) post)
+~'%))
+body)
+body (if pre
+(concat (map (fn* [c] `(assert ~c)) pre)
+body)
+body)]
+(maybe-destructured params body)))
+new-sigs (map psig sigs)]
+(with-meta
+(if name
+(list* 'fn* name new-sigs)
+(cons 'fn* new-sigs))
+(meta &form))))
+(defmacro loop
+"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. Acts as a recur target."
+{:added "1.0"}
+[bindings & body]
+(assert-args loop
+(vector? bindings) "a vector for its binding"
+(even? (count bindings)) "an even number of forms in binding vector")
+(let [db (destructure bindings)]
+(if (= db bindings)
+`(loop* ~bindings ~@body)
+(let [vs (take-nth 2 (drop 1 bindings))
+bs (take-nth 2 bindings)
+gs (map (fn [b] (if (symbol? b) b (gensym))) bs)
+bfs (reduce (fn [ret [b v g]]
+(if (symbol? b)
+(conj ret g v)
+(conj ret g v b g)))
+[] (map vector bs vs gs))]
+`(let ~bfs
+(loop* ~(vec (interleave gs gs))
+(let ~(vec (interleave bs gs))
+~@body)))))))
+(defmacro when-first
+"bindings => x xs
+Same as (when (seq xs) (let [x (first xs)] body))"
+{:added "1.0"}
+[bindings & body]
+(assert-args when-first
+(vector? bindings) "a vector for its binding"
+(= 2 (count bindings)) "exactly 2 forms in binding vector")
+(let [[x xs] bindings]
+`(when (seq ~xs)
+(let [~x (first ~xs)]
+~@body))))
+(defmacro lazy-cat
+"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 "1.0"}
+[& colls]
+`(concat ~@(map #(list `lazy-seq %) colls)))
+(defmacro for
+"List comprehension. Takes a vector of one or more
+binding-form/collection-expr pairs, each followed by zero or more
+modifiers, and yields a lazy sequence of evaluations of expr.
+Collections are iterated in a nested fashion, rightmost fastest,
+and nested coll-exprs can refer to bindings created in prior
+binding-forms.  Supported modifiers are: :let [binding-form expr ...],
+:while test, :when test.
+(take 100 (for [x (range 100000000) y (range 1000000) :while (< y x)] [x y]))"
+{:added "1.0"}
+[seq-exprs body-expr]
+(assert-args for
+(vector? seq-exprs) "a vector for its binding"
+(even? (count seq-exprs)) "an even number of forms in binding vector")
+(let [to-groups (fn [seq-exprs]
+(reduce (fn [groups [k v]]
+(if (keyword? k)
+(conj (pop groups) (conj (peek groups) [k v]))
+(conj groups [k v])))
+[] (partition 2 seq-exprs)))
+err (fn [& msg] (throw (IllegalArgumentException. ^String (apply str msg))))
+emit-bind (fn emit-bind [[[bind expr & mod-pairs]
+& [[_ next-expr] :as next-groups]]]
+(let [giter (gensym "iter__")
+gxs (gensym "s__")
+do-mod (fn do-mod [[[k v :as pair] & etc]]
+(cond
+(= k :let) `(let ~v ~(do-mod etc))
+(= k :while) `(when ~v ~(do-mod etc))
+(= k :when) `(if ~v
+~(do-mod etc)
+(recur (rest ~gxs)))
+(keyword? k) (err "Invalid 'for' keyword " k)
+next-groups
+`(let [iterys# ~(emit-bind next-groups)
+fs# (seq (iterys# ~next-expr))]
+(if fs#
+(concat fs# (~giter (rest ~gxs)))
+(recur (rest ~gxs))))
+:else `(cons ~body-expr
+(~giter (rest ~gxs)))))]
+(if next-groups
+#_"not the inner-most loop"
+`(fn ~giter [~gxs]
+(lazy-seq
+(loop [~gxs ~gxs]
+(when-first [~bind ~gxs]
+~(do-mod mod-pairs)))))
+#_"inner-most loop"
+(let [gi (gensym "i__")
+gb (gensym "b__")
+do-cmod (fn do-cmod [[[k v :as pair] & etc]]
+(cond
+(= k :let) `(let ~v ~(do-cmod etc))
+(= k :while) `(when ~v ~(do-cmod etc))
+(= k :when) `(if ~v
+~(do-cmod etc)
+(recur
+(unchecked-inc ~gi)))
+(keyword? k)
+(err "Invalid 'for' keyword " k)
+:else
+`(do (chunk-append ~gb ~body-expr)
+(recur (unchecked-inc ~gi)))))]
+`(fn ~giter [~gxs]
+(lazy-seq
+(loop [~gxs ~gxs]
+(when-let [~gxs (seq ~gxs)]
+(if (chunked-seq? ~gxs)
+(let [c# (chunk-first ~gxs)
+size# (int (count c#))
+~gb (chunk-buffer size#)]
+(if (loop [~gi (int 0)]
+(if (< ~gi size#)
+(let [~bind (.nth c# ~gi)]
+~(do-cmod mod-pairs))
+true))
+(chunk-cons
+(chunk ~gb)
+(~giter (chunk-rest ~gxs)))
+(chunk-cons (chunk ~gb) nil)))
+(let [~bind (first ~gxs)]
+~(do-mod mod-pairs)))))))))))]
+`(let [iter# ~(emit-bind (to-groups seq-exprs))]
+(iter# ~(second seq-exprs)))))
+(defmacro comment
+"Ignores body, yields nil"
+{:added "1.0"}
+[& body])
+(defmacro with-out-str
+"Evaluates exprs in a context in which *out* is bound to a fresh
+StringWriter.  Returns the string created by any nested printing
+calls."
+{:added "1.0"}
+[& body]
+`(let [s# (new java.io.StringWriter)]
+(binding [*out* s#]
+~@body
+(str s#))))
+(defmacro with-in-str
+"Evaluates body in a context in which *in* is bound to a fresh
+StringReader initialized with the string s."
+{:added "1.0"}
+[s & body]
+`(with-open [s# (-> (java.io.StringReader. ~s) clojure.lang.LineNumberingPushbackReader.)]
+(binding [*in* s#]
+~@body)))
+(defn pr-str
+"pr to a string, returning it"
+{:tag String
+:added "1.0"}
+[& xs]
+(with-out-str
+(apply pr xs)))
+(defn prn-str
+"prn to a string, returning it"
+{:tag String
+:added "1.0"}
+[& xs]
+(with-out-str
+(apply prn xs)))
+(defn print-str
+"print to a string, returning it"
+{:tag String
+:added "1.0"}
+[& xs]
+(with-out-str
+(apply print xs)))
+(defn println-str
+"println to a string, returning it"
+{:tag String
+:added "1.0"}
+[& xs]
+(with-out-str
+(apply println xs)))
+(defmacro assert
+"Evaluates expr and throws an exception if it does not evaluate to
+logical true."
+{:added "1.0"}
+[x]
+(when *assert*
+`(when-not ~x
+(throw (new AssertionError (str "Assert failed: " (pr-str '~x)))))))
+(defn test
+"test [v] finds fn at key :test in var metadata and calls it,
+presuming failure will throw exception"
+{:added "1.0"}
+[v]
+(let [f (:test (meta v))]
+(if f
+(do (f) :ok)
+:no-test)))
+(defn re-pattern
+"Returns an instance of java.util.regex.Pattern, for use, e.g. in
+re-matcher."
+{:tag java.util.regex.Pattern
+:added "1.0"}
+[s] (if (instance? java.util.regex.Pattern s)
+s
+(. java.util.regex.Pattern (compile s))))
+(defn re-matcher
+"Returns an instance of java.util.regex.Matcher, for use, e.g. in
+re-find."
+{:tag java.util.regex.Matcher
+:added "1.0"}
+[^java.util.regex.Pattern re s]
+(. re (matcher s)))
+(defn re-groups
+"Returns the groups from the most recent match/find. If there are no
+nested groups, returns a string of the entire match. If there are
+nested groups, returns a vector of the groups, the first element
+being the entire match."
+{:added "1.0"}
+[^java.util.regex.Matcher m]
+(let [gc  (. m (groupCount))]
+(if (zero? gc)
+(. m (group))
+(loop [ret [] c 0]
+(if (<= c gc)
+(recur (conj ret (. m (group c))) (inc c))
+ret)))))
+(defn re-seq
+"Returns a lazy sequence of successive matches of pattern in string,
+using java.util.regex.Matcher.find(), each such match processed with
+re-groups."
+{:added "1.0"}
+[^java.util.regex.Pattern re s]
+(let [m (re-matcher re s)]
+((fn step []
+(when (. m (find))
+(cons (re-groups m) (lazy-seq (step))))))))
+(defn re-matches
+"Returns the match, if any, of string to pattern, using
+java.util.regex.Matcher.matches().  Uses re-groups to return the
+groups."
+{:added "1.0"}
+[^java.util.regex.Pattern re s]
+(let [m (re-matcher re s)]
+(when (. m (matches))
+(re-groups m))))
+(defn re-find
+"Returns the next regex match, if any, of string to pattern, using
+java.util.regex.Matcher.find().  Uses re-groups to return the
+groups."
+{:added "1.0"}
+([^java.util.regex.Matcher m]
+(when (. m (find))
+(re-groups m)))
+([^java.util.regex.Pattern re s]
+(let [m (re-matcher re s)]
+(re-find m))))
+(defn rand
+"Returns a random floating point number between 0 (inclusive) and
+n (default 1) (exclusive)."
+{:added "1.0"}
+([] (. Math (random)))
+([n] (* n (rand))))
+(defn rand-int
+"Returns a random integer between 0 (inclusive) and n (exclusive)."
+{:added "1.0"}
+[n] (int (rand n)))
+(defmacro defn-
+"same as defn, yielding non-public def"
+{:added "1.0"}
+[name & decls]
+(list* `defn (with-meta name (assoc (meta name) :private true)) decls))
+(defn print-doc [v]
+(println "-------------------------")
+(println (str (ns-name (:ns (meta v))) "/" (:name (meta v))))
+(prn (:arglists (meta v)))
+(when (:macro (meta v))
+(println "Macro"))
+(println " " (:doc (meta v))))
+(defn find-doc
+"Prints documentation for any var whose documentation or name
+contains a match for re-string-or-pattern"
+{:added "1.0"}
+[re-string-or-pattern]
+(let [re  (re-pattern re-string-or-pattern)]
+(doseq [ns (all-ns)
+v (sort-by (comp :name meta) (vals (ns-interns ns)))
+:when (and (:doc (meta v))
+(or (re-find (re-matcher re (:doc (meta v))))
+(re-find (re-matcher re (str (:name (meta v)))))))]
+(print-doc v))))
+(defn special-form-anchor
+"Returns the anchor tag on http://clojure.org/special_forms for the
+special form x, or nil"
+{:added "1.0"}
+[x]
+(#{'. 'def 'do 'fn 'if 'let 'loop 'monitor-enter 'monitor-exit 'new
+'quote 'recur 'set! 'throw 'try 'var} x))
+(defn syntax-symbol-anchor
+"Returns the anchor tag on http://clojure.org/special_forms for the
+special form that uses syntax symbol x, or nil"
+{:added "1.0"}
+[x]
+({'& 'fn 'catch 'try 'finally 'try} x))
+(defn print-special-doc
+[name type anchor]
+(println "-------------------------")
+(println name)
+(println type)
+(println (str "  Please see http://clojure.org/special_forms#" anchor)))
+(defn print-namespace-doc
+"Print the documentation string of a Namespace."
+{:added "1.0"}
+[nspace]
+(println "-------------------------")
+(println (str (ns-name nspace)))
+(println " " (:doc (meta nspace))))
+(defmacro doc
+"Prints documentation for a var or special form given its name"
+{:added "1.0"}
+[name]
+(cond
+(special-form-anchor `~name)
+`(print-special-doc '~name "Special Form" (special-form-anchor '~name))
+(syntax-symbol-anchor `~name)
+`(print-special-doc '~name "Syntax Symbol" (syntax-symbol-anchor '~name))
+:else
+(let [nspace (find-ns name)]
+(if nspace
+`(print-namespace-doc ~nspace)
+`(print-doc (var ~name))))))
+(defn tree-seq
+"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 "1.0"}
+[branch? children root]
+(let [walk (fn walk [node]
+(lazy-seq
+(cons node
+(when (branch? node)
+(mapcat walk (children node))))))]
+(walk root)))
+(defn file-seq
+"A tree seq on java.io.Files"
+{:added "1.0"}
+[dir]
+(tree-seq
+(fn [^java.io.File f] (. f (isDirectory)))
+(fn [^java.io.File d] (seq (. d (listFiles))))
+dir))
+(defn xml-seq
+"A tree seq on the xml elements as per xml/parse"
+{:added "1.0"}
+[root]
+(tree-seq
+(complement string?)
+(comp seq :content)
+root))
+(defn special-symbol?
+"Returns true if s names a special form"
+{:added "1.0"}
+[s]
+(contains? (. clojure.lang.Compiler specials) s))
+(defn var?
+"Returns true if v is of type clojure.lang.Var"
+{:added "1.0"}
+[v] (instance? clojure.lang.Var v))
+(defn ^String subs
+"Returns the substring of s beginning at start inclusive, and ending
+at end (defaults to length of string), exclusive."
+{:added "1.0"}
+([^String s start] (. s (substring start)))
+([^String s start end] (. s (substring start end))))
+(defn max-key
+"Returns the x for which (k x), a number, is greatest."
+{:added "1.0"}
+([k x] x)
+([k x y] (if (> (k x) (k y)) x y))
+([k x y & more]
+(reduce #(max-key k %1 %2) (max-key k x y) more)))
+(defn min-key
+"Returns the x for which (k x), a number, is least."
+{:added "1.0"}
+([k x] x)
+([k x y] (if (< (k x) (k y)) x y))
+([k x y & more]
+(reduce #(min-key k %1 %2) (min-key k x y) more)))
+(defn distinct
+"Returns a lazy sequence of the elements of coll with duplicates removed"
+{:added "1.0"}
+[coll]
+(let [step (fn step [xs seen]
+(lazy-seq
+((fn [[f :as xs] seen]
+(when-let [s (seq xs)]
+(if (contains? seen f)
+(recur (rest s) seen)
+(cons f (step (rest s) (conj seen f))))))
+xs seen)))]
+(step coll #{})))
+(defn replace
+"Given a map of replacement pairs and a vector/collection, returns a
+vector/seq with any elements = a key in smap replaced with the
+corresponding val in smap"
+{:added "1.0"}
+[smap coll]
+(if (vector? coll)
+(reduce (fn [v i]
+(if-let [e (find smap (nth v i))]
+(assoc v i (val e))
+v))
+coll (range (count coll)))
+(map #(if-let [e (find smap %)] (val e) %) coll)))
+(defmacro dosync
+"Runs the exprs (in an implicit do) in a transaction that encompasses
+exprs and any nested calls.  Starts a transaction if none is already
+running on this thread. Any uncaught exception will abort the
+transaction and flow out of dosync. The exprs may be run more than
+once, but any effects on Refs will be atomic."
+{:added "1.0"}
+[& exprs]
+`(sync nil ~@exprs))
+(defmacro with-precision
+"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 "1.0"}
+[precision & exprs]
+(let [[body rm] (if (= (first exprs) :rounding)
+[(next (next exprs))
+`((. java.math.RoundingMode ~(second exprs)))]
+[exprs nil])]
+`(binding [*math-context* (java.math.MathContext. ~precision ~@rm)]
+~@body)))
+(defn mk-bound-fn
+{:private true}
+[^clojure.lang.Sorted sc test key]
+(fn [e]
+(test (.. sc comparator (compare (. sc entryKey e) key)) 0)))
+(defn subseq
+"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 "1.0"}
+([^clojure.lang.Sorted sc test key]
+(let [include (mk-bound-fn sc test key)]
+(if (#{> >=} test)
+(when-let [[e :as s] (. sc seqFrom key true)]
+(if (include e) s (next s)))
+(take-while include (. sc seq true)))))
+([^clojure.lang.Sorted sc start-test start-key end-test end-key]
+(when-let [[e :as s] (. sc seqFrom start-key true)]
+(take-while (mk-bound-fn sc end-test end-key)
+(if ((mk-bound-fn sc start-test start-key) e) s (next s))))))
+(defn rsubseq
+"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 "1.0"}
+([^clojure.lang.Sorted sc test key]
+(let [include (mk-bound-fn sc test key)]
+(if (#{< <=} test)
+(when-let [[e :as s] (. sc seqFrom key false)]
+(if (include e) s (next s)))
+(take-while include (. sc seq false)))))
+([^clojure.lang.Sorted sc start-test start-key end-test end-key]
+(when-let [[e :as s] (. sc seqFrom end-key false)]
+(take-while (mk-bound-fn sc start-test start-key)
+(if ((mk-bound-fn sc end-test end-key) e) s (next s))))))
+(defn repeatedly
+"Takes a function of no args, presumably with side effects, and
+returns an infinite (or length n if supplied) lazy sequence of calls
+to it"
+{:added "1.0"}
+([f] (lazy-seq (cons (f) (repeatedly f))))
+([n f] (take n (repeatedly f))))
+(defn add-classpath
+"DEPRECATED
+Adds the url (String or URL object) to the classpath per
+URLClassLoader.addURL"
+{:added "1.0"
+:deprecated "1.1"}
+[url]
+(println "WARNING: add-classpath is deprecated")
+(clojure.lang.RT/addURL url))
+(defn hash
+"Returns the hash code of its argument"
+{:added "1.0"}
+[x] (. clojure.lang.Util (hash x)))
+(defn interpose
+"Returns a lazy seq of the elements of coll separated by sep"
+{:added "1.0"}
+[sep coll] (drop 1 (interleave (repeat sep) coll)))
+(defmacro definline
+"Experimental - like defmacro, except defines a named function whose
+body is the expansion, calls to which may be expanded inline as if
+it were a macro. Cannot be used with variadic (&) args."
+{:added "1.0"}
+[name & decl]
+(let [[pre-args [args expr]] (split-with (comp not vector?) decl)]
+`(do
+(defn ~name ~@pre-args ~args ~(apply (eval (list `fn args expr)) args))
+(alter-meta! (var ~name) assoc :inline (fn ~name ~args ~expr))
+(var ~name))))
+(defn empty
+"Returns an empty collection of the same category as coll, or nil"
+{:added "1.0"}
+[coll]
+(when (instance? clojure.lang.IPersistentCollection coll)
+(.empty ^clojure.lang.IPersistentCollection coll)))
+(defmacro amap
+"Maps an expression across an array a, using an index named idx, and
+return value named ret, initialized to a clone of a, then setting
+each element of ret to the evaluation of expr, returning the new
+array ret."
+{:added "1.0"}
+[a idx ret expr]
+`(let [a# ~a
+~ret (aclone a#)]
+(loop  [~idx (int 0)]
+(if (< ~idx  (alength a#))
+(do
+(aset ~ret ~idx ~expr)
+(recur (unchecked-inc ~idx)))
+~ret))))
+(defmacro areduce
+"Reduces an expression across an array a, using an index named idx,
+and return value named ret, initialized to init, setting ret to the
+evaluation of expr at each step, returning ret."
+{:added "1.0"}
+[a idx ret init expr]
+`(let [a# ~a]
+(loop  [~idx (int 0) ~ret ~init]
+(if (< ~idx  (alength a#))
+(recur (unchecked-inc ~idx) ~expr)
+~ret))))
+(defn float-array
+"Creates an array of floats"
+{:inline (fn [& args] `(. clojure.lang.Numbers float_array ~@args))
+:inline-arities #{1 2}
+:added "1.0"}
+([size-or-seq] (. clojure.lang.Numbers float_array size-or-seq))
+([size init-val-or-seq] (. clojure.lang.Numbers float_array size init-val-or-seq)))
+(defn boolean-array
+"Creates an array of booleans"
+{:inline (fn [& args] `(. clojure.lang.Numbers boolean_array ~@args))
+:inline-arities #{1 2}
+:added "1.1"}
+([size-or-seq] (. clojure.lang.Numbers boolean_array size-or-seq))
+([size init-val-or-seq] (. clojure.lang.Numbers boolean_array size init-val-or-seq)))
+(defn byte-array
+"Creates an array of bytes"
+{:inline (fn [& args] `(. clojure.lang.Numbers byte_array ~@args))
+:inline-arities #{1 2}
+:added "1.1"}
+([size-or-seq] (. clojure.lang.Numbers byte_array size-or-seq))
+([size init-val-or-seq] (. clojure.lang.Numbers byte_array size init-val-or-seq)))
+(defn char-array
+"Creates an array of chars"
+{:inline (fn [& args] `(. clojure.lang.Numbers char_array ~@args))
+:inline-arities #{1 2}
+:added "1.1"}
+([size-or-seq] (. clojure.lang.Numbers char_array size-or-seq))
+([size init-val-or-seq] (. clojure.lang.Numbers char_array size init-val-or-seq)))
+(defn short-array
+"Creates an array of shorts"
+{:inline (fn [& args] `(. clojure.lang.Numbers short_array ~@args))
+:inline-arities #{1 2}
+:added "1.1"}
+([size-or-seq] (. clojure.lang.Numbers short_array size-or-seq))
+([size init-val-or-seq] (. clojure.lang.Numbers short_array size init-val-or-seq)))
+(defn double-array
+"Creates an array of doubles"
+{:inline (fn [& args] `(. clojure.lang.Numbers double_array ~@args))
+:inline-arities #{1 2}
+:added "1.0"}
+([size-or-seq] (. clojure.lang.Numbers double_array size-or-seq))
+([size init-val-or-seq] (. clojure.lang.Numbers double_array size init-val-or-seq)))
+(defn object-array
+"Creates an array of objects"
+{:inline (fn [arg] `(. clojure.lang.RT object_array ~arg))
+:inline-arities #{1}
+:added "1.2"}
+([size-or-seq] (. clojure.lang.RT object_array size-or-seq)))
+(defn int-array
+"Creates an array of ints"
+{:inline (fn [& args] `(. clojure.lang.Numbers int_array ~@args))
+:inline-arities #{1 2}
+:added "1.0"}
+([size-or-seq] (. clojure.lang.Numbers int_array size-or-seq))
+([size init-val-or-seq] (. clojure.lang.Numbers int_array size init-val-or-seq)))
+(defn long-array
+"Creates an array of longs"
+{:inline (fn [& args] `(. clojure.lang.Numbers long_array ~@args))
+:inline-arities #{1 2}
+:added "1.0"}
+([size-or-seq] (. clojure.lang.Numbers long_array size-or-seq))
+([size init-val-or-seq] (. clojure.lang.Numbers long_array size init-val-or-seq)))
+(definline booleans
+"Casts to boolean[]"
+{:added "1.1"}
+[xs] `(. clojure.lang.Numbers booleans ~xs))
+(definline bytes
+"Casts to bytes[]"
+{:added "1.1"}
+[xs] `(. clojure.lang.Numbers bytes ~xs))
+(definline chars
+"Casts to chars[]"
+{:added "1.1"}
+[xs] `(. clojure.lang.Numbers chars ~xs))
+(definline shorts
+"Casts to shorts[]"
+{:added "1.1"}
+[xs] `(. clojure.lang.Numbers shorts ~xs))
+(definline floats
+"Casts to float[]"
+{:added "1.0"}
+[xs] `(. clojure.lang.Numbers floats ~xs))
+(definline ints
+"Casts to int[]"
+{:added "1.0"}
+[xs] `(. clojure.lang.Numbers ints ~xs))
+(definline doubles
+"Casts to double[]"
+{:added "1.0"}
+[xs] `(. clojure.lang.Numbers doubles ~xs))
+(definline longs
+"Casts to long[]"
+{:added "1.0"}
+[xs] `(. clojure.lang.Numbers longs ~xs))
+(import '(java.util.concurrent BlockingQueue LinkedBlockingQueue))
+(defn seque
+"Creates a queued seq on another (presumably lazy) seq s. The queued
+seq will produce a concrete seq in the background, and can get up to
+n items ahead of the consumer. n-or-q can be an integer n buffer
+size, or an instance of java.util.concurrent BlockingQueue. Note
+that reading from a seque can block if the reader gets ahead of the
+producer."
+{:added "1.0"}
+([s] (seque 100 s))
+([n-or-q s]
+(let [^BlockingQueue q (if (instance? BlockingQueue n-or-q)
+n-or-q
+(LinkedBlockingQueue. (int n-or-q)))
+NIL (Object.) ;nil sentinel since LBQ doesn't support nils
+agt (agent (seq s))
+fill (fn [s]
+(try
+(loop [[x & xs :as s] s]
+(if s
+(if (.offer q (if (nil? x) NIL x))
+(recur xs)
+s)
+(.put q q))) ; q itself is eos sentinel
+(catch Exception e
+(.put q q)
+(throw e))))
+drain (fn drain []
+(lazy-seq
+(let [x (.take q)]
+(if (identical? x q) ;q itself is eos sentinel
+(do @agt nil)  ;touch agent just to propagate errors
+(do
+(send-off agt fill)
+(cons (if (identical? x NIL) nil x) (drain)))))))]
+(send-off agt fill)
+(drain))))
+(defn class?
+"Returns true if x is an instance of Class"
+{:added "1.0"}
+[x] (instance? Class x))
+(defn- is-annotation? [c]
+(and (class? c)
+(.isAssignableFrom java.lang.annotation.Annotation c)))
+(defn- is-runtime-annotation? [^Class c]
+(boolean
+(and (is-annotation? c)
+(when-let [^java.lang.annotation.Retention r
+(.getAnnotation c java.lang.annotation.Retention)]
+(= (.value r) java.lang.annotation.RetentionPolicy/RUNTIME)))))
+(defn- descriptor [^Class c] (clojure.asm.Type/getDescriptor c))
+(declare process-annotation)
+(defn- add-annotation [^clojure.asm.AnnotationVisitor av name v]
+(cond
+(vector? v) (let [avec (.visitArray av name)]
+(doseq [vval v]
+(add-annotation avec "value" vval))
+(.visitEnd avec))
+(symbol? v) (let [ev (eval v)]
+(cond
+(instance? java.lang.Enum ev)
+(.visitEnum av name (descriptor (class ev)) (str ev))
+(class? ev) (.visit av name (clojure.asm.Type/getType ev))
+:else (throw (IllegalArgumentException.
+(str "Unsupported annotation value: " v " of class " (class ev))))))
+(seq? v) (let [[nested nv] v
+c (resolve nested)
+nav (.visitAnnotation av name (descriptor c))]
+(process-annotation nav nv)
+(.visitEnd nav))
+:else (.visit av name v)))
+(defn- process-annotation [av v]
+(if (map? v)
+(doseq [[k v] v]
+(add-annotation av (name k) v))
+(add-annotation av "value" v)))
+(defn- add-annotations
+([visitor m] (add-annotations visitor m nil))
+([visitor m i]
+(doseq [[k v] m]
+(when (symbol? k)
+(when-let [c (resolve k)]
+(when (is-annotation? c)
+;this is known duck/reflective as no common base of ASM Visitors
+(let [av (if i
+(.visitParameterAnnotation visitor i (descriptor c)
+(is-runtime-annotation? c))
+(.visitAnnotation visitor (descriptor c)
+(is-runtime-annotation? c)))]
+(process-annotation av v)
+(.visitEnd av))))))))
+(defn alter-var-root
+"Atomically alters the root binding of var v by applying f to its
+current value plus any args"
+{:added "1.0"}
+[^clojure.lang.Var v f & args] (.alterRoot v f args))
+(defn bound?
+"Returns true if all of the vars provided as arguments have any bound value, root or thread-local.
+Implies that deref'ing the provided vars will succeed. Returns true if no vars are provided."
+{:added "1.2"}
+[& vars]
+(every? #(.isBound ^clojure.lang.Var %) vars))
+(defn thread-bound?
+"Returns true if all of the vars provided as arguments have thread-local bindings.
+Implies that set!'ing the provided vars will succeed.  Returns true if no vars are provided."
+{:added "1.2"}
+[& vars]
+(every? #(.getThreadBinding ^clojure.lang.Var %) vars))
+(defn make-hierarchy
+"Creates a hierarchy object for use with derive, isa? etc."
+{:added "1.0"}
+[] {:parents {} :descendants {} :ancestors {}})
+(def ^{:private true}
+global-hierarchy (make-hierarchy))
+(defn not-empty
+"If coll is empty, returns nil, else coll"
+{:added "1.0"}
+[coll] (when (seq coll) coll))
+(defn bases
+"Returns the immediate superclass and direct interfaces of c, if any"
+{:added "1.0"}
+[^Class c]
+(when c
+(let [i (.getInterfaces c)
+s (.getSuperclass c)]
+(not-empty
+(if s (cons s i) i)))))
+(defn supers
+"Returns the immediate and indirect superclasses and interfaces of c, if any"
+{:added "1.0"}
+[^Class class]
+(loop [ret (set (bases class)) cs ret]
+(if (seq cs)
+(let [c (first cs) bs (bases c)]
+(recur (into ret bs) (into (disj cs c) bs)))
+(not-empty ret))))
+(defn isa?
+"Returns true if (= child parent), or child is directly or indirectly derived from
+parent, either via a Java type inheritance relationship or a
+relationship established via derive. h must be a hierarchy obtained
+from make-hierarchy, if not supplied defaults to the global
+hierarchy"
+{:added "1.0"}
+([child parent] (isa? global-hierarchy child parent))
+([h child parent]
+(or (= child parent)
+(and (class? parent) (class? child)
+(. ^Class parent isAssignableFrom child))
+(contains? ((:ancestors h) child) parent)
+(and (class? child) (some #(contains? ((:ancestors h) %) parent) (supers child)))
+(and (vector? parent) (vector? child)
+(= (count parent) (count child))
+(loop [ret true i 0]
+(if (or (not ret) (= i (count parent)))
+ret
+(recur (isa? h (child i) (parent i)) (inc i))))))))
+(defn parents
+"Returns the immediate parents of tag, either via a Java type
+inheritance relationship or a relationship established via derive. h
+must be a hierarchy obtained from make-hierarchy, if not supplied
+defaults to the global hierarchy"
+{:added "1.0"}
+([tag] (parents global-hierarchy tag))
+([h tag] (not-empty
+(let [tp (get (:parents h) tag)]
+(if (class? tag)
+(into (set (bases tag)) tp)
+tp)))))
+(defn ancestors
+"Returns the immediate and indirect parents of tag, either via a Java type
+inheritance relationship or a relationship established via derive. h
+must be a hierarchy obtained from make-hierarchy, if not supplied
+defaults to the global hierarchy"
+{:added "1.0"}
+([tag] (ancestors global-hierarchy tag))
+([h tag] (not-empty
+(let [ta (get (:ancestors h) tag)]
+(if (class? tag)
+(let [superclasses (set (supers tag))]
+(reduce into superclasses
+(cons ta
+(map #(get (:ancestors h) %) superclasses))))
+ta)))))
+(defn descendants
+"Returns the immediate and indirect children of tag, through a
+relationship established via derive. h must be a hierarchy obtained
+from make-hierarchy, if not supplied defaults to the global
+hierarchy. Note: does not work on Java type inheritance
+relationships."
+{:added "1.0"}
+([tag] (descendants global-hierarchy tag))
+([h tag] (if (class? tag)
+(throw (java.lang.UnsupportedOperationException. "Can't get descendants of classes"))
+(not-empty (get (:descendants h) tag)))))
+(defn derive
+"Establishes a parent/child relationship between parent and
+tag. Parent must be a namespace-qualified symbol or keyword and
+child can be either a namespace-qualified symbol or keyword or a
+class. h must be a hierarchy obtained from make-hierarchy, if not
+supplied defaults to, and modifies, the global hierarchy."
+{:added "1.0"}
+([tag parent]
+(assert (namespace parent))
+(assert (or (class? tag) (and (instance? clojure.lang.Named tag) (namespace tag))))
+(alter-var-root #'global-hierarchy derive tag parent) nil)
+([h tag parent]
+(assert (not= tag parent))
+(assert (or (class? tag) (instance? clojure.lang.Named tag)))
+(assert (instance? clojure.lang.Named parent))
+(let [tp (:parents h)
+td (:descendants h)
+ta (:ancestors h)
+tf (fn [m source sources target targets]
+(reduce (fn [ret k]
+(assoc ret k
+(reduce conj (get targets k #{}) (cons target (targets target)))))
+m (cons source (sources source))))]
+(or
+(when-not (contains? (tp tag) parent)
+(when (contains? (ta tag) parent)
+(throw (Exception. (print-str tag "already has" parent "as ancestor"))))
+(when (contains? (ta parent) tag)
+(throw (Exception. (print-str "Cyclic derivation:" parent "has" tag "as ancestor"))))
+{:parents (assoc (:parents h) tag (conj (get tp tag #{}) parent))
+:ancestors (tf (:ancestors h) tag td parent ta)
+:descendants (tf (:descendants h) parent ta tag td)})
+h))))
+(declare flatten)
+(defn underive
+"Removes a parent/child relationship between parent and
+tag. h must be a hierarchy obtained from make-hierarchy, if not
+supplied defaults to, and modifies, the global hierarchy."
+{:added "1.0"}
+([tag parent] (alter-var-root #'global-hierarchy underive tag parent) nil)
+([h tag parent]
+(let [parentMap (:parents h)
+	  childsParents (if (parentMap tag)
+			  (disj (parentMap tag) parent) #{})
+	  newParents (if (not-empty childsParents)
+		       (assoc parentMap tag childsParents)
+		       (dissoc parentMap tag))
+	  deriv-seq (flatten (map #(cons (key %) (interpose (key %) (val %)))
+				       (seq newParents)))]
+(if (contains? (parentMap tag) parent)
+	(reduce #(apply derive %1 %2) (make-hierarchy)
+		(partition 2 deriv-seq))
+	h))))
+(defn distinct?
+"Returns true if no two of the arguments are ="
+{:tag Boolean
+:added "1.0"}
+([x] true)
+([x y] (not (= x y)))
+([x y & more]
+(if (not= x y)
+(loop [s #{x y} [x & etc :as xs] more]
+(if xs
+(if (contains? s x)
+false
+(recur (conj s x) etc))
+true))
+false)))
+(defn resultset-seq
+"Creates and returns a lazy sequence of structmaps corresponding to
+the rows in the java.sql.ResultSet rs"
+{:added "1.0"}
+[^java.sql.ResultSet rs]
+(let [rsmeta (. rs (getMetaData))
+idxs (range 1 (inc (. rsmeta (getColumnCount))))
+keys (map (comp keyword #(.toLowerCase ^String %))
+(map (fn [i] (. rsmeta (getColumnLabel i))) idxs))
+check-keys
+(or (apply distinct? keys)
+(throw (Exception. "ResultSet must have unique column labels")))
+row-struct (apply create-struct keys)
+row-values (fn [] (map (fn [^Integer i] (. rs (getObject i))) idxs))
+rows (fn thisfn []
+(when (. rs (next))
+(cons (apply struct row-struct (row-values)) (lazy-seq (thisfn)))))]
+(rows)))
+(defn iterator-seq
+"Returns a seq on a java.util.Iterator. Note that most collections
+providing iterators implement Iterable and thus support seq directly."
+{:added "1.0"}
+[iter]
+(clojure.lang.IteratorSeq/create iter))
+(defn enumeration-seq
+"Returns a seq on a java.util.Enumeration"
+{:added "1.0"}
+[e]
+(clojure.lang.EnumerationSeq/create e))
+(defn format
+"Formats a string using java.lang.String.format, see java.util.Formatter for format
+string syntax"
+{:tag String
+:added "1.0"}
+[fmt & args]
+(String/format fmt (to-array args)))
+(defn printf
+"Prints formatted output, as per format"
+{:added "1.0"}
+[fmt & args]
+(print (apply format fmt args)))
+(declare gen-class)
+(defmacro with-loading-context [& body]
+`((fn loading# []
+(. clojure.lang.Var (pushThreadBindings {clojure.lang.Compiler/LOADER
+(.getClassLoader (.getClass ^Object loading#))}))
+(try
+~@body
+(finally
+(. clojure.lang.Var (popThreadBindings)))))))
+(defmacro ns
+"Sets *ns* to the namespace named by name (unevaluated), creating it
+if needed.  references can be zero or more of: (:refer-clojure ...)
+(:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)
+with the syntax of refer-clojure/require/use/import/load/gen-class
+respectively, except the arguments are unevaluated and need not be
+quoted. (:gen-class ...), when supplied, defaults to :name
+corresponding to the ns name, :main true, :impl-ns same as ns, and
+:init-impl-ns true. All options of gen-class are
+supported. The :gen-class directive is ignored when not
+compiling. If :gen-class is not supplied, when compiled only an
+nsname__init.class will be generated. If :refer-clojure is not used, a
+default (refer 'clojure) is used.  Use of ns is preferred to
+individual calls to in-ns/require/use/import:
+(ns foo.bar
+(:refer-clojure :exclude [ancestors printf])
+(:require (clojure.contrib sql sql.tests))
+(:use (my.lib this that))
+(:import (java.util Date Timer Random)
+(java.sql Connection Statement)))"
+{:arglists '([name docstring? attr-map? references*])
+:added "1.0"}
+[name & references]
+(let [process-reference
+(fn [[kname & args]]
+`(~(symbol "clojure.core" (clojure.core/name kname))
+~@(map #(list 'quote %) args)))
+docstring  (when (string? (first references)) (first references))
+references (if docstring (next references) references)
+name (if docstring
+(vary-meta name assoc :doc docstring)
+name)
+metadata   (when (map? (first references)) (first references))
+references (if metadata (next references) references)
+name (if metadata
+(vary-meta name merge metadata)
+name)
+gen-class-clause (first (filter #(= :gen-class (first %)) references))
+gen-class-call
+(when gen-class-clause
+(list* `gen-class :name (.replace (str name) \- \_) :impl-ns name :main true (next gen-class-clause)))
+references (remove #(= :gen-class (first %)) references)
+;ns-effect (clojure.core/in-ns name)
+]
+`(do
+(clojure.core/in-ns '~name)
+(with-loading-context
+~@(when gen-class-call (list gen-class-call))
+~@(when (and (not= name 'clojure.core) (not-any? #(= :refer-clojure (first %)) references))
+`((clojure.core/refer '~'clojure.core)))
+~@(map process-reference references)))))
+(defmacro refer-clojure
+"Same as (refer 'clojure.core <filters>)"
+{:added "1.0"}
+[& filters]
+`(clojure.core/refer '~'clojure.core ~@filters))
+(defmacro defonce
+"defs name to have the root value of the expr iff the named var has no root value,
+else expr is unevaluated"
+{:added "1.0"}
+[name expr]
+`(let [v# (def ~name)]
+(when-not (.hasRoot v#)
+(def ~name ~expr))))
+;;;;;;;;;;; require/use/load, contributed by Stephen C. Gilardi ;;;;;;;;;;;;;;;;;;
+(defonce
+^{:private true
+:doc "A ref to a sorted set of symbols representing loaded libs"}
+*loaded-libs* (ref (sorted-set)))
+(defonce
+^{:private true
+:doc "the set of paths currently being loaded by this thread"}
+*pending-paths* #{})
+(defonce
+^{:private true :doc
+"True while a verbose load is pending"}
+*loading-verbosely* false)
+(defn- throw-if
+"Throws an exception with a message if pred is true"
+[pred fmt & args]
+(when pred
+(let [^String message (apply format fmt args)
+exception (Exception. message)
+raw-trace (.getStackTrace exception)
+boring? #(not= (.getMethodName ^StackTraceElement %) "doInvoke")
+trace (into-array (drop 2 (drop-while boring? raw-trace)))]
+(.setStackTrace exception trace)
+(throw exception))))
+(defn- libspec?
+"Returns true if x is a libspec"
+[x]
+(or (symbol? x)
+(and (vector? x)
+(or
+(nil? (second x))
+(keyword? (second x))))))
+(defn- prependss
+"Prepends a symbol or a seq to coll"
+[x coll]
+(if (symbol? x)
+(cons x coll)
+(concat x coll)))
+(defn- root-resource
+"Returns the root directory path for a lib"
+{:tag String}
+[lib]
+(str \/
+(.. (name lib)
+(replace \- \_)
+(replace \. \/))))
+(defn- root-directory
+"Returns the root resource path for a lib"
+[lib]
+(let [d (root-resource lib)]
+(subs d 0 (.lastIndexOf d "/"))))
+(declare load)
+(defn- load-one
+"Loads a lib given its name. If need-ns, ensures that the associated
+namespace exists after loading. If require, records the load so any
+duplicate loads can be skipped."
+[lib need-ns require]
+(load (root-resource lib))
+(throw-if (and need-ns (not (find-ns lib)))
+"namespace '%s' not found after loading '%s'"
+lib (root-resource lib))
+(when require
+(dosync
+(commute *loaded-libs* conj lib))))
+(defn- load-all
+"Loads a lib given its name and forces a load of any libs it directly or
+indirectly loads. If need-ns, ensures that the associated namespace
+exists after loading. If require, records the load so any duplicate loads
+can be skipped."
+[lib need-ns require]
+(dosync
+(commute *loaded-libs* #(reduce conj %1 %2)
+(binding [*loaded-libs* (ref (sorted-set))]
+(load-one lib need-ns require)
+@*loaded-libs*))))
+(defn- load-lib
+"Loads a lib with options"
+[prefix lib & options]
+(throw-if (and prefix (pos? (.indexOf (name lib) (int \.))))
+"lib names inside prefix lists must not contain periods")
+(let [lib (if prefix (symbol (str prefix \. lib)) lib)
+opts (apply hash-map options)
+{:keys [as reload reload-all require use verbose]} opts
+loaded (contains? @*loaded-libs* lib)
+load (cond reload-all
+load-all
+(or reload (not require) (not loaded))
+load-one)
+need-ns (or as use)
+filter-opts (select-keys opts '(:exclude :only :rename))]
+(binding [*loading-verbosely* (or *loading-verbosely* verbose)]
+(if load
+(load lib need-ns require)
+(throw-if (and need-ns (not (find-ns lib)))
+"namespace '%s' not found" lib))
+(when (and need-ns *loading-verbosely*)
+(printf "(clojure.core/in-ns '%s)\n" (ns-name *ns*)))
+(when as
+(when *loading-verbosely*
+(printf "(clojure.core/alias '%s '%s)\n" as lib))
+(alias as lib))
+(when use
+(when *loading-verbosely*
+(printf "(clojure.core/refer '%s" lib)
+(doseq [opt filter-opts]
+(printf " %s '%s" (key opt) (print-str (val opt))))
+(printf ")\n"))
+(apply refer lib (mapcat seq filter-opts))))))
+(defn- load-libs
+"Loads libs, interpreting libspecs, prefix lists, and flags for
+forwarding to load-lib"
+[& args]
+(let [flags (filter keyword? args)
+opts (interleave flags (repeat true))
+args (filter (complement keyword?) args)]
+; check for unsupported options
+(let [supported #{:as :reload :reload-all :require :use :verbose}
+unsupported (seq (remove supported flags))]
+(throw-if unsupported
+(apply str "Unsupported option(s) supplied: "
+(interpose \, unsupported))))
+; check a load target was specified
+(throw-if (not (seq args)) "Nothing specified to load")
+(doseq [arg args]
+(if (libspec? arg)
+(apply load-lib nil (prependss arg opts))
+(let [[prefix & args] arg]
+(throw-if (nil? prefix) "prefix cannot be nil")
+(doseq [arg args]
+(apply load-lib prefix (prependss arg opts))))))))
+;; Public
+(defn require
+"Loads libs, skipping any that are already loaded. Each argument is
+either a libspec that identifies a lib, a prefix list that identifies
+multiple libs whose names share a common prefix, or a flag that modifies
+how all the identified libs are loaded. Use :require in the ns macro
+in preference to calling this directly.
+Libs
+A 'lib' is a named set of resources in classpath whose contents define a
+library of Clojure code. Lib names are symbols and each lib is associated
+with a Clojure namespace and a Java package that share its name. A lib's
+name also locates its root directory within classpath using Java's
+package name to classpath-relative path mapping. All resources in a lib
+should be contained in the directory structure under its root directory.
+All definitions a lib makes should be in its associated namespace.
+'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
+<classpath>/x/y/, and its root resource is <classpath>/x/y/z.clj. 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
+:as takes a symbol as its argument and makes that symbol an alias to the
+lib's namespace in the current namespace.
+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
+:reload-all implies :reload and also forces loading of all libs that the
+identified libs directly or indirectly load via require or use
+: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 "1.0"}
+[& args]
+(apply load-libs :require args))
+(defn use
+"Like 'require, but also refers to each lib's namespace using
+clojure.core/refer. Use :use in the ns macro in preference to calling
+this directly.
+'use accepts additional options in libspecs: :exclude, :only, :rename.
+The arguments and semantics for :exclude, :only, and :rename are the same
+as those documented for clojure.core/refer."
+{:added "1.0"}
+[& args] (apply load-libs :require :use args))
+(defn loaded-libs
+"Returns a sorted set of symbols naming the currently loaded libs"
+{:added "1.0"}
+[] @*loaded-libs*)
+(defn load
+"Loads Clojure code from resources in classpath. A path is interpreted as
+classpath-relative if it begins with a slash or relative to the root
+directory for the current namespace otherwise."
+{:added "1.0"}
+[& paths]
+(doseq [^String path paths]
+(let [^String path (if (.startsWith path "/")
+path
+(str (root-directory (ns-name *ns*)) \/ path))]
+(when *loading-verbosely*
+(printf "(clojure.core/load \"%s\")\n" path)
+(flush))
+;      (throw-if (*pending-paths* path)
+;                "cannot load '%s' again while it is loading"
+;                path)
+(when-not (*pending-paths* path)
+(binding [*pending-paths* (conj *pending-paths* path)]
+(clojure.lang.RT/load  (.substring path 1)))))))
+(defn compile
+"Compiles the namespace named by the symbol lib into a set of
+classfiles. The source for the lib must be in a proper
+classpath-relative directory. The output files will go into the
+directory specified by *compile-path*, and that directory too must
+be in the classpath."
+{:added "1.0"}
+[lib]
+(binding [*compile-files* true]
+(load-one lib true true))
+lib)
+;;;;;;;;;;;;; nested associative ops ;;;;;;;;;;;
+(defn get-in
+"Returns the value in a nested associative structure,
+where ks is a sequence of ke(ys. Returns nil if the key is not present,
+or the not-found value if supplied."
+{:added "1.2"}
+([m ks]
+(reduce get m ks))
+([m ks not-found]
+(loop [sentinel (Object.)
+m m
+ks (seq ks)]
+(if ks
+(let [m (get m (first ks) sentinel)]
+(if (identical? sentinel m)
+not-found
+(recur sentinel m (next ks))))
+m))))
+(defn assoc-in
+"Associates a value in a nested associative structure, where ks is a
+sequence of keys and v is the new value and returns a new nested structure.
+If any levels do not exist, hash-maps will be created."
+{:added "1.0"}
+[m [k & ks] v]
+(if ks
+(assoc m k (assoc-in (get m k) ks v))
+(assoc m k v)))
+(defn update-in
+"'Updates' a value in a nested associative structure, where ks is a
+sequence of keys and f is a function that will take the old value
+and any supplied args and return the new value, and returns a new
+nested structure.  If any levels do not exist, hash-maps will be
+created."
+{:added "1.0"}
+([m [k & ks] f & args]
+(if ks
+(assoc m k (apply update-in (get m k) ks f args))
+(assoc m k (apply f (get m k) args)))))
+(defn empty?
+"Returns true if coll has no items - same as (not (seq coll)).
+Please use the idiom (seq x) rather than (not (empty? x))"
+{:added "1.0"}
+[coll] (not (seq coll)))
+(defn coll?
+"Returns true if x implements IPersistentCollection"
+{:added "1.0"}
+[x] (instance? clojure.lang.IPersistentCollection x))
+(defn list?
+"Returns true if x implements IPersistentList"
+{:added "1.0"}
+[x] (instance? clojure.lang.IPersistentList x))
+(defn set?
+"Returns true if x implements IPersistentSet"
+{:added "1.0"}
+[x] (instance? clojure.lang.IPersistentSet x))
+(defn ifn?
+"Returns true if x implements IFn. Note that many data structures
+(e.g. sets and maps) implement IFn"
+{:added "1.0"}
+[x] (instance? clojure.lang.IFn x))
+(defn fn?
+"Returns true if x implements Fn, i.e. is an object created via fn."
+{:added "1.0"}
+[x] (instance? clojure.lang.Fn x))
+(defn associative?
+"Returns true if coll implements Associative"
+{:added "1.0"}
+[coll] (instance? clojure.lang.Associative coll))
+(defn sequential?
+"Returns true if coll implements Sequential"
+{:added "1.0"}
+[coll] (instance? clojure.lang.Sequential coll))
+(defn sorted?
+"Returns true if coll implements Sorted"
+{:added "1.0"}
+[coll] (instance? clojure.lang.Sorted coll))
+(defn counted?
+"Returns true if coll implements count in constant time"
+{:added "1.0"}
+[coll] (instance? clojure.lang.Counted coll))
+(defn reversible?
+"Returns true if coll implements Reversible"
+{:added "1.0"}
+[coll] (instance? clojure.lang.Reversible coll))
+(def
+^{:doc "bound in a repl thread to the most recent value printed"
+:added "1.0"}
+*1)
+(def
+^{:doc "bound in a repl thread to the second most recent value printed"
+:added "1.0"}
+*2)
+(def
+^{:doc "bound in a repl thread to the third most recent value printed"
+:added "1.0"}
+*3)
+(def
+^{:doc "bound in a repl thread to the most recent exception caught by the repl"
+:added "1.0"}
+*e)
+(defn trampoline
+"trampoline can be used to convert algorithms requiring mutual
+recursion without stack consumption. Calls f with supplied args, if
+any. If f returns a fn, calls that fn with no arguments, and
+continues to repeat, until the return value is not a fn, then
+returns that non-fn value. Note that if you want to return a fn as a
+final value, you must wrap it in some data structure and unpack it
+after trampoline returns."
+{:added "1.0"}
+([f]
+(let [ret (f)]
+(if (fn? ret)
+(recur ret)
+ret)))
+([f & args]
+(trampoline #(apply f args))))
+(defn intern
+"Finds or creates a var named by the symbol name in the namespace
+ns (which can be a symbol or a namespace), setting its root binding
+to val if supplied. The namespace must exist. The var will adopt any
+metadata from the name symbol.  Returns the var."
+{:added "1.0"}
+([ns ^clojure.lang.Symbol name]
+(let [v (clojure.lang.Var/intern (the-ns ns) name)]
+(when (meta name) (.setMeta v (meta name)))
+v))
+([ns name val]
+(let [v (clojure.lang.Var/intern (the-ns ns) name val)]
+(when (meta name) (.setMeta v (meta name)))
+v)))
+(defmacro while
+"Repeatedly executes body while test expression is true. Presumes
+some side-effect will cause test to become false/nil. Returns nil"
+{:added "1.0"}
+[test & body]
+`(loop []
+(when ~test
+~@body
+(recur))))
+(defn memoize
+"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 "1.0"}
+[f]
+(let [mem (atom {})]
+(fn [& args]
+(if-let [e (find @mem args)]
+(val e)
+(let [ret (apply f args)]
+(swap! mem assoc args ret)
+ret)))))
+(defmacro condp
+"Takes a binary predicate, an expression, and a set of clauses.
+Each clause can take the form of either:
+test-expr result-expr
+test-expr :>> result-fn
+Note :>> is an ordinary keyword.
+For each clause, (pred test-expr expr) is evaluated. If it returns
+logical true, the clause is a match. If a binary clause matches, the
+result-expr is returned, if a ternary clause matches, its result-fn,
+which must be a unary function, is called with the result of the
+predicate as its argument, the result of that call being the return
+value of condp. A single default expression can follow the clauses,
+and its value will be returned if no clause matches. If no default
+expression is provided and no clause matches, an
+IllegalArgumentException is thrown."
+{:added "1.0"}
+[pred expr & clauses]
+(let [gpred (gensym "pred__")
+gexpr (gensym "expr__")
+emit (fn emit [pred expr args]
+(let [[[a b c :as clause] more]
+(split-at (if (= :>> (second args)) 3 2) args)
+n (count clause)]
+(cond
+(= 0 n) `(throw (IllegalArgumentException. (str "No matching clause: " ~expr)))
+(= 1 n) a
+(= 2 n) `(if (~pred ~a ~expr)
+~b
+~(emit pred expr more))
+:else `(if-let [p# (~pred ~a ~expr)]
+(~c p#)
+~(emit pred expr more)))))
+gres (gensym "res__")]
+`(let [~gpred ~pred
+~gexpr ~expr]
+~(emit gpred gexpr clauses))))
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; var documentation ;;;;;;;;;;;;;;;;;;;;;;;;;;
+(alter-meta! #'*agent* assoc :added "1.0")
+(alter-meta! #'in-ns assoc :added "1.0")
+(alter-meta! #'load-file assoc :added "1.0")
+(defmacro add-doc-and-meta {:private true} [name docstring meta]
+`(alter-meta! (var ~name) merge (assoc ~meta :doc ~docstring)))
+(add-doc-and-meta *file*
+"The path of the file being evaluated, as a String.
+Evaluates to nil when there is no file, eg. in the REPL."
+{:added "1.0"})
+(add-doc-and-meta *command-line-args*
+"A sequence of the supplied command line arguments, or nil if
+none were supplied"
+{:added "1.0"})
+(add-doc-and-meta *warn-on-reflection*
+"When set to true, the compiler will emit warnings when reflection is
+needed to resolve Java method calls or field accesses.
+Defaults to false."
+{:added "1.0"})
+(add-doc-and-meta *compile-path*
+"Specifies the directory where 'compile' will write out .class
+files. This directory must be in the classpath for 'compile' to
+work.
+Defaults to \"classes\""
+{:added "1.0"})
+(add-doc-and-meta *compile-files*
+"Set to true when compiling files, false otherwise."
+{:added "1.0"})
+(add-doc-and-meta *ns*
+"A clojure.lang.Namespace object representing the current namespace."
+{:added "1.0"})
+(add-doc-and-meta *in*
+"A java.io.Reader object representing standard input for read operations.
+Defaults to System/in, wrapped in a LineNumberingPushbackReader"
+{:added "1.0"})
+(add-doc-and-meta *out*
+"A java.io.Writer object representing standard output for print operations.
+Defaults to System/out"
+{:added "1.0"})
+(add-doc-and-meta *err*
+"A java.io.Writer object representing standard error for print operations.
+Defaults to System/err, wrapped in a PrintWriter"
+{:added "1.0"})
+(add-doc-and-meta *flush-on-newline*
+"When set to true, output will be flushed whenever a newline is printed.
+Defaults to true."
+{:added "1.0"})
+(add-doc-and-meta *print-meta*
+"If set to logical true, when printing an object, its metadata will also
+be printed in a form that can be read back by the reader.
+Defaults to false."
+{:added "1.0"})
+(add-doc-and-meta *print-dup*
+"When set to logical true, objects will be printed in a way that preserves
+their type when read in later.
+Defaults to false."
+{:added "1.0"})
+(add-doc-and-meta *print-readably*
+"When set to logical false, strings and characters will be printed with
+non-alphanumeric characters converted to the appropriate escape sequences.
+Defaults to true"
+{:added "1.0"})
+(add-doc-and-meta *read-eval*
+"When set to logical false, the EvalReader (#=(...)) is disabled in the
+read/load in the thread-local binding.
+Example: (binding [*read-eval* false] (read-string \"#=(eval (def x 3))\"))
+Defaults to true"
+{:added "1.0"})
+(defn future?
+"Returns true if x is a future"
+{:added "1.1"}
+[x] (instance? java.util.concurrent.Future x))
+(defn future-done?
+"Returns true if future f is done"
+{:added "1.1"}
+[^java.util.concurrent.Future f] (.isDone f))
+(defmacro letfn
+"Takes a vector of function specs and a body, and generates a set of
+bindings of functions to their names. All of the names are available
+in all of the definitions of the functions, as well as the body.
+fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+)"
+{:added "1.0"}
+[fnspecs & body]
+`(letfn* ~(vec (interleave (map first fnspecs)
+(map #(cons `fn %) fnspecs)))
+~@body))
+;;;;;;; case ;;;;;;;;;;;;;
+(defn- shift-mask [shift mask x]
+(-> x (bit-shift-right shift) (bit-and mask)))
+(defn- min-hash
+"takes a collection of keys and returns [shift mask]"
+[keys]
+(let [hashes (map hash keys)
+cnt (count keys)]
+(when-not (apply distinct? hashes)
+(throw (IllegalArgumentException. "Hashes must be distinct")))
+(or (first
+(filter (fn [[s m]]
+(apply distinct? (map #(shift-mask s m %) hashes)))
+(for [mask (map #(dec (bit-shift-left 1 %)) (range 1 14))
+shift (range 0 31)]
+[shift mask])))
+(throw (IllegalArgumentException. "No distinct mapping found")))))
+(defmacro case
+"Takes an expression, and a set of clauses.
+Each clause can take the form of either:
+test-constant result-expr
+(test-constant1 ... test-constantN)  result-expr
+The test-constants are not evaluated. They must be compile-time
+literals, and need not be quoted.  If the expression is equal to a
+test-constant, the corresponding result-expr is returned. A single
+default expression can follow the clauses, and its value will be
+returned if no clause matches. If no default expression is provided
+and no clause matches, an IllegalArgumentException is thrown.
+Unlike cond and condp, case does a constant-time dispatch, the
+clauses are not considered sequentially.  All manner of constant
+expressions are acceptable in case, including numbers, strings,
+symbols, keywords, and (Clojure) composites thereof. Note that since
+lists are used to group multiple constants that map to the same
+expression, a vector can be used to match a list if needed. The
+test-constants need not be all of the same type."
+{:added "1.2"}
+[e & clauses]
+(let [ge (with-meta (gensym) {:tag Object})
+default (if (odd? (count clauses))
+(last clauses)
+`(throw (IllegalArgumentException. (str "No matching clause: " ~ge))))
+cases (partition 2 clauses)
+case-map (reduce (fn [m [test expr]]
+(if (seq? test)
+(into m (zipmap test (repeat expr)))
+(assoc m test expr)))
+{} cases)
+[shift mask] (if (seq case-map) (min-hash (keys case-map)) [0 0])
+hmap (reduce (fn [m [test expr :as te]]
+(assoc m (shift-mask shift mask (hash test)) te))
+(sorted-map) case-map)]
+`(let [~ge ~e]
+~(condp = (count clauses)
+0 default
+1 default
+`(case* ~ge ~shift ~mask ~(key (first hmap)) ~(key (last hmap)) ~default ~hmap
+~(every? keyword? (keys case-map)))))))
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; helper files ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(alter-meta! (find-ns 'clojure.core) assoc :doc "Fundamental library of the Clojure language")
+(load "core_proxy")
+(load "core_print")
+(load "genclass")
+(load "core_deftype")
+(load "core/protocols")
+(load "gvec")
+;; redefine reduce with internal-reduce
+#_(defn reduce
+"f should be a function of 2 arguments. If val is not supplied,
+returns the result of applying f to the first 2 items in coll, then
+applying f to that result and the 3rd item, etc. If coll contains no
+items, f must accept no arguments as well, and reduce returns the
+result of calling f with no arguments.  If coll has only 1 item, it
+is returned and f is not called.  If val is supplied, returns the
+result of applying f to val and the first item in coll, then
+applying f to that result and the 2nd item, etc. If coll contains no
+items, returns val and f is not called."
+{:added "1.0"}
+([f coll]
+(if-let [s (seq coll)]
+(reduce f (first s) (next s))
+(f)))
+([f val coll]
+(let [s (seq coll)]
+(clojure.core.protocols/internal-reduce s f val))))
+(require '[clojure.java.io :as jio])
+(defn- normalize-slurp-opts
+[opts]
+(if (string? (first opts))
+(do
+(println "WARNING: (slurp f enc) is deprecated, use (slurp f :encoding enc).")
+[:encoding (first opts)])
+opts))
+(defn slurp
+"Reads the file named by f using the encoding enc into a string
+and returns it."
+{:added "1.0"}
+([f & opts]
+(let [opts (normalize-slurp-opts opts)
+sb (StringBuilder.)]
+(with-open [#^java.io.Reader r (apply jio/reader f opts)]
+(loop [c (.read r)]
+(if (neg? c)
+(str sb)
+(do
+(.append sb (char c))
+(recur (.read r)))))))))
+(defn spit
+"Opposite of slurp.  Opens f with writer, writes content, then
+closes f. Options passed to clojure.java.io/writer."
+{:added "1.2"}
+[f content & options]
+(with-open [#^java.io.Writer w (apply jio/writer f options)]
+(.write w (str content))))
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; futures (needs proxy);;;;;;;;;;;;;;;;;;
+(defn future-call
+"Takes a function of no args and yields a future object that will
+invoke the function in another thread, and will cache the result and
+return it on all subsequent calls to deref/@. If the computation has
+not yet finished, calls to deref/@ will block."
+{:added "1.1"}
+[^Callable f]
+(let [fut (.submit clojure.lang.Agent/soloExecutor f)]
+(reify
+clojure.lang.IDeref
+(deref [_] (.get fut))
+java.util.concurrent.Future
+(get [_] (.get fut))
+(get [_ timeout unit] (.get fut timeout unit))
+(isCancelled [_] (.isCancelled fut))
+(isDone [_] (.isDone fut))
+(cancel [_ interrupt?] (.cancel fut interrupt?)))))
+(defmacro future
+"Takes a body of expressions and yields a future object that will
+invoke the body in another thread, and will cache the result and
+return it on all subsequent calls to deref/@. If the computation has
+not yet finished, calls to deref/@ will block."
+{:added "1.1"}
+[& body] `(future-call (^{:once true} fn* [] ~@body)))
+(defn future-cancel
+"Cancels the future, if possible."
+{:added "1.1"}
+[^java.util.concurrent.Future f] (.cancel f true))
+(defn future-cancelled?
+"Returns true if future f is cancelled"
+{:added "1.1"}
+[^java.util.concurrent.Future f] (.isCancelled f))
+(defn pmap
+"Like map, except f is applied in parallel. Semi-lazy in that the
+parallel computation stays ahead of the consumption, but doesn't
+realize the entire result unless required. Only useful for
+computationally intensive functions where the time of f dominates
+the coordination overhead."
+{:added "1.0"}
+([f coll]
+(let [n (+ 2 (.. Runtime getRuntime availableProcessors))
+rets (map #(future (f %)) coll)
+step (fn step [[x & xs :as vs] fs]
+(lazy-seq
+(if-let [s (seq fs)]
+(cons (deref x) (step xs (rest s)))
+(map deref vs))))]
+(step rets (drop n rets))))
+([f coll & colls]
+(let [step (fn step [cs]
+(lazy-seq
+(let [ss (map seq cs)]
+(when (every? identity ss)
+(cons (map first ss) (step (map rest ss)))))))]
+(pmap #(apply f %) (step (cons coll colls))))))
+(defn pcalls
+"Executes the no-arg fns in parallel, returning a lazy sequence of
+their values"
+{:added "1.0"}
+[& fns] (pmap #(%) fns))
+(defmacro pvalues
+"Returns a lazy sequence of the values of the exprs, which are
+evaluated in parallel"
+{:added "1.0"}
+[& exprs]
+`(pcalls ~@(map #(list `fn [] %) exprs)))
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; clojure version number ;;;;;;;;;;;;;;;;;;;;;;
+(let [version-stream (.getResourceAsStream (clojure.lang.RT/baseLoader)
+"clojure/version.properties")
+properties     (doto (new java.util.Properties) (.load version-stream))
+prop (fn [k] (.getProperty properties (str "clojure.version." k)))
+clojure-version {:major       (Integer/valueOf ^String (prop "major"))
+:minor       (Integer/valueOf ^String (prop "minor"))
+:incremental (Integer/valueOf ^String (prop "incremental"))
+:qualifier   (prop "qualifier")}]
+(def *clojure-version*
+(if (not (= (prop "interim") "false"))
+(clojure.lang.RT/assoc clojure-version :interim true)
+clojure-version)))
+(add-doc-and-meta *clojure-version*
+"The version info for Clojure core, as a map containing :major :minor
+:incremental and :qualifier keys. Feature releases may increment
+:minor and/or :major, bugfix releases will increment :incremental.
+Possible values of :qualifier include \"GA\", \"SNAPSHOT\", \"RC-x\" \"BETA-x\""
+{:added "1.0"})
+(defn
+clojure-version
+"Returns clojure version as a printable string."
+{:added "1.0"}
+[]
+(str (:major *clojure-version*)
+"."
+(:minor *clojure-version*)
+(when-let [i (:incremental *clojure-version*)]
+(str "." i))
+(when-let [q (:qualifier *clojure-version*)]
+(when (pos? (count q)) (str "-" q)))
+(when (:interim *clojure-version*)
+"-SNAPSHOT")))
+(defn promise
+"Alpha - subject to change.
+Returns a promise object that can be read with deref/@, and set,
+once only, with deliver. Calls to deref/@ prior to delivery will
+block. All subsequent derefs will return the same delivered value
+without blocking."
+{:added "1.1"}
+[]
+(let [d (java.util.concurrent.CountDownLatch. 1)
+v (atom nil)]
+(reify
+clojure.lang.IDeref
+(deref [_] (.await d) @v)
+clojure.lang.IFn
+(invoke [this x]
+(locking d
+(if (pos? (.getCount d))
+(do (reset! v x)
+(.countDown d)
+this)
+(throw (IllegalStateException. "Multiple deliver calls to a promise"))))))))
+(defn deliver
+"Alpha - subject to change.
+Delivers the supplied value to the promise, releasing any pending
+derefs. A subsequent call to deliver on a promise will throw an exception."
+{:added "1.1"}
+[promise val] (promise val))
+(defn flatten
+"Takes any nested combination of sequential things (lists, vectors,
+etc.) and returns their contents as a single, flat sequence.
+(flatten nil) returns nil."
+{:added "1.2"}
+[x]
+(filter (complement sequential?)
+(rest (tree-seq sequential? seq x))))
+(defn group-by
+"Returns a map of the elements of coll keyed by the result of
+f on each element. The value at each key will be a vector of the
+corresponding elements, in the order they appeared in coll."
+{:added "1.2"}
+[f coll]
+(persistent!
+(reduce
+(fn [ret x]
+(let [k (f x)]
+(assoc! ret k (conj (get ret k []) x))))
+(transient {}) coll)))
+(defn partition-by
+"Applies f to each value in coll, splitting it each time f returns
+a new value.  Returns a lazy seq of partitions."
+{:added "1.2"}
+[f coll]
+(lazy-seq
+(when-let [s (seq coll)]
+(let [fst (first s)
+fv (f fst)
+run (cons fst (take-while #(= fv (f %)) (rest s)))]
+(cons run (partition-by f (drop (count run) s)))))))
+(defn frequencies
+"Returns a map from distinct items in coll to the number of times
+they appear."
+{:added "1.2"}
+[coll]
+(persistent!
+(reduce (fn [counts x]
+(assoc! counts x (inc (get counts x 0))))
+(transient {}) coll)))
+(defn reductions
+"Returns a lazy seq of the intermediate values of the reduction (as
+per reduce) of coll by f, starting with init."
+{:added "1.2"}
+([f coll]
+(lazy-seq
+(if-let [s (seq coll)]
+(reductions f (first s) (rest s))
+(list (f)))))
+([f init coll]
+(cons init
+(lazy-seq
+(when-let [s (seq coll)]
+(reductions f (f init (first s)) (rest s)))))))
+(defn rand-nth
+"Return a random element of the (sequential) collection. Will have
+the same performance characteristics as nth for the given
+collection."
+{:added "1.2"}
+[coll]
+(nth coll (rand-int (count coll))))
+(defn partition-all
+"Returns a lazy sequence of lists like partition, but may include
+partitions with fewer than n items at the end."
+{:added "1.2"}
+([n coll]
+(partition-all n n coll))
+([n step coll]
+(lazy-seq
+(when-let [s (seq coll)]
+(cons (take n s) (partition-all n step (drop step s)))))))
+(defn shuffle
+"Return a random permutation of coll"
+{:added "1.2"}
+[coll]
+(let [al (java.util.ArrayList. coll)]
+(java.util.Collections/shuffle al)
+(clojure.lang.RT/vector (.toArray al))))
+(defn map-indexed
+"Returns a lazy sequence consisting of the result of applying f to 0
+and the first item of coll, followed by applying f to 1 and the second
+item in coll, etc, until coll is exhausted. Thus function f should
+accept 2 arguments, index and item."
+{:added "1.2"}
+[f coll]
+(letfn [(mapi [idx coll]
+(lazy-seq
+(when-let [s (seq coll)]
+(if (chunked-seq? s)
+(let [c (chunk-first s)
+size (int (count c))
+b (chunk-buffer size)]
+(dotimes [i size]
+(chunk-append b (f (+ idx i) (.nth c i))))
+(chunk-cons (chunk b) (mapi (+ idx size) (chunk-rest s))))
+(cons (f idx (first s)) (mapi (inc idx) (rest s)))))))]
+(mapi 0 coll)))
+(defn keep
+"Returns a lazy sequence of the non-nil results of (f item). Note,
+this means false return values will be included.  f must be free of
+side-effects."
+{:added "1.2"}
+([f coll]
+(lazy-seq
+(when-let [s (seq coll)]
+(if (chunked-seq? s)
+(let [c (chunk-first s)
+size (count c)
+b (chunk-buffer size)]
+(dotimes [i size]
+(let [x (f (.nth c i))]
+(when-not (nil? x)
+(chunk-append b x))))
+(chunk-cons (chunk b) (keep f (chunk-rest s))))
+(let [x (f (first s))]
+(if (nil? x)
+(keep f (rest s))
+(cons x (keep f (rest s))))))))))
+(defn keep-indexed
+"Returns a lazy sequence of the non-nil results of (f index item). Note,
+this means false return values will be included.  f must be free of
+side-effects."
+{:added "1.2"}
+([f coll]
+(letfn [(keepi [idx coll]
+(lazy-seq
+(when-let [s (seq coll)]
+(if (chunked-seq? s)
+(let [c (chunk-first s)
+size (count c)
+b (chunk-buffer size)]
+(dotimes [i size]
+(let [x (f (+ idx i) (.nth c i))]
+(when-not (nil? x)
+(chunk-append b x))))
+(chunk-cons (chunk b) (keepi (+ idx size) (chunk-rest s))))
+(let [x (f idx (first s))]
+(if (nil? x)
+(keepi (inc idx) (rest s))
+(cons x (keepi (inc idx) (rest s)))))))))]
+(keepi 0 coll))))
+(defn fnil
+"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 "1.2"}
+([f x]
+(fn
+([a] (f (if (nil? a) x a)))
+([a b] (f (if (nil? a) x a) b))
+([a b c] (f (if (nil? a) x a) b c))
+([a b c & ds] (apply f (if (nil? a) x a) b c ds))))
+([f x y]
+(fn
+([a b] (f (if (nil? a) x a) (if (nil? b) y b)))
+([a b c] (f (if (nil? a) x a) (if (nil? b) y b) c))
+([a b c & ds] (apply f (if (nil? a) x a) (if (nil? b) y b) c ds))))
+([f x y z]
+(fn
+([a b] (f (if (nil? a) x a) (if (nil? b) y b)))
+([a b c] (f (if (nil? a) x a) (if (nil? b) y b) (if (nil? c) z c)))
+([a b c & ds] (apply f (if (nil? a) x a) (if (nil? b) y b) (if (nil? c) z c) ds)))))
+(defn- ^{:dynamic true} assert-valid-fdecl
+"A good fdecl looks like (([a] ...) ([a b] ...)) near the end of defn."
+[fdecl]
+(if-let [bad-args (seq (remove #(vector? %) (map first fdecl)))]
+(throw (IllegalArgumentException. (str "Parameter declaration " (first bad-args) " should be a vector")))))

Mercurial > lasercutter

comparison src/clojure/core.clj @ 10:ef7dbbd6452c