[runtime] lazy drain

We experimented with eager drain. In `(do (a) (b))` we don't care about
the return value of `(a)` and with eager drain we can discard the return
value without notifying through the graph.

The problem is it introduces inconsistencies, e.g. in

    (when-let [x (e/watch !x)]
      (prn x)
      (do-something-with x))

the `(prn x)` form will run even when `x` turns falsy, because of its
over-eagerness.

This commit switches to a lazy drain implementation to fix the
inconsistencies at the cost of additional graph churn.

src/hyperfiddle/electric/impl/runtime3.cljc

@@ -2,7 +2,8 @@
   (:refer-clojure :exclude [resolve])
   (:require [hyperfiddle.incseq :as i]
             [missionary.core :as m]
-            [cognitect.transit :as t])
+            [cognitect.transit :as t]
+            [hyperfiddle.incseq.diff-impl :as d])
   (:import missionary.Cancelled
            #?(:clj (clojure.lang IFn IDeref))
            #?(:clj (java.io ByteArrayInputStream ByteArrayOutputStream Writer))
@@ -223,10 +224,7 @@ T T T -> (EXPR T)
 (defn drain "
 (IS T) -> (IS VOID)
 " [incseq]
-  (let [signal (m/signal i/combine incseq)]
-    (m/ap
-      (m/amb (i/empty-diff 0)
-        (do (m/?> signal) (m/amb))))))
+  (m/latest (constantly (d/empty-diff 0)) incseq))
 
 (defn error [^String msg]
   #?(:clj (Error. msg)

test/hyperfiddle/electric3_test.cljc

@@ -2287,4 +2287,27 @@
       #_init         % := :branch
       (swap! !x not) % := :unmount
       (swap! !x not) % := :branch
-      (swap! !x not) % := :unmount)))
+      (swap! !x not) % := :unmount)))
+
+(tests
+  (let [!x (atom false)]
+    (with ((l/single {}
+             (when-let [x (e/watch !x)]
+               (tap x)
+               (e/OnUnmount #(tap :bye)))) {} {})
+      (reset! !x 1)      % := 1
+      (swap! !x inc)     % := 2
+      (swap! !x inc)     % := 3
+      (reset! !x false)  % := :bye)))
+
+(tests
+  (let [!x (atom false)]
+    (with ((l/single {}
+             (if-let [x (e/watch !x)]
+               (tap x)
+               (tap :not))) {} {})
+      #_init             % := :not
+      (reset! !x 1)      % := 1
+      (swap! !x inc)     % := 2
+      (swap! !x inc)     % := 3
+      (reset! !x false)  % := :not)))