De-sigil-ification: #

1 files changed, 33 insertions, 33 deletions

diff --git a/stdlib/source/test/lux/data/text.lux b/stdlib/source/test/lux/data/text.lux
index 2a3a3f919..3e1889c04 100644
--- a/stdlib/source/test/lux/data/text.lux
+++ b/stdlib/source/test/lux/data/text.lux
@@ -34,12 +34,12 @@
 (def: bounded_size
   (random.Random Nat)
   (|> random.nat
-      (# random.monad each (|>> (n.% 20) (n.+ 1)))))
+      (at random.monad each (|>> (n.% 20) (n.+ 1)))))
 
 (def: size
   Test
   (do [! random.monad]
-    [size (# ! each (n.% 10) random.nat)
+    [size (at ! each (n.% 10) random.nat)
      sample (random.unicode size)]
     (all _.and
          (_.coverage [/.size]
@@ -52,11 +52,11 @@
   Test
   (do [! random.monad]
     [inner (random.unicode 1)
-     outer (random.only (|>> (# /.equivalence = inner) not)
+     outer (random.only (|>> (at /.equivalence = inner) not)
                         (random.unicode 1))
      left (random.unicode 1)
      right (random.unicode 1)
-     .let [full (# /.monoid composite inner outer)
+     .let [full (at /.monoid composite inner outer)
            fake_index (-- 0)]]
     (`` (all _.and
              (~~ (template [<affix> <predicate>]
@@ -81,23 +81,23 @@
   Test
   (do [! random.monad]
     [inner (random.unicode 1)
-     outer (random.only (|>> (# /.equivalence = inner) not)
+     outer (random.only (|>> (at /.equivalence = inner) not)
                         (random.unicode 1))
      .let [fake_index (-- 0)]]
     (all _.and
          (_.coverage [/.contains?]
-           (let [full (# /.monoid composite inner outer)]
+           (let [full (at /.monoid composite inner outer)]
              (and (/.contains? inner full)
                   (/.contains? outer full))))
          (_.coverage [/.index]
-           (and (|> (/.index inner (# /.monoid composite inner outer))
+           (and (|> (/.index inner (at /.monoid composite inner outer))
                     (maybe.else fake_index)
                     (n.= 0))
-                (|> (/.index outer (# /.monoid composite inner outer))
+                (|> (/.index outer (at /.monoid composite inner outer))
                     (maybe.else fake_index)
                     (n.= 1))))
          (_.coverage [/.index_since]
-           (let [full (# /.monoid composite inner outer)]
+           (let [full (at /.monoid composite inner outer)]
              (and (|> (/.index_since 0 inner full)
                       (maybe.else fake_index)
                       (n.= 0))
@@ -115,7 +115,7 @@
                       (maybe.else fake_index)
                       (n.= fake_index)))))
          (_.coverage [/.last_index]
-           (let [full (all (# /.monoid composite) outer inner outer)]
+           (let [full (all (at /.monoid composite) outer inner outer)]
              (and (|> (/.last_index inner full)
                       (maybe.else fake_index)
                       (n.= 1))
@@ -131,7 +131,7 @@
               (`` (all _.and
                        (~~ (template [<short> <long>]
                              [(_.coverage [<short> <long>]
-                                (# /.equivalence = <short> <long>))]
+                                (at /.equivalence = <short> <long>))]
 
                              [/.\0  /.null]
                              [/.\a  /.alarm]
@@ -143,13 +143,13 @@
                              [/.\r  /.carriage_return]
                              [/.\'' /.double_quote]))
                        (_.coverage [/.line_feed]
-                         (# /.equivalence = /.new_line /.line_feed))
+                         (at /.equivalence = /.new_line /.line_feed))
                        )))
        (do [! random.monad]
-         [size (# ! each (|>> (n.% 10) ++) random.nat)
+         [size (at ! each (|>> (n.% 10) ++) random.nat)
           characters (random.set /.hash size (random.alphabetic 1))
           .let [sample (|> characters set.list /.together)]
-          expected (# ! each (n.% size) random.nat)]
+          expected (at ! each (n.% size) random.nat)]
          (_.coverage [/.char]
            (case (/.char expected sample)
              {.#Some char}
@@ -178,13 +178,13 @@
 (def: manipulation
   Test
   (do [! random.monad]
-    [size (# ! each (|>> (n.% 10) (n.+ 2)) random.nat)
+    [size (at ! each (|>> (n.% 10) (n.+ 2)) random.nat)
      characters (random.set /.hash size (random.alphabetic 1))
      separator (random.only (|>> (set.member? characters) not)
                             (random.alphabetic 1))
      .let [with_no_separator (|> characters set.list /.together)]
      static (random.alphabetic 1)
-     .let [dynamic (random.only (|>> (# /.equivalence = static) not)
+     .let [dynamic (random.only (|>> (at /.equivalence = static) not)
                                 (random.alphabetic 1))]
      pre dynamic
      post dynamic
@@ -200,19 +200,19 @@
                     (/.interposed separator)
                     (/.all_split_by separator)
                     (set.of_list /.hash)
-                    (# set.equivalence = characters))
-                (# /.equivalence =
-                   (/.together (set.list characters))
-                   (/.interposed "" (set.list characters)))))
+                    (at set.equivalence = characters))
+                (at /.equivalence =
+                    (/.together (set.list characters))
+                    (/.interposed "" (set.list characters)))))
          (_.coverage [/.replaced_once]
-           (# /.equivalence =
-              (# /.monoid composite post static)
-              (/.replaced_once pre post (# /.monoid composite pre static))))
+           (at /.equivalence =
+               (at /.monoid composite post static)
+               (/.replaced_once pre post (at /.monoid composite pre static))))
          (_.coverage [/.split_by]
-           (case (/.split_by static (all (# /.monoid composite) pre static post))
+           (case (/.split_by static (all (at /.monoid composite) pre static post))
              {.#Some [left right]}
-             (and (# /.equivalence = pre left)
-                  (# /.equivalence = post right))
+             (and (at /.equivalence = pre left)
+                  (at /.equivalence = post right))
              
              {.#None}
              false))
@@ -220,19 +220,19 @@
            (let [effectiveness!
                  (|> upper
                      /.lower_cased
-                     (# /.equivalence = upper)
+                     (at /.equivalence = upper)
                      not)
 
                  idempotence!
                  (|> lower
                      /.lower_cased
-                     (# /.equivalence = lower))
+                     (at /.equivalence = lower))
                  
                  inverse!
                  (|> lower
                      /.upper_cased
                      /.lower_cased
-                     (# /.equivalence = lower))]
+                     (at /.equivalence = lower))]
              (and effectiveness!
                   idempotence!
                   inverse!)))
@@ -240,19 +240,19 @@
            (let [effectiveness!
                  (|> lower
                      /.upper_cased
-                     (# /.equivalence = lower)
+                     (at /.equivalence = lower)
                      not)
 
                  idempotence!
                  (|> upper
                      /.upper_cased
-                     (# /.equivalence = upper))
+                     (at /.equivalence = upper))
                  
                  inverse!
                  (|> upper
                      /.lower_cased
                      /.upper_cased
-                     (# /.equivalence = upper))]
+                     (at /.equivalence = upper))]
              (and effectiveness!
                   idempotence!
                   inverse!)))
@@ -318,7 +318,7 @@
               .let [... The wider unicode charset includes control characters that
                     ... can make text replacement work improperly.
                     ... Because of that, I restrict the charset.
-                    normal_char_gen (|> random.nat (# ! each (|>> (n.% 128) (n.max 1))))]
+                    normal_char_gen (|> random.nat (at ! each (|>> (n.% 128) (n.max 1))))]
               sep1 (random.text normal_char_gen 1)
               sep2 (random.text normal_char_gen 1)
               .let [part_gen (|> (random.text normal_char_gen sizeP)