Outsourced the syntax for labelled type definitions to macros.

1 files changed, 18 insertions, 18 deletions

diff --git a/stdlib/source/test/lux/control/parser.lux b/stdlib/source/test/lux/control/parser.lux
index e37a2f355..fd29bd07b 100644
--- a/stdlib/source/test/lux/control/parser.lux
+++ b/stdlib/source/test/lux/control/parser.lux
@@ -90,7 +90,7 @@
   Test
   (do {! random.monad}
     [expected0 random.nat
-     variadic (\ ! map (|>> (n.max 1) (n.min 20)) random.nat)
+     variadic (\ ! each (|>> (n.max 1) (n.min 20)) random.nat)
      expected+ (random.list variadic random.nat)
      even0 (random.only n.even? random.nat)
      odd0 (random.only n.odd? random.nat)
@@ -106,16 +106,16 @@
                           (match #.None
                                  #1))))
         (_.cover [/.some]
-                 (and (|> (list\map code.nat expected+)
+                 (and (|> (list\each code.nat expected+)
                           (/.result (/.some <code>.nat))
                           (match actual
                                  (\ (list.equivalence n.equivalence) = expected+ actual)))
-                      (|> (list\map (|>> .int code.int) expected+)
+                      (|> (list\each (|>> .int code.int) expected+)
                           (/.result (/.some <code>.nat))
                           (match #.End
                                  #1))))
         (_.cover [/.many]
-                 (and (|> (list\map code.nat expected+)
+                 (and (|> (list\each code.nat expected+)
                           (/.result (/.many <code>.nat))
                           (match actual
                                  (\ (list.equivalence n.equivalence) = expected+ actual)))
@@ -123,7 +123,7 @@
                           (/.result (/.many <code>.nat))
                           (match (list actual)
                                  (n.= expected0 actual)))
-                      (|> (list\map (|>> .int code.int) expected+)
+                      (|> (list\each (|>> .int code.int) expected+)
                           (/.result (/.many <code>.nat))
                           fails?)))
         (_.cover [/.only]
@@ -180,72 +180,72 @@
 (def: combinators_1
   Test
   (do {! random.monad}
-    [variadic (\ ! map (|>> (n.max 1) (n.min 20)) random.nat)
-     times (\ ! map (n.% variadic) random.nat)
+    [variadic (\ ! each (|>> (n.max 1) (n.min 20)) random.nat)
+     times (\ ! each (n.% variadic) random.nat)
      expected random.nat
      wrong (|> random.nat (random.only (|>> (n.= expected) not)))
      expected+ (random.list variadic random.nat)
      separator (random.ascii 1)]
     ($_ _.and
         (_.cover [/.exactly]
-                 (and (|> (list\map code.nat expected+)
+                 (and (|> (list\each code.nat expected+)
                           (/.result (/.exactly times <code>.nat))
                           (match actual
                                  (\ (list.equivalence n.equivalence) =
                                     (list.first times expected+)
                                     actual)))
-                      (|> (list\map code.nat expected+)
+                      (|> (list\each code.nat expected+)
                           (/.result (/.exactly (++ variadic) <code>.nat))
                           fails?)))
         (_.cover [/.at_least]
-                 (and (|> (list\map code.nat expected+)
+                 (and (|> (list\each code.nat expected+)
                           (/.result (/.at_least times <code>.nat))
                           (match actual
                                  (\ (list.equivalence n.equivalence) =
                                     expected+
                                     actual)))
-                      (|> (list\map code.nat expected+)
+                      (|> (list\each code.nat expected+)
                           (/.result (/.at_least (++ variadic) <code>.nat))
                           fails?)))
         (_.cover [/.at_most]
-                 (and (|> (list\map code.nat expected+)
+                 (and (|> (list\each code.nat expected+)
                           (/.result (/.at_most times <code>.nat))
                           (match actual
                                  (\ (list.equivalence n.equivalence) =
                                     (list.first times expected+)
                                     actual)))
-                      (|> (list\map code.nat expected+)
+                      (|> (list\each code.nat expected+)
                           (/.result (/.at_most (++ variadic) <code>.nat))
                           (match actual
                                  (\ (list.equivalence n.equivalence) =
                                     expected+
                                     actual)))))
         (_.cover [/.between]
-                 (and (|> (list\map code.nat expected+)
+                 (and (|> (list\each code.nat expected+)
                           (/.result (/.between times (n.- times variadic) <code>.nat))
                           (match actual
                                  (\ (list.equivalence n.equivalence) =
                                     expected+
                                     actual)))
-                      (|> (list\map code.nat (list.first times expected+))
+                      (|> (list\each code.nat (list.first times expected+))
                           (/.result (/.between times (n.- times variadic) <code>.nat))
                           (match actual
                                  (\ (list.equivalence n.equivalence) =
                                     (list.first times expected+)
                                     actual)))))
         (_.cover [/.separated_by]
-                 (|> (list.interposed (code.text separator) (list\map code.nat expected+))
+                 (|> (list.interposed (code.text separator) (list\each code.nat expected+))
                      (/.result (/.separated_by (<code>.this! (code.text separator)) <code>.nat))
                      (match actual
                             (\ (list.equivalence n.equivalence) =
                                expected+
                                actual))))
         (_.cover [/.remaining]
-                 (|> (list\map code.nat expected+)
+                 (|> (list\each code.nat expected+)
                      (/.result /.remaining)
                      (match actual
                             (\ (list.equivalence code.equivalence) =
-                               (list\map code.nat expected+)
+                               (list\each code.nat expected+)
                                actual))))
         (_.cover [/.else]
                  (and (|> (/.result (/.else wrong (\ /.monad in expected)) (list))