 (def temp-reaction (make-reaction nil))
 
 (defn run-in-reaction [f obj key run opts]
-  (let [rea temp-reaction
-        res (deref-capture f rea)]
-    (when-not (nil? (.-watching rea))
+  (let [r temp-reaction
+        res (deref-capture f r)]
+    (when-not (nil? (.-watching r))
       (set! temp-reaction (make-reaction nil))
-      (set! (.-f rea) f)
-      (._set-opts rea opts)
-      (set! (.-auto-run rea) #(run obj))
-      (aset obj key rea))
+      (._set-opts r opts)
+      (set! (.-f r) f)
+      (set! (.-auto-run r) #(run obj))
+      (aset obj key r))
     res))
 
 (defn check-derefs [f]

  (RCursor. src path nil nil nil))



;;; with-let support

(defn with-let-destroy [v]


  IDeref
  (-deref [this]
    (let [non-reactive (nil? *ratom-context*)]
      (when non-reactive
        (flush!))
      (if (and non-reactive (nil? auto-run))
        (when dirty?
          (let [oldstate state]
            (set! state (f))
            (when-not (or (nil? watches) (= oldstate state))
              (notify-w this oldstate state))))
        (do
          (notify-deref-watcher! this)
          (when dirty?
            (._run this)))))
    state)

  IDisposable
