Undid the foolish re-design of "abstract:" and "actor:".

2 files changed, 67 insertions, 67 deletions

diff --git a/stdlib/source/test/lux/control/concurrency/actor.lux b/stdlib/source/test/lux/control/concurrency/actor.lux
index c36e1b074..2767082b2 100644
--- a/stdlib/source/test/lux/control/concurrency/actor.lux
+++ b/stdlib/source/test/lux/control/concurrency/actor.lux
@@ -30,13 +30,13 @@
 (actor: counter
   Nat
 
-  [((on_mail message state self)
-    (message state self))
+  ((on_mail message state self)
+   (message state self))
 
-   (message: (count! [increment Nat] state self)
-     Nat
-     (let [state' (n.+ increment state)]
-       (async\in {#try.Success [state' state']})))]
+  (message: (count! [increment Nat] state self)
+    Nat
+    (let [state' (n.+ increment state)]
+      (async\in {#try.Success [state' state']})))
   )
 
 (def: (mailed? outcome)
diff --git a/stdlib/source/test/lux/type/abstract.lux b/stdlib/source/test/lux/type/abstract.lux
index 826569dae..479b08d68 100644
--- a/stdlib/source/test/lux/type/abstract.lux
+++ b/stdlib/source/test/lux/type/abstract.lux
@@ -49,65 +49,65 @@
            (/.abstract: (g!Foo a)
              Text
 
-             [(/.abstract: (g!Bar a)
-                Nat
+             (/.abstract: (g!Bar a)
+               Nat
 
-                [(def: .public test
-                   Test
-                   (<| (_.covering /._)
-                       (_.for [/.abstract:])
-                       (do random.monad
-                         [expected_foo (random.ascii/lower 5)
-                          expected_bar random.nat]
-                         ($_ _.and
-                             (_.cover [/.:abstraction]
-                                      (and (exec (: (g!Foo Text)
-                                                    (/.:abstraction g!Foo expected_foo))
-                                             true)
-                                           (exec (: (g!Bar Text)
-                                                    (/.:abstraction expected_bar))
-                                             true)))
-                             (_.cover [/.:representation]
-                                      (and (|> expected_foo
-                                               (/.:abstraction g!Foo)
-                                               (: (g!Foo Bit))
-                                               (/.:representation g!Foo)
-                                               (text\= expected_foo))
-                                           (|> (/.:abstraction expected_bar)
-                                               (: (g!Bar Bit))
-                                               /.:representation
-                                               (n.= expected_bar))))
-                             (_.cover [/.:transmutation]
-                                      (and (exec (|> expected_foo
-                                                     (/.:abstraction g!Foo)
-                                                     (: (g!Foo .Macro))
-                                                     (/.:transmutation g!Foo)
-                                                     (: (g!Foo .Lux)))
-                                             true)
-                                           (exec (|> (/.:abstraction expected_bar)
-                                                     (: (g!Bar .Macro))
-                                                     /.:transmutation
-                                                     (: (g!Bar .Lux)))
-                                             true)))
-                             (_.cover [/.^:representation]
-                                      (and (let [(/.^:representation g!Foo actual_foo)
-                                                 (: (g!Foo .Module)
-                                                    (/.:abstraction g!Foo expected_foo))]
-                                             (text\= expected_foo actual_foo))
-                                           (let [(/.^:representation actual_bar)
-                                                 (: (g!Bar .Module)
-                                                    (/.:abstraction expected_bar))]
-                                             (n.= expected_bar actual_bar))))
-                             (_.for [/.Frame]
-                                    ($_ _.and
-                                        (_.cover [/.current]
-                                                 (text\= (template.text [g!Bar])
-                                                         (..current)))
-                                        (_.cover [/.specific]
-                                                 (text\= (template.text [g!Foo])
-                                                         (..specific)))
-                                        (_.cover [/.no_active_frames]
-                                                 (and no_current!
-                                                      no_specific!))
-                                        ))
-                             ))))])]))))
+               (def: .public test
+                 Test
+                 (<| (_.covering /._)
+                     (_.for [/.abstract:])
+                     (do random.monad
+                       [expected_foo (random.ascii/lower 5)
+                        expected_bar random.nat]
+                       ($_ _.and
+                           (_.cover [/.:abstraction]
+                                    (and (exec (: (g!Foo Text)
+                                                  (/.:abstraction g!Foo expected_foo))
+                                           true)
+                                         (exec (: (g!Bar Text)
+                                                  (/.:abstraction expected_bar))
+                                           true)))
+                           (_.cover [/.:representation]
+                                    (and (|> expected_foo
+                                             (/.:abstraction g!Foo)
+                                             (: (g!Foo Bit))
+                                             (/.:representation g!Foo)
+                                             (text\= expected_foo))
+                                         (|> (/.:abstraction expected_bar)
+                                             (: (g!Bar Bit))
+                                             /.:representation
+                                             (n.= expected_bar))))
+                           (_.cover [/.:transmutation]
+                                    (and (exec (|> expected_foo
+                                                   (/.:abstraction g!Foo)
+                                                   (: (g!Foo .Macro))
+                                                   (/.:transmutation g!Foo)
+                                                   (: (g!Foo .Lux)))
+                                           true)
+                                         (exec (|> (/.:abstraction expected_bar)
+                                                   (: (g!Bar .Macro))
+                                                   /.:transmutation
+                                                   (: (g!Bar .Lux)))
+                                           true)))
+                           (_.cover [/.^:representation]
+                                    (and (let [(/.^:representation g!Foo actual_foo)
+                                               (: (g!Foo .Module)
+                                                  (/.:abstraction g!Foo expected_foo))]
+                                           (text\= expected_foo actual_foo))
+                                         (let [(/.^:representation actual_bar)
+                                               (: (g!Bar .Module)
+                                                  (/.:abstraction expected_bar))]
+                                           (n.= expected_bar actual_bar))))
+                           (_.for [/.Frame]
+                                  ($_ _.and
+                                      (_.cover [/.current]
+                                               (text\= (template.text [g!Bar])
+                                                       (..current)))
+                                      (_.cover [/.specific]
+                                               (text\= (template.text [g!Foo])
+                                                       (..specific)))
+                                      (_.cover [/.no_active_frames]
+                                               (and no_current!
+                                                    no_specific!))
+                                      ))
+                           )))))))))