De-sigil-ification: >

1 files changed, 138 insertions, 120 deletions

diff --git a/stdlib/source/specification/compositor/generation/common.lux b/stdlib/source/specification/compositor/generation/common.lux
index 88f13e2ae..19041bbb7 100644
--- a/stdlib/source/specification/compositor/generation/common.lux
+++ b/stdlib/source/specification/compositor/generation/common.lux
@@ -1,32 +1,32 @@
 (.using
-  [lux {"-" i64}
-   ["_" test {"+" Test}]
-   [abstract
-    [monad {"+" do}]]
-   [control
-    [pipe {"+" case>}]
-    ["[0]" try {"+" Try}]]
-   [data
-    ["[0]" bit ("[1]#[0]" equivalence)]
-    [number
-     ["[0]" i64]
-     ["n" nat]
-     ["i" int]
-     ["f" frac]]
-    ["[0]" text ("[1]#[0]" equivalence)
-     ["%" format {"+" format}]]
-    [collection
-     ["[0]" list]]]
-   [math
-    ["r" random {"+" Random}]]
-   [tool
-    [compiler
-     ["[0]" reference]
-     ["[0]" synthesis]]]]
-  ["[0]" // "_"
-   ["[1][0]" case]
-   [//
-    [common {"+" Runner}]]])
+ [lux {"-" i64}
+  ["_" test {"+" Test}]
+  [abstract
+   [monad {"+" do}]]
+  [control
+   ["[0]" pipe]
+   ["[0]" try {"+" Try}]]
+  [data
+   ["[0]" bit ("[1]#[0]" equivalence)]
+   [number
+    ["[0]" i64]
+    ["n" nat]
+    ["i" int]
+    ["f" frac]]
+   ["[0]" text ("[1]#[0]" equivalence)
+    ["%" format {"+" format}]]
+   [collection
+    ["[0]" list]]]
+  [math
+   ["r" random {"+" Random}]]
+  [tool
+   [compiler
+    ["[0]" reference]
+    ["[0]" synthesis]]]]
+ ["[0]" // "_"
+  ["[1][0]" case]
+  [//
+   [common {"+" Runner}]]])
 
 (def: safe
   (-> Text Text)
@@ -42,11 +42,12 @@
                                           (|> {synthesis.#Extension <extension> (list (synthesis.i64 param)
                                                                                       (synthesis.i64 subject))}
                                               (run (..safe <extension>))
-                                              (case> {try.#Success valueT}
-                                                     (n.= (<reference> param subject) (:as Nat valueT))
+                                              (pipe.case
+                                                {try.#Success valueT}
+                                                (n.= (<reference> param subject) (:as Nat valueT))
 
-                                                     {try.#Failure _}
-                                                     false)
+                                                {try.#Failure _}
+                                                false)
                                               (let [param <param_expr>])))]
 
                                  ["lux i64 and"                 i64.and               param]
@@ -62,13 +63,14 @@
                                             (list (synthesis.i64 subject)
                                                   (synthesis.i64 param))}
                       (run (..safe "lux i64 arithmetic-right-shift"))
-                      (case> {try.#Success valueT}
-                             ("lux i64 ="
-                              (i64.arithmetic_right_shifted param subject)
-                              (:as I64 valueT))
-
-                             {try.#Failure _}
-                             false)
+                      (pipe.case
+                        {try.#Success valueT}
+                        ("lux i64 ="
+                         (i64.arithmetic_right_shifted param subject)
+                         (:as I64 valueT))
+
+                        {try.#Failure _}
+                        false)
                       (let [param (n.% 64 param)])))
           ))))
 
@@ -82,11 +84,12 @@
                   [(_.test <extension>
                            (|> {synthesis.#Extension <extension> (list (synthesis.i64 subject))}
                                (run (..safe <extension>))
-                               (case> {try.#Success valueT}
-                                      (<comp> (<prepare> subject) (:as <type> valueT))
+                               (pipe.case
+                                 {try.#Success valueT}
+                                 (<comp> (<prepare> subject) (:as <type> valueT))
 
-                                      {try.#Failure _}
-                                      false)
+                                 {try.#Failure _}
+                                 false)
                                (let [subject <subject_expr>])))]
 
                   ["lux i64 f64"  Frac i.frac f.= subject]
@@ -100,11 +103,12 @@
                            (|> {synthesis.#Extension <extension> (list (synthesis.i64 param)
                                                                        (synthesis.i64 subject))}
                                (run (..safe <extension>))
-                               (case> {try.#Success valueT}
-                                      (<comp> (<reference> param subject) (:as <outputT> valueT))
+                               (pipe.case
+                                 {try.#Success valueT}
+                                 (<comp> (<reference> param subject) (:as <outputT> valueT))
 
-                                      {try.#Failure _}
-                                      false)))]
+                                 {try.#Failure _}
+                                 false)))]
 
                   ["lux i64 +" i.+ Int  i.=]
                   ["lux i64 -" i.- Int  i.=]
@@ -144,12 +148,13 @@
                            (|> {synthesis.#Extension <extension> (list (synthesis.f64 param)
                                                                        (synthesis.f64 subject))}
                                (run (..safe <extension>))
-                               (case> {try.#Success valueV}
-                                      (bit#= (<text> param subject)
-                                             (:as Bit valueV))
+                               (pipe.case
+                                 {try.#Success valueV}
+                                 (bit#= (<text> param subject)
+                                        (:as Bit valueV))
 
-                                      _
-                                      false)))]
+                                 _
+                                 false)))]
 
                   ["lux f64 =" f.=]
                   ["lux f64 <" f.<]
@@ -193,65 +198,72 @@
         (_.test "Can compare texts for equality."
                 (and (|> {synthesis.#Extension "lux text =" (list sample_lowerS sample_lowerS)}
                          (run (..safe "lux text ="))
-                         (case> {try.#Success valueV}
-                                (:as Bit valueV)
+                         (pipe.case
+                           {try.#Success valueV}
+                           (:as Bit valueV)
 
-                                _
-                                false))
+                           _
+                           false))
                      (|> {synthesis.#Extension "lux text =" (list sample_upperS sample_lowerS)}
                          (run (..safe "lux text ="))
-                         (case> {try.#Success valueV}
-                                (not (:as Bit valueV))
+                         (pipe.case
+                           {try.#Success valueV}
+                           (not (:as Bit valueV))
 
-                                _
-                                false))))
+                           _
+                           false))))
         (_.test "Can compare texts for order."
                 (|> {synthesis.#Extension "lux text <" (list sample_lowerS sample_upperS)}
                     (run (..safe "lux text <"))
-                    (case> {try.#Success valueV}
-                           (:as Bit valueV)
+                    (pipe.case
+                      {try.#Success valueV}
+                      (:as Bit valueV)
 
-                           {try.#Failure _}
-                           false)))
+                      {try.#Failure _}
+                      false)))
         (_.test "Can get length of text."
                 (|> {synthesis.#Extension "lux text size" (list sample_lowerS)}
                     (run (..safe "lux text size"))
-                    (case> {try.#Success valueV}
-                           (n.= sample_size (:as Nat valueV))
+                    (pipe.case
+                      {try.#Success valueV}
+                      (n.= sample_size (:as Nat valueV))
 
-                           _
-                           false)))
+                      _
+                      false)))
         (_.test "Can concatenate text."
                 (|> {synthesis.#Extension "lux text size" (list concatenatedS)}
                     (run (..safe "lux text size"))
-                    (case> {try.#Success valueV}
-                           (n.= (n.* 2 sample_size) (:as Nat valueV))
+                    (pipe.case
+                      {try.#Success valueV}
+                      (n.= (n.* 2 sample_size) (:as Nat valueV))
 
-                           _
-                           false)))
+                      _
+                      false)))
         (_.test "Can find index of sub-text."
                 (and (|> {synthesis.#Extension "lux text index"
                                                (list concatenatedS sample_lowerS
                                                      (synthesis.i64 +0))}
                          (run (..safe "lux text index"))
-                         (case> (^multi {try.#Success valueV}
-                                        [(:as (Maybe Nat) valueV)
-                                         {.#Some valueV}])
-                                (n.= 0 valueV)
+                         (pipe.case
+                           (^multi {try.#Success valueV}
+                                   [(:as (Maybe Nat) valueV)
+                                    {.#Some valueV}])
+                           (n.= 0 valueV)
 
-                                _
-                                false))
+                           _
+                           false))
                      (|> {synthesis.#Extension "lux text index"
                                                (list concatenatedS sample_upperS
                                                      (synthesis.i64 +0))}
                          (run (..safe "lux text index"))
-                         (case> (^multi {try.#Success valueV}
-                                        [(:as (Maybe Nat) valueV)
-                                         {.#Some valueV}])
-                                (n.= sample_size valueV)
+                         (pipe.case
+                           (^multi {try.#Success valueV}
+                                   [(:as (Maybe Nat) valueV)
+                                    {.#Some valueV}])
+                           (n.= sample_size valueV)
 
-                                _
-                                false))))
+                           _
+                           false))))
         (let [test_clip (: (-> (I64 Any) (I64 Any) Text Bit)
                            (function (_ offset length expected)
                              (|> {synthesis.#Extension "lux text clip"
@@ -259,13 +271,14 @@
                                                              (synthesis.i64 offset)
                                                              (synthesis.i64 length))}
                                  (run (..safe "lux text clip"))
-                                 (case> (^multi {try.#Success valueV}
-                                                [(:as (Maybe Text) valueV)
-                                                 {.#Some valueV}])
-                                        (text#= expected valueV)
-
-                                        _
-                                        false))))]
+                                 (pipe.case
+                                   (^multi {try.#Success valueV}
+                                           [(:as (Maybe Text) valueV)
+                                            {.#Some valueV}])
+                                   (text#= expected valueV)
+
+                                   _
+                                   false))))]
           (_.test "Can clip text to extract sub-text."
                   (and (test_clip 0 sample_size sample_lower)
                        (test_clip sample_size sample_size sample_upper))))
@@ -274,14 +287,15 @@
                                           (list sample_lowerS
                                                 (synthesis.i64 char_idx))}
                     (run (..safe "lux text char"))
-                    (case> (^multi {try.#Success valueV}
-                                   [(:as (Maybe Int) valueV)
-                                    {.#Some valueV}])
-                           (text.contains? ("lux i64 char" valueV)
-                                           sample_lower)
-
-                           _
-                           false)))
+                    (pipe.case
+                      (^multi {try.#Success valueV}
+                              [(:as (Maybe Int) valueV)
+                               {.#Some valueV}])
+                      (text.contains? ("lux i64 char" valueV)
+                                      sample_lower)
+
+                      _
+                      false)))
         )))
 
 (def: (io run)
@@ -293,11 +307,12 @@
                 (|> {synthesis.#Extension "lux io log"
                                           (list (synthesis.text (format "LOG: " message)))}
                     (run (..safe "lux io log"))
-                    (case> {try.#Success valueV}
-                           true
+                    (pipe.case
+                      {try.#Success valueV}
+                      true
 
-                           {try.#Failure _}
-                           false)))
+                      {try.#Failure _}
+                      false)))
         (_.test "Can throw runtime errors."
                 (and (|> {synthesis.#Extension "lux try"
                                                (list (synthesis.function/abstraction
@@ -306,36 +321,39 @@
                                                        synthesis.#body {synthesis.#Extension "lux io error"
                                                                                              (list (synthesis.text message))}]))}
                          (run (..safe "lux try"))
-                         (case> (^multi {try.#Success valueV}
-                                        [(:as (Try Text) valueV)
-                                         {try.#Failure error}])
-                                (text.contains? message error)
+                         (pipe.case
+                           (^multi {try.#Success valueV}
+                                   [(:as (Try Text) valueV)
+                                    {try.#Failure error}])
+                           (text.contains? message error)
 
-                                _
-                                false))
+                           _
+                           false))
                      (|> {synthesis.#Extension "lux try"
                                                (list (synthesis.function/abstraction
                                                       [synthesis.#environment (list)
                                                        synthesis.#arity 1
                                                        synthesis.#body (synthesis.text message)]))}
                          (run (..safe "lux try"))
-                         (case> (^multi {try.#Success valueV}
-                                        [(:as (Try Text) valueV)
-                                         {try.#Success valueV}])
-                                (text#= message valueV)
+                         (pipe.case
+                           (^multi {try.#Success valueV}
+                                   [(:as (Try Text) valueV)
+                                    {try.#Success valueV}])
+                           (text#= message valueV)
 
-                                _
-                                false))))
+                           _
+                           false))))
         (_.test "Can obtain current time in milli-seconds."
                 (|> (synthesis.tuple (list {synthesis.#Extension "lux io current-time" (list)}
                                            {synthesis.#Extension "lux io current-time" (list)}))
                     (run (..safe "lux io current-time"))
-                    (case> {try.#Success valueV}
-                           (let [[pre post] (:as [Nat Nat] valueV)]
-                             (n.>= pre post))
+                    (pipe.case
+                      {try.#Success valueV}
+                      (let [[pre post] (:as [Nat Nat] valueV)]
+                        (n.>= pre post))
 
-                           {try.#Failure _}
-                           false)))
+                      {try.#Failure _}
+                      false)))
         )))
 
 (def: .public (spec runner)