diff options
| -rw-r--r-- | src/boot.clj | 764 |
1 files changed, 487 insertions, 277 deletions
diff --git a/src/boot.clj b/src/boot.clj index 1ccd5cdc..582191be 100644 --- a/src/boot.clj +++ b/src/boot.clj @@ -15,7 +15,8 @@ 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."} + :doc "Returns a new seq where x is the first element and + seq is the rest."} cons (fn* [x seq] (. clojure.lang.RT (cons x seq)))) ;during bootstrap we don't have destructuring let or fn, will redefine later @@ -29,19 +30,22 @@ fn (fn* [& decl] (cons 'fn* decl))) (def #^{:arglists '([coll x]) - :doc "conj[oin]. Returns a new collection with the item 'added'. (conj nil item) returns (item). - The 'addition' may happen at different 'places' depending on the concrete type."} + :doc "conj[oin]. Returns a new collection with the item + 'added'. (conj nil item) returns (item). The 'addition' + may happen at different 'places' depending on the concrete + type."} conj (fn [coll x] (. clojure.lang.RT (conj coll x)))) (def #^{:arglists '([x]) - :doc "Returns the first item in the collection. Calls seq on its argument. If coll is nil, returns nil."} + :doc "Returns the first item in the collection. Calls seq on + its argument. If coll is nil, returns nil."} first (fn [coll] (. clojure.lang.RT (first coll)))) (def #^{:arglists '([x]) - :doc "Returns a seq of the items after the first. Calls seq on its argument. - If there are no more items, returns nil."} + :doc "Returns a seq of the items after the first. Calls seq on + its argument. If there are no more items, returns nil."} rest (fn [x] (. clojure.lang.RT (rest x)))) (def @@ -66,14 +70,16 @@ rrest (fn [x] (rest (rest x)))) (def #^{:arglists '([coll]) - :doc "Sequence. Returns a new ISeq 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."} + :doc "Sequence. Returns a new ISeq 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."} seq (fn [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"} + :doc "Evaluates x and tests if it is an instance of + the class c. Returns true or false"} instance? (fn [#^Class c x] (. c (isInstance x)))) (def @@ -94,9 +100,11 @@ sigs (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)."} + :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)."} assoc (fn ([map key val] (. clojure.lang.RT (assoc map key val))) ([map key val & kvs] @@ -108,20 +116,23 @@ assoc (fn ;;;;;;;;;;;;;;;;; metadata ;;;;;;;;;;;;;;;;;;;;;;;;;;; (def #^{:arglists '([x]) - :doc "Returns the metadata of obj, returns nil if there is no metadata."} + :doc "Returns the metadata of obj, returns nil if there + is no metadata."} meta (fn [x] (if (instance? clojure.lang.IObj x) (. #^clojure.lang.IObj x (meta))))) (def #^{:arglists '([#^clojure.lang.IObj x m]) - :doc "Returns an object of the same type and value as obj, with map m as its metadata."} + :doc "Returns an object of the same type and value as obj, + with map m as its metadata."} with-meta (fn [#^clojure.lang.IObj x m] (. x (withMeta m)))) (def - #^{:doc "Same as (def name (fn [params* ] exprs*)) or (def name (fn ([params* ] exprs*)+))"} + #^{:doc "Same as (def name (fn [params* ] exprs*)) or + (def name (fn ([params* ] exprs*)+))"} defn (fn [name & fdecl] (list 'def (with-meta name (assoc (meta name) :arglists (list 'quote (sigs fdecl)))) (cons `fn (cons name fdecl))))) @@ -142,7 +153,7 @@ vector (defn #^{:doc "keyval => key val - Returns a new hash map with supplied mappings."} + Returns a new hash map with supplied mappings."} hash-map ([] {}) ([& keyvals] @@ -150,14 +161,15 @@ hash-map (defn #^{:doc "keyval => key val - Returns a new sorted map with supplied mappings."} + Returns a new sorted map with supplied mappings."} sorted-map ([& keyvals] (. clojure.lang.PersistentTreeMap (create keyvals)))) (defn #^{:doc "keyval => key val - Returns a new sorted map with supplied mappings, using the supplied comparator."} + Returns a new sorted map with supplied mappings, using the + supplied comparator."} sorted-map-by ([comparator & keyvals] (. clojure.lang.PersistentTreeMap (create comparator keyvals)))) @@ -166,8 +178,9 @@ sorted-map-by ;;;;;;;;;;;;;;;;;;;; (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."} + #^{: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."} defmacro (fn [name & args] (list 'do (cons `defn (cons name args)) @@ -176,12 +189,14 @@ defmacro (fn [name & args] (. (var defmacro) (setMacro)) (defmacro - #^{:doc "Evaluates test. If logical true, evaluates body in an implicit do."} + #^{:doc "Evaluates test. If logical true, evaluates body + in an implicit do."} when [test & body] (list 'if test (cons 'do body))) (defmacro - #^{:doc "Evaluates test. If logical false, evaluates body in an implicit do."} + #^{:doc "Evaluates test. If logical false, evaluates body + in an implicit do."} when-not [test & body] (list 'if test nil (cons 'do body))) @@ -208,9 +223,12 @@ not [x] (if x false true)) (defn #^{:tag Boolean - :doc "Equality. Returns true if obj1 equals obj2, false if not. Same as Java obj1.equals(obj2) - except it also works for nil, and compares numbers in a type-independent manner. - Clojure's immutable data structures define equals() (and thus =) as a value, not an identity, comparison."} + :doc "Equality. Returns true if obj1 equals obj2, false if + not. Same as Java obj1.equals(obj2) except it also works + for nil, and compares numbers in a type-independent + manner. Clojure's immutable data structures define + equals() (and thus =) as a value, not an identity, + comparison."} = [x y] (. clojure.lang.RT (equal x y))) (defn @@ -220,9 +238,10 @@ not= [x y] (not (= x y))) (defn #^{:tag String - :doc "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."} + :doc "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."} str ([] "") ([#^Object x] @@ -240,23 +259,28 @@ symbol ([ns name] (. clojure.lang.Symbol (intern ns name)))) (defn - #^{:doc "Returns a Keyword with the given namespace and name. - Do not use : in the keyword strings, it will be added automatically."} + #^{:doc "Returns a Keyword with the given namespace and name. Do + not use : in the keyword strings, it will be added + automatically."} keyword ([name] (. clojure.lang.Keyword (intern nil name))) ([ns name] (. clojure.lang.Keyword (intern ns name)))) (defn - #^{:doc "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'."} + #^{:doc "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'."} gensym ([] (gensym "G__")) ([prefix-string] (. clojure.lang.Symbol (intern (str prefix-string (str (. clojure.lang.RT (nextID)))))))) (defmacro - #^{:doc "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."} + #^{:doc "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."} cond [& clauses] (when clauses (list 'if (first clauses) @@ -272,7 +296,8 @@ spread [arglist] :else (cons (first arglist) (spread (rest arglist))))) (defn - #^{:doc "Applies fn f to the argument list formed by prepending args to argseq."} + #^{:doc "Applies fn f to the argument list formed by prepending + args to argseq."} apply [#^clojure.lang.IFn f & args] (. f (applyTo (spread args)))) @@ -286,23 +311,30 @@ delay [& body] (list 'new 'clojure.lang.Delay (list* `fn [] body))) (defn - #^{:doc "Returns a seq object whose first is first and whose rest is the value produced by calling restfn - with no arguments. restfn will be called at most once per step in the sequence, e.g. calling rest repeatedly - on the head of the seq calls restfn once - the value it yields is cached."} + #^{:doc "Returns a seq object whose first is first and whose rest + is the value produced by calling restfn with no + arguments. restfn will be called at most once per step in + the sequence, e.g. calling rest repeatedly on the head of + the seq calls restfn once - the value it yields is + cached."} fnseq [x restfn] (new clojure.lang.FnSeq x restfn)) (defmacro - #^{:doc "Expands to code which produces a seq object whose first is first-expr (evaluated) and whose rest is body, - which is not evaluated until rest is called. rest-expr will be evaluated at most once per step in the sequence, - e.g. calling rest repeatedly on the head of the seq evaluates rest-expr once - the value it yields is cached."} + #^{:doc "Expands to code which produces a seq object whose first + is first-expr (evaluated) and whose rest is body, which is + not evaluated until rest is called. rest-expr will be + evaluated at most once per step in the sequence, + e.g. calling rest repeatedly on the head of the seq + evaluates rest-expr once - the value it yields is cached."} lazy-cons [x & body] (list 'fnseq x (list* `fn [] body))) (defn - #^{:doc "Returns a lazy seq representing the concatenation of the elements in colls."} + #^{:doc "Returns a lazy seq representing the concatenation of + the elements in colls."} concat ([] nil) ([x & xs] @@ -314,9 +346,11 @@ concat ;;at this point all the support for syntax-quote exists (defmacro - #^{:doc "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."} + #^{:doc "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."} and ([] true) ([x] x) @@ -325,9 +359,11 @@ and (if and# (and ~@rest) and#)))) (defmacro - #^{:doc "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."} + #^{:doc "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."} or ([] nil) ([x] x) @@ -338,12 +374,17 @@ or ;;;;;;;;;;;;;;;;;;; sequence fns ;;;;;;;;;;;;;;;;;;;;;;; (defn - #^{: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."} + #^{: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."} reduce ([f coll] (if (seq coll) @@ -355,7 +396,8 @@ reduce val))) (defn - #^{:doc "Returns a seq of the items in coll in reverse order. Not lazy."} + #^{:doc "Returns a seq of the items in coll in reverse order. + Not lazy."} reverse [coll] (reduce conj nil coll)) @@ -380,7 +422,8 @@ reverse [coll] (defn #^{:doc "If no denominators are supplied, returns 1/numerator, - else returns numerator divided by all of the denominators."} + else returns numerator divided by all of the + denominators."} / ([x] (/ 1 x)) ([x y] (. clojure.lang.Num (divide x y))) @@ -388,7 +431,8 @@ reverse [coll] (reduce / (/ x y) more))) (defn - #^{:doc "If no ys are supplied, returns the negation of x, else subtracts the ys from x and returns the result."} + #^{:doc "If no ys are supplied, returns the negation of x, else + subtracts the ys from x and returns the result."} - ([x] (. clojure.lang.Num (negate x))) ([x y] (. clojure.lang.Num (subtract x y))) @@ -396,7 +440,8 @@ reverse [coll] (reduce - (- x y) more))) (defn - #^{:doc "Returns non-nil if nums are in monotonically increasing order, otherwise false."} + #^{:doc "Returns non-nil if nums are in monotonically increasing + order, otherwise false."} < ([x] true) ([x y] (. clojure.lang.Num (lt x y))) @@ -408,7 +453,8 @@ reverse [coll] false))) (defn - #^{:doc "Returns non-nil if nums are in monotonically non-decreasing order, otherwise false."} + #^{:doc "Returns non-nil if nums are in monotonically + non-decreasing order, otherwise false."} <= ([x] true) ([x y] (. clojure.lang.Num (lte x y))) @@ -420,7 +466,8 @@ reverse [coll] false))) (defn - #^{:doc "Returns non-nil if nums are in monotonically decreasing order, otherwise false."} + #^{:doc "Returns non-nil if nums are in monotonically decreasing + order, otherwise false."} > ([x] true) ([x y] (. clojure.lang.Num (gt x y))) @@ -432,7 +479,8 @@ reverse [coll] false))) (defn - #^{:doc "Returns non-nil if nums are in monotonically non-increasing order, otherwise false."} + #^{:doc "Returns non-nil if nums are in monotonically + non-increasing order, otherwise false."} >= ([x] true) ([x y] (. clojure.lang.Num (gte x y))) @@ -444,7 +492,8 @@ reverse [coll] false))) (defn - #^{:doc "Returns non-nil if nums all have the same value, otherwise false"} + #^{:doc "Returns non-nil if nums all have the same value, + otherwise false"} == ([x] true) ([x y] (. clojure.lang.Num (equiv x y))) @@ -542,14 +591,16 @@ bit-not [x] (. clojure.lang.IntegerNum (bitNot x))) (defn - #^{:doc "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."} + #^{:doc "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."} complement [f] (fn [& args] (not (apply f args)))) (defn - #^{:doc "Returns a function that takes any number of arguments and returns x."} + #^{:doc "Returns a function that takes any number of arguments and + returns x."} constantly [x] (fn [& args] x)) @@ -562,26 +613,30 @@ identity [x] x) (defn - #^{:doc "Returns the number of items in the collection. (count nil) returns 0. - Also works on strings, arrays, and Java Collections and Maps"} + #^{:doc "Returns the number of items in the collection. (count + nil) returns 0. Also works on strings, arrays, and Java + Collections and Maps"} count [coll] (. clojure.lang.RT (count coll))) ;;list stuff (defn - #^{:doc "Same as first. Returns the first item in the list. If the list is empty, returns nil."} + #^{:doc "Same as first. Returns the first item in the list. If the + list is empty, returns nil."} peek [list] (. clojure.lang.RT (peek list))) (defn - #^{:doc "Returns a new list without the first item. If the list is empty, throws an exception. - Note - not the same as rest."} + #^{:doc "Returns a new list without the first item. If the list is + empty, throws an exception. Note - not the same as rest."} pop [list] (. clojure.lang.RT (pop list))) (defn - #^{:doc "Returns the value at the index. get returns nil if index out of bounds, nth throws an exception. - nth also works for strings, Java arrays and Lists, and, in O(n) time, for sequences."} + #^{:doc "Returns the value at the index. get returns nil if index + out of bounds, nth throws an exception. nth also works + for strings, Java arrays and Lists, and, in O(n) time, + for sequences."} nth [coll index] (. clojure.lang.RT (nth coll index))) @@ -593,7 +648,8 @@ contains? [map key] (. clojure.lang.RT (contains map key))) (defn - #^{:doc "Returns the value mapped to key, not-found or nil if key not present."} + #^{:doc "Returns the value mapped to key, not-found or + nil if key not present."} get ([map key] (. clojure.lang.RT (get map key))) @@ -601,7 +657,9 @@ get (. clojure.lang.RT (get map key not-found)))) (defn - #^{:doc "dissoc[iate]. Returns a new map of the same (hashed/sorted) type, that does not contain a mapping for key(s)."} + #^{:doc "dissoc[iate]. Returns a new map of the same + (hashed/sorted) type, that does not contain a mapping for + key(s)."} dissoc ([map] map) ([map key] @@ -618,7 +676,8 @@ find [map key] (. clojure.lang.RT (find map key))) (defn - #^{:doc "Returns a map containing only those entries in map whose key is in keys"} + #^{:doc "Returns a map containing only those entries in map whose + key is in keys"} select [map keyseq] (loop [ret {} keys (seq keyseq)] (if keys @@ -651,8 +710,8 @@ val [#^java.util.Map$Entry e] (. e (getValue))) (defn - #^{:doc "Returns, in constant time, a sequence of the items in rev (which can be a vector or sorted-map), - in reverse order."} + #^{:doc "Returns, in constant time, a sequence of the items in rev + (which can be a vector or sorted-map), in reverse order."} rseq [#^clojure.lang.Reversible rev] (. rev (rseq))) @@ -662,7 +721,8 @@ name [#^clojure.lang.Named x] (. x (getName))) (defn - #^{:doc "Returns the namespace String of a symbol or keyword, or nil if not present."} + #^{:doc "Returns the namespace String of a symbol or keyword, or + nil if not present."} namespace [#^clojure.lang.Named x] (. x (getNamespace))) @@ -680,8 +740,9 @@ orfn [& args] (defmacro - #^{:doc "Executes exprs in an implicit do, while holding the monitor of x. -Will release the monitor of x in all circumstances."} + #^{:doc "Executes exprs in an implicit do, while holding the + monitor of x. Will release the monitor of x in all + circumstances."} locking [x & body] `(let [lockee# ~x] (try @@ -692,20 +753,28 @@ locking [x & body] (defmacro #^{:doc "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."} + + 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."} .. ([x form] `(. ~x ~form)) ([x form & more] `(.. (. ~x ~form) ~@more))) (defmacro - #^{:doc "Macro. Threads the expr through the forms. Inserts expr 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."} + #^{:doc "Macro. Threads the expr through the forms. Inserts expr + 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."} -> ([x form] (if (seq? form) `(~(first form) ~x ~@(rest form)) @@ -714,21 +783,25 @@ locking [x & body] ;;multimethods (defmacro - #^{:doc "Creates a new multimethod with the associated dispatch function. If default-dispatch-val is supplied - it becomes the default dispatch value of the multimethod, otherwise the default dispatch value is :default."} + #^{:doc "Creates a new multimethod with the associated dispatch + function. If default-dispatch-val is supplied it becomes + the default dispatch value of the multimethod, otherwise + the default dispatch value is :default."} defmulti ([name dispatch-fn] `(defmulti ~name ~dispatch-fn :default)) ([name dispatch-fn default-val] `(def ~name (new clojure.lang.MultiFn ~dispatch-fn ~default-val)))) (defmacro - #^{:doc "Creates and installs a new method of multimethod associated with dispatch-value. "} + #^{:doc "Creates and installs a new method of multimethod + associated with dispatch-value. "} defmethod [multifn dispatch-val & fn-tail] `(let [pvar# (var ~multifn)] (. pvar# (commuteRoot (fn [mf#] (. mf# (assoc ~dispatch-val (fn ~@fn-tail)))))))) (defmacro - #^{:doc "Removes the method of multimethod associated with dispatch-value."} + #^{:doc "Removes the method of multimethod associated + with dispatch-value."} remove-method [multifn dispatch-val] `(let [pvar# (var ~multifn)] (. pvar# (commuteRoot (fn [mf#] (. mf# (dissoc ~dispatch-val))))))) @@ -737,8 +810,10 @@ remove-method [multifn dispatch-val] (defmacro #^{:doc "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."} + 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."} binding [bindings & body] (let [var-ize (fn [var-vals] (loop [ret [] vvs (seq var-vals)] @@ -753,13 +828,15 @@ binding [bindings & body] (. clojure.lang.Var (popThreadBindings)))))) (defn - #^{:doc "Returns the global var named by the namespace-qualified symbol, or nil if no var with that name."} + #^{:doc "Returns the global var named by the namespace-qualified + symbol, or nil if no var with that name."} find-var [sym] (. clojure.lang.Var (find sym))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Refs ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (defn - #^{:doc "Creates and returns an agent with an initial value of state."} + #^{:doc "Creates and returns an agent with an initial + value of state."} agent [state] (new clojure.lang.Agent state)) @@ -768,19 +845,23 @@ agent-of [state] (:agent ^state)) (defn - #^{:doc "Dispatch an action to an agent. Returns the agent immediately. Subsequently, in a thread in a thread pool, - the state of the agent will be set to the value of: - (apply action-fn state-of-agent args)"} + #^{:doc "Dispatch an action to an agent. Returns the agent + immediately. Subsequently, in a thread in a thread pool, + the state of the agent will be set to the value of: + + (apply action-fn state-of-agent args)"} ! [#^clojure.lang.Agent a f & args] (. a (dispatch f args))) (defn - #^{:doc "Returns a sequence of the exceptions thrown during asynchronous actions of the agent."} + #^{:doc "Returns a sequence of the exceptions thrown during + asynchronous actions of the agent."} agent-errors [#^clojure.lang.Agent a] (. a (getErrors))) (defn - #^{:doc "Clears any exceptions thrown during asynchronous actions of the agent, allowing subsequent actions to occur."} + #^{:doc "Clears any exceptions thrown during asynchronous actions + of the agent, allowing subsequent actions to occur."} clear-agent-errors [#^clojure.lang.Agent a] (. a (clearErrors))) @@ -791,44 +872,61 @@ ref [x] (defn #^{:doc "Also reader macro: @ref/@agent - Within a transaction, returns the in-transaction-value of ref, else returns the - most-recently-committed value of ref. When applied to an agent, returns its current state."} + Within a transaction, returns the in-transaction-value of + ref, else returns the most-recently-committed value of + ref. When applied to an agent, returns its current state."} deref [#^clojure.lang.IRef ref] (. ref (get))) (defn - #^{:doc "Must be called in a transaction. Sets the in-transaction-value of ref to: - (apply fun in-transaction-value-of-ref args) - 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 set."} + #^{:doc "Must be called in a transaction. Sets the + in-transaction-value of ref to: + + (apply fun in-transaction-value-of-ref args) + + 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 set."} commute [#^clojure.lang.Ref ref fun & args] (. ref (commute fun args))) (defn - #^{:doc "Must be called in a transaction. Sets the in-transaction-value of ref to: - (apply fun in-transaction-value-of-ref args)"} + #^{:doc "Must be called in a transaction. Sets the + in-transaction-value of ref to: + + (apply fun in-transaction-value-of-ref args)"} alter [#^clojure.lang.Ref ref fun & args] (. ref (alter fun args))) (defn - #^{:doc "Must be called in a transaction. Sets the value of ref. Returns val."} + #^{:doc "Must be called in a transaction. Sets the value of ref. + Returns val."} set [#^clojure.lang.Ref ref val] (. ref (set val))) (defn - #^{:doc "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 (set ref @ref)"} + #^{:doc "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 (set ref @ref)"} ensure [#^clojure.lang.Ref ref] (. ref (touch)) (. ref (get))) (defmacro #^{:doc "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."} + + 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."} sync [flags-ignored-for-now & body] `(. clojure.lang.LockingTransaction (runInTransaction (fn [] ~@body)))) @@ -839,9 +937,10 @@ sync [flags-ignored-for-now & body] (defn - #^{:doc "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."} + #^{:doc "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."} comp [& fs] (let [fs (reverse fs)] (fn [& args] @@ -851,8 +950,10 @@ comp [& fs] ret))))) (defn - #^{:doc "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."} + #^{:doc "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."} partial ([f arg1] (fn [& args] (apply f arg1 args))) @@ -869,7 +970,8 @@ partial (defn #^{:tag Boolean - :doc "Returns true if (pred x) is logical true for every x in coll, else false."} + :doc "Returns true if (pred x) is logical true for + every x in coll, else false."} every? [pred coll] (if (seq coll) (and (pred (first coll)) @@ -878,24 +980,30 @@ every? [pred coll] (def #^{:tag Boolean - :doc "Returns false if (pred x) is logical true for every x in coll, else true."} + :doc "Returns false if (pred x) is logical true for + every x in coll, else true."} not-every? (comp not every?)) (defn - #^{:doc "Returns the first logical true value of (pred x) for any x in coll, else nil."} + #^{:doc "Returns the first logical true value of (pred x) for + any x in coll, else nil."} some [pred coll] (when (seq coll) (or (pred (first coll)) (recur pred (rest coll))))) (def #^{:tag Boolean - :doc "Returns false if (pred x) is logical true for any x in coll, else true."} + :doc "Returns false if (pred x) is logical true for + any x in coll, else true."} not-any? (comp not some)) (defn - #^{:doc "Returns a lazy seq 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."} + #^{:doc "Returns a lazy seq 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."} map ([f coll] (when (seq coll) @@ -906,13 +1014,15 @@ map (apply map f (rest coll) (map rest colls)))))) (defn - #^{:doc "Returns the result of applying concat to the result of applying map to f and colls. - Thus function f should return a collection."} + #^{:doc "Returns the result of applying concat to the result of + applying map to f and colls. Thus function f should + return a collection."} mapcat [f & colls] (apply concat (apply map f colls))) (defn - #^{:doc "Returns a lazy seq of the items in coll for which (pred item) returns true."} + #^{:doc "Returns a lazy seq of the items in coll for which + (pred item) returns true."} filter [pred coll] (when (seq coll) (if (pred (first coll)) @@ -920,13 +1030,15 @@ filter [pred coll] (recur pred (rest coll))))) (defn - #^{:doc "Returns a lazy seq of the first n items in coll, or all items if there are fewer than n."} + #^{:doc "Returns a lazy seq of the first n items in coll, or all + items if there are fewer than n."} take [n coll] (when (and (pos? n) (seq coll)) (lazy-cons (first coll) (take (dec n) (rest coll))))) (defn - #^{:doc "Returns a lazy seq of successive items from coll while (pred item) returns true."} + #^{:doc "Returns a lazy seq of successive items from coll while + (pred item) returns true."} take-while [pred coll] (when (and (seq coll) (pred (first coll))) (lazy-cons (first coll) (take-while pred (rest coll))))) @@ -939,14 +1051,16 @@ drop [n coll] coll)) (defn - #^{:doc "Returns a lazy seq of the items in coll starting from the first item for which (pred item) returns nil."} + #^{:doc "Returns a lazy seq of the items in coll starting from + the first item for which (pred item) returns nil."} drop-while [pred coll] (if (and (seq coll) (pred (first coll))) (recur pred (rest coll)) coll)) (defn - #^{:doc "Returns a lazy (infinite!) seq of repetitions of the items in coll."} + #^{:doc "Returns a lazy (infinite!) seq of repetitions of + the items in coll."} cycle [coll] (when (seq coll) (let [rep (fn thisfn [xs] @@ -981,8 +1095,9 @@ iterate [f x] (lazy-cons x (iterate f (f x)))) (defn - #^{:doc "Returns a lazy seq of nums from start (inclusive) to end (exclusive), by step, - where start defaults to 0 and step to 1."} + #^{:doc "Returns a lazy seq of nums from start (inclusive) to end + (exclusive), by step, where start defaults to 0 and step + to 1."} range ([end] (take end (iterate inc 0))) ([start end] (take (- end start) (iterate inc start))) @@ -990,16 +1105,19 @@ range (take-while (partial (if (pos? step) > <) end) (iterate (partial + step) start)))) (defn - #^{:doc "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."} + #^{:doc "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."} merge [& maps] (reduce conj maps)) (defn - #^{:doc "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)."} + #^{:doc "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)."} merge-with [f & maps] (let [merge-entry (fn [m e] (let [k (key e) v (val e)] @@ -1025,21 +1143,23 @@ zipmap [keys vals] map))) (defn - #^{:doc "Returns the lines of text from rdr as a lazy sequence of strings. - rdr must implement java.io.BufferedReader."} + #^{:doc "Returns the lines of text from rdr as a lazy sequence of + strings. rdr must implement java.io.BufferedReader."} line-seq [#^java.io.BufferedReader rdr] (let [line (. rdr (readLine))] (when line (lazy-cons line (line-seq rdr))))) (defn - #^{:doc "Returns an implementation of java.util.Comparator based upon pred."} + #^{:doc "Returns an implementation of java.util.Comparator based + upon pred."} comparator [pred] (fn [x y] (cond (pred x y) -1 (pred y x) 1 :else 0))) (defn - #^{:doc "Returns a sorted sequence of the items in coll. If no comparator is supplied, - the items must implement Comparable. comparator must implement java.util.Comparator."} + #^{:doc "Returns a sorted sequence of the items in coll. If no + comparator is supplied, the items must implement + Comparable. comparator must implement java.util.Comparator."} sort ([#^java.util.Collection coll] (when (and coll (not (. coll (isEmpty)))) @@ -1053,8 +1173,10 @@ sort (seq a))))) (defn - #^{:doc "Returns a sorted sequence of the items in coll, where the sort order is determined by comparing (keyfn item). - If no comparator is supplied, the keys must implement Comparable. comparator must implement java.util.Comparator."} + #^{:doc "Returns a sorted sequence of the items in coll, where the + sort order is determined by comparing (keyfn item). If no + comparator is supplied, the keys must implement + Comparable. comparator must implement java.util.Comparator."} sort-by ([keyfn coll] (sort (fn [x y] (. #^Comparable (keyfn x) (compareTo (keyfn y)))) coll)) @@ -1064,7 +1186,8 @@ sort-by ;; evaluation (defn - #^{:doc "Evaluates the form data structure (not text!) and returns the result."} + #^{:doc "Evaluates the form data structure (not text!) and + returns the result."} eval [form] (. clojure.lang.Compiler (eval form))) @@ -1072,8 +1195,9 @@ eval [form] ; (def *imports* (apply merge imports-maps))) (defmacro - #^{:doc "Repeatedly executes body (presumably for side-effects) with binding-form bound to successive items from coll. - Does not retain the head of the sequence. Returns nil."} + #^{:doc "Repeatedly executes body (presumably for side-effects) + with binding-form bound to successive items from coll. + Does not retain the head of the sequence. Returns nil."} doseq [item list & body] `(loop [list# (seq ~list)] (when list# @@ -1085,9 +1209,12 @@ doseq [item list & body] (defn touch [& args] (throw (new Exception "touch is now called doall"))) (defn - #^{:doc "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 rests of the seq, does not retain the head and returns nil."} + #^{:doc "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 rests of the seq, + does not retain the head and returns nil."} dorun ([coll] (when (seq coll) @@ -1097,10 +1224,13 @@ dorun (recur (dec n) (rest coll))))) (defn - #^{:doc "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 rests of the seq, retains the head and returns it, - thus causing the entire seq to reside in memory at one time."} + #^{:doc "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 rests of the seq, + retains the head and returns it, thus causing the entire + seq to reside in memory at one time."} doall ([coll] (dorun coll) @@ -1110,8 +1240,9 @@ doall coll)) (defn - #^{:doc "Blocks the current thread (indefinitely!) until all actions dispatched thus far, - from this thread or agent, to the agent(s) have occurred."} + #^{:doc "Blocks the current thread (indefinitely!) until all + actions dispatched thus far, from this thread or agent, to + the agent(s) have occurred."} await [& agents] (let [latch (new java.util.concurrent.CountDownLatch (count agents)) count-down (fn [agent] (. latch (countDown)) agent)] @@ -1120,8 +1251,11 @@ await [& agents] (. latch (await)))) (defn - #^{:doc "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."} + #^{:doc "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."} await-for [timeout-ms & agents] (let [latch (new java.util.concurrent.CountDownLatch (count agents)) count-down (fn [agent] (. latch (countDown)) agent)] @@ -1130,7 +1264,8 @@ await-for [timeout-ms & agents] (. latch (await timeout-ms (. java.util.concurrent.TimeUnit MILLISECONDS))))) (defmacro - #^{:doc "Repeatedly executes body (presumably for side-effects) with name bound to integers from 0 through n-1."} + #^{:doc "Repeatedly executes body (presumably for side-effects) with + name bound to integers from 0 through n-1."} dotimes [i n & body] `(loop [~i 0 n# ~n] (when (< ~i n#) @@ -1139,8 +1274,9 @@ dotimes [i n & body] (defn #^{:doc "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."} + For each name in class-name-symbols, adds a mapping from + name to the class named by package.name to the current + namespace."} import [& import-lists] (when import-lists (let [#^clojure.lang.Namespace ns *ns* @@ -1151,13 +1287,15 @@ import [& import-lists] (apply import (rest import-lists)))) (defn - #^{:doc "Returns an array of the type of the first element in coll, containing the contents of coll, - which must be of a compatible type."} + #^{:doc "Returns an array of the type of the first element in + coll, containing the contents of coll, which must be of a + compatible type."} into-array [aseq] (. clojure.lang.RT (seqToTypedArray (seq aseq)))) (defn - #^{:doc "Returns a new coll consisting of to-coll with all of the items of from-coll conjoined."} + #^{:doc "Returns a new coll consisting of to-coll with all + of the items of from-coll conjoined."} into [to from] (let [ret to items (seq from)] (if items @@ -1177,10 +1315,14 @@ make-proxy [classes method-map] (defmacro #^{:doc "f => (name [args+] body) - Expands to code which creates a instance of a class that implements the named interface(s) by calling the - supplied fns. The interface names must be valid class names of interface types. If a method is not provided for a - non-void-returning interface method, an UnsupportedOperationException will be thrown should it be called. - Method fns are closures and can capture the environment in which implement is called. "} + Expands to code which creates a instance of a class that + implements the named interface(s) by calling the supplied + fns. The interface names must be valid class names of + interface types. If a method is not provided for a + non-void-returning interface method, an + UnsupportedOperationException will be thrown should it be + called. Method fns are closures and can capture the + environment in which implement is called. "} implement [interfaces & fs] `(make-proxy ~interfaces @@ -1192,9 +1334,10 @@ implement [interfaces & fs] fmap)))) (defn - #^{:doc "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"} + #^{:doc "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"} pr ([] nil) ([x] @@ -1206,7 +1349,8 @@ pr (apply pr more))) (defn - #^{:doc "Writes a newline to the output stream that is the current value of *out*"} + #^{:doc "Writes a newline to the output stream that is + the current value of *out*"} newline [] (. *out* (append \newline)) nil) @@ -1218,8 +1362,9 @@ prn [& more] (newline)) (defn - #^{:doc "Prints the object(s) to the output stream that is the current value of *out*. - print and println produce output for human consumption."} + #^{:doc "Prints the object(s) to the output stream that is the + current value of *out*. print and println produce output + for human consumption."} print [& more] (binding [*print-readably* nil] (apply pr more))) @@ -1232,8 +1377,9 @@ println [& more] (defn - #^{:doc "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* ."} + #^{:doc "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* ."} read ([] (read *in*)) @@ -1245,8 +1391,9 @@ read (. clojure.lang.LispReader (read stream eof-error? eof-value recursive?)))) (defmacro - #^{:doc "Evaluates body in a try expression with name bound to the value of init, - and a finally clause that calls (. name (close))."} + #^{:doc "Evaluates body in a try expression with name bound to the + value of init, and a finally clause that calls (. name + (close))."} with-open [name init & body] `(let [~name ~init] (try @@ -1255,8 +1402,10 @@ with-open [name init & body] (. ~name (close)))))) (defmacro - #^{:doc "Evaluates x then calls all of the methods with the supplied arguments in succession on the resulting object, - returning it. + #^{:doc "Evaluates x then calls all of the methods with the + supplied arguments in succession on the resulting object, + returning it. + (doto (new java.util.HashMap) (put \"a\" 1) (put \"b\" 2))"} doto [x & members] (let [gx (gensym)] @@ -1267,15 +1416,17 @@ doto [x & members] ~gx))) (defmacro - #^{:doc "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."} + #^{:doc "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."} memfn [name & args] `(fn [target# ~@args] (. target# (~name ~@args)))) (defmacro - #^{:doc "Evaluates expr and prints the time it took. Returns the value of expr."} + #^{:doc "Evaluates expr and prints the time it took. + Returns the value of expr."} time [expr] `(let [start# (. System (nanoTime)) ret# ~expr] @@ -1318,12 +1469,14 @@ boolean [x] (import '(java.lang.reflect Array)) (defn - #^{:doc "Returns the length of the Java array. Works on arrays of all types."} + #^{:doc "Returns the length of the Java array. Works on arrays + of all types."} alength [array] (. Array (getLength array))) (defn - #^{:doc "Returns the value at the index/indices. Works on Java arrays of all types."} + #^{:doc "Returns the value at the index/indices. Works on Java arrays + of all types."} aget ([array idx] (. Array (get array idx))) @@ -1331,7 +1484,8 @@ aget (apply aget (aget array idx) idxs))) (defn - #^{:doc "Sets the value at the index/indices. Works on Java arrays of reference types. Returns val."} + #^{:doc "Sets the value at the index/indices. Works on Java arrays + of reference types. Returns val."} aset ([array idx val] (. Array (set array idx val)) @@ -1350,34 +1504,45 @@ def-aset [name method coerce] (apply ~name (aget array# idx#) idx2# idxv#)))) (def-aset - #^{:doc "Sets the value at the index/indices. Works on arrays of int. Returns val."} + #^{:doc "Sets the value at the index/indices. Works on arrays of int. + Returns val."} aset-int setInt int) (def-aset - #^{:doc "Sets the value at the index/indices. Works on arrays of long. Returns val."} + #^{:doc "Sets the value at the index/indices. Works on arrays of long. + Returns val."} aset-long setLong long) (def-aset - #^{:doc "Sets the value at the index/indices. Works on arrays of boolean. Returns val."} + #^{:doc "Sets the value at the index/indices. Works on arrays of boolean. + Returns val."} aset-boolean setBoolean boolean) (def-aset - #^{:doc "Sets the value at the index/indices. Works on arrays of float. Returns val."} + #^{:doc "Sets the value at the index/indices. Works on arrays of float. + Returns val."} aset-float setFloat float) (def-aset - #^{:doc "Sets the value at the index/indices. Works on arrays of double. Returns val."} + #^{:doc "Sets the value at the index/indices. Works on arrays of double. + Returns val."} aset-double setDouble double) (def-aset - #^{:doc "Sets the value at the index/indices. Works on arrays of short. Returns val."} + #^{:doc "Sets the value at the index/indices. Works on arrays of short. + Returns val."} aset-short setShort short) (def-aset - #^{:doc "Sets the value at the index/indices. Works on arrays of byte. Returns val."} + #^{:doc "Sets the value at the index/indices. Works on arrays of byte. + Returns val."} aset-byte setByte byte) (def-aset - #^{:doc "Sets the value at the index/indices. Works on arrays of char. Returns val."} + #^{:doc "Sets the value at the index/indices. Works on arrays of char. + Returns val."} aset-char setChar char) (defn - #^{:doc "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)."} + #^{:doc "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)."} make-array ([#^Class type len] (. Array (newInstance type (int len)))) @@ -1389,16 +1554,18 @@ make-array (. Array (newInstance type dimarray))))) (defn - #^{:doc "Returns an array of Objects containing the contents of coll, which can be any Collection. - Maps to java.util.Collection.toArray()."} + #^{:doc "Returns an array of Objects containing the contents of + coll, which can be any Collection. Maps to + java.util.Collection.toArray()."} to-array [#^java.util.Collection coll] (if (zero? (count coll)) (. clojure.lang.RT EMPTY_ARRAY) (. coll (toArray)))) (defn - #^{:doc "Returns a (potentially-ragged) 2-dimensional array of Objects containing the contents of coll, - which can be any Collection of any Collection."} + #^{:doc "Returns a (potentially-ragged) 2-dimensional array of + Objects containing the contents of coll, which can be any + Collection of any Collection."} to-array-2d [#^java.util.Collection coll] (let [ret (make-array (. Class (forName "[Ljava.lang.Object;")) (. coll (size)))] (loop [i 0 xs (seq coll)] @@ -1447,7 +1614,8 @@ to-array-2d [#^java.util.Collection coll] (encl-fn (cons coll colls)))))) (defn - #^{:doc "If form represents a macro form, returns its expansion, else returns form."} + #^{:doc "If form represents a macro form, returns its expansion, + else returns form."} macroexpand-1 [form] (let [v (. clojure.lang.Compiler (isMacro (first form)))] (if v @@ -1455,8 +1623,9 @@ macroexpand-1 [form] form))) (defn - #^{:doc "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."} + #^{:doc "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."} macroexpand [form] (let [ex (macroexpand-1 form) v (. clojure.lang.Compiler (isMacro (first ex)))] @@ -1475,29 +1644,37 @@ defstruct [name & keys] `(def ~name (create-struct ~@keys))) (defn - #^{:doc "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."} + #^{:doc "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."} struct-map [s & inits] (. clojure.lang.PersistentStructMap (create s inits))) (defn - #^{:doc "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."} + #^{:doc "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."} struct [s & vals] (. clojure.lang.PersistentStructMap (construct s vals))) (defn - #^{:doc "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."} + #^{:doc "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."} accessor [s key] (. clojure.lang.PersistentStructMap (getAccessor s key))) (defn - #^{:doc "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."} + #^{:doc "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."} subvec ([v start] (subvec v start (count v))) @@ -1505,12 +1682,14 @@ subvec (. clojure.lang.RT (subvec v start end)))) (defn - #^{:doc "sequentially read and evaluate the set of forms contained in the stream/file"} + #^{:doc "sequentially read and evaluate the set of forms contained + in the stream/file"} load [rdr] (. clojure.lang.Compiler (load rdr))) (defn - #^{:doc "Creates and returns a lazy sequence of structmaps corresponding to the rows in the java.sql.ResultSet rs"} + #^{:doc "Creates and returns a lazy sequence of structmaps corresponding + to the rows in the java.sql.ResultSet rs"} resultset-seq [#^java.sql.ResultSet rs] (let [rsmeta (. rs (getMetaData)) idxs (range 1 (inc (. rsmeta (getColumnCount)))) @@ -1535,7 +1714,8 @@ to-set [coll] ret))) (defn - #^{:doc "Returns a sequence of the elements of coll with duplicates removed"} + #^{:doc "Returns a sequence of the elements of coll with + duplicates removed"} distinct [coll] (keys (to-set coll))) @@ -1549,19 +1729,21 @@ filter-key [keyfn pred amap] ret))) (defn - #^{:doc "Returns the namespace named by the symbol or nil if it doesn't exist."} + #^{:doc "Returns the namespace named by the symbol or nil if + it doesn't exist."} find-ns [sym] (. clojure.lang.Namespace (find sym))) (defn - #^{:doc "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."} + #^{:doc "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."} create-ns [sym] (. clojure.lang.Namespace (findOrCreate sym))) (defn - #^{:doc "Removes the namespace named by the symbol. Use with caution. - Cannot be used to remove the clojure namespace."} + #^{:doc "Removes the namespace named by the symbol. Use with + caution. Cannot be used to remove the clojure namespace."} remove-ns [sym] (. clojure.lang.Namespace (remove sym))) @@ -1603,17 +1785,21 @@ ns-imports [#^clojure.lang.Namespace ns] (filter-key val (partial instance? Class) (ns-map ns))) (defn - #^{:doc "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 + #^{:doc "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."} + 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."} refer [ns-sym & filters] (let [ns (or (find-ns ns-sym) (throw (new Exception (str "No namespace: " ns-sym)))) fs (apply hash-map filters) @@ -1649,7 +1835,8 @@ take-nth [n coll] (lazy-cons (first coll) (take-nth n (drop n coll))))) (defn - #^{:doc "Returns a lazy seq of the first item in each coll, then the second etc."} + #^{:doc "Returns a lazy seq of the first item in each coll, + then the second etc."} interleave [& colls] (apply concat (apply map list colls))) @@ -1659,14 +1846,17 @@ var-get [#^clojure.lang.Var x] (. x (get))) (defn - #^{:doc "Sets the value in the var object to val. The var must be thread-locally bound."} + #^{:doc "Sets the value in the var object to val. The var + must be thread-locally bound."} var-set [#^clojure.lang.Var x val] (. x (set val))) (defmacro #^{:doc "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"} + 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"} with-local-vars [name-vals-vec & body] `(let [~@(interleave (take-nth 2 name-vals-vec) (repeat '(. clojure.lang.Var (create))))] @@ -1676,9 +1866,10 @@ with-local-vars [name-vals-vec & body] (finally (. clojure.lang.Var (popThreadBindings)))))) (defn - #^{:doc "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."} + #^{:doc "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."} ns-resolve [ns sym] (. clojure.lang.Compiler (maybeResolveIn ns sym))) @@ -1729,8 +1920,9 @@ vector? [x] ;redefine let with destructuring (defmacro - #^{:doc "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."} + #^{:doc "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."} let [bindings & body] (let [bmap (apply array-map bindings) pb (fn pb [bvec b v] @@ -1789,8 +1981,9 @@ when-first [x xs & body] ~@body))) (defmacro - #^{:doc "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."} + #^{:doc "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 ([coll] `(seq ~coll)) ([coll & colls] @@ -1801,9 +1994,12 @@ lazy-cat (iter# ~coll)))) (defmacro - #^{:doc "List comprehension. Takes one or more binding-form/collection-expr pairs, an optional filtering (where) - expression, 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."} + #^{:doc "List comprehension. Takes one or more + binding-form/collection-expr pairs, an optional filtering + (where) expression, 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."} for ([seq-expr expr] (list `for seq-expr `true expr)) ([seq-exprs filter-expr expr] @@ -1862,8 +2058,9 @@ fn [& sigs] comment [& body]) (defmacro - #^{:doc "Evaluates exprs in a context in which *out* is bound to a fresh StringWriter. - Returns the string created by any nested printing calls."} + #^{:doc "Evaluates exprs in a context in which *out* is bound to a + fresh StringWriter. Returns the string created by any + nested printing calls."} with-out-str [& body] `(let [s# (new java.io.StringWriter)] (binding [*out* s#] @@ -1895,13 +2092,15 @@ println-str [& xs] (apply println xs))) (defmacro - #^{:doc "Evaluates expr and throws an exception if it does not evaluate to logical true."} + #^{:doc "Evaluates expr and throws an exception if it does not + evaluate to logical true."} assert [x] `(when-not ~x (throw (new Exception (str "Assert failed: " (pr-str '~x)))))) (defn - #^{:doc "test [v] finds fn at key :test in var metadata and calls it, presuming failure will throw exception"} + #^{:doc "test [v] finds fn at key :test in var metadata and calls it, + presuming failure will throw exception"} test [v] (let [f (:test ^v)] (if f @@ -1910,20 +2109,23 @@ test [v] (defn #^{:tag java.util.regex.Pattern - :doc "Returns an instance of java.util.regex.Pattern, for use, e.g. in re-matcher."} + :doc "Returns an instance of java.util.regex.Pattern, + for use, e.g. in re-matcher."} re-pattern [s] (. java.util.regex.Pattern (compile s))) (defn #^{:tag java.util.regex.Matcher - :doc "Returns an instance of java.util.regex.Matcher, for use, e.g. in re-find."} + :doc "Returns an instance of java.util.regex.Matcher, + for use, e.g. in re-find."} re-matcher [#^java.util.regex.Pattern re s] (. re (matcher s))) (defn - #^{:doc "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."} + #^{:doc "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."} re-groups [#^java.util.regex.Matcher m] (let [gc (. m (groupCount))] (if (zero? gc) @@ -1934,8 +2136,9 @@ re-groups [#^java.util.regex.Matcher m] ret))))) (defn - #^{:doc "Returns a lazy sequence of successive matches of pattern in string, using java.util.regex.Matcher.find(), - each such match processed with re-groups."} + #^{:doc "Returns a lazy sequence of successive matches of pattern + in string, using java.util.regex.Matcher.find(), each such + match processed with re-groups."} re-seq [#^java.util.regex.Pattern re s] (let [m (re-matcher re s)] ((fn step [] @@ -1943,8 +2146,9 @@ re-seq [#^java.util.regex.Pattern re s] (lazy-cons (re-groups m) (step))))))) (defn - #^{:doc "Returns the match, if any, of string to pattern, using java.util.regex.Matcher.matches(). - Uses re-groups to return the groups."} + #^{:doc "Returns the match, if any, of string to pattern, using + java.util.regex.Matcher.matches(). Uses re-groups to + return the groups."} re-matches [#^java.util.regex.Pattern re s] (let [m (re-matcher re s)] (when (. m (matches)) @@ -1952,8 +2156,9 @@ re-matches [#^java.util.regex.Pattern re s] (defn - #^{:doc "Returns the next regex match, if any, of string to pattern, using java.util.regex.Matcher.find(). - Uses re-groups to return the groups."} + #^{:doc "Returns the next regex match, if any, of string to + pattern, using java.util.regex.Matcher.find(). Uses + re-groups to return the groups."} re-find ([#^java.util.regex.Matcher m] (when (. m (find)) @@ -1988,7 +2193,8 @@ print-doc [v] (println "\t\t" (:doc ^v))) (defn - #^{:doc "Prints documentation for any var whose documentation or name contains a match for re-string"} + #^{:doc "Prints documentation for any var whose documentation or + name contains a match for re-string"} find-doc [re-string] (let [re (re-pattern re-string)] (dorun (for [ns (all-ns) v (sort-by (comp :name meta) (vals (ns-interns ns)))] @@ -2004,9 +2210,13 @@ doc [varname] (defn #^{:doc "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, must be a branch."} + + 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, + must be a branch."} tree-seq [branch? children root] (let [walk (fn walk [nodes] (when-first node nodes @@ -2047,4 +2257,4 @@ var? [v] (defn #^{:doc "Returns the Class of x"} class [#^Object x] - (. x (getClass)))
\ No newline at end of file + (. x (getClass))) |