Re-named List's tags: Nil => End && Cons => Item

21 files changed, 435 insertions, 417 deletions

diff --git a/stdlib/source/test/aedifex/command/build.lux b/stdlib/source/test/aedifex/command/build.lux
index 141573f6f..b38b61340 100644
--- a/stdlib/source/test/aedifex/command/build.lux
+++ b/stdlib/source/test/aedifex/command/build.lux
@@ -84,18 +84,18 @@
             (if error?
               (exception.except shell.no_more_output [])
               (case state
-                (#.Cons head tail)
+                (#.Item head tail)
                 (#try.Success [tail head])
                 
-                #.Nil
+                #.End
                 (exception.except shell.no_more_output []))))
           (def: (on_error state)
             (if error?
               (case state
-                (#.Cons head tail)
+                (#.Item head tail)
                 (#try.Success [tail head])
                 
-                #.Nil
+                #.End
                 (exception.except shell.no_more_output []))
               (exception.except shell.no_more_output [])))
           (def: (on_write input state)
diff --git a/stdlib/source/test/lux.lux b/stdlib/source/test/lux.lux
index de99ee775..bfdc93f30 100644
--- a/stdlib/source/test/lux.lux
+++ b/stdlib/source/test/lux.lux
@@ -972,6 +972,23 @@
                         (is? post (io.run (atom.read box)))))))
       ))
 
+(def: identity/constant
+  (All [a] (-> a a))
+  (function (_ value)
+    value))
+
+(def: (identity/function value)
+  (All [a] (-> a a))
+  value)
+
+(def: for_def:
+  Test
+  (do random.monad
+    [expected random.nat]
+    (_.cover [/.def:]
+             (and (is? expected (identity/constant expected))
+                  (is? expected (identity/function expected))))))
+
 (def: test
   Test
   (<| (_.covering /._)
@@ -995,6 +1012,7 @@
           ..for_value
           ..for_case
           ..for_control_flow
+          ..for_def:
           
           ..sub_tests
           )))
diff --git a/stdlib/source/test/lux/abstract/enum.lux b/stdlib/source/test/lux/abstract/enum.lux
index b5c39ad75..8e472db22 100644
--- a/stdlib/source/test/lux/abstract/enum.lux
+++ b/stdlib/source/test/lux/abstract/enum.lux
@@ -37,7 +37,7 @@
                                                   (/.range n.enum start end)
                                                   (list.reverse (/.range n.enum end start)))
                              every_element_is_a_successor? (case range
-                                                             (#.Cons head tail)
+                                                             (#.Item head tail)
                                                              (|> (list\fold (function (_ next [verdict prev])
                                                                               [(and verdict
                                                                                     (n.= next (\ n.enum succ prev)))
@@ -46,7 +46,7 @@
                                                                             tail)
                                                                  product.left)
                                                              
-                                                             #.Nil
+                                                             #.End
                                                              false)]
                          (and (n.= expected_size (list.size range))
                               expected_start?
diff --git a/stdlib/source/test/lux/abstract/equivalence.lux b/stdlib/source/test/lux/abstract/equivalence.lux
index 007382e60..10af6891d 100644
--- a/stdlib/source/test/lux/abstract/equivalence.lux
+++ b/stdlib/source/test/lux/abstract/equivalence.lux
@@ -45,10 +45,10 @@
                                                    (implementation
                                                     (def: (= left right)
                                                       (case [left right]
-                                                        [#.Nil #.Nil]
+                                                        [#.End #.End]
                                                         true
 
-                                                        [(#.Cons leftH lefT) (#.Cons rightH rightT)]
+                                                        [(#.Item leftH lefT) (#.Item rightH rightT)]
                                                         (and (n.= leftH rightH)
                                                              (\ equivalence = lefT rightT))
 
diff --git a/stdlib/source/test/lux/abstract/predicate.lux b/stdlib/source/test/lux/abstract/predicate.lux
index 0e902fb40..b821865de 100644
--- a/stdlib/source/test/lux/abstract/predicate.lux
+++ b/stdlib/source/test/lux/abstract/predicate.lux
@@ -80,10 +80,10 @@
                                       (/.rec (function (_ recur)
                                                (function (_ values)
                                                  (case values
-                                                   #.Nil
+                                                   #.End
                                                    false
 
-                                                   (#.Cons head tail)
+                                                   (#.Item head tail)
                                                    (or (even? head)
                                                        (recur tail)))))))]
                      (bit\= (list.any? even? samples)
diff --git a/stdlib/source/test/lux/control/concatenative.lux b/stdlib/source/test/lux/control/concatenative.lux
index 678a8aa99..fe7773eea 100644
--- a/stdlib/source/test/lux/control/concatenative.lux
+++ b/stdlib/source/test/lux/control/concatenative.lux
@@ -266,12 +266,12 @@
                            (/.push |inc|)
                            /.compose
                            /.call)))
-        (_.cover [/.curry]
+        (_.cover [/.partial]
                  (n.= (n.+ sample sample)
                       (||> (/.push sample)
                            (/.push sample)
                            (/.push (/.apply/2 n.+))
-                           /.curry
+                           /.partial
                            /.call)))
         (_.cover [/.when]
                  (n.= (if choice
diff --git a/stdlib/source/test/lux/control/concurrency/frp.lux b/stdlib/source/test/lux/control/concurrency/frp.lux
index 5c555ebfc..6d60c750f 100644
--- a/stdlib/source/test/lux/control/concurrency/frp.lux
+++ b/stdlib/source/test/lux/control/concurrency/frp.lux
@@ -51,15 +51,15 @@
   (case amount_of_polls
     0 (do async.monad
         [_ (async.future (\ sink close))]
-        (in #.Nil))
+        (in #.End))
     _ (do {! async.monad}
         [event channel]
         (case event
           #.None
-          (in #.Nil)
+          (in #.End)
 
           (#.Some [head tail])
-          (\ ! map (|>> (#.Cons head))
+          (\ ! map (|>> (#.Item head))
              (take_amount (dec amount_of_polls) [channel sink]))))))
 
 (def: #export test
diff --git a/stdlib/source/test/lux/control/continuation.lux b/stdlib/source/test/lux/control/continuation.lux
index 24944c49e..4103d1a1f 100644
--- a/stdlib/source/test/lux/control/continuation.lux
+++ b/stdlib/source/test/lux/control/continuation.lux
@@ -72,15 +72,15 @@
                                       (/.Cont (List Nat) (List Nat)))
                                   (function (visit xs)
                                     (case xs
-                                      #.Nil
-                                      (_\in #.Nil)
+                                      #.End
+                                      (_\in #.End)
 
-                                      (#.Cons x xs')
+                                      (#.Item x xs')
                                       (do {! /.monad}
                                         [output (/.shift (function (_ k)
                                                            (do !
                                                              [tail (k xs')]
-                                                             (in (#.Cons x tail)))))]
+                                                             (in (#.Item x tail)))))]
                                         (visit output)))))]
                      (list\= elems
                              (/.run (/.reset (visit elems))))))
diff --git a/stdlib/source/test/lux/control/parser.lux b/stdlib/source/test/lux/control/parser.lux
index 382d17063..b71ab1256 100644
--- a/stdlib/source/test/lux/control/parser.lux
+++ b/stdlib/source/test/lux/control/parser.lux
@@ -110,7 +110,7 @@
                                  (\ (list.equivalence n.equivalence) = expected+ actual)))
                       (|> (list\map (|>> .int code.int) expected+)
                           (/.run (/.some <code>.nat))
-                          (match #.Nil
+                          (match #.End
                                  #1))))
         (_.cover [/.many]
                  (and (|> (list\map code.nat expected+)
diff --git a/stdlib/source/test/lux/data/binary.lux b/stdlib/source/test/lux/data/binary.lux
index b8775be48..a9e977c0a 100644
--- a/stdlib/source/test/lux/data/binary.lux
+++ b/stdlib/source/test/lux/data/binary.lux
@@ -72,7 +72,7 @@
 (def: as_list
   (-> /.Binary (List Nat))
   (/.fold (function (_ head tail)
-            (#.Cons head tail))
+            (#.Item head tail))
           (list)))
 
 (def: #export test
@@ -138,10 +138,10 @@
                             (and (\ /.equivalence = sample (/.drop 0 sample))
                                  (\ /.equivalence = (/.create 0) (/.drop size sample))
                                  (case (list.reverse (..as_list sample))
-                                   #.Nil
+                                   #.End
                                    false
 
-                                   (#.Cons head tail)
+                                   (#.Item head tail)
                                    (n.= (list.fold n.+ 0 tail)
                                         (/.fold n.+ 0 (/.drop 1 sample))))))
                    (_.cover [/.copy]
diff --git a/stdlib/source/test/lux/data/collection/list.lux b/stdlib/source/test/lux/data/collection/list.lux
index 207ba73d9..2374b2f21 100644
--- a/stdlib/source/test/lux/data/collection/list.lux
+++ b/stdlib/source/test/lux/data/collection/list.lux
@@ -238,20 +238,20 @@
                     [($_ _.and
                          (_.cover [<head>]
                                   (case [(<pre> sample) (<head> sample)]
-                                    [(#.Cons expected _) (#.Some actual)]
+                                    [(#.Item expected _) (#.Some actual)]
                                     (n.= expected actual)
 
-                                    [#.Nil #.None]
+                                    [#.End #.None]
                                     true
 
                                     _
                                     false))
                          (_.cover [<tail>]
                                   (case [(<pre> sample) (<tail> sample)]
-                                    [(#.Cons _ expected) (#.Some actual)]
+                                    [(#.Item _ expected) (#.Some actual)]
                                     (/\= (<pre> expected) actual)
 
-                                    [#.Nil #.None]
+                                    [#.End #.None]
                                     true
 
                                     _
diff --git a/stdlib/source/test/lux/data/collection/queue.lux b/stdlib/source/test/lux/data/collection/queue.lux
index 3bc695aca..b394220ef 100644
--- a/stdlib/source/test/lux/data/collection/queue.lux
+++ b/stdlib/source/test/lux/data/collection/queue.lux
@@ -60,10 +60,10 @@
                             all_empty_queues_look_the_same!)))
             (_.cover [/.peek]
                      (case [members (/.peek sample)]
-                       [(#.Cons head tail) (#.Some first)]
+                       [(#.Item head tail) (#.Some first)]
                        (n.= head first)
                        
-                       [#.Nil #.None]
+                       [#.End #.None]
                        true
 
                        _
@@ -95,7 +95,7 @@
                             has_expected_order!)))
             (_.cover [/.pop]
                      (case members
-                       (#.Cons target expected)
+                       (#.Item target expected)
                        (let [popped (/.pop sample)
 
                              size_decreases!
@@ -113,7 +113,7 @@
                               popped_member_is_not_identified!
                               has_expected_order!))
                        
-                       #.Nil
+                       #.End
                        (and (/.empty? sample)
                             (/.empty? (/.pop sample)))))
             ))))
diff --git a/stdlib/source/test/lux/target/jvm.lux b/stdlib/source/test/lux/target/jvm.lux
index fbbcc2414..1f52753d1 100644
--- a/stdlib/source/test/lux/target/jvm.lux
+++ b/stdlib/source/test/lux/target/jvm.lux
@@ -1030,7 +1030,7 @@
                   (..bytecode (|>> (:as Nat) (n.= sizesH)))
                   (do {! /.monad}
                     [_ (monad.map ! (|>> (:as java/lang/Long) ffi.long_to_int ..$Integer::literal)
-                                  (#.Cons sizesH sizesT))
+                                  (#.Item sizesH sizesT))
                      _ (/.multianewarray type (|> dimensions /unsigned.u1 try.assumed))
                      _ ?length]
                     $Long::wrap))))
diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/case.lux b/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/case.lux
index 0c1d1a712..4afc28a2d 100644
--- a/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/case.lux
+++ b/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/case.lux
@@ -40,17 +40,17 @@
 (def: (exhaustive_weaving branchings)
   (-> (List (List Code)) (List (List Code)))
   (case branchings
-    #.Nil
-    #.Nil
+    #.End
+    #.End
 
-    (#.Cons head+ #.Nil)
+    (#.Item head+ #.End)
     (list\map (|>> list) head+)
 
-    (#.Cons head+ tail++)
+    (#.Item head+ tail++)
     (do list.monad
       [tail+ (exhaustive_weaving tail++)
        head head+]
-      (in (#.Cons head tail+)))))
+      (in (#.Item head tail+)))))
 
 (def: #export (exhaustive_branches allow_literals? variantTC inputC)
   (-> Bit (List [Code Code]) Code (Random (List Code)))
diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/function.lux b/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/function.lux
index b8a692f07..1cf61d839 100644
--- a/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/function.lux
+++ b/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/function.lux
@@ -101,7 +101,7 @@
            partial_polyT1 (<| (type.function partial_poly_inputsT)
                               poly_inputT)
            partial_polyT2 (<| (type.univ_q 1)
-                              (type.function (#.Cons varT partial_poly_inputsT))
+                              (type.function (#.Item varT partial_poly_inputsT))
                               varT)
            dummy_function (#////analysis.Function (list) (#////analysis.Reference (////reference.local 1)))]]
     (<| (_.context (%.name (name_of /.apply)))
diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/case.lux b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/case.lux
index 8eed2d440..e24fac097 100644
--- a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/case.lux
+++ b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/case.lux
@@ -39,7 +39,7 @@
         [meta
          ["." archive]]]]]]]])
 
-(def: masking-test
+(def: masking_test
   Test
   (do {! random.monad}
     [maskedA //primitive.primitive
@@ -49,14 +49,14 @@
                    [[(#analysis.Bind temp)
                      (#analysis.Reference (////reference.local temp))]
                     (list)]])]]
-    (_.cover [/.synthesize-masking]
+    (_.cover [/.synthesize_masking]
              (|> maskA
                  (//.phase archive.empty)
                  (phase.run [///bundle.empty synthesis.init])
                  (try\map (//primitive.corresponds? maskedA))
                  (try.default false)))))
 
-(def: let-test
+(def: let_test
   Test
   (do random.monad
     [registerA random.nat
@@ -67,7 +67,7 @@
                   [[(#analysis.Bind registerA)
                     outputA]
                    (list)]])]]
-    (_.cover [/.synthesize-let]
+    (_.cover [/.synthesize_let]
              (|> letA
                  (//.phase archive.empty)
                  (phase.run [///bundle.empty synthesis.init])
@@ -79,7 +79,7 @@
                         _
                         false)))))
 
-(def: if-test
+(def: if_test
   Test
   (do random.monad
     [then|else random.bit
@@ -95,7 +95,7 @@
            ifA (if then|else
                  (analysis.control/case [inputA [thenB (list elseB)]])
                  (analysis.control/case [inputA [elseB (list thenB)]]))]]
-    (_.cover [/.synthesize-if]
+    (_.cover [/.synthesize_if]
              (|> ifA
                  (//.phase archive.empty)
                  (phase.run [///bundle.empty synthesis.init])
@@ -107,7 +107,7 @@
                         _
                         false)))))
 
-(def: random-member
+(def: random_member
   (Random synthesis.Member)
   (do {! random.monad}
     [lefts (|> random.nat (\ ! map (n.% 10)))
@@ -116,13 +116,13 @@
           (#.Right lefts)
           (#.Left lefts)))))
 
-(def: random-path
+(def: random_path
   (Random (analysis.Tuple synthesis.Member))
   (do {! random.monad}
-    [size-1 (|> random.nat (\ ! map (|>> (n.% 10) inc)))]
-    (random.list size-1 ..random-member)))
+    [size_1 (|> random.nat (\ ! map (|>> (n.% 10) inc)))]
+    (random.list size_1 ..random_member)))
 
-(def: (get-pattern path)
+(def: (get_pattern path)
   (-> (analysis.Tuple synthesis.Member)
       (Random [analysis.Pattern Register]))
   (do random.monad
@@ -142,19 +142,19 @@
                     (list.reverse path))
          @member])))
 
-(def: get-test
+(def: get_test
   Test
   (do {! random.monad}
     [recordA (|> random.nat
                  (\ ! map (|>> analysis.nat))
                  (random.list 10)
                  (\ ! map (|>> analysis.tuple)))
-     pathA ..random-path
-     [pattern @member] (get-pattern pathA)
+     pathA ..random_path
+     [pattern @member] (get_pattern pathA)
      #let [getA (analysis.control/case [recordA [[pattern
                                                   (#analysis.Reference (////reference.local @member))]
                                                  (list)]])]]
-    (_.cover [/.synthesize-get]
+    (_.cover [/.synthesize_get]
              (|> getA
                  (//.phase archive.empty)
                  (phase.run [///bundle.empty synthesis.init])
@@ -165,7 +165,7 @@
                         _
                         false)))))
 
-(def: random-bit
+(def: random_bit
   (Random [Path Match])
   (do {! random.monad}
     [test random.bit
@@ -180,9 +180,9 @@
           (list {#analysis.when (analysis.pattern/bit (not test))
                  #analysis.then (analysis.nat else)})]])))
 
-(def: (random-five hash random-element)
+(def: (random_five hash random_element)
   (All [a] (-> (Hash a) (Random a) (Random [a a a a a])))
-  (|> random-element
+  (|> random_element
       (random.set hash 5)
       (\ random.monad map (|>> set.to_list
                                (case> (^ (list s0 s1 s2 s3 s4))
@@ -195,8 +195,8 @@
   [(def: <name>
      (Random [Path Match])
      (do {! random.monad}
-       [[test/0 test/1 test/2 test/3 test/4] (random-five <hash> <random>)
-        [body/0 body/1 body/2 body/3 body/4] (random-five <hash> <random>)]
+       [[test/0 test/1 test/2 test/3 test/4] (random_five <hash> <random>)
+        [body/0 body/1 body/2 body/3 body/4] (random_five <hash> <random>)]
        (in [($_ #synthesis.Alt
                 (#synthesis.Seq (<path> test/0) (#synthesis.Then (<synthesis> body/0)))
                 (#synthesis.Seq (<path> test/1) (#synthesis.Then (<synthesis> body/1)))
@@ -209,30 +209,30 @@
                    {#analysis.when (<pattern> test/3) #analysis.then (<analysis> body/3)}
                    {#analysis.when (<pattern> test/4) #analysis.then (<analysis> body/4)})]])))]
 
-  [random-nat n.hash random.nat (|>> .i64 synthesis.path/i64) (|>> .i64 synthesis.i64) analysis.pattern/nat analysis.nat]
-  [random-int int.hash random.int (|>> .i64 synthesis.path/i64) (|>> .i64 synthesis.i64) analysis.pattern/int analysis.int]
-  [random-rev rev.hash random.rev (|>> .i64 synthesis.path/i64) (|>> .i64 synthesis.i64) analysis.pattern/rev analysis.rev]
-  [random-frac frac.hash random.frac synthesis.path/f64 synthesis.f64 analysis.pattern/frac analysis.frac]
-  [random-text text.hash (random.unicode 1) synthesis.path/text synthesis.text analysis.pattern/text analysis.text]
+  [random_nat n.hash random.nat (|>> .i64 synthesis.path/i64) (|>> .i64 synthesis.i64) analysis.pattern/nat analysis.nat]
+  [random_int int.hash random.int (|>> .i64 synthesis.path/i64) (|>> .i64 synthesis.i64) analysis.pattern/int analysis.int]
+  [random_rev rev.hash random.rev (|>> .i64 synthesis.path/i64) (|>> .i64 synthesis.i64) analysis.pattern/rev analysis.rev]
+  [random_frac frac.hash random.frac synthesis.path/f64 synthesis.f64 analysis.pattern/frac analysis.frac]
+  [random_text text.hash (random.unicode 1) synthesis.path/text synthesis.text analysis.pattern/text analysis.text]
   )
 
-(def: random-simple
+(def: random_simple
   ($_ random.either
-      ..random-bit
-      ..random-nat
-      ..random-int
-      ..random-rev
-      ..random-frac
-      ..random-text
+      ..random_bit
+      ..random_nat
+      ..random_int
+      ..random_rev
+      ..random_frac
+      ..random_text
       ))
 
-(def: random-variant
+(def: random_variant
   (Random [Path Match])
   (do {! random.monad}
-    [[lefts/0 lefts/1 lefts/2 lefts/3 lefts/4] (random-five n.hash random.nat)
-     [value/0 value/1 value/2 value/3 value/4] (random-five text.hash (random.unicode 1))
-     last-is-right? random.bit
-     [body/0 body/1 body/2 body/3 body/4] (random-five frac.hash random.frac)
+    [[lefts/0 lefts/1 lefts/2 lefts/3 lefts/4] (random_five n.hash random.nat)
+     [value/0 value/1 value/2 value/3 value/4] (random_five text.hash (random.unicode 1))
+     last_is_right? random.bit
+     [body/0 body/1 body/2 body/3 body/4] (random_five frac.hash random.frac)
      #let [path (: (-> Nat Bit Text Frac Path)
                    (function (_ lefts right? value body)
                      ($_ #synthesis.Seq
@@ -252,24 +252,24 @@
              (path lefts/1 false value/1 body/1)
              (path lefts/2 false value/2 body/2)
              (path lefts/3 false value/3 body/3)
-             (path lefts/4 last-is-right? value/4 body/4))
+             (path lefts/4 last_is_right? value/4 body/4))
          [(branch lefts/0 false value/0 body/0)
           (list (branch lefts/1 false value/1 body/1)
                 (branch lefts/2 false value/2 body/2)
                 (branch lefts/3 false value/3 body/3)
-                (branch lefts/4 last-is-right? value/4 body/4))]])))
+                (branch lefts/4 last_is_right? value/4 body/4))]])))
 
-(def: random-tuple
+(def: random_tuple
   (Random [Path Match])
   (do {! random.monad}
-    [mid-size (\ ! map (n.% 4) random.nat)
+    [mid_size (\ ! map (n.% 4) random.nat)
 
      value/first (random.unicode 1)
-     value/mid (random.list mid-size (random.unicode 1))
+     value/mid (random.list mid_size (random.unicode 1))
      value/last (random.unicode 1)
 
      body/first random.frac
-     body/mid (random.list mid-size random.frac)
+     body/mid (random.list mid_size random.frac)
      body/last random.frac
      #let [path (: (-> Nat Bit Text Frac Path)
                    (function (_ lefts right? value body)
@@ -299,9 +299,9 @@
                         #analysis.then (analysis.frac body)}))]]
     (in [(list\fold (function (_ left right)
                       (#synthesis.Alt left right))
-                    (path (inc mid-size) true value/last body/last)
+                    (path (inc mid_size) true value/last body/last)
                     (|> (list.zipped/2 value/mid body/mid)
-                        (#.Cons [value/first body/first])
+                        (#.Item [value/first body/first])
                         list.enumeration
                         (list\map (function (_ [lefts' [value body]])
                                     (path lefts' false value body)))
@@ -311,31 +311,31 @@
                             list.enumeration
                             (list\map (function (_ [lefts' [value body]])
                                         (branch (inc lefts') false value body))))
-                        (list (branch (inc mid-size) true value/last body/last)))]])))
+                        (list (branch (inc mid_size) true value/last body/last)))]])))
 
-(def: random-complex
+(def: random_complex
   ($_ random.either
-      ..random-variant
-      ..random-tuple
+      ..random_variant
+      ..random_tuple
       ))
 
-(def: random-case
+(def: random_case
   ($_ random.either
-      ..random-simple
-      ..random-complex
+      ..random_simple
+      ..random_complex
       ))
 
-(def: case-test
+(def: case_test
   Test
   (do {! random.monad}
-    [expected-input (\ ! map (|>> .i64 synthesis.i64) random.nat)
-     [expected-path match] ..random-case]
-    (_.cover [/.synthesize-case]
-             (|> (/.synthesize-case //.phase archive.empty expected-input match)
+    [expected_input (\ ! map (|>> .i64 synthesis.i64) random.nat)
+     [expected_path match] ..random_case]
+    (_.cover [/.synthesize_case]
+             (|> (/.synthesize_case //.phase archive.empty expected_input match)
                  (phase.run [///bundle.empty synthesis.init])
-                 (case> (^ (#try.Success (synthesis.branch/case [actual-input actual-path])))
-                        (and (\ synthesis.equivalence = expected-input actual-input)
-                             (\ synthesis.path-equivalence = expected-path actual-path))
+                 (case> (^ (#try.Success (synthesis.branch/case [actual_input actual_path])))
+                        (and (\ synthesis.equivalence = expected_input actual_input)
+                             (\ synthesis.path_equivalence = expected_path actual_path))
 
                         _
                         false)))))
@@ -345,9 +345,9 @@
   (<| (_.covering /._)
       (_.for [/.synthesize])
       ($_ _.and
-          ..masking-test
-          ..let-test
-          ..if-test
-          ..get-test
-          ..case-test
+          ..masking_test
+          ..let_test
+          ..if_test
+          ..get_test
+          ..case_test
           )))
diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/function.lux b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/function.lux
index 63d9d9d20..4b9b9a9f3 100644
--- a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/function.lux
+++ b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/function.lux
@@ -37,7 +37,7 @@
         [meta
          ["." archive]]]]]]]])
 
-(def: (n-function loop? arity body)
+(def: (n_function loop? arity body)
   (-> Bit Arity Synthesis Synthesis)
   (synthesis.function/abstraction
    {#synthesis.environment (list)
@@ -49,14 +49,14 @@
                         #synthesis.iteration body})
                       body)}))
 
-(def: (n-abstraction arity body)
+(def: (n_abstraction arity body)
   (-> Arity Analysis Analysis)
-  (list\fold (function (_ arity-1 body)
-               (case arity-1
+  (list\fold (function (_ arity_1 body)
+               (case arity_1
                  0 (#analysis.Function (list) body)
                  _ (#analysis.Function ($_ list\compose
                                            (list\map (|>> #variable.Foreign)
-                                                     (list.indices arity-1))
+                                                     (list.indices arity_1))
                                            (list (#variable.Local 1)))
                                        body)))
              body
@@ -78,7 +78,7 @@
 (type: Scenario
   (-> Bit (Random Circumstance)))
 
-(def: (random-unit output?)
+(def: (random_unit output?)
   Scenario
   (\ random.monad in
      [true
@@ -94,57 +94,57 @@
             (<synthesis> value)
             (<analysis> value)])))]
 
-  [random-bit random.bit synthesis.bit analysis.bit]
-  [random-nat random.nat (|>> .i64 synthesis.i64) analysis.nat]
-  [random-int random.int (|>> .i64 synthesis.i64) analysis.int]
-  [random-rev random.rev (|>> .i64 synthesis.i64) analysis.rev]
-  [random-frac random.frac synthesis.f64 analysis.frac]
-  [random-text (random.unicode 1) synthesis.text analysis.text]
+  [random_bit random.bit synthesis.bit analysis.bit]
+  [random_nat random.nat (|>> .i64 synthesis.i64) analysis.nat]
+  [random_int random.int (|>> .i64 synthesis.i64) analysis.int]
+  [random_rev random.rev (|>> .i64 synthesis.i64) analysis.rev]
+  [random_frac random.frac synthesis.f64 analysis.frac]
+  [random_text (random.unicode 1) synthesis.text analysis.text]
   )
 
-(def: (random-primitive output?)
+(def: (random_primitive output?)
   Scenario
-  (random.either (random.either (..random-unit output?)
-                                (random.either (..random-bit output?)
-                                               (..random-nat output?)))
-                 (random.either (random.either (..random-int output?)
-                                               (..random-rev output?))
-                                (random.either (..random-frac output?)
-                                               (..random-text output?)))))
-
-(def: (random-variant random-value output?)
+  (random.either (random.either (..random_unit output?)
+                                (random.either (..random_bit output?)
+                                               (..random_nat output?)))
+                 (random.either (random.either (..random_int output?)
+                                               (..random_rev output?))
+                                (random.either (..random_frac output?)
+                                               (..random_text output?)))))
+
+(def: (random_variant random_value output?)
   (-> Scenario Scenario)
   (do {! random.monad}
     [lefts random.nat
      right? random.bit
-     [loop? expected-value actual-value] (random-value false)]
+     [loop? expected_value actual_value] (random_value false)]
     (in [loop?
          (synthesis.variant
           {#analysis.lefts lefts
            #analysis.right? right?
-           #analysis.value expected-value})
+           #analysis.value expected_value})
          (analysis.variant
           {#analysis.lefts lefts
            #analysis.right? right?
-           #analysis.value actual-value})])))
+           #analysis.value actual_value})])))
 
-(def: (random-tuple random-value output?)
+(def: (random_tuple random_value output?)
   (-> Scenario Scenario)
   (do {! random.monad}
-    [[loop?-left expected-left actual-left] (random-value false)
-     [loop?-right expected-right actual-right] (random-value false)]
-    (in [(and loop?-left
-              loop?-right)
-         (synthesis.tuple (list expected-left expected-right))
-         (analysis.tuple (list actual-left actual-right))])))
-
-(def: (random-structure random-value output?)
+    [[loop?_left expected_left actual_left] (random_value false)
+     [loop?_right expected_right actual_right] (random_value false)]
+    (in [(and loop?_left
+              loop?_right)
+         (synthesis.tuple (list expected_left expected_right))
+         (analysis.tuple (list actual_left actual_right))])))
+
+(def: (random_structure random_value output?)
   (-> Scenario Scenario)
   ($_ random.either
-      (..random-variant random-value output?)
-      (..random-tuple random-value output?)))
+      (..random_variant random_value output?)
+      (..random_tuple random_value output?)))
 
-(def: (random-variable arity output?)
+(def: (random_variable arity output?)
   (-> Arity Scenario)
   (do {! random.monad}
     [register (\ ! map (|>> (n.% arity) inc) random.nat)]
@@ -154,7 +154,7 @@
            (#analysis.Reference (reference.local 1))
            (#analysis.Reference (reference.foreign register)))])))
 
-(def: (random-constant output?)
+(def: (random_constant output?)
   Scenario
   (do {! random.monad}
     [module (random.unicode 1)
@@ -163,131 +163,131 @@
          (synthesis.constant [module short])
          (#analysis.Reference (reference.constant [module short]))])))
 
-(def: (random-reference arity output?)
+(def: (random_reference arity output?)
   (-> Arity Scenario)
-  (random.either (..random-variable arity output?)
-                 (..random-constant output?)))
+  (random.either (..random_variable arity output?)
+                 (..random_constant output?)))
 
-(def: (random-case arity random-value output?)
+(def: (random_case arity random_value output?)
   (-> Arity Scenario Scenario)
   (do {! random.monad}
-    [bit-test random.bit
-     i64-test random.nat
-     f64-test random.frac
-     text-test (random.unicode 1)
-     [loop?-input expected-input actual-input] (random-value false)
-     [loop?-output expected-output actual-output] (random-value output?)
+    [bit_test random.bit
+     i64_test random.nat
+     f64_test random.frac
+     text_test (random.unicode 1)
+     [loop?_input expected_input actual_input] (random_value false)
+     [loop?_output expected_output actual_output] (random_value output?)
      lefts (|> random.nat (\ ! map (n.% 10)))
      right? random.bit
      #let [side|member (if right?
                          (#.Right lefts)
                          (#.Left lefts))]]
-    (in [(and loop?-input
-              loop?-output)
-         (synthesis.branch/case [expected-input
+    (in [(and loop?_input
+              loop?_output)
+         (synthesis.branch/case [expected_input
                                  ($_ synthesis.path/alt
-                                     (synthesis.path/then expected-output)
-                                     (synthesis.path/seq (synthesis.path/bit bit-test)
-                                                         (synthesis.path/then expected-output))
-                                     (synthesis.path/seq (synthesis.path/i64 (.i64 i64-test))
-                                                         (synthesis.path/then expected-output))
-                                     (synthesis.path/seq (synthesis.path/f64 f64-test)
-                                                         (synthesis.path/then expected-output))
-                                     (synthesis.path/seq (synthesis.path/text text-test)
-                                                         (synthesis.path/then expected-output))
+                                     (synthesis.path/then expected_output)
+                                     (synthesis.path/seq (synthesis.path/bit bit_test)
+                                                         (synthesis.path/then expected_output))
+                                     (synthesis.path/seq (synthesis.path/i64 (.i64 i64_test))
+                                                         (synthesis.path/then expected_output))
+                                     (synthesis.path/seq (synthesis.path/f64 f64_test)
+                                                         (synthesis.path/then expected_output))
+                                     (synthesis.path/seq (synthesis.path/text text_test)
+                                                         (synthesis.path/then expected_output))
                                      (synthesis.path/seq (synthesis.path/bind (inc arity))
-                                                         (synthesis.path/then expected-output))
+                                                         (synthesis.path/then expected_output))
                                      ($_ synthesis.path/seq
                                          (synthesis.path/side side|member)
                                          (synthesis.path/bind (inc arity))
-                                         (synthesis.path/then expected-output))
+                                         (synthesis.path/then expected_output))
                                      (if right?
                                        ($_ synthesis.path/seq
                                            (synthesis.path/member side|member)
                                            (synthesis.path/bind (inc arity))
-                                           (synthesis.path/then expected-output)) 
+                                           (synthesis.path/then expected_output)) 
                                        ($_ synthesis.path/seq
                                            (synthesis.path/member side|member)
                                            (synthesis.path/bind (inc arity))
                                            synthesis.path/pop
-                                           (synthesis.path/then expected-output))))])
-         (#analysis.Case actual-input
+                                           (synthesis.path/then expected_output))))])
+         (#analysis.Case actual_input
                          [{#analysis.when (analysis.pattern/unit)
-                           #analysis.then actual-output}
-                          (list {#analysis.when (analysis.pattern/bit bit-test)
-                                 #analysis.then actual-output}
-                                {#analysis.when (analysis.pattern/nat (.nat i64-test))
-                                 #analysis.then actual-output}
-                                {#analysis.when (analysis.pattern/frac f64-test)
-                                 #analysis.then actual-output}
-                                {#analysis.when (analysis.pattern/text text-test)
-                                 #analysis.then actual-output}
+                           #analysis.then actual_output}
+                          (list {#analysis.when (analysis.pattern/bit bit_test)
+                                 #analysis.then actual_output}
+                                {#analysis.when (analysis.pattern/nat (.nat i64_test))
+                                 #analysis.then actual_output}
+                                {#analysis.when (analysis.pattern/frac f64_test)
+                                 #analysis.then actual_output}
+                                {#analysis.when (analysis.pattern/text text_test)
+                                 #analysis.then actual_output}
                                 {#analysis.when (#analysis.Bind 2)
-                                 #analysis.then actual-output}
+                                 #analysis.then actual_output}
                                 {#analysis.when (analysis.pattern/variant
                                                  {#analysis.lefts lefts
                                                   #analysis.right? right?
                                                   #analysis.value (#analysis.Bind 2)})
-                                 #analysis.then actual-output}
+                                 #analysis.then actual_output}
                                 {#analysis.when (analysis.pattern/tuple
                                                  (list\compose (list.repeat lefts (analysis.pattern/unit))
                                                                (if right?
                                                                  (list (analysis.pattern/unit) (#analysis.Bind 2))
                                                                  (list (#analysis.Bind 2) (analysis.pattern/unit)))))
-                                 #analysis.then actual-output})])])))
+                                 #analysis.then actual_output})])])))
 
-(def: (random-let arity random-value output?)
+(def: (random_let arity random_value output?)
   (-> Arity Scenario Scenario)
   (do {! random.monad}
-    [[loop?-input expected-input actual-input] (random-value false)
-     [loop?-output expected-output actual-output] (random-value output?)]
-    (in [(and loop?-input
-              loop?-output)
-         (synthesis.branch/let [expected-input
+    [[loop?_input expected_input actual_input] (random_value false)
+     [loop?_output expected_output actual_output] (random_value output?)]
+    (in [(and loop?_input
+              loop?_output)
+         (synthesis.branch/let [expected_input
                                 (inc arity)
-                                expected-output])
-         (#analysis.Case actual-input
+                                expected_output])
+         (#analysis.Case actual_input
                          [{#analysis.when (#analysis.Bind 2)
-                           #analysis.then actual-output}
+                           #analysis.then actual_output}
                           (list)])])))
 
-(def: (random-if random-value output?)
+(def: (random_if random_value output?)
   (-> Scenario Scenario)
   (do {! random.monad}
-    [[loop?-test expected-test actual-test] (random-value false)
-     [loop?-then expected-then actual-then] (random-value output?)
-     [loop?-else expected-else actual-else] (random-value output?)
+    [[loop?_test expected_test actual_test] (random_value false)
+     [loop?_then expected_then actual_then] (random_value output?)
+     [loop?_else expected_else actual_else] (random_value output?)
      flip? random.bit]
-    (in [(and loop?-test
-              loop?-then
-              loop?-else)
-         (synthesis.branch/if [expected-test
-                               expected-then
-                               expected-else])
+    (in [(and loop?_test
+              loop?_then
+              loop?_else)
+         (synthesis.branch/if [expected_test
+                               expected_then
+                               expected_else])
          (if flip?
-           (#analysis.Case actual-test
+           (#analysis.Case actual_test
                            [{#analysis.when (analysis.pattern/bit false)
-                             #analysis.then actual-else}
+                             #analysis.then actual_else}
                             (list {#analysis.when (analysis.pattern/bit true)
-                                   #analysis.then actual-then})])
-           (#analysis.Case actual-test
+                                   #analysis.then actual_then})])
+           (#analysis.Case actual_test
                            [{#analysis.when (analysis.pattern/bit true)
-                             #analysis.then actual-then}
+                             #analysis.then actual_then}
                             (list {#analysis.when (analysis.pattern/bit false)
-                                   #analysis.then actual-else})]))])))
+                                   #analysis.then actual_else})]))])))
 
-(def: (random-get random-value output?)
+(def: (random_get random_value output?)
   (-> Scenario Scenario)
   (do {! random.monad}
     [lefts (|> random.nat (\ ! map (n.% 10)))
      right? random.bit
-     [loop?-record expected-record actual-record] (random-value false)]
-    (in [loop?-record
+     [loop?_record expected_record actual_record] (random_value false)]
+    (in [loop?_record
          (synthesis.branch/get [(list (if right?
                                         (#.Right lefts)
                                         (#.Left lefts)))
-                                expected-record])
-         (#analysis.Case actual-record
+                                expected_record])
+         (#analysis.Case actual_record
                          [{#analysis.when (analysis.pattern/tuple
                                            (list\compose (list.repeat lefts (analysis.pattern/unit))
                                                          (if right?
@@ -296,17 +296,17 @@
                            #analysis.then (#analysis.Reference (reference.local 2))}
                           (list)])])))
 
-(def: (random-branch arity random-value output?)
+(def: (random_branch arity random_value output?)
   (-> Arity Scenario Scenario)
-  (random.either (random.either (..random-case arity random-value output?)
-                                (..random-let arity random-value output?))
-                 (random.either (..random-if random-value output?)
-                                (..random-get random-value output?))))
+  (random.either (random.either (..random_case arity random_value output?)
+                                (..random_let arity random_value output?))
+                 (random.either (..random_if random_value output?)
+                                (..random_get random_value output?))))
 
-(def: (random-recur arity random-value output?)
+(def: (random_recur arity random_value output?)
   (-> Arity Scenario Scenario)
   (do {! random.monad}
-    [resets (random.list arity (random-value false))]
+    [resets (random.list arity (random_value false))]
     (in [true
          (synthesis.loop/recur (list\map (|>> product.right product.left) resets))
          (analysis.apply [(#analysis.Reference (case arity
@@ -314,11 +314,11 @@
                                                  _ (reference.foreign 0)))
                           (list\map (|>> product.right product.right) resets)])])))
 
-(def: (random-scope arity output?)
+(def: (random_scope arity output?)
   (-> Arity Scenario)
   (do {! random.monad}
-    [resets (random.list arity (..random-variable arity output?))
-     [_ expected-output actual-output] (..random-nat output?)]
+    [resets (random.list arity (..random_variable arity output?))
+     [_ expected_output actual_output] (..random_nat output?)]
     (in [(list\fold (function (_ new old)
                       (and new old))
                     true
@@ -326,23 +326,23 @@
          (synthesis.loop/scope
           {#synthesis.start (inc arity)
            #synthesis.inits (list\map (|>> product.right product.left) resets)
-           #synthesis.iteration expected-output})
-         (analysis.apply [(..n-abstraction arity actual-output)
+           #synthesis.iteration expected_output})
+         (analysis.apply [(..n_abstraction arity actual_output)
                           (list\map (|>> product.right product.right) resets)])])))
 
-(def: (random-loop arity random-value output?)
+(def: (random_loop arity random_value output?)
   (-> Arity Scenario Scenario)
   (if output?
     ($_ random.either
-        (..random-recur arity random-value output?)
-        (..random-scope arity output?)
+        (..random_recur arity random_value output?)
+        (..random_scope arity output?)
         )
-    (..random-scope arity output?)))
+    (..random_scope arity output?)))
 
-(def: (random-abstraction' output?)
+(def: (random_abstraction' output?)
   Scenario
   (do {! random.monad}
-    [[loop?-output expected-output actual-output] (..random-nat output?)
+    [[loop?_output expected_output actual_output] (..random_nat output?)
      arity (|> random.nat (\ ! map (|>> (n.% 5) inc)))
      #let [environment ($_ list\compose
                            (list\map (|>> #variable.Foreign)
@@ -355,79 +355,79 @@
            #synthesis.body (synthesis.loop/scope
                             {#synthesis.start 1
                              #synthesis.inits (list)
-                             #synthesis.iteration expected-output})})
+                             #synthesis.iteration expected_output})})
          (#analysis.Function environment
-                             actual-output)])))
+                             actual_output)])))
 
-(def: (random-apply random-value output?)
+(def: (random_apply random_value output?)
   (-> Scenario Scenario)
   (do {! random.monad}
-    [[loop?-abstraction expected-abstraction actual-abstraction] (..random-nat output?)
+    [[loop?_abstraction expected_abstraction actual_abstraction] (..random_nat output?)
      arity (|> random.nat (\ ! map (|>> (n.% 5) inc)))
-     inputs (random.list arity (random-value false))]
+     inputs (random.list arity (random_value false))]
     (in [(list\fold (function (_ new old)
                       (and new old))
-                    loop?-abstraction
+                    loop?_abstraction
                     (list\map product.left inputs))
-         (synthesis.function/apply [expected-abstraction
+         (synthesis.function/apply [expected_abstraction
                                     (list\map (|>> product.right product.left) inputs)])
-         (analysis.apply [actual-abstraction
+         (analysis.apply [actual_abstraction
                           (list\map (|>> product.right product.right) inputs)])])))
 
-(def: (random-function random-value output?)
+(def: (random_function random_value output?)
   (-> Scenario Scenario)
   (if output?
-    (..random-apply random-value output?)
+    (..random_apply random_value output?)
     ($_ random.either
-        (..random-abstraction' output?)
-        (..random-apply random-value output?)
+        (..random_abstraction' output?)
+        (..random_apply random_value output?)
         )))
 
-(def: (random-control arity random-value output?)
+(def: (random_control arity random_value output?)
   (-> Arity Scenario Scenario)
   ($_ random.either
-      (..random-branch arity random-value output?)
-      (..random-loop arity random-value output?)
-      (..random-function random-value output?)
+      (..random_branch arity random_value output?)
+      (..random_loop arity random_value output?)
+      (..random_function random_value output?)
       ))
 
-(def: (random-extension random-value output?)
+(def: (random_extension random_value output?)
   (-> Scenario Scenario)
   (do {! random.monad}
     [name (random.unicode 1)
-     [loop?-first expected-first actual-first] (random-value false)
-     [loop?-second expected-second actual-second] (random-value false)
-     [loop?-third expected-third actual-third] (random-value false)]
-    (in [(and loop?-first
-              loop?-second
-              loop?-third)
-         (#synthesis.Extension name (list expected-first expected-second expected-third))
-         (#analysis.Extension name (list actual-first actual-second actual-third))])))
-
-(def: (random-body arity)
+     [loop?_first expected_first actual_first] (random_value false)
+     [loop?_second expected_second actual_second] (random_value false)
+     [loop?_third expected_third actual_third] (random_value false)]
+    (in [(and loop?_first
+              loop?_second
+              loop?_third)
+         (#synthesis.Extension name (list expected_first expected_second expected_third))
+         (#analysis.Extension name (list actual_first actual_second actual_third))])))
+
+(def: (random_body arity)
   (-> Arity Scenario)
-  (function (random-value output?)
+  (function (random_value output?)
     (random.rec
      (function (_ _)
        ($_ random.either
-           (..random-primitive output?)
-           (..random-structure random-value output?)
-           (..random-reference arity output?)
-           (..random-control arity random-value output?)
-           (..random-extension random-value output?))))))
+           (..random_primitive output?)
+           (..random_structure random_value output?)
+           (..random_reference arity output?)
+           (..random_control arity random_value output?)
+           (..random_extension random_value output?))))))
 
-(def: random-abstraction
+(def: random_abstraction
   (Random [Synthesis Analysis])
   (do {! random.monad}
     [arity (|> random.nat (\ ! map (|>> (n.% 5) inc)))
-     [loop? expected-body actual-body] (random-body arity true)]
-    (in [(..n-function loop? arity expected-body)
-         (..n-abstraction arity actual-body)])))
+     [loop? expected_body actual_body] (random_body arity true)]
+    (in [(..n_function loop? arity expected_body)
+         (..n_abstraction arity actual_body)])))
 
 (def: abstraction
   Test
   (do random.monad
-    [[expected input] ..random-abstraction]
+    [[expected input] ..random_abstraction]
     (_.cover [/.abstraction]
              (|> input
                  (//.phase archive.empty)
diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/primitive.lux b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/primitive.lux
index e46960793..e4ccec535 100644
--- a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/primitive.lux
+++ b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/primitive.lux
@@ -44,11 +44,11 @@
 (def: #export (corresponds? analysis synthesis)
   (-> Analysis Synthesis Bit)
   (`` (case [analysis synthesis]
-        (~~ (template [<analysis> <post-analysis> <synthesis> <post-synthesis>]
+        (~~ (template [<analysis> <post_analysis> <synthesis> <post_synthesis>]
               [[(#////analysis.Primitive (<analysis> expected))
                 (#////synthesis.Primitive (<synthesis> actual))]
-               (is? (|> expected <post-analysis>)
-                    (|> actual <post-synthesis>))]
+               (is? (|> expected <post_analysis>)
+                    (|> actual <post_synthesis>))]
 
               [#////analysis.Unit (:as Text) #////synthesis.Text (|>)]
               [#////analysis.Bit  (|>) #////synthesis.Bit (|>)]
@@ -72,12 +72,12 @@
 
 (def: #export test
   Test
-  (<| (_.context (%.name (name-of #////synthesis.Primitive)))
+  (<| (_.context (%.name (name_of #////synthesis.Primitive)))
       (`` ($_ _.and
               (~~ (template [<analysis> <synthesis> <generator>]
                     [(do r.monad
                        [expected <generator>]
-                       (_.test (%.name (name-of <synthesis>))
+                       (_.test (%.name (name_of <synthesis>))
                                (|> (#////analysis.Primitive (<analysis> expected))
                                    (//.phase archive.empty)
                                    (phase.run [///bundle.empty ////synthesis.init])
diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/structure.lux b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/structure.lux
index af665dd7a..36d59cfd9 100644
--- a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/structure.lux
+++ b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/structure.lux
@@ -74,7 +74,7 @@
 
 (def: #export test
   Test
-  (<| (_.context (%.name (name-of #////synthesis.Structure)))
+  (<| (_.context (%.name (name_of #////synthesis.Structure)))
       ($_ _.and
           ..variant
           ..tuple
diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/variable.lux b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/variable.lux
index 8fa9ad158..e9f9268ac 100644
--- a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/variable.lux
+++ b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/variable.lux
@@ -49,42 +49,42 @@
        (in [(<synthesis> value)
             (<synthesis> value)])))]
 
-  [bit-scenario synthesis.bit random.bit]
-  [i64-scenario synthesis.i64 (\ ! map .i64 random.nat)]
-  [f64-scenario synthesis.f64 random.frac]
-  [text-scenario synthesis.text (random.unicode 1)]
+  [bit_scenario synthesis.bit random.bit]
+  [i64_scenario synthesis.i64 (\ ! map .i64 random.nat)]
+  [f64_scenario synthesis.f64 random.frac]
+  [text_scenario synthesis.text (random.unicode 1)]
   )
 
-(def: (primitive-scenario context)
+(def: (primitive_scenario context)
   (Scenario Synthesis)
-  (random.either (random.either (..bit-scenario context)
-                                (..i64-scenario context))
-                 (random.either (..f64-scenario context)
-                                (..text-scenario context))))
+  (random.either (random.either (..bit_scenario context)
+                                (..i64_scenario context))
+                 (random.either (..f64_scenario context)
+                                (..text_scenario context))))
 
-(def: (with-redundancy scenario context)
+(def: (with_redundancy scenario context)
   (-> (Scenario Synthesis) (Scenario Synthesis))
   (do {! random.monad}
     [redundant? random.bit]
     (if redundant?
       (do !
         [let? random.bit
-         [expected-input actual-input] (..primitive-scenario context)
-         #let [fake-register (n.+ (get@ #redundants context)
+         [expected_input actual_input] (..primitive_scenario context)
+         #let [fake_register (n.+ (get@ #redundants context)
                                   (dictionary.size (get@ #necessary context)))]
-         [expected-output actual-output] (scenario (update@ #redundants inc context))]
-        (in [(synthesis.branch/case [expected-input
+         [expected_output actual_output] (scenario (update@ #redundants inc context))]
+        (in [(synthesis.branch/case [expected_input
                                      (#synthesis.Seq #synthesis.Pop
-                                                     (#synthesis.Then expected-output))])
+                                                     (#synthesis.Then expected_output))])
              (if let?
-               (synthesis.branch/let [actual-input fake-register actual-output])
-               (synthesis.branch/case [actual-input
-                                       (#synthesis.Seq (#synthesis.Bind fake-register)
+               (synthesis.branch/let [actual_input fake_register actual_output])
+               (synthesis.branch/case [actual_input
+                                       (#synthesis.Seq (#synthesis.Bind fake_register)
                                                        (#synthesis.Seq #synthesis.Pop
-                                                                       (#synthesis.Then actual-output)))]))]))
+                                                                       (#synthesis.Then actual_output)))]))]))
       (scenario context))))
 
-(def: (variant-scenario scenario context)
+(def: (variant_scenario scenario context)
   (-> (Scenario Synthesis) (Scenario Synthesis))
   (do {! random.monad}
     [lefts random.nat
@@ -93,45 +93,45 @@
     (in [(synthesis.variant [lefts right? expected])
          (synthesis.variant [lefts right? input])])))
 
-(def: (tuple-scenario context)
+(def: (tuple_scenario context)
   (Scenario Synthesis)
   (let [registers (dictionary.entries (get@ #necessary context))]
     (\ random.monad in
        [(synthesis.tuple (list\map (|>> product.left synthesis.variable/local) registers))
         (synthesis.tuple (list\map (|>> product.right synthesis.variable/local) registers))])))
 
-(def: (structure-scenario context)
+(def: (structure_scenario context)
   (Scenario Synthesis)
-  (random.either (..variant-scenario (..with-redundancy ..tuple-scenario) context)
-                 (..tuple-scenario context)))
+  (random.either (..variant_scenario (..with_redundancy ..tuple_scenario) context)
+                 (..tuple_scenario context)))
 
-(def: (let-scenario scenario context)
+(def: (let_scenario scenario context)
   (-> (Scenario Synthesis) (Scenario Synthesis))
   (do random.monad
     [_ (in [])
-     [expected-input actual-input] (scenario context)
-     #let [real-register (dictionary.size (get@ #necessary context))
-           fake-register (n.+ (get@ #redundants context)
+     [expected_input actual_input] (scenario context)
+     #let [real_register (dictionary.size (get@ #necessary context))
+           fake_register (n.+ (get@ #redundants context)
                               (dictionary.size (get@ #necessary context)))]
-     [expected-output actual-output] (scenario (update@ #necessary (dictionary.put real-register fake-register) context))]
-    (in [(synthesis.branch/let [expected-input real-register expected-output])
-         (synthesis.branch/let [actual-input fake-register actual-output])])))
+     [expected_output actual_output] (scenario (update@ #necessary (dictionary.put real_register fake_register) context))]
+    (in [(synthesis.branch/let [expected_input real_register expected_output])
+         (synthesis.branch/let [actual_input fake_register actual_output])])))
 
-(def: (if-scenario scenario context)
+(def: (if_scenario scenario context)
   (-> (Scenario Synthesis) (Scenario Synthesis))
   (do random.monad
     [_ (in [])
-     [expected-test actual-test] (scenario context)
-     [expected-then actual-then] (scenario context)
-     [expected-else actual-else] (scenario context)]
-    (in [(synthesis.branch/if [expected-test
-                               expected-then
-                               expected-else])
-         (synthesis.branch/if [actual-test
-                               actual-then
-                               actual-else])])))
+     [expected_test actual_test] (scenario context)
+     [expected_then actual_then] (scenario context)
+     [expected_else actual_else] (scenario context)]
+    (in [(synthesis.branch/if [expected_test
+                               expected_then
+                               expected_else])
+         (synthesis.branch/if [actual_test
+                               actual_then
+                               actual_else])])))
 
-(def: random-member
+(def: random_member
   (Random Member)
   (do random.monad
     [lefts random.nat
@@ -140,51 +140,51 @@
           (#.Right lefts)
           (#.Left lefts)))))
 
-(def: (get-scenario scenario context)
+(def: (get_scenario scenario context)
   (-> (Scenario Synthesis) (Scenario Synthesis))
   (do {! random.monad}
     [length (\ ! map (|>> (n.% 5) inc) random.nat)
-     path (random.list length ..random-member)
-     [expected-record actual-record] (scenario context)]
-    (in [(synthesis.branch/get [path expected-record])
-         (synthesis.branch/get [path actual-record])])))
+     path (random.list length ..random_member)
+     [expected_record actual_record] (scenario context)]
+    (in [(synthesis.branch/get [path expected_record])
+         (synthesis.branch/get [path actual_record])])))
 
-(def: random-side
+(def: random_side
   (Random Side)
-  ..random-member)
+  ..random_member)
 
-(def: (path-scenario scenario context)
+(def: (path_scenario scenario context)
   (-> (Scenario Synthesis) (Scenario Path))
   (`` ($_ random.either
           ($_ random.either
               (do {! random.monad}
                 [_ (in [])
-                 [expected-then actual-then] (scenario context)]
+                 [expected_then actual_then] (scenario context)]
                 (in [(#synthesis.Seq #synthesis.Pop
-                                     (#synthesis.Then expected-then))
+                                     (#synthesis.Then expected_then))
                      (#synthesis.Seq #synthesis.Pop
-                                     (#synthesis.Then actual-then))]))
+                                     (#synthesis.Then actual_then))]))
               (do {! random.monad}
                 [_ (in [])
-                 #let [real-register (dictionary.size (get@ #necessary context))
-                       fake-register (n.+ (get@ #redundants context)
+                 #let [real_register (dictionary.size (get@ #necessary context))
+                       fake_register (n.+ (get@ #redundants context)
                                           (dictionary.size (get@ #necessary context)))]
-                 [expected-then actual-then] (scenario (update@ #necessary (dictionary.put real-register fake-register) context))]
-                (in [(#synthesis.Seq (#synthesis.Bind real-register)
+                 [expected_then actual_then] (scenario (update@ #necessary (dictionary.put real_register fake_register) context))]
+                (in [(#synthesis.Seq (#synthesis.Bind real_register)
                                      (#synthesis.Seq #synthesis.Pop
-                                                     (#synthesis.Then expected-then)))
-                     (#synthesis.Seq (#synthesis.Bind fake-register)
+                                                     (#synthesis.Then expected_then)))
+                     (#synthesis.Seq (#synthesis.Bind fake_register)
                                      (#synthesis.Seq #synthesis.Pop
-                                                     (#synthesis.Then actual-then)))])))
+                                                     (#synthesis.Then actual_then)))])))
           ($_ random.either
               (~~ (template [<tag> <random>]
                     [(do {! random.monad}
                        [test <random>
-                        [expected-then actual-then] (scenario context)]
+                        [expected_then actual_then] (scenario context)]
                        (in [(#synthesis.Seq (#synthesis.Test (<tag> test))
-                                            (#synthesis.Then expected-then))
+                                            (#synthesis.Then expected_then))
                             (#synthesis.Seq (#synthesis.Test (<tag> test))
-                                            (#synthesis.Then actual-then))]))]
+                                            (#synthesis.Then actual_then))]))]
 
                     [#synthesis.Bit random.bit]
                     [#synthesis.I64 (\ ! map .i64 random.nat)]
@@ -193,127 +193,127 @@
                     )))
           ($_ random.either
               (do {! random.monad}
-                [side ..random-side
-                 [expected-next actual-next] (path-scenario scenario context)]
+                [side ..random_side
+                 [expected_next actual_next] (path_scenario scenario context)]
                 (in [(#synthesis.Seq (#synthesis.Access (#synthesis.Side side))
-                                     expected-next)
+                                     expected_next)
                      (#synthesis.Seq (#synthesis.Access (#synthesis.Side side))
-                                     actual-next)]))
+                                     actual_next)]))
               (do {! random.monad}
-                [member ..random-member
-                 [expected-next actual-next] (path-scenario scenario context)]
+                [member ..random_member
+                 [expected_next actual_next] (path_scenario scenario context)]
                 (in [(#synthesis.Seq (#synthesis.Access (#synthesis.Member member))
-                                     expected-next)
+                                     expected_next)
                      (#synthesis.Seq (#synthesis.Access (#synthesis.Member member))
-                                     actual-next)])))
+                                     actual_next)])))
           (do {! random.monad}
             [_ (in [])
-             [expected-left actual-left] (path-scenario scenario context)
-             [expected-right actual-right] (path-scenario scenario context)]
-            (in [(#synthesis.Alt expected-left expected-right)
-                 (#synthesis.Alt actual-left actual-right)]))
+             [expected_left actual_left] (path_scenario scenario context)
+             [expected_right actual_right] (path_scenario scenario context)]
+            (in [(#synthesis.Alt expected_left expected_right)
+                 (#synthesis.Alt actual_left actual_right)]))
           )))
 
-(def: (case-scenario scenario context)
+(def: (case_scenario scenario context)
   (-> (Scenario Synthesis) (Scenario Synthesis))
   (do {! random.monad}
     [_ (in [])
-     [expected-input actual-input] (scenario context)
-     [expected-path actual-path] (..path-scenario scenario context)]
-    (in [(synthesis.branch/case [expected-input expected-path])
-         (synthesis.branch/case [actual-input actual-path])])))
+     [expected_input actual_input] (scenario context)
+     [expected_path actual_path] (..path_scenario scenario context)]
+    (in [(synthesis.branch/case [expected_input expected_path])
+         (synthesis.branch/case [actual_input actual_path])])))
 
-(def: (branch-scenario scenario context)
+(def: (branch_scenario scenario context)
   (-> (Scenario Synthesis) (Scenario Synthesis))
   ($_ random.either
-      (..let-scenario scenario context)
-      (..if-scenario scenario context)
-      (..get-scenario scenario context)
-      (..case-scenario scenario context)
+      (..let_scenario scenario context)
+      (..if_scenario scenario context)
+      (..get_scenario scenario context)
+      (..case_scenario scenario context)
       ))
 
-(def: scope-arity 5)
+(def: scope_arity 5)
 
-(def: (scope-scenario scenario context)
+(def: (scope_scenario scenario context)
   (-> (Scenario Synthesis) (Scenario Synthesis))
   (do {! random.monad}
     [_ (in [])
-     #let [real-start (dictionary.size (get@ #necessary context))
-           fake-start (n.+ (get@ #redundants context)
-                           real-start)]
-     inits (random.list ..scope-arity (scenario context))
-     [expected-iteration actual-iteration] (scenario (update@ #necessary
+     #let [real_start (dictionary.size (get@ #necessary context))
+           fake_start (n.+ (get@ #redundants context)
+                           real_start)]
+     inits (random.list ..scope_arity (scenario context))
+     [expected_iteration actual_iteration] (scenario (update@ #necessary
                                                               (function (_ necessary)
                                                                 (list\fold (function (_ [idx _] context)
-                                                                             (dictionary.put (n.+ real-start idx)
-                                                                                             (n.+ fake-start idx)
+                                                                             (dictionary.put (n.+ real_start idx)
+                                                                                             (n.+ fake_start idx)
                                                                                              context))
                                                                            necessary
                                                                            (list.enumeration inits)))
                                                               context))]
-    (in [(synthesis.loop/scope [real-start (list\map product.left inits) expected-iteration])
-         (synthesis.loop/scope [fake-start (list\map product.right inits) actual-iteration])])))
+    (in [(synthesis.loop/scope [real_start (list\map product.left inits) expected_iteration])
+         (synthesis.loop/scope [fake_start (list\map product.right inits) actual_iteration])])))
 
-(def: (recur-scenario scenario context)
+(def: (recur_scenario scenario context)
   (-> (Scenario Synthesis) (Scenario Synthesis))
   (do {! random.monad}
     [_ (in [])
-     resets (random.list ..scope-arity (scenario context))]
+     resets (random.list ..scope_arity (scenario context))]
     (in [(synthesis.loop/recur (list\map product.left resets))
          (synthesis.loop/recur (list\map product.right resets))])))
 
-(def: (loop-scenario scenario context)
+(def: (loop_scenario scenario context)
   (-> (Scenario Synthesis) (Scenario Synthesis))
   ($_ random.either
-      (..scope-scenario scenario context)
-      (..recur-scenario scenario context)
+      (..scope_scenario scenario context)
+      (..recur_scenario scenario context)
       ))
 
-(def: (abstraction-scenario scenario context)
+(def: (abstraction_scenario scenario context)
   (-> (Scenario Synthesis) (Scenario Synthesis))
   (do {! random.monad}
     [_ (in [])
      #let [registers (dictionary.entries (get@ #necessary context))
-           expected-environment (list\map (|>> product.left #variable.Local) registers)
-           actual-environment (list\map (|>> product.right #variable.Local) registers)]
-     [expected-body actual-body] (..primitive-scenario context)]
-    (in [(synthesis.function/abstraction [expected-environment 1 expected-body])
-         (synthesis.function/abstraction [actual-environment 1 actual-body])])))
+           expected_environment (list\map (|>> product.left #variable.Local) registers)
+           actual_environment (list\map (|>> product.right #variable.Local) registers)]
+     [expected_body actual_body] (..primitive_scenario context)]
+    (in [(synthesis.function/abstraction [expected_environment 1 expected_body])
+         (synthesis.function/abstraction [actual_environment 1 actual_body])])))
 
-(def: (apply-scenario scenario context)
+(def: (apply_scenario scenario context)
   (-> (Scenario Synthesis) (Scenario Synthesis))
   (do {! random.monad}
     [abstraction (\ ! map (|>> synthesis.constant)
                     (random.and (random.unicode 1)
                                 (random.unicode 1)))
-     inputs (random.list ..scope-arity (scenario context))]
+     inputs (random.list ..scope_arity (scenario context))]
     (in [(synthesis.function/apply [abstraction (list\map product.left inputs)])
          (synthesis.function/apply [abstraction (list\map product.right inputs)])])))
 
-(def: (function-scenario scenario context)
+(def: (function_scenario scenario context)
   (-> (Scenario Synthesis) (Scenario Synthesis))
   ($_ random.either
-      (..abstraction-scenario scenario context)
-      (..apply-scenario scenario context)
+      (..abstraction_scenario scenario context)
+      (..apply_scenario scenario context)
       ))
 
-(def: (control-scenario scenario context)
+(def: (control_scenario scenario context)
   (-> (Scenario Synthesis) (Scenario Synthesis))
   ($_ random.either
-      (..branch-scenario scenario context)
-      (..loop-scenario scenario context)
-      (..function-scenario scenario context)
+      (..branch_scenario scenario context)
+      (..loop_scenario scenario context)
+      (..function_scenario scenario context)
       ))
 
 (def: (scenario context)
   (Scenario Synthesis)
   ($_ random.either
-      (..primitive-scenario context)
-      (..structure-scenario context)
-      (..control-scenario (..with-redundancy
-                           (..control-scenario
-                            (..with-redundancy
-                             ..structure-scenario)))
+      (..primitive_scenario context)
+      (..structure_scenario context)
+      (..control_scenario (..with_redundancy
+                            (..control_scenario
+                             (..with_redundancy
+                               ..structure_scenario)))
                           context)
       ))
 
diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/syntax.lux b/stdlib/source/test/lux/tool/compiler/language/lux/syntax.lux
index 4e4968462..48f1f9817 100644
--- a/stdlib/source/test/lux/tool/compiler/language/lux/syntax.lux
+++ b/stdlib/source/test/lux/tool/compiler/language/lux/syntax.lux
@@ -24,15 +24,15 @@
   [\\
    ["." /]])
 
-(def: name-part^
+(def: name_part^
   (Random Text)
   (do {! r.monad}
     [size (|> r.nat (\ ! map (|>> (n.% 20) (n.max 1))))]
-    (r.ascii/lower-alpha size)))
+    (r.ascii/lower_alpha size)))
 
 (def: name^
   (Random Name)
-  (r.and name-part^ name-part^))
+  (r.and name_part^ name_part^))
 
 (def: code^
   (Random Code)
@@ -42,12 +42,12 @@
                         (|> r.nat (r\map code.nat))
                         (|> r.int (r\map code.int))
                         (|> r.rev (r\map code.rev))
-                        (|> r.safe-frac (r\map code.frac))))
+                        (|> r.safe_frac (r\map code.frac))))
         textual^ (: (Random Code)
                     ($_ r.either
                         (do r.monad
                           [size (|> r.nat (r\map (n.% 20)))]
-                          (|> (r.ascii/upper-alpha size) (r\map code.text)))
+                          (|> (r.ascii/upper_alpha size) (r\map code.text)))
                         (|> name^ (r\map code.identifier))
                         (|> name^ (r\map code.tag))))
         simple^ (: (Random Code)
@@ -77,9 +77,9 @@
     [sample code^]
     ($_ _.and
         (_.test "Can parse Lux code."
-                (case (let [source-code (%.code sample)]
-                        (/.parse "" (dictionary.new text.hash) (text.size source-code)
-                                 [location.dummy 0 source-code]))
+                (case (let [source_code (%.code sample)]
+                        (/.parse "" (dictionary.new text.hash) (text.size source_code)
+                                 [location.dummy 0 source_code]))
                   (#.Left error)
                   false
 
@@ -88,15 +88,15 @@
         (do !
           [other code^]
           (_.test "Can parse multiple Lux code nodes."
-                  (let [source-code (format (%.code sample) " " (%.code other))
-                        source-code//size (text.size source-code)]
-                    (case (/.parse "" (dictionary.new text.hash) source-code//size
-                                   [location.dummy 0 source-code])
+                  (let [source_code (format (%.code sample) " " (%.code other))
+                        source_code//size (text.size source_code)]
+                    (case (/.parse "" (dictionary.new text.hash) source_code//size
+                                   [location.dummy 0 source_code])
                       (#.Left error)
                       false
 
                       (#.Right [remaining =sample])
-                      (case (/.parse "" (dictionary.new text.hash) source-code//size
+                      (case (/.parse "" (dictionary.new text.hash) source_code//size
                                      remaining)
                         (#.Left error)
                         false
@@ -106,18 +106,18 @@
                              (\ code.equivalence = other =other)))))))
         )))
 
-(def: comment-text^
+(def: comment_text^
   (Random Text)
-  (let [char-gen (|> r.nat (r.only (|>> (n.= (`` (char (~~ (static text.new-line))))) not)))]
+  (let [char_gen (|> r.nat (r.only (|>> (n.= (`` (char (~~ (static text.new_line))))) not)))]
     (do r.monad
       [size (|> r.nat (r\map (n.% 20)))]
-      (r.text char-gen size))))
+      (r.text char_gen size))))
 
 (def: comment^
   (Random Text)
   (do r.monad
-    [comment comment-text^]
-    (in (format "## " comment text.new-line))))
+    [comment comment_text^]
+    (in (format "## " comment text.new_line))))
 
 (def: comments
   Test
@@ -126,10 +126,10 @@
      comment comment^]
     ($_ _.and
         (_.test "Can handle comments."
-                (case (let [source-code (format comment (%.code sample))
-                            source-code//size (text.size source-code)]
-                        (/.parse "" (dictionary.new text.hash) source-code//size
-                                 [location.dummy 0 source-code]))
+                (case (let [source_code (format comment (%.code sample))
+                            source_code//size (text.size source_code)]
+                        (/.parse "" (dictionary.new text.hash) source_code//size
+                                 [location.dummy 0 source_code]))
                   (#.Left error)
                   false
 
@@ -139,7 +139,7 @@
 
 (def: #export test
   Test
-  (<| (_.context (name.module (name-of /._)))
+  (<| (_.context (name.module (name_of /._)))
       ($_ _.and
           ..code
           ..comments