Better names for testing macros (plus better indentation).

1 files changed, 112 insertions, 112 deletions

diff --git a/stdlib/source/test/lux/data/collection/sequence.lux b/stdlib/source/test/lux/data/collection/sequence.lux
index a88a1f8de..f3c3bb0d0 100644
--- a/stdlib/source/test/lux/data/collection/sequence.lux
+++ b/stdlib/source/test/lux/data/collection/sequence.lux
@@ -54,29 +54,29 @@
      .let [sample (|> sample set.list /.of_list)]
      .let [(open "/#[0]") (/.equivalence n.equivalence)]]
     (all _.and
-         (_.cover [/.size]
-                  (n.= size (/.size sample)))
-         (_.cover [/.empty?]
-                  (bit#= (/.empty? sample) (n.= 0 (/.size sample))))
-         (_.cover [/.empty]
-                  (/.empty? /.empty))
-         (_.cover [/.list /.of_list]
-                  (|> sample /.list /.of_list (/#= sample)))
-         (_.cover [/.reversed]
-                  (or (n.< 2 (/.size sample))
-                      (let [not_same!
-                            (not (/#= sample
-                                      (/.reversed sample)))
+         (_.coverage [/.size]
+           (n.= size (/.size sample)))
+         (_.coverage [/.empty?]
+           (bit#= (/.empty? sample) (n.= 0 (/.size sample))))
+         (_.coverage [/.empty]
+           (/.empty? /.empty))
+         (_.coverage [/.list /.of_list]
+           (|> sample /.list /.of_list (/#= sample)))
+         (_.coverage [/.reversed]
+           (or (n.< 2 (/.size sample))
+               (let [not_same!
+                     (not (/#= sample
+                               (/.reversed sample)))
 
-                            self_symmetry!
-                            (/#= sample
-                                 (/.reversed (/.reversed sample)))]
-                        (and not_same!
-                             self_symmetry!))))
-         (_.cover [/.every? /.any?]
-                  (if (/.every? n.even? sample)
-                    (not (/.any? (bit.complement n.even?) sample))
-                    (/.any? (bit.complement n.even?) sample)))
+                     self_symmetry!
+                     (/#= sample
+                          (/.reversed (/.reversed sample)))]
+                 (and not_same!
+                      self_symmetry!))))
+         (_.coverage [/.every? /.any?]
+           (if (/.every? n.even? sample)
+             (not (/.any? (bit.complement n.even?) sample))
+             (/.any? (bit.complement n.even?) sample)))
          )))
 
 (def: index_based
@@ -92,41 +92,41 @@
                                     random.nat)
             .let [sample (|> sample set.list /.of_list)]]
            (all _.and
-                (_.cover [/.item]
-                         (case (/.item good_index sample)
-                           {try.#Success member}
-                           (/.member? n.equivalence sample member)
-                           
-                           {try.#Failure error}
-                           false))
-                (_.cover [/.has]
-                         (<| (try.else false)
-                             (do try.monad
-                               [sample (/.has good_index non_member sample)
-                                actual (/.item good_index sample)]
-                               (in (same? non_member actual)))))
-                (_.cover [/.revised]
-                         (<| (try.else false)
-                             (do try.monad
-                               [sample (/.has good_index non_member sample)
-                                sample (/.revised good_index ++ sample)
-                                actual (/.item good_index sample)]
-                               (in (n.= (++ non_member) actual)))))
-                (_.cover [/.within_bounds?]
-                         (and (/.within_bounds? sample good_index)
-                              (not (/.within_bounds? sample bad_index))))
-                (_.cover [/.index_out_of_bounds]
-                         (let [fails! (is (All (_ a) (-> (Try a) Bit))
-                                          (function (_ situation)
-                                            (case situation
-                                              {try.#Success member}
-                                              false
-                                              
-                                              {try.#Failure error}
-                                              (exception.match? /.index_out_of_bounds error))))]
-                           (and (fails! (/.item bad_index sample))
-                                (fails! (/.has bad_index non_member sample))
-                                (fails! (/.revised bad_index ++ sample)))))
+                (_.coverage [/.item]
+                  (case (/.item good_index sample)
+                    {try.#Success member}
+                    (/.member? n.equivalence sample member)
+                    
+                    {try.#Failure error}
+                    false))
+                (_.coverage [/.has]
+                  (<| (try.else false)
+                      (do try.monad
+                        [sample (/.has good_index non_member sample)
+                         actual (/.item good_index sample)]
+                        (in (same? non_member actual)))))
+                (_.coverage [/.revised]
+                  (<| (try.else false)
+                      (do try.monad
+                        [sample (/.has good_index non_member sample)
+                         sample (/.revised good_index ++ sample)
+                         actual (/.item good_index sample)]
+                        (in (n.= (++ non_member) actual)))))
+                (_.coverage [/.within_bounds?]
+                  (and (/.within_bounds? sample good_index)
+                       (not (/.within_bounds? sample bad_index))))
+                (_.coverage [/.index_out_of_bounds]
+                  (let [fails! (is (All (_ a) (-> (Try a) Bit))
+                                   (function (_ situation)
+                                     (case situation
+                                       {try.#Success member}
+                                       false
+                                       
+                                       {try.#Failure error}
+                                       (exception.match? /.index_out_of_bounds error))))]
+                    (and (fails! (/.item bad_index sample))
+                         (fails! (/.has bad_index non_member sample))
+                         (fails! (/.revised bad_index ++ sample)))))
                 ))
          )))
 
@@ -152,66 +152,66 @@
                       [value/0 random.nat
                        value/1 random.nat
                        value/2 random.nat]
-                      (_.cover [/.sequence]
-                               (/#= (/.of_list (list value/0 value/1 value/2))
-                                    (/.sequence value/0 value/1 value/2))))
-                    (_.cover [/.member?]
-                             (and (list.every? (/.member? n.equivalence sample)
-                                               (/.list sample))
-                                  (not (/.member? n.equivalence sample non_member))))
-                    (_.cover [/.suffix]
-                             (let [added (/.suffix non_member sample)
+                      (_.coverage [/.sequence]
+                        (/#= (/.of_list (list value/0 value/1 value/2))
+                             (/.sequence value/0 value/1 value/2))))
+                    (_.coverage [/.member?]
+                      (and (list.every? (/.member? n.equivalence sample)
+                                        (/.list sample))
+                           (not (/.member? n.equivalence sample non_member))))
+                    (_.coverage [/.suffix]
+                      (let [added (/.suffix non_member sample)
 
-                                   size_increases!
-                                   (n.= (++ (/.size sample))
-                                        (/.size added))
+                            size_increases!
+                            (n.= (++ (/.size sample))
+                                 (/.size added))
 
-                                   is_a_member!
-                                   (/.member? n.equivalence added non_member)]
-                               (and size_increases!
-                                    is_a_member!)))
-                    (_.cover [/.prefix]
-                             (if (/.empty? sample)
-                               (/.empty? (/.prefix sample))
-                               (let [expected_size!
-                                     (n.= (-- (/.size sample))
-                                          (/.size (/.prefix sample)))
+                            is_a_member!
+                            (/.member? n.equivalence added non_member)]
+                        (and size_increases!
+                             is_a_member!)))
+                    (_.coverage [/.prefix]
+                      (if (/.empty? sample)
+                        (/.empty? (/.prefix sample))
+                        (let [expected_size!
+                              (n.= (-- (/.size sample))
+                                   (/.size (/.prefix sample)))
 
-                                     symmetry!
-                                     (|> sample
-                                         (/.suffix non_member)
-                                         /.prefix
-                                         (/#= sample))]
-                                 (and expected_size!
-                                      symmetry!))))
-                    (_.cover [/.only]
-                             (let [positives (/.only n.even? sample)
-                                   negatives (/.only (bit.complement n.even?) sample)]
-                               (and (/.every? n.even? positives)
-                                    (not (/.any? n.even? negatives))
+                              symmetry!
+                              (|> sample
+                                  (/.suffix non_member)
+                                  /.prefix
+                                  (/#= sample))]
+                          (and expected_size!
+                               symmetry!))))
+                    (_.coverage [/.only]
+                      (let [positives (/.only n.even? sample)
+                            negatives (/.only (bit.complement n.even?) sample)]
+                        (and (/.every? n.even? positives)
+                             (not (/.any? n.even? negatives))
 
-                                    (n.= (/.size sample)
-                                         (n.+ (/.size positives)
-                                              (/.size negatives))))))
-                    (_.cover [/.one]
-                             (let [(open "/#[0]") /.functor
-                                   choice (is (-> Nat (Maybe Text))
-                                              (function (_ value)
-                                                (if (n.even? value)
-                                                  {.#Some (# n.decimal encoded value)}
-                                                  {.#None})))]
-                               (case [(|> sample
-                                          (/.only n.even?)
-                                          (/#each (# n.decimal encoded))
-                                          (/.item 0))
-                                      (/.one choice sample)]
-                                 [{try.#Success expected} {.#Some actual}]
-                                 (text#= expected actual)
+                             (n.= (/.size sample)
+                                  (n.+ (/.size positives)
+                                       (/.size negatives))))))
+                    (_.coverage [/.one]
+                      (let [(open "/#[0]") /.functor
+                            choice (is (-> Nat (Maybe Text))
+                                       (function (_ value)
+                                         (if (n.even? value)
+                                           {.#Some (# n.decimal encoded value)}
+                                           {.#None})))]
+                        (case [(|> sample
+                                   (/.only n.even?)
+                                   (/#each (# n.decimal encoded))
+                                   (/.item 0))
+                               (/.one choice sample)]
+                          [{try.#Success expected} {.#Some actual}]
+                          (text#= expected actual)
 
-                                 [{try.#Failure _} {.#None}]
-                                 true
+                          [{try.#Failure _} {.#None}]
+                          true
 
-                                 _
-                                 false)))
+                          _
+                          false)))
                     ))
              ))))