Merge branch 'master' of github.com:ztellman/potemkin

.gitignore

@@ -6,4 +6,6 @@ classes
 target/**
 push
 .DS_Store
-.nrepl*
+.nrepl*
+.idea
+*.iml

project.clj

@@ -13,5 +13,6 @@
                                         (cons (:tag %) (keys %))))
                    :benchmark :benchmark
                    :all (constantly true)}
+  :aot [potemkin.LazyMapEntry]
   :jvm-opts ^:replace ["-server"]
   :repositories {"sonatype-oss-public" "https://oss.sonatype.org/content/groups/public/"})

src/potemkin/LazyMapEntry.clj

@@ -0,0 +1,12 @@
+(ns potemkin.LazyMapEntry
+  (:import (clojure.lang ILookup MapEntry))
+  (:gen-class :extends clojure.lang.MapEntry
+              :init init
+              :constructors {[clojure.lang.ILookup Object] [Object Object]}
+              :state state))
+
+(defn -init [map k]
+  [[k nil] map])
+
+(defn -val [^potemkin.LazyMapEntry this]
+  (.valAt ^ILookup (.state this) (.key this)))

src/potemkin/collections.clj

@@ -88,7 +88,7 @@
   (seq [this]
     (seq
       (map
-        #(clojure.lang.MapEntry. % (.valAt this % nil))
+        #(potemkin.LazyMapEntry. this %)
         (potemkin.collections/keys* this))))
 
   ^{:min-version "1.4.0"}
@@ -142,9 +142,8 @@
     (contains? (.keySet this) k))
 
   (entryAt [this k]
-    (let [v (.valAt this k ::not-found)]
-      (when (not= v ::not-found)
-        (clojure.lang.MapEntry. k v))))
+    (when (contains? (.keySet this) k)
+      (potemkin.LazyMapEntry this k)))
 
   (assoc [this k v]
     (potemkin.collections/assoc* this k v))

test/potemkin/collections_test.clj

@@ -45,3 +45,26 @@
     (is (= {:lower "abc" :upper "ABC"} (dissoc m :string)))
     (is (= {:string "foo" :lower "abc" :upper "ABC" :bar "baz"}
           (assoc m :string "foo" :bar "baz")))))
+
+(def-map-type LazyMap [m]
+  (get [_ k default-value]
+       (if (contains? m k)
+         (let [v (get m k)]
+           (if (instance? clojure.lang.Delay v)
+             @v
+             v))
+         default-value))
+  (assoc [_ k v]
+    (LazyMap. (assoc m k v)))
+  (dissoc [_ k]
+          (LazyMap. (dissoc m k)))
+  (keys [_]
+        (keys m)))
+
+(deftest map-entries-are-lazy
+  (let [was-called (atom false)
+        d (delay (reset! was-called true))
+        m (LazyMap. {:d d})]
+
+    (doall (keys m))
+    (is (= false @was-called))))