We have a tool to run a body only once, use it

`dosync` does not create an exclusion context on executing its body,
so it's possible for two threads to enter the `dosync` and try to run
`eval-fn` independently. Only one of them will win and get into
`ref-map`, but there's still two outbound requests. This is bad.

Delay actually promises exactly once execution and deferred execution,
which are the two things we want. Makes sure that locks are localized
on individual bodies and we don't e.g. lock on the entire map.

Author: aredington

Diff for: src/nodely/engine/lazy_env.clj

@@ -1,6 +1,6 @@
 (ns nodely.engine.lazy-env)
 
-(deftype LazySchedulingEnvironment [env ref-map eval-fn opts]
+(deftype LazySchedulingEnvironment [env delay-map opts]
   clojure.lang.ILookup
   (valAt [this k]
     (or (.valAt this k nil)
@@ -10,23 +10,27 @@
           (throw ex))))
   (valAt [this k not-found]
     (if (find env k)
-      (let [first-read @ref-map]
-        (if (find first-read k)
-          (get first-read k)
-          (-> (dosync
-               (let [second-read @ref-map]
-                 (if-not (find second-read k)
-                   (alter ref-map assoc k (eval-fn env k this opts))
-                   second-read)))
-              (get k))))
+      @(get delay-map k)
       not-found)))
 
 (defn scheduled-nodes
   "Return the current map of nodes to applicative contexts in the
   LazySchedulingEnvironment `lazy-env`."
   [lazy-env]
-  @(.-ref-map lazy-env))
+  (reduce-kv (fn [m k v]
+               (if (realized? v)
+                 (assoc m k @v)
+                 m))
+             {}
+             (.-delay-map lazy-env)))
 
 (defn lazy-env
   [env eval-fn opts]
-  (->LazySchedulingEnvironment env (ref {}) eval-fn opts))
+  (let [this-promise (promise)
+        delay-map (reduce-kv (fn [m k _]
+                               (assoc m k (delay (eval-fn env k @this-promise opts))))
+                             {}
+                             env)
+        lookup (->LazySchedulingEnvironment env delay-map opts)]
+    (deliver this-promise lookup)
+    lookup))