Better names for testing macros (plus better indentation).

1 files changed, 206 insertions, 206 deletions

diff --git a/stdlib/source/specification/compositor/generation/common.lux b/stdlib/source/specification/compositor/generation/common.lux
index 77854d953..e93a46c29 100644
--- a/stdlib/source/specification/compositor/generation/common.lux
+++ b/stdlib/source/specification/compositor/generation/common.lux
@@ -40,17 +40,17 @@
     [param r.i64
      subject r.i64]
     (with_expansions [<binary> (template [<extension> <reference> <param_expr>]
-                                 [(_.test <extension>
-                                          (|> {synthesis.#Extension <extension> (list (synthesis.i64 param)
-                                                                                      (synthesis.i64 subject))}
-                                              (run (..safe <extension>))
-                                              (pipe.case
-                                                {try.#Success valueT}
-                                                (n.= (<reference> param subject) (as Nat valueT))
-
-                                                {try.#Failure _}
-                                                false)
-                                              (let [param <param_expr>])))]
+                                 [(_.property <extension>
+                                    (|> {synthesis.#Extension <extension> (list (synthesis.i64 param)
+                                                                                (synthesis.i64 subject))}
+                                        (run (..safe <extension>))
+                                        (pipe.case
+                                          {try.#Success valueT}
+                                          (n.= (<reference> param subject) (as Nat valueT))
+
+                                          {try.#Failure _}
+                                          false)
+                                        (let [param <param_expr>])))]
 
                                  ["lux i64 and"                 i64.and               param]
                                  ["lux i64 or"                  i64.or                param]
@@ -60,20 +60,20 @@
                                  )]
       (all _.and
            <binary>
-           (_.test "lux i64 arithmetic-right-shift"
-                   (|> {synthesis.#Extension "lux i64 arithmetic-right-shift"
-                                             (list (synthesis.i64 subject)
-                                                   (synthesis.i64 param))}
-                       (run (..safe "lux i64 arithmetic-right-shift"))
-                       (pipe.case
-                         {try.#Success valueT}
-                         ("lux i64 ="
-                          (i64.arithmetic_right_shifted param subject)
-                          (as I64 valueT))
-
-                         {try.#Failure _}
-                         false)
-                       (let [param (n.% 64 param)])))
+           (_.property "lux i64 arithmetic-right-shift"
+             (|> {synthesis.#Extension "lux i64 arithmetic-right-shift"
+                                       (list (synthesis.i64 subject)
+                                             (synthesis.i64 param))}
+                 (run (..safe "lux i64 arithmetic-right-shift"))
+                 (pipe.case
+                   {try.#Success valueT}
+                   ("lux i64 ="
+                    (i64.arithmetic_right_shifted param subject)
+                    (as I64 valueT))
+
+                   {try.#Failure _}
+                   false)
+                 (let [param (n.% 64 param)])))
            ))))
 
 (def: (i64 run)
@@ -83,16 +83,16 @@
      subject r.i64]
     (`` (all _.and
              (~~ (template [<extension> <type> <prepare> <comp> <subject_expr>]
-                   [(_.test <extension>
-                            (|> {synthesis.#Extension <extension> (list (synthesis.i64 subject))}
-                                (run (..safe <extension>))
-                                (pipe.case
-                                  {try.#Success valueT}
-                                  (<comp> (<prepare> subject) (as <type> valueT))
+                   [(_.property <extension>
+                      (|> {synthesis.#Extension <extension> (list (synthesis.i64 subject))}
+                          (run (..safe <extension>))
+                          (pipe.case
+                            {try.#Success valueT}
+                            (<comp> (<prepare> subject) (as <type> valueT))
 
-                                  {try.#Failure _}
-                                  false)
-                                (let [subject <subject_expr>])))]
+                            {try.#Failure _}
+                            false)
+                          (let [subject <subject_expr>])))]
 
                    ["lux i64 f64"  Frac i.frac f.= subject]
                    ["lux i64 char" Text (|>> (as Nat) text.from_code) text#= (|> subject
@@ -101,16 +101,16 @@
                                                                                  (as Int))]
                    ))
              (~~ (template [<extension> <reference> <outputT> <comp>]
-                   [(_.test <extension>
-                            (|> {synthesis.#Extension <extension> (list (synthesis.i64 param)
-                                                                        (synthesis.i64 subject))}
-                                (run (..safe <extension>))
-                                (pipe.case
-                                  {try.#Success valueT}
-                                  (<comp> (<reference> param subject) (as <outputT> valueT))
+                   [(_.property <extension>
+                      (|> {synthesis.#Extension <extension> (list (synthesis.i64 param)
+                                                                  (synthesis.i64 subject))}
+                          (run (..safe <extension>))
+                          (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.=]
@@ -133,11 +133,11 @@
      subject ..simple_frac]
     (`` (all _.and
              (~~ (template [<extension> <reference> <comp>]
-                   [(_.test <extension>
-                            (|> {synthesis.#Extension <extension> (list (synthesis.f64 param)
-                                                                        (synthesis.f64 subject))}
-                                (run (..safe <extension>))
-                                (//case.verify (<reference> param subject))))]
+                   [(_.property <extension>
+                      (|> {synthesis.#Extension <extension> (list (synthesis.f64 param)
+                                                                  (synthesis.f64 subject))}
+                          (run (..safe <extension>))
+                          (//case.verify (<reference> param subject))))]
 
                    ["lux f64 +" f.+ f.=]
                    ["lux f64 -" f.- f.=]
@@ -146,37 +146,37 @@
                    ["lux f64 %" f.% f.=]
                    ))
              (~~ (template [<extension> <text>]
-                   [(_.test <extension>
-                            (|> {synthesis.#Extension <extension> (list (synthesis.f64 param)
-                                                                        (synthesis.f64 subject))}
-                                (run (..safe <extension>))
-                                (pipe.case
-                                  {try.#Success valueV}
-                                  (bit#= (<text> param subject)
-                                         (as Bit valueV))
-
-                                  _
-                                  false)))]
+                   [(_.property <extension>
+                      (|> {synthesis.#Extension <extension> (list (synthesis.f64 param)
+                                                                  (synthesis.f64 subject))}
+                          (run (..safe <extension>))
+                          (pipe.case
+                            {try.#Success valueV}
+                            (bit#= (<text> param subject)
+                                   (as Bit valueV))
+
+                            _
+                            false)))]
 
                    ["lux f64 =" f.=]
                    ["lux f64 <" f.<]
                    ))
              (~~ (template [<extension> <reference>]
-                   [(_.test <extension>
-                            (|> {synthesis.#Extension <extension> (list)}
-                                (run (..safe <extension>))
-                                (//case.verify <reference>)))]
+                   [(_.property <extension>
+                      (|> {synthesis.#Extension <extension> (list)}
+                          (run (..safe <extension>))
+                          (//case.verify <reference>)))]
 
                    ["lux f64 min"      ("lux f64 min")]
                    ["lux f64 max"      ("lux f64 max")]
                    ["lux f64 smallest" ("lux f64 smallest")]
                    ))
-             (_.test "'lux f64 i64 && 'lux i64 f64'"
-                     (|> (run (..safe "lux f64 i64")
-                              (|> subject synthesis.f64
-                                  (list) {synthesis.#Extension "lux f64 i64"}
-                                  (list) {synthesis.#Extension "lux i64 f64"}))
-                         (//case.verify subject)))
+             (_.property "'lux f64 i64 && 'lux i64 f64'"
+               (|> (run (..safe "lux f64 i64")
+                        (|> subject synthesis.f64
+                            (list) {synthesis.#Extension "lux f64 i64"}
+                            (list) {synthesis.#Extension "lux i64 f64"}))
+                   (//case.verify subject)))
              ))))
 
 (def: (text run)
@@ -197,75 +197,75 @@
            pre_rep_all (|> sample_lower (list.repeated sample_size) (text.interposed sample_upper))
            post_rep_all (|> sample_lower (list.repeated sample_size) (text.interposed sample_alpha))]]
     (all _.and
-         (_.test "Can compare texts for equality."
-                 (and (|> {synthesis.#Extension "lux text =" (list sample_lowerS sample_lowerS)}
-                          (run (..safe "lux text ="))
-                          (pipe.case
-                            {try.#Success valueV}
-                            (as Bit valueV)
-
-                            _
-                            false))
-                      (|> {synthesis.#Extension "lux text =" (list sample_upperS sample_lowerS)}
-                          (run (..safe "lux text ="))
-                          (pipe.case
-                            {try.#Success valueV}
-                            (not (as Bit valueV))
-
-                            _
-                            false))))
-         (_.test "Can compare texts for order."
-                 (|> {synthesis.#Extension "lux text <" (list sample_lowerS sample_upperS)}
-                     (run (..safe "lux text <"))
-                     (pipe.case
-                       {try.#Success valueV}
-                       (as Bit valueV)
-
-                       {try.#Failure _}
-                       false)))
-         (_.test "Can get length of text."
-                 (|> {synthesis.#Extension "lux text size" (list sample_lowerS)}
-                     (run (..safe "lux text size"))
-                     (pipe.case
-                       {try.#Success valueV}
-                       (n.= sample_size (as Nat valueV))
-
-                       _
-                       false)))
-         (_.test "Can concatenate text."
-                 (|> {synthesis.#Extension "lux text size" (list concatenatedS)}
-                     (run (..safe "lux text size"))
-                     (pipe.case
-                       {try.#Success valueV}
-                       (n.= (n.* 2 sample_size) (as Nat valueV))
-
-                       _
-                       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"))
-                          (pipe.case
-                            (^.multi {try.#Success valueV}
-                                     [(as (Maybe Nat) valueV)
-                                      {.#Some valueV}])
-                            (n.= 0 valueV)
-
-                            _
-                            false))
-                      (|> {synthesis.#Extension "lux text index"
-                                                (list concatenatedS sample_upperS
-                                                      (synthesis.i64 +0))}
-                          (run (..safe "lux text index"))
-                          (pipe.case
-                            (^.multi {try.#Success valueV}
-                                     [(as (Maybe Nat) valueV)
-                                      {.#Some valueV}])
-                            (n.= sample_size valueV)
-
-                            _
-                            false))))
+         (_.property "Can compare texts for equality."
+           (and (|> {synthesis.#Extension "lux text =" (list sample_lowerS sample_lowerS)}
+                    (run (..safe "lux text ="))
+                    (pipe.case
+                      {try.#Success valueV}
+                      (as Bit valueV)
+
+                      _
+                      false))
+                (|> {synthesis.#Extension "lux text =" (list sample_upperS sample_lowerS)}
+                    (run (..safe "lux text ="))
+                    (pipe.case
+                      {try.#Success valueV}
+                      (not (as Bit valueV))
+
+                      _
+                      false))))
+         (_.property "Can compare texts for order."
+           (|> {synthesis.#Extension "lux text <" (list sample_lowerS sample_upperS)}
+               (run (..safe "lux text <"))
+               (pipe.case
+                 {try.#Success valueV}
+                 (as Bit valueV)
+
+                 {try.#Failure _}
+                 false)))
+         (_.property "Can get length of text."
+           (|> {synthesis.#Extension "lux text size" (list sample_lowerS)}
+               (run (..safe "lux text size"))
+               (pipe.case
+                 {try.#Success valueV}
+                 (n.= sample_size (as Nat valueV))
+
+                 _
+                 false)))
+         (_.property "Can concatenate text."
+           (|> {synthesis.#Extension "lux text size" (list concatenatedS)}
+               (run (..safe "lux text size"))
+               (pipe.case
+                 {try.#Success valueV}
+                 (n.= (n.* 2 sample_size) (as Nat valueV))
+
+                 _
+                 false)))
+         (_.property "Can find index of sub-text."
+           (and (|> {synthesis.#Extension "lux text index"
+                                          (list concatenatedS sample_lowerS
+                                                (synthesis.i64 +0))}
+                    (run (..safe "lux text index"))
+                    (pipe.case
+                      (^.multi {try.#Success valueV}
+                               [(as (Maybe Nat) valueV)
+                                {.#Some valueV}])
+                      (n.= 0 valueV)
+
+                      _
+                      false))
+                (|> {synthesis.#Extension "lux text index"
+                                          (list concatenatedS sample_upperS
+                                                (synthesis.i64 +0))}
+                    (run (..safe "lux text index"))
+                    (pipe.case
+                      (^.multi {try.#Success valueV}
+                               [(as (Maybe Nat) valueV)
+                                {.#Some valueV}])
+                      (n.= sample_size valueV)
+
+                      _
+                      false))))
          (let [test_clip (is (-> (I64 Any) (I64 Any) Text Bit)
                              (function (_ offset length expected)
                                (|> {synthesis.#Extension "lux text clip"
@@ -281,23 +281,23 @@
 
                                      _
                                      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))))
-         (_.test "Can extract individual characters from text."
-                 (|> {synthesis.#Extension "lux text char"
-                                           (list sample_lowerS
-                                                 (synthesis.i64 char_idx))}
-                     (run (..safe "lux text char"))
-                     (pipe.case
-                       (^.multi {try.#Success valueV}
-                                [(as (Maybe Int) valueV)
-                                 {.#Some valueV}])
-                       (text.contains? ("lux i64 char" valueV)
-                                       sample_lower)
-
-                       _
-                       false)))
+           (_.property "Can clip text to extract sub-text."
+             (and (test_clip 0 sample_size sample_lower)
+                  (test_clip sample_size sample_size sample_upper))))
+         (_.property "Can extract individual characters from text."
+           (|> {synthesis.#Extension "lux text char"
+                                     (list sample_lowerS
+                                           (synthesis.i64 char_idx))}
+               (run (..safe "lux text char"))
+               (pipe.case
+                 (^.multi {try.#Success valueV}
+                          [(as (Maybe Int) valueV)
+                           {.#Some valueV}])
+                 (text.contains? ("lux i64 char" valueV)
+                                 sample_lower)
+
+                 _
+                 false)))
          )))
 
 (def: (io run)
@@ -305,57 +305,57 @@
   (do r.monad
     [message (r.alphabetic 5)]
     (all _.and
-         (_.test "Can log messages."
-                 (|> {synthesis.#Extension "lux io log"
-                                           (list (synthesis.text (format "LOG: " message)))}
-                     (run (..safe "lux io log"))
-                     (pipe.case
-                       {try.#Success valueV}
-                       true
-
-                       {try.#Failure _}
-                       false)))
-         (_.test "Can throw runtime errors."
-                 (and (|> {synthesis.#Extension "lux try"
-                                                (list (synthesis.function/abstraction
-                                                       [synthesis.#environment (list)
-                                                        synthesis.#arity 1
-                                                        synthesis.#body {synthesis.#Extension "lux io error"
-                                                                                              (list (synthesis.text message))}]))}
-                          (run (..safe "lux try"))
-                          (pipe.case
-                            (^.multi {try.#Success valueV}
-                                     [(as (Try Text) valueV)
-                                      {try.#Failure error}])
-                            (text.contains? message error)
-
-                            _
-                            false))
-                      (|> {synthesis.#Extension "lux try"
-                                                (list (synthesis.function/abstraction
-                                                       [synthesis.#environment (list)
-                                                        synthesis.#arity 1
-                                                        synthesis.#body (synthesis.text message)]))}
-                          (run (..safe "lux try"))
-                          (pipe.case
-                            (^.multi {try.#Success valueV}
-                                     [(as (Try Text) valueV)
-                                      {try.#Success valueV}])
-                            (text#= message valueV)
-
-                            _
-                            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"))
-                     (pipe.case
-                       {try.#Success valueV}
-                       (let [[pre post] (as [Nat Nat] valueV)]
-                         (n.>= pre post))
-
-                       {try.#Failure _}
-                       false)))
+         (_.property "Can log messages."
+           (|> {synthesis.#Extension "lux io log"
+                                     (list (synthesis.text (format "LOG: " message)))}
+               (run (..safe "lux io log"))
+               (pipe.case
+                 {try.#Success valueV}
+                 true
+
+                 {try.#Failure _}
+                 false)))
+         (_.property "Can throw runtime errors."
+           (and (|> {synthesis.#Extension "lux try"
+                                          (list (synthesis.function/abstraction
+                                                 [synthesis.#environment (list)
+                                                  synthesis.#arity 1
+                                                  synthesis.#body {synthesis.#Extension "lux io error"
+                                                                                        (list (synthesis.text message))}]))}
+                    (run (..safe "lux try"))
+                    (pipe.case
+                      (^.multi {try.#Success valueV}
+                               [(as (Try Text) valueV)
+                                {try.#Failure error}])
+                      (text.contains? message error)
+
+                      _
+                      false))
+                (|> {synthesis.#Extension "lux try"
+                                          (list (synthesis.function/abstraction
+                                                 [synthesis.#environment (list)
+                                                  synthesis.#arity 1
+                                                  synthesis.#body (synthesis.text message)]))}
+                    (run (..safe "lux try"))
+                    (pipe.case
+                      (^.multi {try.#Success valueV}
+                               [(as (Try Text) valueV)
+                                {try.#Success valueV}])
+                      (text#= message valueV)
+
+                      _
+                      false))))
+         (_.property "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"))
+               (pipe.case
+                 {try.#Success valueV}
+                 (let [[pre post] (as [Nat Nat] valueV)]
+                   (n.>= pre post))
+
+                 {try.#Failure _}
+                 false)))
          )))
 
 (def: .public (spec runner)