From 3afc978cbc298130c2b010cbacb554e39489e281 Mon Sep 17 00:00:00 2001
From: Maciej Bielecki <zyla@prati.pl>
Date: Fri, 26 Apr 2024 18:29:02 +0200
Subject: [PATCH] Remove old DOM API, WeakDynamic and Widgets.{Button, Input,
 RadioGroup, Select) (#97)

* Remove old DOM API and Widgets.{Button, Input, RadioGroup, Select)

* Fix benchmark

* Remove WeakDynamic

* Format code

* Revert package.json changes

* Fix warnings

* Fix formatting
---
 bench/Bench/Builder.js                      | 142 +++++++++------
 bench/Bench/Builder.purs                    |  80 ++-------
 bench/Bench/Primitives.purs                 |  63 ++-----
 bench/BenchMain.js                          |  25 ++-
 bench/BenchMain.purs                        |   3 +-
 package.json                                |   2 +-
 spago.dhall                                 |   6 +-
 src/Specular/Dom/Browser.js                 |  32 ++++
 src/Specular/Dom/Browser.purs               |   5 +
 src/Specular/Dom/Builder.purs               |  61 +------
 src/Specular/Dom/Builder/Class.purs         |  62 +------
 src/Specular/Dom/Element.purs               |  27 ++-
 src/Specular/Dom/Element/Class.purs         |   3 +-
 src/Specular/Dom/Node/Class.purs            |   4 -
 src/Specular/Dom/Widgets/Button.purs        |  20 ---
 src/Specular/Dom/Widgets/Input.js           |  31 ----
 src/Specular/Dom/Widgets/Input.purs         | 151 ----------------
 src/Specular/Dom/Widgets/RadioGroup.purs    |  70 --------
 src/Specular/Dom/Widgets/Select.purs        |  76 --------
 src/Specular/FRP.purs                       |   6 +-
 src/Specular/FRP/Base.purs                  |   2 +-
 src/Specular/FRP/Fix.purs                   |  90 ----------
 src/Specular/FRP/List.purs                  |  51 ------
 src/Specular/FRP/Replaceable.purs           |  11 --
 src/Specular/FRP/WeakDynamic.purs           | 109 ------------
 src/Specular/Ref.purs                       |  14 +-
 test/Test/Utils/Dom.purs                    |   3 +-
 test/browser/BrowserMain.purs               |   8 -
 test/browser/BuilderSpec.purs               | 187 ++++++--------------
 test/browser/DemoMain.purs                  |  41 ++---
 test/browser/InputWidgetsSpec.purs          | 120 -------------
 test/browser/ListSpec.purs                  |  74 +-------
 test/browser/NewBuilderSpec.purs            |  38 +---
 test/browser/RadioGroupSpec.purs            |  34 ----
 test/browser/examples/AsyncRequest.purs     |  94 ++--------
 test/browser/examples/Counter.purs          |  92 ----------
 test/browser/examples/CounterRef.purs       |   8 +-
 test/browser/examples/Radio.purs            |  24 ---
 test/browser/examples/RegistrationForm.purs | 137 ++++++--------
 test/node/FixSpec.purs                      | 136 --------------
 test/node/Main.purs                         |   4 -
 test/node/WeakDynamicSpec.purs              |  68 -------
 42 files changed, 356 insertions(+), 1858 deletions(-)
 delete mode 100644 src/Specular/Dom/Node/Class.purs
 delete mode 100644 src/Specular/Dom/Widgets/Button.purs
 delete mode 100644 src/Specular/Dom/Widgets/Input.js
 delete mode 100644 src/Specular/Dom/Widgets/Input.purs
 delete mode 100644 src/Specular/Dom/Widgets/RadioGroup.purs
 delete mode 100644 src/Specular/Dom/Widgets/Select.purs
 delete mode 100644 src/Specular/FRP/Fix.purs
 delete mode 100644 src/Specular/FRP/WeakDynamic.purs
 delete mode 100644 test/browser/InputWidgetsSpec.purs
 delete mode 100644 test/browser/RadioGroupSpec.purs
 delete mode 100644 test/browser/examples/Counter.purs
 delete mode 100644 test/browser/examples/Radio.purs
 delete mode 100644 test/node/FixSpec.purs
 delete mode 100644 test/node/WeakDynamicSpec.purs

diff --git a/bench/Bench/Builder.js b/bench/Bench/Builder.js
index ce39603..e6aa736 100644
--- a/bench/Bench/Builder.js
+++ b/bench/Bench/Builder.js
@@ -11,43 +11,63 @@
 
 // replicateM_Widget_ :: Int -> Widget Unit -> Widget Unit
 // replicateM_, optimized for Widget.
-exports.replicateM_Widget_ = function(n) {
-  return function(widget) {
-    return function(env) {
-      for(var i = 0; i < n; i++) {
+export function replicateM_Widget_(n) {
+  return function (widget) {
+    return function (env) {
+      for (var i = 0; i < n; i++) {
         widget(env);
       }
     };
   };
-};
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 // staticJS :: forall e. Int -> Eff e Unit
 //
 // This is what we're aiming for in terms of performance: imperative JS code
 // that just creates and appends the nodes.
-exports.staticJS = function(n) {
-  return function() {
-    var parent = document.createElement('div');
-    for(var i = 0; i < n; i++) {
-      elAttr('div', {'class':'foo'}, function(parent) {
-        elAttr('div', {'class':'bar'}, function(parent) {
-          text('foo', parent);
-        }, parent);
-        elAttr('div', {'class':'baz'}, function(parent) {
-          text('foo', parent);
-        }, parent);
-        elAttr('div', {'class':'thud'}, function(parent) {
-          text('foo', parent);
-        }, parent);
-      }, parent);
+export function staticJS(n) {
+  return function () {
+    var parent = document.createElement("div");
+    for (var i = 0; i < n; i++) {
+      elAttr(
+        "div",
+        { class: "foo" },
+        function (parent) {
+          elAttr(
+            "div",
+            { class: "bar" },
+            function (parent) {
+              text("foo", parent);
+            },
+            parent
+          );
+          elAttr(
+            "div",
+            { class: "baz" },
+            function (parent) {
+              text("foo", parent);
+            },
+            parent
+          );
+          elAttr(
+            "div",
+            { class: "thud" },
+            function (parent) {
+              text("foo", parent);
+            },
+            parent
+          );
+        },
+        parent
+      );
     }
   };
-};
+}
 
 function elAttr(tag, attrs, content, parent) {
   var el = document.createElement(tag);
-  for(var k in attrs) {
+  for (var k in attrs) {
     el.setAttribute(k, attrs[k]);
   }
   content(el);
@@ -65,31 +85,31 @@ function text(t, parent) {
 // Like staticJS, but all functions are curried. This is more similar to what
 // PureScript emits, but still uses imperative sequencing instead of `bindE`.
 
-exports.staticJS_c = function(n) {
-  return function() {
-    var parent = document.createElement('div');
-    for(var i = 0; i < n; i++) {
-      elAttr_c('div')({'class':'foo'})(function(parent) {
-        elAttr_c('div')({'class':'bar'})(function(parent) {
-          text_c('foo')(parent);
+export function staticJS_c(n) {
+  return function () {
+    var parent = document.createElement("div");
+    for (var i = 0; i < n; i++) {
+      elAttr_c("div")({ class: "foo" })(function (parent) {
+        elAttr_c("div")({ class: "bar" })(function (parent) {
+          text_c("foo")(parent);
         })(parent);
-        elAttr_c('div')({'class':'baz'})(function(parent) {
-          text_c('foo')(parent);
+        elAttr_c("div")({ class: "baz" })(function (parent) {
+          text_c("foo")(parent);
         })(parent);
-        elAttr_c('div')({'class':'thud'})(function(parent) {
-          text_c('foo')(parent);
+        elAttr_c("div")({ class: "thud" })(function (parent) {
+          text_c("foo")(parent);
         })(parent);
       })(parent);
     }
   };
-};
+}
 
 function elAttr_c(tag) {
-  return function(attrs) {
-    return function(content) {
-      return function(parent) {
+  return function (attrs) {
+    return function (content) {
+      return function (parent) {
         var el = document.createElement(tag);
-        for(var k in attrs) {
+        for (var k in attrs) {
           el.setAttribute(k, attrs[k]);
         }
         content(el);
@@ -100,7 +120,7 @@ function elAttr_c(tag) {
 }
 
 function text_c(t) {
-  return function(parent) {
+  return function (parent) {
     var node = document.createTextNode(t);
     parent.appendChild(node);
   };
@@ -112,33 +132,41 @@ function text_c(t) {
 // Functions are curried, and sequencing is done using monadic `bind`, though
 // specialized to `RIO` monad - "Reader + IO".
 
-exports.staticJS_m = function(n) {
-  return function() {
-    var parent = document.createElement('div');
-    replicateM_RIO(n,
-      elAttr_c('div')({'class':'foo'})(
-        bind_RIO( elAttr_c('div')({'class':'bar'})(text_c('foo')), function(_) {
-          return bind_RIO( elAttr_c('div')({'class':'baz'})(text_c('foo')), function(_) {
-            return elAttr_c('div')({'class':'thud'})(text_c('foo'));
-          });
-        })
-      ))(parent);
+export function staticJS_m(n) {
+  return function () {
+    var parent = document.createElement("div");
+    replicateM_RIO(
+      n,
+      elAttr_c("div")({ class: "foo" })(
+        bind_RIO(
+          elAttr_c("div")({ class: "bar" })(text_c("foo")),
+          function (_) {
+            return bind_RIO(
+              elAttr_c("div")({ class: "baz" })(text_c("foo")),
+              function (_) {
+                return elAttr_c("div")({ class: "thud" })(text_c("foo"));
+              }
+            );
+          }
+        )
+      )
+    )(parent);
   };
-};
+}
 
 function bind_RIO(m, k) {
-  return function(env) {
+  return function (env) {
     return k(m(env))(env);
   };
-};
+}
 
 // Generic implementation of `replicateM` in terms of `bind_RIO`.
 function replicateM_RIO(n, x) {
-  if(n == 0) {
-    return function() {};
+  if (n == 0) {
+    return function () {};
   } else {
-    return bind_RIO(x, function(_) {
-      return replicateM_RIO(n-1, x);
+    return bind_RIO(x, function (_) {
+      return replicateM_RIO(n - 1, x);
     });
   }
 }
diff --git a/bench/Bench/Builder.purs b/bench/Bench/Builder.purs
index f30d621..2f94d42 100644
--- a/bench/Bench/Builder.purs
+++ b/bench/Bench/Builder.purs
@@ -5,88 +5,35 @@ module Bench.Builder
 import Prelude
 
 import Bench.Types (Tests)
-import Control.Monad.Reader (runReaderT)
-import Data.List.Lazy (replicateM)
 import Data.Tuple (Tuple(Tuple))
 import Effect (Effect)
-import Specular.Dom.Browser (Node)
-import Specular.Dom.Builder.Class (elAttr, elDynAttr, text)
+import Specular.Dom.Browser (Node, createElement, (:=))
 import Specular.Dom.Element as E
-import Specular.Dom.Node.Class (createElement, (:=))
-import Specular.Dom.Widget (class MonadWidget, Widget, runWidgetInNode)
+import Specular.Dom.Widget (Widget, runWidgetInNode)
 import Test.Utils.Dom (T3(T3))
 
--- | The widget we're rendering.
-staticWidget :: forall m. MonadWidget m => Int -> m Unit
-staticWidget n =
-  void $ replicateM n $
-    elAttr "div" ("class" := "foo") $ do
-      elAttr "div" ("class" := "bar") $ do
-        text "foo"
-      elAttr "div" ("class" := "baz") $ do
-        text "foo"
-      elAttr "div" ("class" := "thud") $ do
-        text "foo"
-
--- | The same widget, but monomorphic. Can be used to test the effect of
--- | polymorphism to some degree.
-staticWidgetMono :: Int -> Widget Unit
-staticWidgetMono n =
-  void $ replicateM n $
-    elAttr "div" ("class" := "foo") $ do
-      elAttr "div" ("class" := "bar") $ do
-        text "foo"
-      elAttr "div" ("class" := "baz") $ do
-        text "foo"
-      elAttr "div" ("class" := "thud") $ do
-        text "foo"
-
--- | The same widget, but monomorphic. Can be used to test the effect of
--- | polymorphism to some degree.
-staticWidgetMonoOptReplicate :: Int -> Widget Unit
-staticWidgetMonoOptReplicate n =
-  replicateM_Widget_ n $
-    elAttr "div" ("class" := "foo") $ do
-      elAttr "div" ("class" := "bar") $ do
-        text "foo"
-      elAttr "div" ("class" := "baz") $ do
-        text "foo"
-      elAttr "div" ("class" := "thud") $ do
-        text "foo"
-
-staticWidgetMonoOptReplicateD :: Int -> Widget Unit
-staticWidgetMonoOptReplicateD n =
-  replicateM_Widget_ n $
-    elDynAttr "div" (pure $ "class" := "foo") do
-      elDynAttr "div" (pure $ "class" := "bar") do
-        text "foo"
-      elDynAttr "div" (pure $ "class" := "baz") do
-        text "foo"
-      elDynAttr "div" (pure $ "class" := "thud") do
-        text "foo"
-
 foreign import replicateM_Widget_ :: Int -> Widget Unit -> Widget Unit
 
 staticWidgetNewApi :: Int -> Widget Unit
 staticWidgetNewApi n =
   replicateM_Widget_ n $
-    E.el "div" [E.attrs ("class" := "foo")] do
-      E.el "div" [E.attrs ("class" := "bar")] do
+    E.el "div" [ E.attrs ("class" := "foo") ] do
+      E.el "div" [ E.attrs ("class" := "bar") ] do
         E.text "foo"
-      E.el "div" [E.attrs ("class" := "baz")] do
+      E.el "div" [ E.attrs ("class" := "baz") ] do
         E.text "foo"
-      E.el "div" [E.attrs ("class" := "thud")] do
+      E.el "div" [ E.attrs ("class" := "thud") ] do
         E.text "foo"
 
 staticWidgetNewApiD :: Int -> Widget Unit
 staticWidgetNewApiD n =
   replicateM_Widget_ n $
-    E.el "div" [E.attrsD (pure ("class" := "foo"))] do
-      E.el "div" [E.attrsD (pure ("class" := "bar"))] do
+    E.el "div" [ E.attrsD (pure ("class" := "foo")) ] do
+      E.el "div" [ E.attrsD (pure ("class" := "bar")) ] do
         E.text "foo"
-      E.el "div" [E.attrsD (pure ("class" := "baz"))] do
+      E.el "div" [ E.attrsD (pure ("class" := "baz")) ] do
         E.text "foo"
-      E.el "div" [E.attrsD (pure ("class" := "thud"))] do
+      E.el "div" [ E.attrsD (pure ("class" := "thud")) ] do
         E.text "foo"
 
 -- See comments in the FFI module.
@@ -99,15 +46,12 @@ builderTests =
   [ Tuple "js                         " (pure $ delay \_ -> staticJS 10)
   , Tuple "js curried                 " (pure $ delay \_ -> staticJS_c 10)
   , Tuple "js monad                   " (pure $ delay \_ -> staticJS_m 10)
-  , Tuple "Widget + elAttr            " (pure $ delay \_ -> runWidget $ staticWidgetMonoOptReplicate 10)
-  , Tuple "Widget + elDynAttr         " (pure $ delay \_ -> runWidget $ staticWidgetMonoOptReplicateD 10)
   , Tuple "Widget + attr              " (pure $ delay \_ -> runWidget $ staticWidgetNewApi 10)
   , Tuple "Widget + attrD             " (pure $ delay \_ -> runWidget $ staticWidgetNewApiD 10)
-  , Tuple "MonadWidget + ReaderT      " (pure $ delay \_ -> runWidget $ runReaderT (staticWidget 10) unit)
-  , Tuple "MonadWidget + 2x ReaderT   " (pure $ delay \_ -> runWidget $ flip runReaderT unit $ flip runReaderT unit $ staticWidget 10)
   ]
 
-  where delay x = pure unit >>= x
+  where
+  delay x = pure unit >>= x
 
 -- mechanics
 
diff --git a/bench/Bench/Primitives.purs b/bench/Bench/Primitives.purs
index a03c233..1396248 100644
--- a/bench/Bench/Primitives.purs
+++ b/bench/Bench/Primitives.purs
@@ -1,7 +1,4 @@
-module Bench.Primitives
-  ( dynamicTests
-  , weakDynamicTests
-  ) where
+module Bench.Primitives (dynamicTests) where
 
 import Prelude
 
@@ -12,7 +9,7 @@ import Data.Foldable (for_, sum)
 import Data.Traversable (sequence)
 import Data.Tuple (Tuple(..), fst)
 import Effect (Effect)
-import Specular.FRP (Dynamic, WeakDynamic, holdDyn, holdWeakDyn, never, newDynamic, newEvent, subscribeWeakDyn_)
+import Specular.FRP (Dynamic, holdDyn, newDynamic, newEvent)
 import Specular.FRP.Base (subscribeDyn_)
 
 dynamicTests :: Tests
@@ -21,16 +18,18 @@ dynamicTests =
   , Tuple "20 subscribers" $ nsubscribers 20
   , Tuple "30 subscribers" $ nsubscribers 30
   , Tuple "40 subscribers" $ nsubscribers 40
-  ] <>
-  [ Tuple "dyn" $ testDynFn1 pure
-  , Tuple "dyn fmap" $ testDynFn1 \d -> pure (add 1 <$> d)
-  , Tuple "dyn ap pure" $ testDynFn1 \d -> pure (pure (const 1) <*> d)
-  , Tuple "dyn ap self" $ testDynFn1 \d -> pure (add <$> d <*> d)
-  , Tuple "dyn bind self" $ testDynFn1 \d -> pure (d >>= \_ -> d)
-  , Tuple "dyn bind inner" $ testDynFn1 \d -> pure (pure 10 >>= \_ -> d)
-  , Tuple "dyn bind outer" $ testDynFn1 \d -> pure (d >>= \_ -> pure 10)
-  ] <>
-  nestedApplyTests
+  ]
+    <>
+      [ Tuple "dyn" $ testDynFn1 pure
+      , Tuple "dyn fmap" $ testDynFn1 \d -> pure (add 1 <$> d)
+      , Tuple "dyn ap pure" $ testDynFn1 \d -> pure (pure (const 1) <*> d)
+      , Tuple "dyn ap self" $ testDynFn1 \d -> pure (add <$> d <*> d)
+      , Tuple "dyn bind self" $ testDynFn1 \d -> pure (d >>= \_ -> d)
+      , Tuple "dyn bind inner" $ testDynFn1 \d -> pure (pure 10 >>= \_ -> d)
+      , Tuple "dyn bind outer" $ testDynFn1 \d -> pure (d >>= \_ -> pure 10)
+      ]
+    <>
+      nestedApplyTests
 
 nestedApplyTests :: Tests
 nestedApplyTests =
@@ -51,14 +50,14 @@ nestedApplyTests =
       dynamics <- sequence $ replicate n do
         event <- newEvent
         holdDyn 0 event.event
-      pure $ map sum $ sequence ([d] <> dynamics)
+      pure $ map sum $ sequence ([ d ] <> dynamics)
 
   test_n_ap_last n =
     testDynFn1 \d -> do
       dynamics <- sequence $ replicate n do
         event <- newEvent
         holdDyn 0 event.event
-      pure $ map sum $ sequence (dynamics <> [d])
+      pure $ map sum $ sequence (dynamics <> [ d ])
 
 nsubscribers :: Int -> Effect (Effect Unit)
 nsubscribers n =
@@ -77,37 +76,7 @@ testDynFn1 fn =
     subscribeDyn_ (\_ -> pure unit) dyn'
     pure (event.fire 1)
 
-testDynFn2 :: (Dynamic Int -> Dynamic Int -> Host (Dynamic Int)) -> Effect (Effect Unit)
-testDynFn2 fn =
-  runHost do
-    event <- newEvent
-    dyn <- holdDyn 0 event.event
-    dyn2 <- holdDyn 0 never
-    dyn' <- fn dyn dyn2
-    subscribeDyn_ (\_ -> pure unit) dyn'
-    pure (event.fire 1)
-
 type Host = CleanupT Effect
 
 runHost :: forall a. Host a -> Effect a
 runHost = map fst <<< runCleanupT
-
-weakDynamicTests :: Tests
-weakDynamicTests =
-  [ Tuple "weak dyn" $ testWeakDynFn1 pure
-  , Tuple "weak dyn fmap" $ testWeakDynFn1 \d -> pure (add 1 <$> d)
-  , Tuple "weak dyn ap pure" $ testWeakDynFn1 \d -> pure (pure (const 1) <*> d)
-  , Tuple "weak dyn ap self" $ testWeakDynFn1 \d -> pure (add <$> d <*> d)
-  , Tuple "weak dyn bind self" $ testWeakDynFn1 \d -> pure (d >>= \_ -> d)
-  , Tuple "weak dyn bind inner" $ testWeakDynFn1 \d -> pure (pure 10 >>= \_ -> d)
-  , Tuple "weak dyn bind outer" $ testWeakDynFn1 \d -> pure (d >>= \_ -> pure 10)
-  ]
-
-testWeakDynFn1 :: (WeakDynamic Int -> Host (WeakDynamic Int)) -> Effect (Effect Unit)
-testWeakDynFn1 fn =
-  runHost do
-    event <- newEvent
-    dyn <- holdWeakDyn event.event
-    dyn' <- fn dyn
-    subscribeWeakDyn_ (\_ -> pure unit) dyn'
-    pure ( event.fire 1)
diff --git a/bench/BenchMain.js b/bench/BenchMain.js
index 9c130ee..d80cd29 100644
--- a/bench/BenchMain.js
+++ b/bench/BenchMain.js
@@ -1,24 +1,31 @@
-exports.runBenchmark = function(tests) {
-  return function() {
-    tests.forEach(function(t) {
-      for(var k = 0; k < 1; k++) {
+export function runBenchmark(tests) {
+  return function () {
+    tests.forEach(function (t) {
+      for (var k = 0; k < 1; k++) {
         var minTime = 99999;
         var M = 1000;
         var allStart = performance.now();
         var n = 0;
-        while(performance.now() - allStart < 2000) {
+        while (performance.now() - allStart < 2000) {
           var start = performance.now();
-          for(var j = 0; j < M; j++) {
+          for (var j = 0; j < M; j++) {
             t.fn();
           }
           var elapsed = performance.now() - start;
-          if(elapsed < minTime) {
+          if (elapsed < minTime) {
             minTime = elapsed;
           }
           n += M;
         }
-        console.log(t.name + ': ' + (Math.round(1000000 * minTime / M) / 1000) + ' us (' + n + ' runs)');
+        console.log(
+          t.name +
+            ": " +
+            Math.round((1000000 * minTime) / M) / 1000 +
+            " us (" +
+            n +
+            " runs)"
+        );
       }
     });
   };
-};
+}
diff --git a/bench/BenchMain.purs b/bench/BenchMain.purs
index 08a9966..b091cb8 100644
--- a/bench/BenchMain.purs
+++ b/bench/BenchMain.purs
@@ -3,7 +3,7 @@ module BenchMain where
 import Prelude
 
 import Bench.Builder (builderTests)
-import Bench.Primitives (dynamicTests, weakDynamicTests)
+import Bench.Primitives (dynamicTests)
 import Bench.Types (Tests)
 import Data.Traversable (for)
 import Data.Tuple (Tuple(Tuple))
@@ -16,7 +16,6 @@ main :: Effect Unit
 main = launchAff_ do
   bench "Builder" builderTests
   bench "Dynamic" dynamicTests
-  bench "WeakDynamic" weakDynamicTests
 
 bench :: String -> Tests -> Aff Unit
 bench suiteName tests = do
diff --git a/package.json b/package.json
index b8773a4..920ab27 100644
--- a/package.json
+++ b/package.json
@@ -13,7 +13,7 @@
     "build-bench": "spago bundle-app --main BenchMain --to output/BenchMain.js",
     "open-bench": "xdg-open ./bench/benchmark.html",
     "run-bench": "node bench/run.js",
-    "format": "purs-tidy format-in-place 'src/**/*.purs' 'test/**/*.purs' && prettier -w src test"
+    "format": "purs-tidy format-in-place 'src/**/*.purs' 'test/**/*.purs' 'bench/**/*.purs' && prettier -w src test"
   },
   "author": "Maciej Bielecki <zyla@prati.pl>",
   "license": "MIT",
diff --git a/spago.dhall b/spago.dhall
index bdca796..221f791 100644
--- a/spago.dhall
+++ b/spago.dhall
@@ -12,14 +12,11 @@
   , "foreign"
   , "foreign-object"
   , "functions"
-  , "integers"
   , "invariant"
   , "maybe"
   , "newtype"
   , "partial"
   , "prelude"
-  , "random"
-  , "record"
   , "refs"
   , "safe-coerce"
   , "spec"
@@ -27,13 +24,12 @@
   , "strings"
   , "transformers"
   , "tuples"
-  , "type-equality"
   , "typelevel-prelude"
   , "unsafe-coerce"
   , "unsafe-reference"
   ]
 , packages = ./packages.dhall
-, sources = [ "src/**/*.purs", "test/**/*.purs" ]
+, sources = [ "src/**/*.purs", "test/**/*.purs", "bench/**/*.purs" ]
 , license = "MIT"
 , repository = "https://github.com/restaumatic/purescript-specular"
 }
diff --git a/src/Specular/Dom/Browser.js b/src/Specular/Dom/Browser.js
index bf79350..c59d846 100644
--- a/src/Specular/Dom/Browser.js
+++ b/src/Specular/Dom/Browser.js
@@ -195,3 +195,35 @@ export function removeNode(node) {
     }
   };
 }
+
+// getTextInputValue :: Node -> IOSync String
+export function getTextInputValue(node) {
+  return function () {
+    return node.value;
+  };
+}
+
+// setTextInputValue :: Node -> String -> IOSync String
+export function setTextInputValue(node) {
+  return function (value) {
+    return function () {
+      node.value = value;
+    };
+  };
+}
+
+// getCheckboxChecked :: Node -> IOSync Boolean
+export function getCheckboxChecked(node) {
+  return function () {
+    return node.checked;
+  };
+}
+
+// setCheckboxChecked :: Node -> Boolean -> IOSync Unit
+export function setCheckboxChecked(node) {
+  return function (value) {
+    return function () {
+      return (node.checked = value);
+    };
+  };
+}
diff --git a/src/Specular/Dom/Browser.purs b/src/Specular/Dom/Browser.purs
index 607b51e..8cc0c94 100644
--- a/src/Specular/Dom/Browser.purs
+++ b/src/Specular/Dom/Browser.purs
@@ -116,3 +116,8 @@ foreign import preventDefault :: Event -> Effect Unit
 
 -- | Get `innerHTML` of a node.
 foreign import innerHTML :: Node -> Effect String
+
+foreign import getCheckboxChecked :: Node -> Effect Boolean
+foreign import setCheckboxChecked :: Node -> Boolean -> Effect Unit
+foreign import getTextInputValue :: Node -> Effect String
+foreign import setTextInputValue :: Node -> String -> Effect Unit
diff --git a/src/Specular/Dom/Builder.purs b/src/Specular/Dom/Builder.purs
index 773bea2..1669761 100644
--- a/src/Specular/Dom/Builder.purs
+++ b/src/Specular/Dom/Builder.purs
@@ -4,6 +4,7 @@ module Specular.Dom.Builder
   , local
   , unBuilder
   , mkBuilder'
+  , mkBuilder
   , runBuilder'
   , getParentNode
   ) where
@@ -15,16 +16,13 @@ import Control.Monad.Cleanup (class MonadCleanup, onCleanup)
 import Control.Monad.Reader (ask, asks)
 import Control.Monad.Reader.Class (class MonadAsk, class MonadReader)
 import Control.Monad.Replace (class MonadReplace, Slot(Slot), newSlot)
-import Data.Array as A
 import Data.Maybe (Maybe(..))
 import Data.Tuple (Tuple(Tuple))
 import Effect (Effect)
 import Effect.Class (class MonadEffect, liftEffect)
 import Effect.Uncurried (EffectFn1, EffectFn2, mkEffectFn2, runEffectFn1, runEffectFn2)
-import Foreign.Object as SM
 import Specular.Dom.Builder.Class (class MonadDomBuilder)
-import Specular.Dom.Browser (Node, appendChild, appendRawHtml, createDocumentFragment, createElementNS, createTextNode, insertBefore, parentNode, removeAllBetween, removeAttributes, setAttributes, setText, removeNode)
-import Specular.FRP.WeakDynamic (subscribeWeakDyn_)
+import Specular.Dom.Browser (Node, appendChild, createDocumentFragment, createTextNode, insertBefore, parentNode, removeAllBetween, removeNode)
 import Effect.Ref (modify_, new, read, write)
 import Specular.Internal.Effect (DelayedEffects, emptyDelayed, pushDelayed, sequenceEffects, unsafeFreezeDelayed)
 import Specular.Internal.RIO (RIO(..), rio, runRIO)
@@ -84,13 +82,10 @@ runBuilderWithUserEnv userEnv parent (Builder f) = do
 getEnv :: forall env. Builder env (BuilderEnv env)
 getEnv = Builder ask
 
-setParent :: forall env. Node -> BuilderEnv env -> BuilderEnv env
-setParent parent env = env { parent = parent }
-
 getParentNode :: forall env. Builder env Node
 getParentNode = Builder (asks _.parent)
 
-instance monadReplaceBuilder :: MonadReplace (Builder env) where
+instance MonadReplace (Builder env) where
 
   newSlot = do
     env <- getEnv
@@ -159,58 +154,14 @@ instance monadReplaceBuilder :: MonadReplace (Builder env) where
 
     pure $ Slot replace destroy append
 
-instance monadDomBuilderBuilder :: MonadDomBuilder (Builder env) where
-
-  text str = mkBuilder \env -> do
-    node <- createTextNode str
-    appendChild node env.parent
-
-  dynText dstr = do
-    node <- mkBuilder \env -> do
-      node <- createTextNode ""
-      appendChild node env.parent
-      pure node
-    subscribeWeakDyn_ (setText node) dstr
-
-  rawHtml html = mkBuilder \env ->
-    appendRawHtml html env.parent
-
-  elDynAttrNS' namespace tagName dynAttrs inner = do
-    env <- getEnv
-    node <- liftEffect $ createElementNS namespace tagName
-
-    attrsRef <- liftEffect $ new mempty
-    let
-      resetAttributes newAttrs = do
-        oldAttrs <- read attrsRef
-        write newAttrs attrsRef
-        let
-          changed = SM.filterWithKey (\k v -> SM.lookup k oldAttrs /= Just v) newAttrs
-          removed = A.filter (\k -> not (k `SM.member` newAttrs)) $ SM.keys oldAttrs
-
-        removeAttributes node removed
-        setAttributes node changed
-
-    subscribeWeakDyn_ resetAttributes dynAttrs
-    result <- Builder $ RIO.local (setParent node) $ unBuilder inner
-    liftEffect $ appendChild node env.parent
-    pure (Tuple node result)
-
-  elAttr tagName attrs inner = do
-    env <- getEnv
-    node <- liftEffect $ createElementNS Nothing tagName
-    liftEffect $ setAttributes node attrs
-    result <- Builder $ RIO.local (setParent node) $ unBuilder inner
-    liftEffect $ appendChild node env.parent
-    pure result
-
+instance MonadDomBuilder (Builder env) where
   liftBuilder fn = Builder (RIO fn)
   liftBuilderWithRun fn =
     Builder $ rio \env ->
       runEffectFn2 fn env (mkEffectFn2 \env' (Builder (RIO m)) -> runEffectFn1 m env')
 
-instance semigroupBuilder :: Semigroup a => Semigroup (Builder node a) where
+instance Semigroup a => Semigroup (Builder node a) where
   append = lift2 append
 
-instance monoidBuilder :: Monoid a => Monoid (Builder node a) where
+instance Monoid a => Monoid (Builder node a) where
   mempty = pure mempty
diff --git a/src/Specular/Dom/Builder/Class.purs b/src/Specular/Dom/Builder/Class.purs
index f67d2f2..e078389 100644
--- a/src/Specular/Dom/Builder/Class.purs
+++ b/src/Specular/Dom/Builder/Class.purs
@@ -4,17 +4,13 @@ import Prelude
 
 import Control.Monad.Cleanup (onCleanup)
 import Control.Monad.Reader (ReaderT(..), runReaderT)
-import Control.Monad.Replace (class MonadReplace)
 import Control.Monad.Trans.Class (lift)
-import Data.Maybe (Maybe(..))
-import Data.Tuple (Tuple, snd)
 import Effect (Effect)
 import Effect.Class (liftEffect)
 import Effect.Uncurried (EffectFn1, EffectFn2, mkEffectFn2, runEffectFn2)
-import Specular.Dom.Browser (Attrs, EventType, Namespace, Node, TagName, addEventListener)
+import Specular.Dom.Browser (EventType, Node, addEventListener)
 import Specular.Dom.Browser as DOM
-import Specular.FRP (class MonadFRP, WeakDynamic, newEvent, weakDynamic_)
-import Specular.FRP as FRP
+import Specular.FRP (class MonadFRP)
 import Specular.Internal.Effect (DelayedEffects)
 
 type BuilderEnv env =
@@ -24,68 +20,16 @@ type BuilderEnv env =
   }
 
 class Monad m <= MonadDomBuilder m where
-  text :: String -> m Unit
-  dynText :: WeakDynamic String -> m Unit
-  elDynAttrNS' :: forall a. Maybe Namespace -> TagName -> WeakDynamic Attrs -> m a -> m (Tuple Node a)
-  rawHtml :: String -> m Unit
-
-  elAttr :: forall a. TagName -> Attrs -> m a -> m a
-
   liftBuilder :: forall a. (forall env. EffectFn1 (BuilderEnv env) a) -> m a
   liftBuilderWithRun :: forall a b. (forall env. EffectFn2 (BuilderEnv env) (EffectFn2 (BuilderEnv env) (m b) b) a) -> m a
 
-elDynAttr' :: forall m a. MonadDomBuilder m => String -> WeakDynamic Attrs -> m a -> m (Tuple Node a)
-elDynAttr' = elDynAttrNS' Nothing
-
-elDynAttr
-  :: forall m a
-   . MonadDomBuilder m
-  => String
-  -> WeakDynamic Attrs
-  -> m a
-  -> m a
-elDynAttr tagName dynAttrs inner = snd <$> elDynAttr' tagName dynAttrs inner
-
-elAttr' :: forall m a. MonadDomBuilder m => String -> Attrs -> m a -> m (Tuple Node a)
-elAttr' tagName attrs inner = elDynAttr' tagName (pure attrs) inner
-
-elAttr_ :: forall m. MonadDomBuilder m => String -> Attrs -> m Unit
-elAttr_ tagName attrs = elAttr tagName attrs (pure unit)
-
-el' :: forall m a. MonadDomBuilder m => String -> m a -> m (Tuple Node a)
-el' tagName inner = elAttr' tagName mempty inner
-
-el :: forall m a. MonadDomBuilder m => String -> m a -> m a
-el tagName inner = elAttr tagName mempty inner
-
-el_ :: forall m. MonadDomBuilder m => String -> m Unit
-el_ tagName = el tagName (pure unit)
-
-dynRawHtml :: forall m. MonadDomBuilder m => MonadReplace m => MonadFRP m => WeakDynamic String -> m Unit
-dynRawHtml dynHtml = weakDynamic_ (rawHtml <$> dynHtml)
-
-domEventWithSample :: forall m a. MonadFRP m => (DOM.Event -> Effect a) -> EventType -> Node -> m (FRP.Event a)
-domEventWithSample sample eventType node = do
-  { event, fire } <- newEvent
-  onDomEvent eventType node (sample >=> fire)
-  pure event
-
-domEvent :: forall m. MonadFRP m => EventType -> Node -> m (FRP.Event Unit)
-domEvent = domEventWithSample (\_ -> pure unit)
-
 -- | Register a DOM event listener.
 onDomEvent :: forall m. MonadFRP m => EventType -> Node -> (DOM.Event -> Effect Unit) -> m Unit
 onDomEvent eventType node handler = do
   unsub <- liftEffect $ addEventListener eventType handler node
   onCleanup unsub
 
-instance monadDomBuilderReaderT :: MonadDomBuilder m => MonadDomBuilder (ReaderT r m) where
-  text = lift <<< text
-  dynText = lift <<< dynText
-  elDynAttrNS' ns tag attrs body = ReaderT $ \env -> elDynAttrNS' ns tag attrs $ runReaderT body env
-  rawHtml = lift <<< rawHtml
-  elAttr tag attrs body =
-    ReaderT $ \env -> elAttr tag attrs $ runReaderT body env
+instance MonadDomBuilder m => MonadDomBuilder (ReaderT r m) where
   liftBuilder b = lift (liftBuilder b)
   liftBuilderWithRun fn = ReaderT \e ->
     liftBuilderWithRun
diff --git a/src/Specular/Dom/Element.purs b/src/Specular/Dom/Element.purs
index e8e35b4..b0ef8da 100644
--- a/src/Specular/Dom/Element.purs
+++ b/src/Specular/Dom/Element.purs
@@ -1,8 +1,9 @@
 module Specular.Dom.Element
-  ( module X
+  ( rawHtml
   , el'
   , el
   , el_
+  , elNS'
   , Prop(..)
 
   , text
@@ -53,23 +54,20 @@ import Data.Array as Array
 import Data.Maybe (Maybe(..))
 import Data.Tuple (Tuple(..))
 import Effect (foreachE, Effect)
+import Effect.Ref (new, read, write)
 import Effect.Uncurried (EffectFn1, EffectFn2, EffectFn3, EffectFn4, mkEffectFn1, mkEffectFn2, mkEffectFn3, mkEffectFn4, runEffectFn1, runEffectFn2, runEffectFn3, runEffectFn4)
 import Foreign.Object as Object
-import Specular.Dom.Browser (EventType, Node, appendChild, createTextNode, setText, (:=))
+import Specular.Dom.Browser (Attrs, EventType, Namespace, Node, TagName, appendChild, appendRawHtml, createElement, createElementNS, createTextNode, getCheckboxChecked, getTextInputValue, removeAttributes, setAttributes, setText, (:=))
 import Specular.Dom.Browser as DOM
-import Specular.Dom.Builder (mkBuilder', runBuilder')
+import Specular.Dom.Builder (Builder, mkBuilder, mkBuilder', runBuilder')
 import Specular.Dom.Builder.Class (BuilderEnv)
-import Specular.Dom.Builder.Class (rawHtml) as X
-import Specular.Dom.Node.Class (Attrs, TagName, createElement, removeAttributes, setAttributes)
 import Specular.Dom.Widget (RWidget)
-import Specular.Dom.Widgets.Input (getCheckboxChecked, getTextInputValue)
 import Specular.FRP (Dynamic, _subscribeEvent, changed, readDynamic, subscribeDyn_)
-import Effect.Ref (new, read, write)
 import Specular.Internal.Effect (DelayedEffects, pushDelayed)
-import Specular.Ref (Ref(..))
-import Unsafe.Coerce (unsafeCoerce)
 import Specular.Internal.Profiling as ProfilingInternal
 import Specular.Profiling as Profiling
+import Specular.Ref (Ref(..))
+import Unsafe.Coerce (unsafeCoerce)
 
 newtype Prop = Prop (EffectFn2 Node DelayedEffects Unit)
 
@@ -81,6 +79,12 @@ instance semigroupProp :: Semigroup Prop where
 instance monoidProp :: Monoid Prop where
   mempty = Prop $ mkEffectFn2 \_ _ -> pure unit
 
+elNS' :: forall r a. Maybe Namespace -> TagName -> Array Prop -> RWidget r a -> RWidget r (Tuple Node a)
+elNS' ns tagName props body = mkBuilder' $ mkEffectFn1 \env -> do
+  node <- createElementNS ns tagName
+  result <- runEffectFn4 initElement env node props body
+  pure (Tuple node result)
+
 el' :: forall r a. TagName -> Array Prop -> RWidget r a -> RWidget r (Tuple Node a)
 el' tagName props body = mkBuilder' $ mkEffectFn1 \env -> do
   node <- createElement tagName
@@ -341,3 +345,8 @@ classWhen enabled cls = if enabled then class_ cls else mempty
 
 classUnless :: Boolean -> ClassName -> Prop
 classUnless enabled cls = if enabled then mempty else class_ cls
+
+-- | Insert a chunk of HTML.
+rawHtml :: forall env. String -> Builder env Unit
+rawHtml html = mkBuilder \env ->
+  appendRawHtml html env.parent
diff --git a/src/Specular/Dom/Element/Class.purs b/src/Specular/Dom/Element/Class.purs
index fe74652..74027c1 100644
--- a/src/Specular/Dom/Element/Class.purs
+++ b/src/Specular/Dom/Element/Class.purs
@@ -5,10 +5,9 @@ import Prelude
 import Data.Tuple (Tuple(..), snd)
 import Effect (foreachE)
 import Effect.Uncurried (mkEffectFn2, runEffectFn2)
-import Specular.Dom.Browser (Node, appendChild)
+import Specular.Dom.Browser (Node, TagName, appendChild, createElement)
 import Specular.Dom.Builder.Class (liftBuilderWithRun)
 import Specular.Dom.Element (Prop(..))
-import Specular.Dom.Node.Class (TagName, createElement)
 import Specular.Dom.Widget (class MonadWidget)
 
 el' :: forall m a. MonadWidget m => TagName -> Array Prop -> m a -> m (Tuple Node a)
diff --git a/src/Specular/Dom/Node/Class.purs b/src/Specular/Dom/Node/Class.purs
deleted file mode 100644
index f4b222a..0000000
--- a/src/Specular/Dom/Node/Class.purs
+++ /dev/null
@@ -1,4 +0,0 @@
--- | Module preserved only for backwards compatibility. Use Specular.Dom.Browser instead.
-module Specular.Dom.Node.Class (module X) where
-
-import Specular.Dom.Browser (Attrs, Event, EventType, Namespace, Node, TagName, addEventListener, addEventListenerImpl, appendChild, appendChildImpl, appendRawHtml, appendRawHtmlImpl, createDocumentFragment, createDocumentFragmentImpl, createElement, createElementImpl, createElementNS, createElementNSImpl, createTextNode, createTextNodeImpl, innerHTML, insertBefore, insertBeforeImpl, moveAllBetweenInclusive, moveAllBetweenInclusiveImpl, parentNode, parentNodeImpl, preventDefault, removeAllBetween, removeAllBetweenImpl, removeAttributes, removeAttributesImpl, setAttributes, setText, setTextImpl, (:=)) as X
diff --git a/src/Specular/Dom/Widgets/Button.purs b/src/Specular/Dom/Widgets/Button.purs
deleted file mode 100644
index cf6d305..0000000
--- a/src/Specular/Dom/Widgets/Button.purs
+++ /dev/null
@@ -1,20 +0,0 @@
-module Specular.Dom.Widgets.Button
-  ( buttonOnClick
-  ) where
-
-import Prelude
-
-import Data.Tuple (Tuple(..))
-import Specular.Dom.Builder.Class (domEventWithSample, elDynAttr')
-import Specular.Dom.Node.Class (Attrs)
-import Specular.Dom.Widget (class MonadWidget)
-import Specular.FRP (Event, WeakDynamic)
-
--- | `buttonOnClick attrs body` - Creates a HTML `<button>` element with the
--- | specified dynamic attributes and body.
--- |
--- | Returns an Event that occurs when the button is clicked.
-buttonOnClick :: forall m. MonadWidget m => WeakDynamic Attrs -> m Unit -> m (Event Unit)
-buttonOnClick attrs inner = do
-  Tuple node _ <- elDynAttr' "button" attrs inner
-  domEventWithSample (\_ -> pure unit) "click" node
diff --git a/src/Specular/Dom/Widgets/Input.js b/src/Specular/Dom/Widgets/Input.js
deleted file mode 100644
index 9f3ce23..0000000
--- a/src/Specular/Dom/Widgets/Input.js
+++ /dev/null
@@ -1,31 +0,0 @@
-// getTextInputValue :: Node -> IOSync String
-export function getTextInputValue(node) {
-  return function () {
-    return node.value;
-  };
-}
-
-// setTextInputValue :: Node -> String -> IOSync String
-export function setTextInputValue(node) {
-  return function (value) {
-    return function () {
-      node.value = value;
-    };
-  };
-}
-
-// getCheckboxChecked :: Node -> IOSync Boolean
-export function getCheckboxChecked(node) {
-  return function () {
-    return node.checked;
-  };
-}
-
-// setCheckboxChecked :: Node -> Boolean -> IOSync Unit
-export function setCheckboxChecked(node) {
-  return function (value) {
-    return function () {
-      return (node.checked = value);
-    };
-  };
-}
diff --git a/src/Specular/Dom/Widgets/Input.purs b/src/Specular/Dom/Widgets/Input.purs
deleted file mode 100644
index 44d7760..0000000
--- a/src/Specular/Dom/Widgets/Input.purs
+++ /dev/null
@@ -1,151 +0,0 @@
-module Specular.Dom.Widgets.Input
-  ( textInputOnChange
-  , textInputOnInput
-  , textareaOnChange
-
-  , TextInput
-  , TextInputConfig
-  , textInput
-  , textInputValue
-  , textInputValueOnChange
-  , textInputValueEventOnEnter
-
-  , checkbox
-  , checkboxView
-  , BooleanInputType(..)
-  , booleanInputView
-
-  -- TODO: move to Internal
-  , getTextInputValue
-  , setTextInputValue
-  , getCheckboxChecked
-  , setCheckboxChecked
-  ) where
-
-import Prelude
-
-import Effect (Effect)
-import Effect.Class (liftEffect)
-import Data.Tuple (Tuple(..))
-import Specular.Dom.Browser (Node)
-import Specular.Dom.Browser as Browser
-import Specular.Dom.Builder.Class (domEventWithSample, elDynAttr', text)
-import Specular.Dom.Node.Class (Attrs, (:=))
-import Specular.Dom.Widget (class MonadWidget)
-import Specular.FRP (class MonadFRP, Dynamic, Event, WeakDynamic, filterEvent, holdDyn, leftmost, never, subscribeWeakDyn_)
-import Specular.FRP.Base (subscribeEvent_, tagDyn)
-import Unsafe.Coerce (unsafeCoerce)
-
-textInputOnChange :: forall m. MonadWidget m => String -> Attrs -> m (Dynamic String)
-textInputOnChange initial attrs = do
-  input <- textInput { initialValue: initial, attributes: pure attrs, setValue: never }
-  textInputValueOnChange input
-
-textInputOnInput :: forall m. MonadWidget m => String -> Attrs -> m (Dynamic String)
-textInputOnInput initial attrs = do
-  textInputValue <$> textInput { initialValue: initial, attributes: pure attrs, setValue: never }
-
-textareaOnChange :: forall m. MonadWidget m => String -> Attrs -> m (Dynamic String)
-textareaOnChange initial attrs = do
-  Tuple node _ <- elDynAttr' "textarea" (pure attrs) (text initial)
-  changed <- domEventWithSample (\_ -> getTextInputValue node) "change" node
-  holdDyn initial changed
-
-checkbox
-  :: forall m
-   . MonadWidget m
-  => Boolean -- ^ initial value
-  -> Attrs
-  -> m (Dynamic Boolean)
-checkbox initial attrs = do
-  let attrs' = attrs <> ("type" := "checkbox") <> (if initial then "checked" := "checked" else mempty)
-  Tuple node _ <- elDynAttr' "input" (pure attrs') (pure unit)
-  changed <- domEventWithSample (\_ -> getCheckboxChecked node) "change" node
-  holdDyn initial changed
-
-checkboxView
-  :: forall m
-   . MonadWidget m
-  => WeakDynamic Boolean
-  -> WeakDynamic Attrs
-  -> m (Event Boolean)
-checkboxView = booleanInputView Checkbox
-
-data BooleanInputType = Checkbox | Radio
-
-booleanInputTypeToAttributeValue :: BooleanInputType -> String
-booleanInputTypeToAttributeValue =
-  case _ of
-    Checkbox -> "checkbox"
-    Radio -> "radio"
-
-booleanInputView
-  :: forall m
-   . MonadWidget m
-  => BooleanInputType
-  -> WeakDynamic Boolean
-  -> WeakDynamic Attrs
-  -> m (Event Boolean)
-booleanInputView type_ dchecked dattrs = do
-  let dattrs' = map (\attrs -> attrs <> ("type" := booleanInputTypeToAttributeValue type_)) dattrs
-
-  Tuple node _ <- elDynAttr' "input" dattrs' (pure unit)
-  subscribeWeakDyn_ (setCheckboxChecked node) dchecked
-  domEventWithSample (\_ -> getCheckboxChecked node) "change" node
-
-foreign import getCheckboxChecked :: Node -> Effect Boolean
-foreign import setCheckboxChecked :: Node -> Boolean -> Effect Unit
-
-type TextInputConfig =
-  { initialValue :: String
-  , setValue :: Event String
-  , attributes :: WeakDynamic Attrs
-  }
-
-newtype TextInput = TextInput
-  { element :: Node
-  , value :: Dynamic String
-  , setValue :: Event String
-  }
-
-textInput
-  :: forall m
-   . MonadWidget m
-  => TextInputConfig
-  -> m TextInput
-textInput config = do
-  Tuple element _ <- elDynAttr' "input" config.attributes (pure unit)
-  liftEffect $ setTextInputValue element config.initialValue
-  subscribeEvent_ (setTextInputValue element) config.setValue
-  domChanged <- domEventWithSample (\_ -> getTextInputValue element) "input" element
-  value <- holdDyn config.initialValue (leftmost [ domChanged, config.setValue ])
-  pure $ TextInput { element, value, setValue: config.setValue }
-
-textInputValue :: TextInput -> Dynamic String
-textInputValue (TextInput { value }) = value
-
-textInputValueOnChange
-  :: forall m
-   . MonadFRP m
-  => TextInput
-  -> m (Dynamic String)
-textInputValueOnChange (TextInput { element, setValue }) = do
-  initial <- liftEffect $ getTextInputValue element
-  changed <- domEventWithSample (\_ -> getTextInputValue element) "change" element
-  holdDyn initial (leftmost [ setValue, changed ])
-
-textInputValueEventOnEnter
-  :: forall m
-   . MonadFRP m
-  => TextInput
-  -> m (Event String)
-textInputValueEventOnEnter (TextInput { element, value }) = do
-  keypress <- domEventWithSample unsafeEventKey "keypress" element
-  let enter = void $ filterEvent (_ == "Enter") keypress
-  pure $ tagDyn value enter
-
-unsafeEventKey :: Browser.Event -> Effect String
-unsafeEventKey event = pure (unsafeCoerce event).key
-
-foreign import getTextInputValue :: Node -> Effect String
-foreign import setTextInputValue :: Node -> String -> Effect Unit
diff --git a/src/Specular/Dom/Widgets/RadioGroup.purs b/src/Specular/Dom/Widgets/RadioGroup.purs
deleted file mode 100644
index 6cfbfc5..0000000
--- a/src/Specular/Dom/Widgets/RadioGroup.purs
+++ /dev/null
@@ -1,70 +0,0 @@
-module Specular.Dom.Widgets.RadioGroup
-  ( radioGroup
-  ) where
-
-import Prelude
-
-import Data.Array as Array
-import Data.Maybe (Maybe(..))
-import Data.TraversableWithIndex (forWithIndex)
-import Data.Tuple (Tuple(..), fst, snd)
-import Effect.Class (liftEffect)
-import Effect.Random (random)
-import Partial.Unsafe (unsafePartial)
-import Specular.Dom.Node.Class (Attrs, (:=))
-import Specular.Dom.Widget (class MonadWidget)
-import Specular.Dom.Widgets.Input (BooleanInputType(Radio), booleanInputView)
-import Specular.FRP (Dynamic, Event, WeakDynamic, fixFRP, holdDyn, leftmost)
-import Specular.FRP.Base (filterMapEvent)
-
-type RadioGroupConfig :: forall k. (k -> Type) -> Type -> Type
-type RadioGroupConfig m a =
-  { options :: Array a
-  -- ^ Possible selections
-  , initialValueIndex :: Int
-  -- ^ Index of initial value in `options`.
-  -- Must be in bounds, else `radioGroup` will crash
-  , render :: forall b. String -> a -> (WeakDynamic Attrs -> m b) -> m b
-  -- ^ Render an option. Takes the radio input ID, the value and the radio input.
-  -- Must return the return value of the radio, as evidenced by the type.
-  --
-  -- The radio input ID is intended to be passed to the `for` attribute of
-  -- `<label>`. If you do that, click events on label cause the radio to be selected.
-  }
-
-radioGroup
-  :: forall m a
-   . MonadWidget m
-  => RadioGroupConfig m a
-  -> m (Dynamic a)
-radioGroup config = fixFRP $ \selectedIndex -> do
-  let randomIdentifier = liftEffect $ map (\n -> "radio" <> show n) random
-  name <- randomIdentifier
-  -- ^ FIXME: document this sorcery
-
-  (changeEvents :: Array (Event (Tuple Int a))) <-
-    forWithIndex config.options $ \index option -> do
-      id <- randomIdentifier
-      let
-        isSelected = map (_ == index) selectedIndex
-        radio extraAttrs =
-          let
-            attrs = map (\x -> "name" := name <> "id" := id <> x) extraAttrs
-          in
-            map
-              ( filterMapEvent
-                  ( \b ->
-                      if b then Just (Tuple index option)
-                      else Nothing
-                  )
-              ) $
-              booleanInputView Radio isSelected attrs
-      config.render id option radio
-
-  let
-    initialValue = unsafePartial (Array.unsafeIndex config.options config.initialValueIndex)
-    valueChanged = leftmost changeEvents
-
-  (value :: Dynamic (Tuple Int a)) <-
-    holdDyn (Tuple config.initialValueIndex initialValue) valueChanged
-  pure $ Tuple (map fst value) (map snd value)
diff --git a/src/Specular/Dom/Widgets/Select.purs b/src/Specular/Dom/Widgets/Select.purs
deleted file mode 100644
index 2a88a2a..0000000
--- a/src/Specular/Dom/Widgets/Select.purs
+++ /dev/null
@@ -1,76 +0,0 @@
-module Specular.Dom.Widgets.Select
-  ( SelectConfig
-  , selectInput
-
-  , SelectViewConfig
-  , selectView
-  ) where
-
-import Prelude
-
-import Effect.Class (liftEffect)
-import Data.Array as Array
-import Data.Foldable (for_)
-import Data.FoldableWithIndex (traverseWithIndex_)
-import Data.Int as Int
-import Data.Tuple (Tuple(..))
-import Partial.Unsafe (unsafePartial)
-import Specular.Dom.Builder.Class (domEventWithSample, elAttr, elDynAttr', text)
-import Specular.Dom.Node.Class (Attrs, (:=))
-import Specular.Dom.Widget (class MonadWidget)
-import Specular.Dom.Widgets.Input (getTextInputValue, setTextInputValue)
-import Specular.FRP (Dynamic, Event, WeakDynamic, holdDyn)
-import Specular.FRP.Base (filterMapEvent)
-import Specular.FRP.WeakDynamic (subscribeWeakDyn_)
-
-type SelectConfig a =
-  { options :: Array a -- ^ Possible selections
-  , initialValueIndex :: Int -- ^ Index of initial value in `options`.
-  -- Must be in bounds, else this function will crash
-  , display :: a -> String -- ^ Human readable text to display for each option
-  , attributes :: WeakDynamic Attrs -- ^ Additional attributes for `<select>`
-  }
-
--- | A <select> element with static list of options.
--- | The returned Dynamic represents the currently selected value.
-selectInput
-  :: forall m a
-   . MonadWidget m
-  => SelectConfig a
-  -> m (Dynamic a)
-selectInput config = do
-  let toOption index value = elAttr "option" ("value" := show index) $ text $ config.display value
-  Tuple element _ <- elDynAttr' "select" config.attributes $ traverseWithIndex_ toOption config.options
-  liftEffect $ setTextInputValue element $ show config.initialValueIndex
-  domChanged <- domEventWithSample (\_ -> getTextInputValue element) "change" element
-  let
-    valueChanged = filterMapEvent (Int.fromString >=> Array.index config.options) domChanged
-
-    initialValue = unsafePartial (Array.unsafeIndex config.options config.initialValueIndex)
-
-  holdDyn initialValue valueChanged
-
-type SelectViewConfig a =
-  { options :: Array a
-  , display :: a -> String
-  , attributes :: WeakDynamic Attrs
-  }
-
--- | A <select> element with static list of options.
-selectView
-  :: forall m a
-   . MonadWidget m
-  => Eq a
-  => SelectViewConfig a
-  -> WeakDynamic a -- ^ selected option
-  -> m (Event a) -- ^ event: user changed selection
-selectView config valueD = do
-  let toOption index value = elAttr "option" ("value" := show index) $ text $ config.display value
-  Tuple element _ <- elDynAttr' "select" config.attributes $ traverseWithIndex_ toOption config.options
-
-  flip subscribeWeakDyn_ valueD $ \value ->
-    for_ (Array.findIndex (eq value) config.options) $ \index ->
-      liftEffect $ setTextInputValue element $ show index
-
-  domChanged <- domEventWithSample (\_ -> getTextInputValue element) "change" element
-  pure $ filterMapEvent (Int.fromString >=> Array.index config.options) domChanged
diff --git a/src/Specular/FRP.purs b/src/Specular/FRP.purs
index 025456a..43a804b 100644
--- a/src/Specular/FRP.purs
+++ b/src/Specular/FRP.purs
@@ -1,11 +1,7 @@
 module Specular.FRP
   ( module X.Base
-  , module X.WeakDynamic
-  , module X.Fix
   , module X.Replaceable
   ) where
 
 import Specular.FRP.Base (class MonadFRP, Behavior, Dynamic, Event, _subscribeEvent, annotate, annotated, attachDynWith, changed, changed_, current, filterEvent, filterJustEvent, filterMapEvent, foldDyn, foldDynMaybe, holdDyn, holdUniqDynBy, latestJust, leftmost, map2, never, newBehavior, newDynamic, newEvent, pull, readBehavior, readDynamic, sampleAt, subscribeDyn, subscribeDyn_, subscribeEvent_, switch, tagDyn, traceDynIO, traceEventIO, uniqDyn, uniqDynBy) as X.Base
-import Specular.FRP.WeakDynamic (WeakDynamic, attachWeakDynWith, changedW, holdWeakDyn, subscribeWeakDyn, subscribeWeakDyn_, switchWeakDyn, tagWeakDyn, unWeakDynamic, uniqWeakDynBy, weaken) as X.WeakDynamic
-import Specular.FRP.Fix (class FixFRP, class FixFRPRecord, fixDyn, fixEvent, fixFRP, fixFRP_, fixRecord) as X.Fix
-import Specular.FRP.Replaceable (dynamic, dynamic_, unlessD, weakDynamic, weakDynamic_, whenD, whenJustD, withDynamic_) as X.Replaceable
+import Specular.FRP.Replaceable (dynamic, dynamic_, unlessD, whenD, whenJustD, withDynamic_) as X.Replaceable
diff --git a/src/Specular/FRP/Base.purs b/src/Specular/FRP/Base.purs
index 71c29d5..313f3cc 100644
--- a/src/Specular/FRP/Base.purs
+++ b/src/Specular/FRP/Base.purs
@@ -126,7 +126,7 @@ newtype Event a = Event (Node a)
 
 -- append biased towards first argument - if appended events occur simultaneously then the first one is returned
 instance Semigroup (Event a) where
-  append e1 e2 = leftmost [e1, e2]
+  append e1 e2 = leftmost [ e1, e2 ]
 
 instance Monoid (Event a) where
   mempty = never
diff --git a/src/Specular/FRP/Fix.purs b/src/Specular/FRP/Fix.purs
deleted file mode 100644
index 3ffe118..0000000
--- a/src/Specular/FRP/Fix.purs
+++ /dev/null
@@ -1,90 +0,0 @@
-module Specular.FRP.Fix
-  ( fixDyn
-  , fixEvent
-  , class FixFRP
-  , fixFRP
-  , fixFRP_
-  , class FixFRPRecord
-  , fixRecord
-  ) where
-
-import Prelude
-
-import Data.Symbol (class IsSymbol)
-import Type.Proxy (Proxy(..))
-import Data.Tuple (Tuple(Tuple), snd)
-import Prim.Row as Row
-import Prim.RowList (RowList)
-import Record (delete, get, insert)
-import Specular.FRP.Base (class MonadFRP, Dynamic, Event, newEvent, subscribeDyn_, subscribeEvent_)
-import Specular.FRP.WeakDynamic (WeakDynamic, holdWeakDyn)
-import Type.Equality (class TypeEquals, to)
-import Type.RowList (class RowToList, Cons, Nil)
-
-fixEvent
-  :: forall m a b
-   . MonadFRP m
-  => (Event a -> m (Tuple (Event a) b))
-  -> m b
-fixEvent f = do
-  { event, fire } <- newEvent
-  Tuple event' result <- f event
-  subscribeEvent_ fire event'
-  pure result
-
-fixDyn
-  :: forall m a b
-   . MonadFRP m
-  => (WeakDynamic a -> m (Tuple (Dynamic a) b))
-  -> m b
-fixDyn f = do
-  { event, fire } <- newEvent
-  wdyn <- holdWeakDyn event
-  Tuple dyn result <- f wdyn
-  subscribeDyn_ fire dyn
-  pure result
-
-fixFRP_ :: forall input output m. FixFRP input output => MonadFRP m => (input -> m output) -> m Unit
-fixFRP_ f = fixFRP (\input -> (\x -> Tuple x unit) <$> f input)
-
-class FixFRP input output | output -> input, input -> output where
-  fixFRP :: forall m b. MonadFRP m => (input -> m (Tuple output b)) -> m b
-
-instance fixFRPEvent :: FixFRP (Event a) (Event a) where
-  fixFRP = fixEvent
-
-instance fixFRPDynamic :: FixFRP (WeakDynamic a) (Dynamic a) where
-  fixFRP = fixDyn
-
-instance fixFRPRecord :: (FixFRPRecord ro_list ri ro, RowToList ro ro_list) => FixFRP (Record ri) (Record ro) where
-  fixFRP = fixRecord (Proxy :: Proxy ro_list)
-
-class FixFRPRecord (ro_list :: RowList Type) (ri :: Row Type) (ro :: Row Type) | ro_list -> ri ro where
-  fixRecord
-    :: forall m b
-     . MonadFRP m
-    => Proxy ro_list
-    -> (Record ri -> m (Tuple (Record ro) b))
-    -> m b
-
-instance fixFRPRecordNil :: TypeEquals {} (Record empty) => FixFRPRecord Nil empty empty where
-  fixRecord _ f = snd <$> f (to {})
-
-instance fixFRPRecordCons ::
-  ( IsSymbol label
-  , Row.Lacks label tail_ri
-  , Row.Cons label input tail_ri ri
-  , Row.Lacks label tail_ro
-  , Row.Cons label output tail_ro ro
-  , FixFRP input output
-  , FixFRPRecord tail_ro_list tail_ri tail_ro
-  ) =>
-  FixFRPRecord (Cons label output tail_ro_list) ri ro where
-  fixRecord _ f =
-    fixFRP $ \(input :: input) ->
-      fixRecord (Proxy :: Proxy tail_ro_list) $ \(tail_ri :: Record tail_ri) -> do
-        let ri = insert (Proxy :: Proxy label) input tail_ri :: Record ri
-        Tuple (ro :: Record ro) result <- f ri
-        let output = get (Proxy :: Proxy label) ro :: output
-        let tail_ro = delete (Proxy :: Proxy label) ro :: Record tail_ro
-        pure (Tuple tail_ro (Tuple output result))
diff --git a/src/Specular/FRP/List.purs b/src/Specular/FRP/List.purs
index 4fff736..760deac 100644
--- a/src/Specular/FRP/List.purs
+++ b/src/Specular/FRP/List.purs
@@ -3,10 +3,6 @@ module Specular.FRP.List
   , dynamicList
   , dynamicListWithIndex_
   , dynamicList_
-  , weakDynamicListWithIndex
-  , weakDynamicList
-  , weakDynamicListWithIndex_
-  , weakDynamicList_
   ) where
 
 import Prelude
@@ -19,7 +15,6 @@ import Data.Maybe (Maybe(..))
 import Data.Traversable (traverse)
 import Specular.FRP (Dynamic, holdDyn, subscribeDyn_)
 import Specular.FRP.Base (class MonadFRP, holdUniqDynBy, newEvent)
-import Specular.FRP.WeakDynamic (WeakDynamic, holdWeakDyn, subscribeWeakDyn_, weaken)
 import Effect.Ref (Ref, new, read, write)
 import Unsafe.Reference (unsafeRefEq)
 
@@ -51,25 +46,6 @@ dynamicListWithIndex dynArray handler = do
   subscribeDyn_ (updateList latestRef mainSlot handler >=> resultChanged.fire) dynArray
   pure result
 
--- | Like `listWithIndex`, but operates on `WeakDynamics`.
-weakDynamicListWithIndex
-  :: forall m a b
-   . MonadFRP m
-  => MonadReplace m
-  => WeakDynamic (Array a)
-  -> (Int -> WeakDynamic a -> m b)
-  -> m (WeakDynamic (Array b))
-weakDynamicListWithIndex dynArray handler = do
-  (latestRef :: Ref (Array (ListEntry m a b))) <- liftEffect $ new []
-
-  mainSlot <- newSlot
-  resultChanged <- newEvent
-
-  let handler' i dyn = handler i (weaken dyn)
-  subscribeWeakDyn_ (updateList latestRef mainSlot handler' >=> resultChanged.fire) dynArray
-
-  holdWeakDyn resultChanged.event
-
 type ListEntry m a b =
   { slot :: Slot m
   , fire :: a -> Effect Unit
@@ -118,33 +94,6 @@ dynamicList
   -> m (Dynamic (Array b))
 dynamicList dynArray handler = dynamicListWithIndex dynArray (\_ -> handler)
 
-weakDynamicList
-  :: forall m a b
-   . MonadFRP m
-  => MonadReplace m
-  => WeakDynamic (Array a)
-  -> (WeakDynamic a -> m b)
-  -> m (WeakDynamic (Array b))
-weakDynamicList dynArray handler = weakDynamicListWithIndex dynArray (\_ -> handler)
-
-weakDynamicListWithIndex_
-  :: forall m a
-   . MonadFRP m
-  => MonadReplace m
-  => WeakDynamic (Array a)
-  -> (Int -> WeakDynamic a -> m Unit)
-  -> m Unit
-weakDynamicListWithIndex_ dynArray handler = void $ weakDynamicListWithIndex dynArray handler
-
-weakDynamicList_
-  :: forall m a
-   . MonadFRP m
-  => MonadReplace m
-  => WeakDynamic (Array a)
-  -> (WeakDynamic a -> m Unit)
-  -> m Unit
-weakDynamicList_ dynArray handler = void $ weakDynamicListWithIndex dynArray (\_ -> handler)
-
 dynamicListWithIndex_
   :: forall m a
    . MonadFRP m
diff --git a/src/Specular/FRP/Replaceable.purs b/src/Specular/FRP/Replaceable.purs
index 81262d9..328893f 100644
--- a/src/Specular/FRP/Replaceable.purs
+++ b/src/Specular/FRP/Replaceable.purs
@@ -5,7 +5,6 @@ import Prelude
 import Control.Monad.Replace (class MonadReplace, newSlot, replaceSlot)
 import Data.Maybe (Maybe(..), isJust)
 import Specular.FRP.Base (class MonadFRP, Dynamic, changed, filterJustEvent, newDynamic, readDynamic, subscribeDyn, subscribeDyn_, subscribeEvent_, uniqDyn)
-import Specular.FRP.WeakDynamic (WeakDynamic, subscribeWeakDyn, subscribeWeakDyn_)
 
 dynamic_ :: forall m. MonadReplace m => MonadFRP m => Dynamic (m Unit) -> m Unit
 dynamic_ dyn = do
@@ -22,16 +21,6 @@ dynamic dyn = do
   slot <- newSlot
   subscribeDyn (replaceSlot slot) dyn
 
-weakDynamic_ :: forall m. MonadReplace m => MonadFRP m => WeakDynamic (m Unit) -> m Unit
-weakDynamic_ dyn = do
-  slot <- newSlot
-  subscribeWeakDyn_ (replaceSlot slot) dyn
-
-weakDynamic :: forall m a. MonadReplace m => MonadFRP m => WeakDynamic (m a) -> m (WeakDynamic a)
-weakDynamic dyn = do
-  slot <- newSlot
-  subscribeWeakDyn (replaceSlot slot) dyn
-
 whenJustD :: forall m a. MonadReplace m => MonadFRP m => Dynamic (Maybe a) -> (Dynamic a -> m Unit) -> m Unit
 whenJustD dyn widget = do
   whenD (isJust <$> dyn) do
diff --git a/src/Specular/FRP/WeakDynamic.purs b/src/Specular/FRP/WeakDynamic.purs
deleted file mode 100644
index 33577e5..0000000
--- a/src/Specular/FRP/WeakDynamic.purs
+++ /dev/null
@@ -1,109 +0,0 @@
-module Specular.FRP.WeakDynamic
-  ( WeakDynamic
-  , unWeakDynamic
-  , changedW
-  , weaken
-  , holdWeakDyn
-  , switchWeakDyn
-  , subscribeWeakDyn
-  , subscribeWeakDyn_
-  , attachWeakDynWith
-  , tagWeakDyn
-  , uniqWeakDynBy
-  ) where
-
-import Prelude
-
-import Control.Monad.Maybe.Trans (MaybeT(..))
-import Data.Foldable (traverse_)
-import Data.Maybe (Maybe(..), fromMaybe)
-import Effect (Effect)
-import Specular.FRP.Base (class MonadFRP, Dynamic, Event, attachDynWith, changed, filterMapEvent, holdDyn, never, newEvent, subscribeDyn_, switch, uniqDynBy)
-
--- | A primitive similar to Dynamic. The difference is: while Dynamic always
--- | has a value, WeakDynamic has a value always after some point, but for
--- | some time after construction it may be without value.
--- |
--- | A Dynamic can be always converted to a WeakDynamic using `weaken`.
---
--- Invariant: Once the Dynamic changed to Just, it will never again turn to Nothing.
-newtype WeakDynamic a = WeakDynamic (MaybeT Dynamic a)
-
-unWeakDynamic :: forall a. WeakDynamic a -> Dynamic (Maybe a)
-unWeakDynamic (WeakDynamic (MaybeT mdyn)) = mdyn
-
-mkWeakDynamic :: forall a. Dynamic (Maybe a) -> WeakDynamic a
-mkWeakDynamic = WeakDynamic <<< MaybeT
-
-derive newtype instance functorWeakDynamic :: Functor WeakDynamic
-derive newtype instance applyWeakDynamic :: Apply WeakDynamic
-derive newtype instance applicativeWeakDynamic :: Applicative WeakDynamic
-derive newtype instance bindWeakDynamic :: Bind WeakDynamic
-derive newtype instance monadWeakDynamic :: Monad WeakDynamic
-
--- | Convert a Dynamic to a WeakDynamic. It will have the same value as the
--- | original Dynamic, and will change whenever the original Dynamic changes.
-weaken :: forall a. Dynamic a -> WeakDynamic a
-weaken = WeakDynamic <<< MaybeT <<< map Just
-
--- | An Event that fires every time a WeakDynamic changes, with the new value.
-changedW :: forall a. WeakDynamic a -> Event a
-changedW = filterMapEvent identity <<< changed <<< unWeakDynamic
-
--- | Make a WeakDynamic that will have no value, but will acquire one when the Event fires.
--- | It will also change every time the Event fires.
-holdWeakDyn :: forall m a. MonadFRP m => Event a -> m (WeakDynamic a)
-holdWeakDyn change = WeakDynamic <<< MaybeT <$> holdDyn Nothing (Just <$> change)
-
--- | Make an Event that occurs when the given WeakDynamic has a value, and the
--- | value (an Event) occurs.
-switchWeakDyn :: forall a. WeakDynamic (Event a) -> Event a
-switchWeakDyn (WeakDynamic (MaybeT mdyn)) = switch $ map (fromMaybe never) mdyn
-
--- | Invoke the handler immediately if the WeakDynamic has a value currently,
--- | and invoke it every time it changes, until cleanup.
-subscribeWeakDyn_
-  :: forall m a
-   . MonadFRP m
-  => (a -> Effect Unit)
-  -> WeakDynamic a
-  -> m Unit
-subscribeWeakDyn_ handler (WeakDynamic (MaybeT mdyn)) =
-  subscribeDyn_ (traverse_ handler) mdyn
-
--- | Invoke the handler immediately if the WeakDynamic has a value currently,
--- | and invoke it every time it changes, until cleanup.
-subscribeWeakDyn
-  :: forall m a b
-   . MonadFRP m
-  => (a -> Effect b)
-  -> WeakDynamic a
-  -> m (WeakDynamic b)
-subscribeWeakDyn handler wdyn = do
-  { event, fire } <- newEvent
-  result <- holdWeakDyn event
-  subscribeWeakDyn_ (handler >=> fire) wdyn
-  pure result
-
-attachWeakDynWith :: forall a b c. (a -> b -> c) -> WeakDynamic a -> Event b -> Event c
-attachWeakDynWith f wdyn event =
-  filterMapEvent identity $ attachDynWith (\a b -> f <$> a <*> pure b) (unWeakDynamic wdyn) event
-
-tagWeakDyn :: forall a. WeakDynamic a -> Event Unit -> Event a
-tagWeakDyn wdyn event =
-  filterMapEvent identity $ attachDynWith (\a _b -> a) (unWeakDynamic wdyn) event
-
--- | Make a WeakDynamic that only changes value when the input WeakDynamic changes
--- | value, and the new value is not equal to the previous value with respect to
--- | the given equality test.
-uniqWeakDynBy :: forall m a. MonadFRP m => (a -> a -> Boolean) -> WeakDynamic a -> m (WeakDynamic a)
-uniqWeakDynBy eq wdyn = mkWeakDynamic <$> uniqDynBy (liftEqMaybe eq) (unWeakDynamic wdyn)
-
--- | Lift an equivalence relation on `a` to an equivalence relation on `Maybe a`.
-liftEqMaybe :: forall a. (a -> a -> Boolean) -> Maybe a -> Maybe a -> Boolean
-liftEqMaybe eq =
-  case _, _ of
-    Just x, Just y -> eq x y
-    Nothing, Nothing -> true
-    _, _ -> false
-
diff --git a/src/Specular/Ref.purs b/src/Specular/Ref.purs
index 9f37d1a..f419f02 100644
--- a/src/Specular/Ref.purs
+++ b/src/Specular/Ref.purs
@@ -10,7 +10,6 @@ module Specular.Ref
   , focusRef
   , pureFocusRef
   , previewRef
-  , wrapViewWidget
   , Lens
   , Prism
   --
@@ -42,8 +41,7 @@ import Data.Maybe (Maybe(..))
 import Effect (Effect)
 import Effect.Class (class MonadEffect, liftEffect)
 import Prelude as Prelude
-import Specular.Dom.Widget (class MonadWidget)
-import Specular.FRP (class MonadFRP, Dynamic, Event, WeakDynamic, newDynamic, readDynamic, subscribeEvent_, weaken)
+import Specular.FRP (class MonadFRP, Dynamic, Event, newDynamic, readDynamic, subscribeEvent_)
 
 data Ref a = Ref (Dynamic a) ((a -> a) -> Effect Unit)
 
@@ -115,16 +113,6 @@ previewRef prism (Ref value_ update) =
       ) >>> update
     )
 
-wrapViewWidget
-  :: forall m a
-   . MonadWidget m
-  => (WeakDynamic a -> m (Event a))
-  -> Ref a
-  -> m Unit
-wrapViewWidget widget r@(Ref value_ _update) = do
-  updateE <- widget (weaken value_)
-  subscribeEvent_ (set r) updateE
-
 -- | Old name for `new`.
 newRef :: forall m a. MonadEffect m => a -> m (Ref a)
 newRef = new
diff --git a/test/Test/Utils/Dom.purs b/test/Test/Utils/Dom.purs
index a7cb487..7686c6c 100644
--- a/test/Test/Utils/Dom.purs
+++ b/test/Test/Utils/Dom.purs
@@ -6,8 +6,7 @@ import Data.Tuple (Tuple(..))
 import Effect (Effect)
 import Effect.Aff (Aff)
 import Foreign (Foreign, unsafeToForeign)
-import Specular.Dom.Browser (Node)
-import Specular.Dom.Node.Class (EventType, createElement)
+import Specular.Dom.Browser (EventType, Node, createElement)
 import Specular.Dom.Widget (Widget, runWidgetInNode)
 import Test.Utils (liftEffect)
 
diff --git a/test/browser/BrowserMain.purs b/test/browser/BrowserMain.purs
index 75d12d7..117dcf5 100644
--- a/test/browser/BrowserMain.purs
+++ b/test/browser/BrowserMain.purs
@@ -5,13 +5,9 @@ import Prelude
 import BuilderSpec as BuilderSpec
 import Effect (Effect)
 import Examples.AsyncRequest as AsyncRequest
-import Examples.Counter as Counter
 import Examples.CounterRef as CounterRef
 import Examples.RegistrationForm as RegistrationForm
-import InputWidgetsSpec as InputWidgetsSpec
 import ListSpec as ListSpec
-import NewBuilderSpec as NewBuilderSpec
-import RadioGroupSpec as RadioGroupSpec
 import Test.Spec (describe, mapSpecTree)
 import Data.Newtype (unwrap)
 import Test.Spec.Mocha (runMocha)
@@ -19,13 +15,9 @@ import Test.Spec.Mocha (runMocha)
 main :: Effect Unit
 main = runMocha $ mapSpecTree (pure <<< unwrap) identity do
   BuilderSpec.spec
-  NewBuilderSpec.spec
-  InputWidgetsSpec.spec
   ListSpec.spec
-  RadioGroupSpec.spec
 
   describe "example apps" do
-    Counter.spec
     CounterRef.spec
     RegistrationForm.spec
     AsyncRequest.spec
diff --git a/test/browser/BuilderSpec.purs b/test/browser/BuilderSpec.purs
index de968e6..4c2ea87 100644
--- a/test/browser/BuilderSpec.purs
+++ b/test/browser/BuilderSpec.purs
@@ -2,52 +2,46 @@ module BuilderSpec where
 
 import Prelude hiding (append)
 
-import Control.Monad.Cleanup (execCleanupT)
+import Specular.Dom.Element (attrs, attrsD, dynText, el, el', elNS', el_, rawHtml, text)
 import Data.Maybe (Maybe(..))
 import Data.Tuple (Tuple(..))
 import Effect (Effect)
-import Specular.Dom.Browser (innerHTML)
-import Specular.Dom.Builder.Class (domEventWithSample, el, elAttr, elDynAttr, elDynAttr', elDynAttrNS', rawHtml, text)
-import Specular.Dom.Element (dynText)
-import Specular.Dom.Node.Class ((:=))
-import Specular.Dom.Widgets.Button (buttonOnClick)
-import Specular.FRP (Dynamic, Event, WeakDynamic, dynamic_, never, subscribeEvent_, switch, weaken, whenJustD, whenD, unlessD)
-import Specular.FRP as FRP
-import Specular.FRP.Replaceable (dynamic, weakDynamic)
-import Specular.FRP.WeakDynamic (switchWeakDyn)
 import Effect.Ref (modify_, new)
+import Specular.Dom.Browser (innerHTML, (:=))
+import Specular.Dom.Builder.Class (onDomEvent)
+import Specular.Dom.Widget (emptyWidget)
+import Specular.FRP (Dynamic, dynamic_, unlessD, whenD, whenJustD)
+import Specular.FRP as FRP
 import Test.Spec (Spec, describe, it)
 import Test.Spec.Assertions (shouldEqual)
 import Test.Utils (append, liftEffect, shouldHaveValue, shouldReturn, withLeakCheck)
-import Test.Utils.Dom (T3(..), dispatchTrivialEvent, querySelector, runBuilderInDiv')
+import Test.Utils.Dom (T3(..), dispatchTrivialEvent, runBuilderInDiv, runBuilderInDiv')
 import Unsafe.Coerce (unsafeCoerce)
 
 spec :: Spec Unit
 spec = describe "Builder" do
   it "builds static DOM" $ withLeakCheck do
-    T3 node _result unsub <- runBuilderInDiv' do
-      elAttr "div" ("class" := "content") do
+    Tuple node _result <- runBuilderInDiv do
+      el "div" [ attrs ("class" := "content") ] do
         text "foo"
-        elDynAttr "span" (pure mempty) $ text "bar"
+        el "span" [] $ text "bar"
         rawHtml """<p class="foo">Raw</p>"""
         text "baz"
-      elAttr "span" mempty $ pure unit
+      el_ "hr" emptyWidget
+      el_ "span" (text "foo")
 
     liftEffect (innerHTML node) `shouldReturn`
-      """<div class="content">foo<span>bar</span><p class="foo">Raw</p>baz</div><span></span>"""
-
-    -- clean up
-    liftEffect unsub
+      """<div class="content">foo<span>bar</span><p class="foo">Raw</p>baz</div><hr><span>foo</span>"""
 
   it "updates attributes" $ withLeakCheck do
-    Tuple dyn updateDyn <- liftEffect $ newDynamic $ "k1" := "v1" <> "k2" := "v2"
+    Tuple dynamic set <- liftEffect $ newDynamic $ "k1" := "v1" <> "k2" := "v2"
     T3 node _result unsub <- runBuilderInDiv' do
-      elDynAttr "div" (weaken dyn) $ pure unit
+      el "div" [ attrsD dynamic ] emptyWidget
 
     liftEffect (innerHTML node) `shouldReturn`
       """<div k2="v2" k1="v1"></div>"""
 
-    liftEffect $ updateDyn $ "k1" := "v1.1" <> "k3" := "v3"
+    liftEffect $ set $ "k1" := "v1.1" <> "k3" := "v3"
 
     liftEffect (innerHTML node) `shouldReturn`
       """<div k1="v1.1" k3="v3"></div>"""
@@ -74,9 +68,9 @@ spec = describe "Builder" do
     it "surrounded by other elements" $ withLeakCheck do
       Tuple dyn updateDyn <- liftEffect $ newDynamic $ text "foo"
       T3 node _result unsub <- runBuilderInDiv' do
-        elDynAttr "span" (pure mempty) $ pure unit
+        el_ "span" $ pure unit
         dynamic_ dyn
-        elDynAttr "span" (pure mempty) $ pure unit
+        el_ "span" $ pure unit
 
       liftEffect (innerHTML node) `shouldReturn`
         """<span></span>foo<span></span>"""
@@ -149,9 +143,9 @@ spec = describe "Builder" do
     it "with rawHtml" $ withLeakCheck do
       Tuple dyn updateDyn <- liftEffect $ newDynamic $ rawHtml "<p>raw</p>"
       T3 node _result unsub <- runBuilderInDiv' do
-        el "br" $ pure unit
+        el_ "br" $ pure unit
         dynamic_ dyn
-        el "br" $ pure unit
+        el_ "br" $ pure unit
 
       liftEffect (innerHTML node) `shouldReturn`
         """<br><p>raw</p><br>"""
@@ -168,9 +162,9 @@ spec = describe "Builder" do
     it "renders empty when dynamic is initially Nothing" $ withLeakCheck do
       Tuple dynMb _ <- liftEffect $ newDynamic Nothing
       T3 node _ unsub <- runBuilderInDiv' do
-        elDynAttr "span" (pure mempty) $ pure unit
+        el_ "span" $ pure unit
         whenJustD dynMb $ \dyn -> dynText dyn
-        elDynAttr "span" (pure mempty) $ pure unit
+        el_ "span" $ pure unit
 
       liftEffect (innerHTML node) `shouldReturn`
         """<span></span><span></span>"""
@@ -181,9 +175,9 @@ spec = describe "Builder" do
     it "renders contents when dynamic is initially Just" $ withLeakCheck do
       Tuple dynMb _ <- liftEffect $ newDynamic $ Just "foobar"
       T3 node _ unsub <- runBuilderInDiv' do
-        elDynAttr "span" (pure mempty) $ pure unit
+        el_ "span" $ pure unit
         whenJustD dynMb $ \dyn -> dynText dyn
-        elDynAttr "span" (pure mempty) $ pure unit
+        el_ "span" $ pure unit
 
       liftEffect (innerHTML node) `shouldReturn`
         """<span></span>foobar<span></span>"""
@@ -194,9 +188,9 @@ spec = describe "Builder" do
     it "renders contents when dynamic is initially Nothing then updated to Just" $ withLeakCheck do
       Tuple dynMb updateDyn <- liftEffect $ newDynamic $ Nothing
       T3 node _ unsub <- runBuilderInDiv' do
-        elDynAttr "span" (pure mempty) $ pure unit
+        el_ "span" $ pure unit
         whenJustD dynMb $ \dyn -> dynText dyn
-        elDynAttr "span" (pure mempty) $ pure unit
+        el_ "span" $ pure unit
 
       liftEffect (innerHTML node) `shouldReturn`
         """<span></span><span></span>"""
@@ -211,9 +205,9 @@ spec = describe "Builder" do
     it "renders empty when dynamic is initially Just then updated to Nothing" $ withLeakCheck do
       Tuple dynMb updateDyn <- liftEffect $ newDynamic $ Just "foobar"
       T3 node _ unsub <- runBuilderInDiv' do
-        elDynAttr "span" (pure mempty) $ pure unit
+        el_ "span" $ pure unit
         whenJustD dynMb $ \dyn -> dynText dyn
-        elDynAttr "span" (pure mempty) $ pure unit
+        el_ "span" $ pure unit
 
       liftEffect (innerHTML node) `shouldReturn`
         """<span></span>foobar<span></span>"""
@@ -230,11 +224,11 @@ spec = describe "Builder" do
       count <- liftEffect $ new 0
 
       T3 node _ unsub <- runBuilderInDiv' do
-        elDynAttr "span" (pure mempty) $ pure unit
+        el_ "span" $ pure unit
         whenJustD dynMb $ \dyn -> do
           liftEffect $ modify_ (_ + 1) count
           dynText dyn
-        elDynAttr "span" (pure mempty) $ pure unit
+        el_ "span" $ pure unit
 
       liftEffect $ updateDyn $ Just "foo"
       liftEffect $ updateDyn $ Just "bar"
@@ -254,9 +248,9 @@ spec = describe "Builder" do
       it "renders empty when dynamic is initially false" $ withLeakCheck do
         Tuple dynMb _ <- liftEffect $ newDynamic false
         T3 node _ unsub <- runBuilderInDiv' do
-          elDynAttr "span" (pure mempty) $ pure unit
+          el_ "span" $ pure unit
           whenD dynMb $ text "hello"
-          elDynAttr "span" (pure mempty) $ pure unit
+          el_ "span" $ pure unit
 
         liftEffect (innerHTML node) `shouldReturn`
           """<span></span><span></span>"""
@@ -267,9 +261,9 @@ spec = describe "Builder" do
       it "renders contents when dynamic is initially true" $ withLeakCheck do
         Tuple dynMb _ <- liftEffect $ newDynamic true
         T3 node _ unsub <- runBuilderInDiv' do
-          elDynAttr "span" (pure mempty) $ pure unit
+          el_ "span" $ pure unit
           whenD dynMb $ text "hello"
-          elDynAttr "span" (pure mempty) $ pure unit
+          el_ "span" $ pure unit
 
         liftEffect (innerHTML node) `shouldReturn`
           """<span></span>hello<span></span>"""
@@ -280,9 +274,9 @@ spec = describe "Builder" do
       it "renders contents when dynamic is initially false then updated to true" $ withLeakCheck do
         Tuple dynMb updateDyn <- liftEffect $ newDynamic false
         T3 node _ unsub <- runBuilderInDiv' do
-          elDynAttr "span" (pure mempty) $ pure unit
+          el_ "span" $ pure unit
           whenD dynMb $ text "hello"
-          elDynAttr "span" (pure mempty) $ pure unit
+          el_ "span" $ pure unit
 
         liftEffect $ updateDyn true
         liftEffect (innerHTML node) `shouldReturn`
@@ -294,9 +288,9 @@ spec = describe "Builder" do
       it "renders empty when dynamic is initially true then updated to false" $ withLeakCheck do
         Tuple dynMb updateDyn <- liftEffect $ newDynamic true
         T3 node _ unsub <- runBuilderInDiv' do
-          elDynAttr "span" (pure mempty) $ pure unit
+          el_ "span" $ pure unit
           whenD dynMb $ text "hello"
-          elDynAttr "span" (pure mempty) $ pure unit
+          el_ "span" $ pure unit
 
         liftEffect $ updateDyn false
         liftEffect (innerHTML node) `shouldReturn`
@@ -310,11 +304,11 @@ spec = describe "Builder" do
         count <- liftEffect $ new 0
 
         T3 node _ unsub <- runBuilderInDiv' do
-          elDynAttr "span" (pure mempty) $ pure unit
+          el_ "span" $ pure unit
           whenD dynMb do
             liftEffect $ modify_ (_ + 1) count
             text "hello"
-          elDynAttr "span" (pure mempty) $ pure unit
+          el_ "span" $ pure unit
 
         liftEffect $ updateDyn true
         liftEffect $ updateDyn true
@@ -334,9 +328,9 @@ spec = describe "Builder" do
       it "renders empty when dynamic is initially true" $ withLeakCheck do
         Tuple dynMb _ <- liftEffect $ newDynamic true
         T3 node _ unsub <- runBuilderInDiv' do
-          elDynAttr "span" (pure mempty) $ pure unit
+          el_ "span" $ pure unit
           unlessD dynMb $ text "hello"
-          elDynAttr "span" (pure mempty) $ pure unit
+          el_ "span" $ pure unit
 
         liftEffect (innerHTML node) `shouldReturn`
           """<span></span><span></span>"""
@@ -347,9 +341,9 @@ spec = describe "Builder" do
       it "renders contents when dynamic is initially false" $ withLeakCheck do
         Tuple dynMb _ <- liftEffect $ newDynamic false
         T3 node _ unsub <- runBuilderInDiv' do
-          elDynAttr "span" (pure mempty) $ pure unit
+          el_ "span" $ pure unit
           unlessD dynMb $ text "hello"
-          elDynAttr "span" (pure mempty) $ pure unit
+          el_ "span" $ pure unit
 
         liftEffect (innerHTML node) `shouldReturn`
           """<span></span>hello<span></span>"""
@@ -360,9 +354,9 @@ spec = describe "Builder" do
       it "renders contents when dynamic is initially true then updated to false" $ withLeakCheck do
         Tuple dynMb updateDyn <- liftEffect $ newDynamic true
         T3 node _ unsub <- runBuilderInDiv' do
-          elDynAttr "span" (pure mempty) $ pure unit
+          el_ "span" $ pure unit
           unlessD dynMb $ text "hello"
-          elDynAttr "span" (pure mempty) $ pure unit
+          el_ "span" $ pure unit
 
         liftEffect $ updateDyn false
         liftEffect (innerHTML node) `shouldReturn`
@@ -374,9 +368,9 @@ spec = describe "Builder" do
       it "renders empty when dynamic is initially false then updated to true" $ withLeakCheck do
         Tuple dynMb updateDyn <- liftEffect $ newDynamic false
         T3 node _ unsub <- runBuilderInDiv' do
-          elDynAttr "span" (pure mempty) $ pure unit
+          el_ "span" $ pure unit
           unlessD dynMb $ text "hello"
-          elDynAttr "span" (pure mempty) $ pure unit
+          el_ "span" $ pure unit
 
         liftEffect $ updateDyn true
         liftEffect (innerHTML node) `shouldReturn`
@@ -390,11 +384,11 @@ spec = describe "Builder" do
         count <- liftEffect $ new 0
 
         T3 node _ unsub <- runBuilderInDiv' do
-          elDynAttr "span" (pure mempty) $ pure unit
+          el_ "span" $ pure unit
           unlessD dynMb do
             liftEffect $ modify_ (_ + 1) count
             text "hello"
-          elDynAttr "span" (pure mempty) $ pure unit
+          el_ "span" $ pure unit
 
         liftEffect $ updateDyn false
         liftEffect $ updateDyn false
@@ -410,92 +404,25 @@ spec = describe "Builder" do
         -- clean up
         liftEffect unsub
 
-  describe "domEventWithSample" do
-    it "dispatches DOM events and handles unsubscribe" $ withLeakCheck do
-      T3 _node { button, event } unsub1 <- runBuilderInDiv' do
-        Tuple button _ <- elDynAttr' "button" (pure mempty) (text "foo")
-        event <- domEventWithSample (\_ -> pure unit) "click" button
-        pure { button, event }
-
-      log <- liftEffect $ new []
-      unsub2 <- liftEffect $ execCleanupT $ subscribeEvent_ (append log) event
-
-      liftEffect $ dispatchTrivialEvent button "click"
-      log `shouldHaveValue` [ unit ]
-
-      -- clean up
-      liftEffect unsub1
-      liftEffect unsub2
-
-  describe "integration test - `dynamic`/`weakDynamic` and flattening" do
-    it "clearCompletedButton from TodoMVC, using Dynamic" $ withLeakCheck do
-      Tuple dyn updateDyn <- liftEffect $ newDynamic false
-      let
-        anyCompletedTasks :: Dynamic Boolean
-        anyCompletedTasks = dyn
-
-      T3 node (result :: Dynamic (Event Unit)) unsub1 <- runBuilderInDiv' do
-        dynamic $ anyCompletedTasks <#> \anyCompletedTasks' ->
-          if anyCompletedTasks' then buttonOnClick (pure mempty) (text "Clear")
-          else pure never
-
-      let
-        event :: Event Unit
-        event = switch result
-
+  describe "onDomEvent" do
+    it "dispatches DOM events" $ withLeakCheck do
       log <- liftEffect $ new []
-      unsub2 <- liftEffect $ execCleanupT $ subscribeEvent_ (append log) event
-
-      liftEffect (innerHTML node) `shouldReturn` ""
 
-      liftEffect $ updateDyn true
-      liftEffect (innerHTML node) `shouldReturn`
-        """<button>Clear</button>"""
-
-      button <- liftEffect $ querySelector "button" node
-      liftEffect $ dispatchTrivialEvent button "click"
-      log `shouldHaveValue` [ unit ]
-
-      -- clean up
-      liftEffect unsub1
-      liftEffect unsub2
-
-    it "clearCompletedButton from TodoMVC, using WeakDynamic" $ withLeakCheck do
-      Tuple dyn updateDyn <- liftEffect $ newDynamic false
-      let
-        anyCompletedTasks :: WeakDynamic Boolean
-        anyCompletedTasks = weaken dyn
-
-      T3 node (result :: WeakDynamic (Event Unit)) unsub1 <- runBuilderInDiv' do
-        weakDynamic $ anyCompletedTasks <#> \anyCompletedTasks' ->
-          if anyCompletedTasks' then buttonOnClick (pure mempty) (text "Clear")
-          else pure never
-
-      let
-        event :: Event Unit
-        event = switchWeakDyn result
-
-      log <- liftEffect $ new []
-      unsub2 <- liftEffect $ execCleanupT $ subscribeEvent_ (append log) event
-
-      liftEffect (innerHTML node) `shouldReturn` ""
-
-      liftEffect $ updateDyn true
-      liftEffect (innerHTML node) `shouldReturn`
-        """<button>Clear</button>"""
+      T3 _node button unsub1 <- runBuilderInDiv' do
+        Tuple button _ <- el' "button" [] (text "foo")
+        onDomEvent "click" button \_ -> append log unit
+        pure button
 
-      button <- liftEffect $ querySelector "button" node
       liftEffect $ dispatchTrivialEvent button "click"
       log `shouldHaveValue` [ unit ]
 
       -- clean up
       liftEffect unsub1
-      liftEffect unsub2
 
   it "supports element namespaces" $ withLeakCheck do
     let xmlns = "http://www.w3.org/2000/svg"
     T3 _ (Tuple svgNode _) unsub <- runBuilderInDiv' $
-      elDynAttrNS' (Just xmlns) "svg" (pure mempty) (pure unit)
+      elNS' (Just xmlns) "svg" [] (pure unit)
 
     (unsafeCoerce svgNode).namespaceURI `shouldEqual` xmlns
 
diff --git a/test/browser/DemoMain.purs b/test/browser/DemoMain.purs
index 75b47dc..efe23bf 100644
--- a/test/browser/DemoMain.purs
+++ b/test/browser/DemoMain.purs
@@ -2,20 +2,16 @@ module DemoMain where
 
 import Prelude
 
+import Data.Foldable (for_)
 import Data.Maybe (Maybe(..))
-import Data.Traversable (traverse)
-import Data.Tuple (Tuple(..))
 import Effect (Effect)
 import Examples.AsyncRequest as AsyncRequest
-import Examples.Counter as Counter
 import Examples.CounterRef as CounterRef
-import Examples.Radio as Radio
 import Examples.RegistrationForm as RegistrationForm
-import Specular.Dom.Builder.Class (el, text)
-import Specular.Dom.Widget (class MonadWidget, Widget, runMainWidgetInBody)
-import Specular.Dom.Widgets.Button (buttonOnClick)
-import Specular.FRP (Event, holdDyn, leftmost, weakDynamic_)
-import Specular.FRP.Fix (fixFRP)
+import Specular.Dom.Element (el, el_, onClick_, text)
+import Specular.Dom.Widget (Widget, runMainWidgetInBody)
+import Specular.FRP (withDynamic_)
+import Specular.Ref as Ref
 
 newtype Demo = Demo
   { name :: String
@@ -27,34 +23,27 @@ runDemo (Demo { run }) = run unit
 
 demos :: Array Demo
 demos =
-  [ Demo { name: "Counter", run: \_ -> Counter.mainWidget }
-  , Demo { name: "RegistrationForm", run: \_ -> void RegistrationForm.mainWidget }
+  [ Demo { name: "RegistrationForm", run: \_ -> void RegistrationForm.mainWidget }
   , Demo { name: "AsyncRequest", run: \_ -> AsyncRequest.mainWidget }
-  , Demo { name: "Radio", run: \_ -> Radio.mainWidget }
   , Demo { name: "CounterRef", run: \_ -> CounterRef.mainWidget }
   ]
 
-demoButton :: forall m. MonadWidget m => Demo -> m (Event Demo)
-demoButton demo@(Demo { name }) = do
-  clicked <- buttonOnClick (pure mempty) (text name)
-  pure $ demo <$ clicked
-
 mainWidget :: Widget Unit
-mainWidget = fixFRP $ \view -> do
-  weakDynamic_ $ view.currentDemo <#> \m_demo ->
+mainWidget = do
+  currentDemo <- Ref.new Nothing
+
+  withDynamic_ (Ref.value currentDemo) \m_demo ->
     case m_demo of
       Nothing -> text "(no demo chosen)"
 
       Just (Demo { name, run }) -> do
-        el "h2" $ text $ "Current demo: " <> name
+        el_ "h2" $ text $ "Current demo: " <> name
         run unit
 
-  el "h2" $ text "Choose another demo:"
-  changeDemo <- leftmost <$> traverse demoButton demos
-
-  currentDemo <- holdDyn Nothing (map Just changeDemo)
-
-  pure (Tuple { currentDemo } unit)
+  el_ "h2" $ text "Choose another demo:"
+  for_ demos \demo@(Demo { name }) -> do
+    el "button" [ onClick_ $ Ref.write currentDemo (Just demo) ] do
+      text name
 
 main :: Effect Unit
 main = runMainWidgetInBody mainWidget
diff --git a/test/browser/InputWidgetsSpec.purs b/test/browser/InputWidgetsSpec.purs
deleted file mode 100644
index bf8d55c..0000000
--- a/test/browser/InputWidgetsSpec.purs
+++ /dev/null
@@ -1,120 +0,0 @@
-module InputWidgetsSpec where
-
-import Prelude hiding (append)
-
-import Control.Monad.Cleanup (runCleanupT)
-import Data.Tuple (Tuple(..))
-import Effect (Effect)
-import Effect.Ref (new)
-import Foreign (unsafeToForeign)
-import Specular.Dom.Browser (Node)
-import Specular.Dom.Widgets.Input (checkboxView, getCheckboxChecked, getTextInputValue, setTextInputValue, textInput, textInputValue, textInputValueEventOnEnter, textInputValueOnChange)
-import Specular.FRP (holdDyn, never, newEvent, weaken)
-import Specular.FRP.Base (subscribeDyn_, subscribeEvent_)
-import Test.Spec (Spec, describe, it, pending')
-import Test.Utils (append, liftEffect, shouldHaveValue, shouldReturn)
-import Test.Utils.Dom (dispatchEvent, dispatchTrivialEvent, querySelector, runBuilderInDiv)
-
-spec :: Spec Unit
-spec = describe "Input widgets" $ do
-  describe "textInput" $ do
-    let
-      makeTextInput config = do
-        Tuple div widget <- runBuilderInDiv $ textInput config
-        node <- liftEffect $ querySelector "input" div
-        pure { node, widget }
-
-    it "sets initial value" $ do
-      { node } <- makeTextInput
-        { initialValue: "foo", setValue: never, attributes: pure mempty }
-      liftEffect (getTextInputValue node) `shouldReturn` "foo"
-
-    it "changes value on event" $ do
-      { event, fire } <- liftEffect newEvent
-      { node } <- makeTextInput
-        { initialValue: "foo", setValue: event, attributes: pure mempty }
-
-      liftEffect $ fire "bar"
-      liftEffect (getTextInputValue node) `shouldReturn` "bar"
-
-    it "return value changes when setValue fires" $ do
-      { event, fire } <- liftEffect newEvent
-      log <- liftEffect $ new []
-      { node, widget } <- makeTextInput
-        { initialValue: "initial", setValue: event, attributes: pure mempty }
-
-      liftEffect $ do
-        void $ runCleanupT $ subscribeDyn_ (append log) (textInputValue widget)
-        fire "setValue"
-        setTextInputValue node "oninput"
-        dispatchTrivialEvent node "input"
-
-      log `shouldHaveValue` [ "initial", "setValue", "oninput" ]
-
-    describe "textInputValueOnChange" do
-      it "return value changes when setValue fires" do
-        { event, fire } <- liftEffect newEvent
-        log <- liftEffect $ new []
-        { node, widget } <- makeTextInput
-          { initialValue: "initial", setValue: event, attributes: pure mempty }
-
-        liftEffect $ do
-          void $ runCleanupT $ (textInputValueOnChange widget) >>= subscribeDyn_ (append log)
-          fire "setValue"
-          setTextInputValue node "onchange"
-          dispatchTrivialEvent node "change"
-
-        log `shouldHaveValue` [ "initial", "setValue", "onchange" ]
-
-    pending' "textInputValueEventOnEnter" $ do
-      -- FIXME: unable to simulate the keypress event correctly
-      log <- liftEffect $ new []
-      { node, widget } <- makeTextInput
-        { initialValue: "initial", setValue: never, attributes: pure mempty }
-      void $ liftEffect $ runCleanupT $ do
-        event <- textInputValueEventOnEnter widget
-        subscribeEvent_ (append log) event
-
-      liftEffect $ do
-        setTextInputValue node "changed1"
-        dispatchEvent node "keypress" (unsafeToForeign { key: "A" })
-
-        setTextInputValue node "changed2"
-        dispatchEvent node "keypress" (unsafeToForeign { key: "Enter" })
-
-      log `shouldHaveValue` [ "changed2" ]
-
-  describe "checkboxView" $ do
-    let
-      makeCheckbox value = do
-        Tuple div event <- runBuilderInDiv $ checkboxView value (pure mempty)
-        node <- liftEffect $ querySelector "input" div
-        pure { node, event }
-    it "sets initial value (false)" do
-      { node, event: _event } <- makeCheckbox (pure false)
-      liftEffect (getCheckboxChecked node) `shouldReturn` false
-    it "sets initial value (true)" do
-      { node, event: _event } <- makeCheckbox (pure true)
-      liftEffect (getCheckboxChecked node) `shouldReturn` true
-    it "handle external update when not touched by the user" $ do
-      { event: changeValueEvt, fire: changeValue } <- liftEffect newEvent
-      Tuple valueDyn _ <- runCleanupT $ holdDyn false changeValueEvt
-      { node, event: _event } <- makeCheckbox (weaken valueDyn)
-      liftEffect (getCheckboxChecked node) `shouldReturn` false
-      liftEffect $ changeValue true
-      liftEffect (getCheckboxChecked node) `shouldReturn` true
-      liftEffect $ changeValue false
-      liftEffect (getCheckboxChecked node) `shouldReturn` false
-    it "handle external update after touched by the user" $ do
-      { event: changeValueEvt, fire: changeValue } <- liftEffect newEvent
-      Tuple valueDyn _ <- runCleanupT $ holdDyn false changeValueEvt
-      { node, event: _event } <- makeCheckbox (weaken valueDyn)
-      liftEffect (getCheckboxChecked node) `shouldReturn` false
-      liftEffect $ triggerNodeClicked node
-      liftEffect (getCheckboxChecked node) `shouldReturn` true
-      liftEffect $ changeValue false
-      liftEffect (getCheckboxChecked node) `shouldReturn` false
-      liftEffect $ changeValue true
-      liftEffect (getCheckboxChecked node) `shouldReturn` true
-
-foreign import triggerNodeClicked :: Node -> Effect Unit -- for some reason dispatchTrivialEvent node "click" didn't work
diff --git a/test/browser/ListSpec.purs b/test/browser/ListSpec.purs
index f96122a..9c02b1f 100644
--- a/test/browser/ListSpec.purs
+++ b/test/browser/ListSpec.purs
@@ -2,52 +2,21 @@ module ListSpec where
 
 import Prelude hiding (append)
 
-import Effect.Aff (Milliseconds(..), delay)
 import BuilderSpec (newDynamic)
 import Data.Foldable (for_)
-import Data.Traversable (sequence)
 import Data.Tuple (Tuple(..))
+import Effect.Aff (Milliseconds(..), delay)
 import Specular.Dom.Browser (innerHTML)
-import Specular.Dom.Builder.Class (dynText, el, text)
-import Specular.FRP (changedW, dynamic_, subscribeEvent_, weaken)
-import Specular.FRP.List (weakDynamicList, weakDynamicList_, dynamicList_)
-import Specular.FRP.Replaceable (weakDynamic_)
-import Specular.FRP.WeakDynamic (attachWeakDynWith)
-import Effect.Ref (new)
-import Test.Spec (Spec, describe, it, pending')
+import Specular.Dom.Element (dynText, el_, text)
+import Specular.FRP (withDynamic_)
+import Specular.FRP.List (dynamicList_)
+import Test.Spec (Spec, describe, it)
 import Test.Spec.Assertions (shouldEqual)
-import Test.Utils (append, liftEffect, shouldHaveValue)
+import Test.Utils (liftEffect)
 import Test.Utils.Dom (runBuilderInDiv)
 
--- | import Debug (trace)
-
 spec :: Spec Unit
 spec = do
-  describe "weakDynamicList_" $ do
-    it "builds and updates DOM correctly" $ do
-      let states = [ [ 1 ], [], [ 1, 2, 3, 4 ], [ 2, 3, 4 ], [ 2 ] ]
-
-      Tuple dyn fire <- liftEffect $ newDynamic []
-      let wdyn = weaken dyn
-
-      Tuple node1 _ <- runBuilderInDiv
-        $ weakDynamic_
-        $ wdyn <#> \array ->
-            for_ array $ \item ->
-              el "p" $ text $ show item
-
-      Tuple node2 _ <- runBuilderInDiv
-        $ weakDynamicList_ wdyn
-        $ \item ->
-            el "p" $ dynText $ map show item
-
-      for_ states $ \state -> do
-        liftEffect (fire state)
-        delay (Milliseconds 1.0)
-        html1 <- liftEffect (innerHTML node1)
-        html2 <- liftEffect (innerHTML node2)
-        html1 `shouldEqual` html2
-
   describe "dynamicList_" $ do
     it "builds and updates DOM correctly" $ do
       let states = [ [ 1 ], [], [ 1, 2, 3, 4 ], [ 2, 3, 4 ], [ 2 ] ]
@@ -55,10 +24,9 @@ spec = do
       Tuple dyn fire <- liftEffect $ newDynamic []
 
       Tuple node1 _ <- runBuilderInDiv
-        $ dynamic_
-        $ dyn <#> \array ->
+        $ withDynamic_ dyn \array ->
             for_ array $ \item ->
-              el "p" $ text $ show item
+              el_ "p" $ text $ show item
 
       Tuple node2 _ <- runBuilderInDiv
         $ dynamicList_ dyn
@@ -67,7 +35,7 @@ spec = do
             let
               mapFn = \x -> show x
             in
-              el "p" $ dynText $ weaken $ map mapFn item
+              el_ "p" $ dynText $ map mapFn item
 
       for_ states $ \state -> do
         liftEffect (fire state)
@@ -75,27 +43,3 @@ spec = do
         html1 <- liftEffect (innerHTML node1)
         html2 <- liftEffect (innerHTML node2)
         html1 `shouldEqual` html2
-
-  describe "weakDynamicList" $ do
-    pending' "updates return value if input changes" $ do
-      let states = [ [ 1 ], [], [ 1, 2, 3, 4 ], [ 2, 3, 4 ], [ 1 ] ]
-
-      Tuple dyn fire <- liftEffect $ newDynamic []
-      let wdyn = weaken dyn
-
-      log <- liftEffect $ new []
-
-      _ <- runBuilderInDiv do
-        resultDyn <- weakDynamicList wdyn pure
-        subscribeEvent_ (append log)
-          $ attachWeakDynWith const (join $ map sequence resultDyn)
-          $
-            -- ^ Workaround for glitches in the WeakDynamics given to
-            -- individual array elements
-            changedW resultDyn
-
-      for_ states \state -> do
-        liftEffect $ fire state
-
-      delay (Milliseconds 1.0)
-      log `shouldHaveValue` states
diff --git a/test/browser/NewBuilderSpec.purs b/test/browser/NewBuilderSpec.purs
index 0e64924..22c29f8 100644
--- a/test/browser/NewBuilderSpec.purs
+++ b/test/browser/NewBuilderSpec.purs
@@ -4,16 +4,15 @@ import Prelude hiding (append)
 
 import Data.Tuple (Tuple(..))
 import Effect (Effect)
-import Specular.Dom.Browser (innerHTML)
-import Specular.Dom.Element (ClassName, attrs, attrsD, classWhenD, classesD, dynText, el, el_, rawHtml, text, class_)
+import Specular.Dom.Browser (createElement, innerHTML, (:=))
+import Specular.Dom.Element (ClassName, attrs, classWhenD, class_, classesD, dynText, el, el_, text)
 import Specular.Dom.Element as E
-import Specular.Dom.Node.Class ((:=), createElement)
 import Specular.Dom.Widget (emptyWidget, runMainWidgetInBody, runWidgetInNode)
 import Specular.FRP (newDynamic)
+import Specular.Ref as Ref
 import Test.Spec (Spec, after_, describe, it)
 import Test.Utils (liftEffect, shouldReturn, withLeakCheck)
-import Test.Utils.Dom (T3(..), runBuilderInDiv, runBuilderInDiv', numChildNodes)
-import Specular.Ref as Ref
+import Test.Utils.Dom (T3(..), numChildNodes, runBuilderInDiv')
 
 spec :: Spec Unit
 spec =
@@ -40,35 +39,6 @@ spec =
           liftEffect (innerHTML parent) `shouldReturn` ""
           liftEffect (numChildNodes parent) `shouldReturn` 0
 
-      it "builds static DOM" $ withLeakCheck do
-        Tuple node _result <- runBuilderInDiv do
-          el "div" [ attrs ("class" := "content") ] do
-            text "foo"
-            el "span" [] $ text "bar"
-            rawHtml """<p class="foo">Raw</p>"""
-            text "baz"
-          el_ "hr" emptyWidget
-          el_ "span" (text "foo")
-
-        liftEffect (innerHTML node) `shouldReturn`
-          """<div class="content">foo<span>bar</span><p class="foo">Raw</p>baz</div><hr><span>foo</span>"""
-
-      it "updates attributes" $ withLeakCheck do
-        { dynamic, set } <- liftEffect $ newDynamic $ "k1" := "v1" <> "k2" := "v2"
-        T3 node _result unsub <- runBuilderInDiv' do
-          el "div" [ attrsD dynamic ] emptyWidget
-
-        liftEffect (innerHTML node) `shouldReturn`
-          """<div k2="v2" k1="v1"></div>"""
-
-        liftEffect $ set $ "k1" := "v1.1" <> "k3" := "v3"
-
-        liftEffect (innerHTML node) `shouldReturn`
-          """<div k1="v1.1" k3="v3"></div>"""
-
-        -- clean up
-        liftEffect unsub
-
       describe "classesD" do
         it "single instance" do
           { dynamic: d, set } <- newDynamic [ "foo", "bar" ]
diff --git a/test/browser/RadioGroupSpec.purs b/test/browser/RadioGroupSpec.purs
deleted file mode 100644
index d195cd2..0000000
--- a/test/browser/RadioGroupSpec.purs
+++ /dev/null
@@ -1,34 +0,0 @@
-module RadioGroupSpec where
-
-import Prelude hiding (append)
-
-import Effect.Ref (new)
-import Data.Tuple (Tuple(..))
-import Specular.Dom.Widgets.RadioGroup (radioGroup)
-import Specular.FRP.Base (subscribeDyn_)
-import Test.Spec (Spec, describe, pending')
-import Test.Utils (append, clear, liftEffect, shouldHaveValue)
-import Test.Utils.Dom (dispatchTrivialEvent, querySelector, runBuilderInDiv)
-
-spec :: Spec Unit
-spec = describe "radioGroup" $ do
-  pending' "works" $ do
-    log <- liftEffect $ new []
-    Tuple div _ <- runBuilderInDiv $ do
-      dyn <- radioGroup
-        { options: [ "foo", "bar" ]
-        , initialValueIndex: 0
-        , render: \_ _ input -> input (pure mempty)
-        }
-      subscribeDyn_ (append log) dyn
-
-    _inputFoo <- liftEffect $ querySelector "input:nth-child(1)" div
-    inputBar <- liftEffect $ querySelector "input:nth-child(2)" div
-
-    log `shouldHaveValue` [ "foo" ]
-
-    clear log
-    liftEffect $ dispatchTrivialEvent inputBar "click"
-    -- FIXME: the click event doesn't trigger the change in PhantomJS
-
-    log `shouldHaveValue` [ "bar" ]
diff --git a/test/browser/examples/AsyncRequest.purs b/test/browser/examples/AsyncRequest.purs
index 7b63099..e22049e 100644
--- a/test/browser/examples/AsyncRequest.purs
+++ b/test/browser/examples/AsyncRequest.purs
@@ -2,24 +2,19 @@ module Examples.AsyncRequest (spec, mainWidget) where
 
 import Prelude hiding (append)
 
-import BuilderSpec (newDynamic)
 import Data.Maybe (Maybe(..))
 import Data.String as String
 import Data.Time.Duration (Milliseconds(..))
 import Data.Tuple (Tuple(..))
 import Effect.Aff (Aff, delay)
-import Effect.Aff.AVar as AVar
 import Effect.Class (liftEffect)
 import Effect.Class.Console as Console
 import Specular.Dom.Browser (innerHTML)
-import Specular.Dom.Builder.Class (el, text)
-import Specular.Dom.Widget (class MonadWidget)
-import Specular.Dom.Widgets.Input (textInputOnInput)
-import Specular.FRP (Dynamic, current, pull, readBehavior, weakDynamic_)
+import Specular.Dom.Element (bindValueOnChange, el, el_, text)
+import Specular.Dom.Widget (Widget)
+import Specular.FRP (withDynamic_)
 import Specular.FRP.Async (RequestState(Loaded, Loading, NotRequested), asyncRequestMaybe)
-import Specular.FRP.Fix (fixFRP)
-import Specular.FRP.WeakDynamic (WeakDynamic)
-import Effect.Ref (new, read, write)
+import Specular.Ref as Ref
 import Test.Spec (Spec, describe, it)
 import Test.Utils (shouldReturn)
 import Test.Utils.Dom (runBuilderInDiv)
@@ -34,45 +29,6 @@ spec = describe "AsyncRequest" $ do
           """<div></div>"""
       )
 
-  describe "logic" $ do
-    it "renders request state" $ do
-      avar <- AVar.empty
-      let backend = { toUpper: \_ -> AVar.take avar }
-      Tuple query setQuery <- liftEffect $ newDynamic ""
-
-      Tuple _ (Tuple { result } _) <- runBuilderInDiv $ control backend { query }
-      liftEffect (pull $ readBehavior $ current result) `shouldReturn` NotRequested
-
-      liftEffect $ setQuery "foo"
-      liftEffect (pull $ readBehavior $ current result) `shouldReturn` Loading
-
-      AVar.put "FOO" avar
-      liftEffect (pull $ readBehavior $ current result) `shouldReturn` Loaded "FOO"
-
-    it "always displays the latest request" $ do
-      firstRequest <- AVar.empty
-      secondRequest <- AVar.empty
-      currentRequestVar <- liftEffect $ new firstRequest
-      let
-        backend =
-          { toUpper: \_ -> do
-              var <- liftEffect $ read currentRequestVar
-              AVar.take var
-          }
-      Tuple query setQuery <- liftEffect $ newDynamic ""
-
-      Tuple _ (Tuple { result } _) <- runBuilderInDiv $ control backend { query }
-
-      liftEffect $ setQuery "foo"
-      liftEffect $ write secondRequest currentRequestVar
-      liftEffect $ setQuery "bar"
-
-      AVar.put "FOO" firstRequest
-      liftEffect (pull $ readBehavior $ current result) `shouldReturn` Loading
-
-      AVar.put "BAR" secondRequest
-      liftEffect (pull $ readBehavior $ current result) `shouldReturn` Loaded "BAR"
-
 instantBackend :: Backend
 instantBackend = { toUpper: pure <<< String.toUpper }
 
@@ -89,42 +45,22 @@ type Backend =
   { toUpper :: String -> Aff String
   }
 
-mainWidget :: forall m. MonadWidget m => m Unit
+mainWidget :: Widget Unit
 mainWidget = mainWidgetWith slowBackend
 
-mainWidgetWith :: forall m. MonadWidget m => Backend -> m Unit
-mainWidgetWith backend = fixFRP $ view >=> control backend
+mainWidgetWith :: Backend -> Widget Unit
+mainWidgetWith backend = do
+  query <- Ref.new ""
+  result <- asyncRequestMaybe $
+    map (\s -> if s == "" then Nothing else Just (backend.toUpper s)) (Ref.value query)
 
-view
-  :: forall m
-   . MonadWidget m
-  => { result :: WeakDynamic (RequestState String) }
-  -> m { query :: Dynamic String }
-view { result } = do
-  query <- el "div" $ do
-    el "label" $ text "Input: "
-    textInputOnInput "" mempty
+  el_ "div" do
+    el_ "label" $ text "Input: "
+    el "input" [ bindValueOnChange query ] (pure unit)
 
-  el "div" $ do
-    weakDynamic_ $ flip map result $
+  el_ "div" do
+    withDynamic_ result $
       case _ of
         NotRequested -> pure unit
         Loading -> text $ "Accessing Webscale Uppercase Service..."
         Loaded x -> text $ "Result is: " <> x
-
-  pure { query }
-
-control
-  :: forall m
-   . MonadWidget m
-  => Backend
-  -> { query :: Dynamic String }
-  -> m
-       ( Tuple
-           { result :: Dynamic (RequestState String) }
-           Unit
-       )
-control backend { query } = do
-  result <- asyncRequestMaybe $
-    map (\s -> if s == "" then Nothing else Just (backend.toUpper s)) query
-  pure $ Tuple { result } unit
diff --git a/test/browser/examples/Counter.purs b/test/browser/examples/Counter.purs
deleted file mode 100644
index bcc2a64..0000000
--- a/test/browser/examples/Counter.purs
+++ /dev/null
@@ -1,92 +0,0 @@
-module Examples.Counter (spec, mainWidget) where
-
-import Prelude hiding (append)
-
-import Data.Tuple (Tuple(..))
-import Specular.Dom.Browser (innerHTML)
-import Specular.Dom.Builder.Class (dynText, el, text)
-import Specular.Dom.Node.Class ((:=))
-import Specular.Dom.Widget (class MonadWidget)
-import Specular.Dom.Widgets.Button (buttonOnClick)
-import Specular.FRP (class MonadFRP, Dynamic, Event, foldDyn, leftmost)
-import Specular.FRP.Fix (fixFRP)
-import Specular.FRP.WeakDynamic (WeakDynamic)
-import Test.Spec (Spec, describe, it)
-import Test.Utils (liftEffect, shouldReturn)
-import Test.Utils.Dom (runBuilderInDiv, dispatchTrivialEvent, querySelector)
-
-spec :: Spec Unit
-spec = describe "Counter" $ do
-  it "initially renders zero" $ do
-    Tuple node _ <- runBuilderInDiv mainWidget
-
-    liftEffect (innerHTML node) `shouldReturn`
-      ( """<p>0</p>"""
-          <> """<button class="increment">Increment</button>"""
-          <>
-            """<button class="decrement">Decrement</button>"""
-      )
-
-  it "reacts to increment/decrement buttons" $ do
-    Tuple node _ <- runBuilderInDiv mainWidget
-
-    incrementButton <- liftEffect $ querySelector ".increment" node
-    decrementButton <- liftEffect $ querySelector ".decrement" node
-
-    liftEffect $ dispatchTrivialEvent incrementButton "click"
-
-    liftEffect (innerHTML node) `shouldReturn`
-      ( """<p>1</p>"""
-          <> """<button class="increment">Increment</button>"""
-          <>
-            """<button class="decrement">Decrement</button>"""
-      )
-
-    liftEffect $ dispatchTrivialEvent decrementButton "click"
-    liftEffect $ dispatchTrivialEvent decrementButton "click"
-    liftEffect $ dispatchTrivialEvent decrementButton "click"
-
-    liftEffect (innerHTML node) `shouldReturn`
-      ( """<p>-2</p>"""
-          <> """<button class="increment">Increment</button>"""
-          <>
-            """<button class="decrement">Decrement</button>"""
-      )
-
-mainWidget :: forall m. MonadWidget m => m Unit
-mainWidget = fixFRP $ view >=> control
-
-view
-  :: forall m
-   . MonadWidget m
-  => { value :: WeakDynamic Int }
-  -> m
-       { increment :: Event Unit
-       , decrement :: Event Unit
-       }
-view { value } = do
-  el "p" $ dynText (show <$> value)
-
-  increment <- buttonOnClick (pure $ "class" := "increment") $ text "Increment"
-  decrement <- buttonOnClick (pure $ "class" := "decrement") $ text "Decrement"
-
-  pure { increment, decrement }
-
-control
-  :: forall m
-   . MonadFRP m
-  => { increment :: Event Unit
-     , decrement :: Event Unit
-     }
-  -> m
-       ( Tuple
-           { value :: Dynamic Int }
-           Unit
-       )
-control { increment, decrement } = do
-  value <- foldDyn ($) 0 $
-    leftmost
-      [ (_ + 1) <$ increment
-      , (_ - 1) <$ decrement
-      ]
-  pure (Tuple { value } unit)
diff --git a/test/browser/examples/CounterRef.purs b/test/browser/examples/CounterRef.purs
index 41d7726..40246b4 100644
--- a/test/browser/examples/CounterRef.purs
+++ b/test/browser/examples/CounterRef.purs
@@ -76,20 +76,20 @@ mainWidget = do
   counter :: Ref Int <- Ref.new 0
 
   -- | Subtract 1 from counter value
-  let subtractCb = (Ref.modify counter) (add (negate 1))
+  let decrement = Ref.modify counter (_ - 1)
 
   -- | Add 1 to counter value
-  let addCb = (Ref.modify counter) (add 1)
+  let increment = Ref.modify counter (_ + 1)
 
   -- | Reset counter to 0
   let reset = Ref.write counter 0
 
   el_ "p" $ dynText $ show <$> Ref.value counter
 
-  el "button" [ class_ "increment", attr "type" "button", onClick_ addCb ] do
+  el "button" [ class_ "increment", attr "type" "button", onClick_ increment ] do
     text "Increment"
 
-  el "button" [ class_ "decrement", attr "type" "button", onClick_ subtractCb ] do
+  el "button" [ class_ "decrement", attr "type" "button", onClick_ decrement ] do
     text "Decrement"
 
   el "button" [ class_ "reset", attr "type" "button", onClick_ reset ] do
diff --git a/test/browser/examples/Radio.purs b/test/browser/examples/Radio.purs
deleted file mode 100644
index c328295..0000000
--- a/test/browser/examples/Radio.purs
+++ /dev/null
@@ -1,24 +0,0 @@
-module Examples.Radio (mainWidget) where
-
-import Prelude hiding (append)
-
-import Specular.Dom.Builder.Class (dynText, el, elAttr, text)
-import Specular.Dom.Node.Class ((:=))
-import Specular.Dom.Widget (class MonadWidget)
-import Specular.Dom.Widgets.RadioGroup (radioGroup)
-import Specular.FRP (weaken)
-
-mainWidget :: forall m. MonadWidget m => m Unit
-mainWidget = do
-  dyn <- radioGroup
-    { options: [ "foo", "bar", "baz" ]
-    , initialValueIndex: 0
-    , render: \name value input ->
-        el "div" $
-          input (pure mempty)
-            <* elAttr "label" ("for" := name) (text value)
-    }
-  el "br" (pure unit)
-
-  text "Selected value: "
-  dynText $ weaken dyn
diff --git a/test/browser/examples/RegistrationForm.purs b/test/browser/examples/RegistrationForm.purs
index 6f94744..08e75ad 100644
--- a/test/browser/examples/RegistrationForm.purs
+++ b/test/browser/examples/RegistrationForm.purs
@@ -2,38 +2,33 @@ module Examples.RegistrationForm (spec, mainWidget) where
 
 import Prelude hiding (append)
 
-import Control.Monad.Cleanup (class MonadCleanup, runCleanupT)
-import Effect.Class (class MonadEffect)
-import Effect.Ref (new)
+import Control.Monad.Cleanup (runCleanupT)
 import Data.Tuple (Tuple(..))
+import Effect.Ref (new)
 import Specular.Dom.Browser (innerHTML)
-import Specular.Dom.Builder.Class (el, text)
-import Specular.Dom.Node.Class ((:=))
-import Specular.Dom.Widget (class MonadWidget)
-import Specular.Dom.Widgets.Button (buttonOnClick)
-import Specular.Dom.Widgets.Input (textInputOnChange)
-import Specular.FRP (Dynamic, Event, tagDyn, weakDynamic_)
+import Specular.Dom.Element (attr, bindValueOnChange, class_, el, el_, onClick_, text)
+import Specular.Dom.Widget (Widget)
+import Specular.FRP (Dynamic, Event, newEvent, readDynamic, unlessD, whenD)
 import Specular.FRP.Base (subscribeEvent_)
-import Specular.FRP.Fix (fixFRP)
-import Specular.FRP.WeakDynamic (WeakDynamic)
+import Specular.Ref as Ref
 import Test.Spec (Spec, describe, it)
 import Test.Utils (append, liftEffect, shouldHaveValue, shouldReturn)
 import Test.Utils.Dom (dispatchTrivialEvent, querySelector, runBuilderInDiv, setInputValueWithChange)
 
 spec :: Spec Unit
-spec = describe "RegistrationForm" $ do
-  it "initially renders empty form" $ do
+spec = describe "RegistrationForm" do
+  it "initially renders empty form" do
     Tuple node _ <- runBuilderInDiv mainWidget
 
     liftEffect (innerHTML node) `shouldReturn`
       ( """<div><label>Login: </label><input class="login"></div>"""
-          <> """<div><label>Password: </label><input class="password" type="password"></div>"""
-          <> """<div><label>Repeat password: </label><input class="repeat-password" type="password"></div>"""
+          <> """<div><label>Password: </label><input type="password" class="password"></div>"""
+          <> """<div><label>Repeat password: </label><input type="password" class="repeat-password"></div>"""
           <>
             """<button>Register</button>"""
       )
 
-  it "reacts to password change" $ do
+  it "reacts to password change" do
     Tuple node _ <- runBuilderInDiv mainWidget
 
     passwordInput <- liftEffect $ querySelector ".password" node
@@ -42,14 +37,14 @@ spec = describe "RegistrationForm" $ do
     -- NB: Input values are not present in innerHTML
     liftEffect (innerHTML node) `shouldReturn`
       ( """<div><label>Login: </label><input class="login"></div>"""
-          <> """<div><label>Password: </label><input class="password" type="password"></div>"""
-          <> """<div><label>Repeat password: </label><input class="repeat-password" type="password"></div>"""
+          <> """<div><label>Password: </label><input type="password" class="password"></div>"""
+          <> """<div><label>Repeat password: </label><input type="password" class="repeat-password"></div>"""
           <> """<div>Passwords do not match</div>"""
           <>
             """<button>Register</button>"""
       )
 
-  it "reacts to submit button" $ do
+  it "reacts to submit button" do
     let showFormResult { login, password } = "login: " <> login <> ", password: " <> password
 
     Tuple node event <- runBuilderInDiv mainWidget
@@ -78,77 +73,47 @@ type FormResult =
 -- | Renders a registration form.
 -- | Returns an Event that fires on "Register" button,
 -- | with the form data.
-mainWidget :: forall m. MonadWidget m => m (Event FormResult)
-mainWidget = fixFRP $ view >=> control
-
-view
-  :: forall m
-   . MonadWidget m
-  => { loginIsTaken :: WeakDynamic Boolean
-     , passwordsMatch :: WeakDynamic Boolean
-     }
-  -> m
-       { login :: Dynamic String
-       , password :: Dynamic String
-       , repeatPassword :: Dynamic String
-       , register :: Event Unit
-       }
-view { loginIsTaken, passwordsMatch } = do
-  login <- el "div" $ do
-    el "label" $ text "Login: "
-    value <- textInputOnChange "" ("class" := "login")
-    weakDynamic_ $ flip map loginIsTaken $ \loginIsTakenValue ->
-      when loginIsTakenValue $
-        text "Login already taken"
-    pure value
-
-  password <- el "div" $ do
-    el "label" $ text "Password: "
-    textInputOnChange "" ("type" := "password" <> "class" := "password")
-
-  repeatPassword <- el "div" $ do
-    el "label" $ text "Repeat password: "
-    textInputOnChange "" ("type" := "password" <> "class" := "repeat-password")
-
-  weakDynamic_ $ flip map passwordsMatch $ \passwordsMatchValue ->
-    unless passwordsMatchValue
-      $ el "div"
-      $ text "Passwords do not match"
-
-  register <- buttonOnClick (pure mempty) $ text "Register"
-
-  pure { login, password, repeatPassword, register }
-
-control
-  :: forall m
-   . MonadEffect m
-  => MonadCleanup m
-  => { login :: Dynamic String
-     , password :: Dynamic String
-     , repeatPassword :: Dynamic String
-     , register :: Event Unit
-     }
-  -> m
-       ( Tuple
-           { loginIsTaken :: Dynamic Boolean
-           , passwordsMatch :: Dynamic Boolean
-           }
-           (Event FormResult)
-       )
-control { login, password, repeatPassword, register: registerButtonClicked } = do
-  let
-    loginIsTaken = map (_ == "admin") login
-    passwordsMatch = (==) <$> password <*> repeatPassword
+mainWidget :: Widget (Event FormResult)
+mainWidget = do
+  login <- Ref.new ""
+  password <- Ref.new ""
+  repeatPassword <- Ref.new ""
 
-    register = tagDyn formResult registerButtonClicked
+  result <- newEvent
+
+  let
+    loginIsTaken = map (_ == "admin") (Ref.value login)
+    passwordsMatch = (==) <$> Ref.value password <*> Ref.value repeatPassword
 
     -- FIXME: This should be replaced by `rsequence`
     formResult :: Dynamic FormResult
     formResult = do
-      loginValue <- login
-      passwordValue <- password
+      loginValue <- Ref.value login
+      passwordValue <- Ref.value password
       pure { login: loginValue, password: passwordValue }
 
-  pure $ Tuple
-    { loginIsTaken, passwordsMatch }
-    register
+    register = do
+      value <- readDynamic formResult
+      result.fire value
+
+  el_ "div" do
+    el_ "label" $ text "Login: "
+    el "input" [ class_ "login", bindValueOnChange login ] (pure unit)
+    whenD loginIsTaken do
+      text "Login already taken"
+
+  el_ "div" do
+    el_ "label" $ text "Password: "
+    el "input" [ attr "type" "password", class_ "password", bindValueOnChange password ] (pure unit)
+
+  el_ "div" do
+    el_ "label" $ text "Repeat password: "
+    el "input" [ attr "type" "password", class_ "repeat-password", bindValueOnChange repeatPassword ] (pure unit)
+
+  unlessD passwordsMatch do
+    el_ "div" $ text "Passwords do not match"
+
+  el "button" [ onClick_ register ] do
+    text "Register"
+
+  pure result.event
diff --git a/test/node/FixSpec.purs b/test/node/FixSpec.purs
deleted file mode 100644
index 7d54cde..0000000
--- a/test/node/FixSpec.purs
+++ /dev/null
@@ -1,136 +0,0 @@
-module FixSpec where
-
-import Prelude hiding (append)
-
-import Control.Monad.Cleanup (runCleanupT)
-import Effect.Ref (new)
-import Data.Tuple (Tuple(..))
-import Specular.FRP (Dynamic, Event, WeakDynamic, holdDyn, never, newEvent, subscribeEvent_, weaken)
-import Specular.FRP.Fix (fixDyn, fixEvent, fixFRP)
-import Specular.FRP.WeakDynamic (subscribeWeakDyn_)
-import Test.Spec (Spec, describe, it, pending')
-import Test.Utils (append, liftEffect, shouldHaveInferredType, shouldHaveValue)
-import Type.Prelude (Proxy(..))
-
-spec :: Spec Unit
-spec = do
-  describe "fixEvent" $ do
-    it "connects result Event to input Event" $ do
-      log <- liftEffect $ new []
-      Tuple fire _ <- liftEffect $ runCleanupT
-        $ fixEvent
-        $ \input -> do
-            _ <- subscribeEvent_ (append log) input
-
-            { event: output, fire } <- liftEffect newEvent
-            pure (Tuple output fire)
-
-      liftEffect $ fire 1
-
-      log `shouldHaveValue` [ 1 ]
-
-  {-
-    pending' "input and output occur simultaneously" $ do
-     log <- liftEffect $ new []
-     Tuple fire _ <- liftEffect $ runCleanupT $
-       fixEvent $ \input -> do
-         {event: output, fire} <- liftEffect newEvent
-         _ <- subscribeEvent_ (append log) $
-           mergeEvents
-             (\_ -> pure "input") (\_ -> pure "output") (\_ _ -> pure "both")
-             input output
-         pure (Tuple output fire)
-
-     liftEffect $ fire unit
-
-     -- TODO: the result of this test is doubly wrong:
-     -- The "wrong" result is ["output", "input"],
-     -- but the implementation currently gives ["output", "both"]
-     log `shouldHaveValue` ["both"]
--}
-
-  describe "fixDyn" $ do
-    it "gives input WeakDynamic initial value" $ do
-      log <- liftEffect $ new []
-      Tuple _ _ <- liftEffect $ runCleanupT
-        $ fixDyn
-        $ \input -> do
-            _ <- subscribeWeakDyn_ (append log) input
-
-            output <- holdDyn 1 never
-            pure (Tuple output unit)
-
-      log `shouldHaveValue` [ 1 ]
-
-    it "propagates output changes to input" $ do
-      { event, fire } <- liftEffect newEvent
-      log <- liftEffect $ new []
-      Tuple _ _ <- liftEffect $ runCleanupT
-        $ fixDyn
-        $ \input -> do
-            _ <- subscribeWeakDyn_ (append log) input
-
-            output <- holdDyn 1 event
-            pure (Tuple output unit)
-
-      liftEffect $ fire 2
-
-      log `shouldHaveValue` [ 1, 2 ]
-
-    pending' "input and output change simultaneously" $ do
-      { event, fire } <- liftEffect newEvent
-      log <- liftEffect $ new []
-      Tuple _ _ <- liftEffect $ runCleanupT
-        $ fixDyn
-        $ \input -> do
-            output <- holdDyn 1 event
-            _ <- subscribeWeakDyn_ (append log) $ Tuple <$> input <*> weaken output
-            pure (Tuple output unit)
-
-      liftEffect $ fire 2
-
-      log `shouldHaveValue` [ Tuple 1 1, Tuple 2 2 ]
-
-  describe "fixRecord" $ do
-    describe "type inference" $ do
-      it "empty record" $ do
-        void $ liftEffect $ runCleanupT
-          $ fixFRP
-          $ \r -> do
-              let _ = r `shouldHaveInferredType` (Proxy :: Proxy {})
-              pure (Tuple {} unit)
-
-      it "non-empty record" $ do
-        void $ liftEffect $ runCleanupT
-          $ fixFRP
-          $ \r -> do
-              let
-                _ = r `shouldHaveInferredType`
-                  ( Proxy :: Proxy
-                      { event :: Event Int
-                      , dynamic :: WeakDynamic Int
-                      }
-                  )
-              pure
-                ( Tuple
-                    { event: never :: Event Int
-                    , dynamic: pure 0 :: Dynamic Int
-                    }
-                    unit
-                )
-
-    it "works for Events and Dynamics" $ do
-      log <- liftEffect $ new []
-      Tuple fire _ <- liftEffect $ runCleanupT
-        $ fixFRP
-        $ \input -> do
-            { event, fire } <- liftEffect newEvent
-            dynamic <- holdDyn 0 event
-
-            _ <- subscribeEvent_ (append log) input.event
-            _ <- subscribeWeakDyn_ (append log) input.dynamic
-            pure (Tuple { event, dynamic } fire)
-
-      liftEffect $ fire 1
-
-      log `shouldHaveValue` [ 0, 1, 1 ]
diff --git a/test/node/Main.purs b/test/node/Main.purs
index 01b0ad6..efbe286 100644
--- a/test/node/Main.purs
+++ b/test/node/Main.purs
@@ -7,19 +7,15 @@ import DynamicSpec as DynamicSpec
 import Effect (Effect)
 import Effect.Aff (launchAff_)
 import EventSpec as EventSpec
-import FixSpec as FixSpec
 import RIOSpec as RIOSpec
 import Test.Spec.Reporter (consoleReporter)
 import Test.Spec.Runner (runSpec)
 import TraceSpec as TraceSpec
-import WeakDynamicSpec as WeakDynamicSpec
 
 main :: Effect Unit
 main = launchAff_ $ runSpec [ consoleReporter ] do
-  FixSpec.spec
   EventSpec.spec
   DynamicSpec.spec
-  WeakDynamicSpec.spec
   RIOSpec.spec
   TraceSpec.spec
   AsyncSpec.spec
diff --git a/test/node/WeakDynamicSpec.purs b/test/node/WeakDynamicSpec.purs
deleted file mode 100644
index 4c10257..0000000
--- a/test/node/WeakDynamicSpec.purs
+++ /dev/null
@@ -1,68 +0,0 @@
-module WeakDynamicSpec where
-
-import Prelude hiding (append)
-
-import Control.Monad.Cleanup (execCleanupT, runCleanupT)
-import Data.Either (Either(..))
-import Data.Tuple (Tuple(..))
-import Specular.FRP (holdDyn, newEvent, subscribeWeakDyn_, uniqWeakDynBy, weaken)
-import Specular.FRP.WeakDynamic (subscribeWeakDyn)
-import Effect.Ref (new)
-import Test.Spec (Spec, describe, it)
-import Test.Utils (append, clear, liftEffect, shouldHaveValue, withLeakCheck)
-
-spec :: Spec Unit
-spec = describe "WeakDynamic" $ do
-
-  describe "pure" $ do
-    it "has a value immediately" $ do
-      log <- liftEffect $ new []
-      _ <- liftEffect $ runCleanupT
-        $ subscribeWeakDyn_ (\x -> append log x)
-        $
-          pure 0
-
-      log `shouldHaveValue` [ 0 ]
-
-  describe "subscribeWeakDyn" $ do
-    it "updates the resulting Dynamic" $ do
-      { event, fire } <- liftEffect newEvent
-      log <- liftEffect $ new []
-      Tuple dyn _ <- liftEffect $ runCleanupT $ map weaken $ holdDyn 1 event
-
-      Tuple derivedDyn _ <- liftEffect $ runCleanupT $ subscribeWeakDyn
-        ( \x ->
-            do
-              append log (Left x)
-              pure (2 * x)
-        )
-        dyn
-
-      _ <- liftEffect $ execCleanupT $ subscribeWeakDyn_ (\x -> append log (Right x)) derivedDyn
-
-      liftEffect $ fire 5
-
-      log `shouldHaveValue` [ Left 1, Right 2, Left 5, Right 10 ]
-
-  describe "uniqWeakDynBy" $ do
-    it "updates value only when it changes" $ withLeakCheck $ do
-      { event, fire } <- liftEffect newEvent
-      log <- liftEffect $ new []
-      Tuple wdyn unsub1 <- liftEffect $ runCleanupT do
-        dyn <- holdDyn 0 event
-        uniqWeakDynBy eq (weaken dyn)
-
-      unsub2 <- liftEffect $ execCleanupT $ subscribeWeakDyn_ (\x -> append log x) wdyn
-      log `shouldHaveValue` [ 0 ]
-
-      clear log
-      liftEffect $ fire 0
-      liftEffect $ fire 1
-      liftEffect $ fire 2
-      liftEffect $ fire 2
-
-      log `shouldHaveValue` [ 1, 2 ]
-
-      -- clean up
-      liftEffect unsub1
-      liftEffect unsub2