Re-named \ => # && \\ => ##

1 files changed, 21 insertions, 21 deletions

diff --git a/stdlib/source/test/lux/data/collection/sequence.lux b/stdlib/source/test/lux/data/collection/sequence.lux
index 0d772e7dd..2c9a8aca5 100644
--- a/stdlib/source/test/lux/data/collection/sequence.lux
+++ b/stdlib/source/test/lux/data/collection/sequence.lux
@@ -13,7 +13,7 @@
      ["[0]" text
       ["%" format {"+" [format]}]]
      [collection
-      ["[0]" list ("[1]\[0]" functor)]]]
+      ["[0]" list ("[1]#[0]" functor)]]]
     [math
      ["[0]" random]
      [number
@@ -25,7 +25,7 @@
   (All (_ a) (-> (Equivalence a) (Equivalence (/.Sequence a))))
 
   (def: (= reference subject)
-    (\ (list.equivalence super) =
+    (# (list.equivalence super) =
        (/.first 100 reference)
        (/.first 100 subject))))
 
@@ -42,12 +42,12 @@
   Test
   (<| (_.covering /._)
       (_.for [/.Sequence])
-      (let [(^open "list\[0]") (list.equivalence n.equivalence)])
+      (let [(^open "list#[0]") (list.equivalence n.equivalence)])
       (do [! random.monad]
         [repeated random.nat
-         index (\ ! each (n.% 100) random.nat)
-         size (\ ! each (|>> (n.% 10) ++) random.nat)
-         offset (\ ! each (n.% 100) random.nat)
+         index (# ! each (n.% 100) random.nat)
+         size (# ! each (|>> (n.% 10) ++) random.nat)
+         offset (# ! each (n.% 100) random.nat)
          cycle_start random.nat
          cycle_next (random.list size random.nat)]
         ($_ _.and
@@ -63,38 +63,38 @@
                      (n.= repeated
                           (/.item index (/.repeated repeated))))
             (_.cover [/.first]
-                     (list\= (enum.range n.enum offset (-- (n.+ size offset)))
+                     (list#= (enum.range n.enum offset (-- (n.+ size offset)))
                              (/.first size (..iterations ++ offset))))
             (_.cover [/.after]
-                     (list\= (enum.range n.enum offset (-- (n.+ size offset)))
+                     (list#= (enum.range n.enum offset (-- (n.+ size offset)))
                              (/.first size (/.after offset (..iterations ++ 0)))))
             (_.cover [/.split_at]
                      (let [[drops takes] (/.split_at size (..iterations ++ 0))]
-                       (and (list\= (enum.range n.enum 0 (-- size))
+                       (and (list#= (enum.range n.enum 0 (-- size))
                                     drops)
-                            (list\= (enum.range n.enum size (-- (n.* 2 size)))
+                            (list#= (enum.range n.enum size (-- (n.* 2 size)))
                                     (/.first size takes)))))
             (_.cover [/.while]
-                     (list\= (enum.range n.enum 0 (-- size))
+                     (list#= (enum.range n.enum 0 (-- size))
                              (/.while (n.< size) (..iterations ++ 0))))
             (_.cover [/.until]
-                     (list\= (enum.range n.enum offset (-- (n.+ size offset)))
+                     (list#= (enum.range n.enum offset (-- (n.+ size offset)))
                              (/.while (n.< (n.+ size offset))
                                       (/.until (n.< offset) (..iterations ++ 0)))))
             (_.cover [/.split_when]
                      (let [[drops takes] (/.split_when (n.= size) (..iterations ++ 0))]
-                       (and (list\= (enum.range n.enum 0 (-- size))
+                       (and (list#= (enum.range n.enum 0 (-- size))
                                     drops)
-                            (list\= (enum.range n.enum size (-- (n.* 2 size)))
+                            (list#= (enum.range n.enum size (-- (n.* 2 size)))
                                     (/.while (n.< (n.* 2 size)) takes)))))
             (_.cover [/.head]
                      (n.= offset
                           (/.head (..iterations ++ offset))))
             (_.cover [/.tail]
-                     (list\= (enum.range n.enum (++ offset) (n.+ size offset))
+                     (list#= (enum.range n.enum (++ offset) (n.+ size offset))
                              (/.first size (/.tail (..iterations ++ offset)))))
             (_.cover [/.only]
-                     (list\= (list\each (n.* 2) (enum.range n.enum 0 (-- size)))
+                     (list#= (list#each (n.* 2) (enum.range n.enum 0 (-- size)))
                              (/.first size (/.only n.even? (..iterations ++ 0)))))
             (_.cover [/.partition]
                      (let [[evens odds] (/.partition n.even? (..iterations ++ 0))]
@@ -103,16 +103,16 @@
                             (n.= (++ (n.* 2 offset))
                                  (/.item offset odds)))))
             (_.cover [/.iterations]
-                     (let [(^open "/\[0]") /.functor
-                           (^open "list\[0]") (list.equivalence text.equivalence)]
-                       (list\= (/.first size
-                                        (/\each %.nat (..iterations ++ offset)))
+                     (let [(^open "/#[0]") /.functor
+                           (^open "list#[0]") (list.equivalence text.equivalence)]
+                       (list#= (/.first size
+                                        (/#each %.nat (..iterations ++ offset)))
                                (/.first size
                                         (/.iterations (function (_ n) [(++ n) (%.nat n)])
                                                       offset)))))
             (_.cover [/.cycle]
                      (let [cycle (list& cycle_start cycle_next)]
-                       (list\= (list.together (list.repeated size cycle))
+                       (list#= (list.together (list.repeated size cycle))
                                (/.first (n.* size (list.size cycle))
                                         (/.cycle [cycle_start cycle_next])))))
             (_.cover [/.^sequence&]