Merge branch 'master' of git://github.com/richhickey/clojure

Author: Dimitry Gashinsky

build.xml

@@ -88,6 +88,7 @@
           classpath="${build}:${cljsrc}"
           failonerror="true">
       <sysproperty key="clojure.compile.path" value="${build}"/>
+      <!-- <sysproperty key="clojure.compile.warn-on-reflection" value="true"/> -->
       <arg value="clojure.core"/>
       <arg value="clojure.main"/>
       <arg value="clojure.set"/>

src/clj/clojure/core.clj

@@ -357,12 +357,14 @@
 
 (defn symbol
   "Returns a Symbol with the given namespace and name."
+  {:tag clojure.lang.Symbol}
   ([name] (if (symbol? name) name (clojure.lang.Symbol/intern name)))
   ([ns name] (clojure.lang.Symbol/intern ns name)))
 
 (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}
   ([name] (if (keyword? name) name (clojure.lang.Keyword/intern name)))
   ([ns name] (clojure.lang.Keyword/intern ns name)))
 
@@ -540,10 +542,11 @@
 
 
 (defn compare
-  "Comparator. Returns 0 if x equals y, -1 if x is logically 'less
-  than' y, else 1. 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"
+  "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"
   {:tag Integer
    :inline (fn [x y] `(. clojure.lang.Util compare ~x ~y))}
   [x y] (. clojure.lang.Util (compare x y)))
@@ -1070,6 +1073,16 @@
               (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."
+  ([x form] (if (seq? form)
+              `(~(first form) ~@(next form)  ~x)
+              (list form x)))
+  ([x form & more] `(->> (->> ~x ~form) ~@more)))
+
 ;;multimethods
 (def global-hierarchy)
 
@@ -1181,28 +1194,58 @@
          (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)))"
+  [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."
+  []
+  (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."
+  []
+  (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."
+  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."
   [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 []
-         (. clojure.lang.Var (pushThreadBindings (hash-map ~@(var-ize bindings))))
-         (try
-          ~@body
-          (finally
-           (. clojure.lang.Var (popThreadBindings)))))))
+  (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 find-var
   "Returns the global var named by the namespace-qualified symbol, or
@@ -1759,6 +1802,15 @@
   ([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."
+  [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."
@@ -2936,7 +2988,7 @@
                                 (conj (pop groups) (conj (peek groups) [k v]))
                                 (conj groups [k v])))
                             [] (partition 2 seq-exprs)))
-        err (fn [& msg] (throw (IllegalArgumentException. (apply str msg))))
+        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__")
@@ -3728,7 +3780,7 @@
 (defmacro with-loading-context [& body]
   `((fn loading# [] 
         (. clojure.lang.Var (pushThreadBindings {clojure.lang.Compiler/LOADER  
-                                                 (-> loading# .getClass .getClassLoader)}))
+                                                 (.getClassLoader (.getClass #^Object loading#))}))
         (try
          ~@body
          (finally
@@ -4403,9 +4455,9 @@
                                            "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 (prop "major"))
-                       :minor       (Integer/valueOf (prop "minor"))
-                       :incremental (Integer/valueOf (prop "incremental"))
+      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"))
@@ -4502,6 +4554,18 @@
   [#^clojure.lang.ITransientVector coll] 
   (.pop coll)) 
 
+(defn disj!
+  "disj[oin]. Returns a transient set of the same (hashed/sorted) type, that
+  does not contain key(s)."
+  ([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
@@ -4516,3 +4580,4 @@
         (if items
           (recur (conj ret (first items)) (next items))
           ret)))))
+

src/clj/clojure/core_proxy.clj

@@ -258,7 +258,7 @@
           pname (proxy-name super interfaces)]
       (or (RT/loadClassForName pname)
           (let [[cname bytecode] (generate-proxy super interfaces)]
-            (. (deref clojure.lang.Compiler/LOADER) (defineClass pname bytecode))))))
+            (. #^DynamicClassLoader (deref clojure.lang.Compiler/LOADER) (defineClass pname bytecode))))))
 
 (defn construct-proxy
   "Takes a proxy class and any arguments for its superclass ctor and

src/clj/clojure/main.clj

@@ -93,7 +93,7 @@
 (defn- root-cause
   "Returns the initial cause of an exception or error by peeling off all of
   its wrappers"
-  [throwable]
+  [#^Throwable throwable]
   (loop [cause throwable]
     (if-let [cause (.getCause cause)]
       (recur cause)
@@ -161,7 +161,7 @@
   (let [{:keys [init need-prompt prompt flush read eval print caught]
          :or {init        #()
               need-prompt (if (instance? LineNumberingPushbackReader *in*)
-                            #(.atLineStart *in*)
+                            #(.atLineStart #^LineNumberingPushbackReader *in*)
                             #(identity true))
               prompt      repl-prompt
               flush       flush
@@ -203,7 +203,7 @@
 (defn load-script
   "Loads Clojure source from a file or resource given its path. Paths
   beginning with @ or @/ are considered relative to classpath."
-  [path]
+  [#^String path]
   (if (.startsWith path "@")
     (RT/loadResourceScript
      (.substring path (if (.startsWith path "@/") 2 1)))

src/clj/clojure/test.clj

@@ -505,7 +505,7 @@ Chas Emerick, Allen Rohner, and Stuart Halloway",
   "Returns a vector [filename line-number] for the nth call up the
   stack."
   [n]
-  (let [s (nth (.getStackTrace (new java.lang.Throwable)) n)]
+  (let [#^StackTraceElement s (nth (.getStackTrace (new java.lang.Throwable)) n)]
     [(.getFileName s) (.getLineNumber s)]))
 
 (defn testing-vars-str

src/clj/clojure/test/tap.clj

@@ -51,7 +51,7 @@
   "Prints a TAP diagnostic line.  data is a (possibly multi-line)
   string."
   [data]
-  (doseq [line (.split data "\n")]
+  (doseq [line (.split #^String data "\n")]
     (println "#" line)))
 
 (defn print-tap-pass

src/clj/clojure/xml.clj

@@ -26,22 +26,22 @@
                        (assoc e :content (conj (or (:content e) []) c)))
         push-chars (fn []
                      (when (and (= *state* :chars)
-                                (some (complement #(. Character (isWhitespace %))) (str *sb*)))
+                                (some (complement #(Character/isWhitespace (char %))) (str *sb*)))
                        (set! *current* (push-content *current* (str *sb*)))))]
     (new clojure.lang.XMLHandler
          (proxy [ContentHandler] []
            (startElement [uri local-name q-name #^Attributes atts]
              (let [attrs (fn [ret i]
                            (if (neg? i)
                              ret
-                             (recur (assoc ret 
-                                           (. clojure.lang.Keyword (intern (symbol (. atts (getQName i)))))
-                                           (. atts (getValue i)))
+                             (recur (assoc ret
+                                           (clojure.lang.Keyword/intern (symbol (.getQName atts i)))
+                                           (.getValue atts (int i)))
                                     (dec i))))
-                   e (struct element 
+                   e (struct element
                              (. clojure.lang.Keyword (intern (symbol q-name)))
-                             (when (pos? (. atts (getLength)))
-                               (attrs {} (dec (. atts (getLength))))))]
+                             (when (pos? (.getLength atts))
+                               (attrs {} (dec (.getLength atts)))))]
                (push-chars)
                (set! *stack* (conj *stack* *current*))
                (set! *current* e)
@@ -53,11 +53,11 @@
              (set! *stack* (pop *stack*))
              (set! *state* :between)
              nil)
-           (characters [ch start length]
+           (characters [#^chars ch start length]
              (when-not (= *state* :chars)
                (set! *sb* (new StringBuilder)))
              (let [#^StringBuilder sb *sb*]
-               (. sb (append ch start length))
+               (.append sb ch (int start) (int length))
                (set! *state* :chars))
              nil)
            (setDocumentLocator [locator])

src/jvm/clojure/lang/ATransientSet.java

@@ -0,0 +1,54 @@
+/**
+ *   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.
+ **/
+
+/* rich Mar 3, 2008 */
+
+package clojure.lang;
+
+public abstract class ATransientSet extends AFn implements ITransientSet{
+	ITransientMap impl;
+
+	ATransientSet(ITransientMap impl) {
+		this.impl = impl;
+	}
+	
+	public int count() {
+		return impl.count();
+	}
+
+	public ITransientSet conj(Object val) {
+		ITransientMap m = impl.assoc(val, val);
+		if (m != impl) this.impl = m;
+		return this;
+	}
+
+	public boolean contains(Object key) {
+		return this != impl.valAt(key, this);
+	}
+
+	public ITransientSet disjoin(Object key) throws Exception {
+		ITransientMap m = impl.without(key);
+		if (m != impl) this.impl = m;
+		return this;
+	}
+
+	public Object get(Object key) {
+		return impl.valAt(key);
+	}
+
+	public Object invoke(Object key, Object notFound) throws Exception {
+		return impl.valAt(key, notFound);
+	}
+
+	public Object invoke(Object key) throws Exception {
+		return impl.valAt(key);	
+	}
+	
+}