- Minor refactorings and additions.

6 files changed, 265 insertions, 169 deletions

diff --git a/stdlib/source/lux/data/format/json.lux b/stdlib/source/lux/data/format/json.lux
index f9dafee7a..d9ef60605 100644
--- a/stdlib/source/lux/data/format/json.lux
+++ b/stdlib/source/lux/data/format/json.lux
@@ -628,8 +628,8 @@
     (#;Left _)  (#;Right #;None)
     (#;Right x) (#;Right (#;Some x))))
 
-(def: #export (run parser json)
-  (All [a] (-> (Parser a) JSON (Error a)))
+(def: #export (run json parser)
+  (All [a] (-> JSON (Parser a) (Error a)))
   (parser json))
 
 (def: #export (ensure test parser json)
@@ -710,7 +710,7 @@
 
 (struct: #export _ (Codec Text JSON)
   (def: encode show-json)
-  (def: decode (lexer;run (json~' []))))
+  (def: decode (lambda [input] (lexer;run input (json~' [])))))
 
 ## [Syntax]
 (type: Shape
@@ -980,7 +980,7 @@
                                     (lambda [(~ g!key)]
                                       (do Monad<Error>
                                         [(~ g!val) (;;get (~ g!key) (~ g!input))
-                                         (~ g!val) (;;run (~ .val.) (~ g!val))]
+                                         (~ g!val) (;;run (~ g!val) (~ .val.))]
                                         ((~ (' wrap)) [(~ g!key) (~ g!val)])))
                                     (~ g!key))))
                           )))
diff --git a/stdlib/source/lux/lexer.lux b/stdlib/source/lux/lexer.lux
index 04e9dfef1..bc5bea5f0 100644
--- a/stdlib/source/lux/lexer.lux
+++ b/stdlib/source/lux/lexer.lux
@@ -15,7 +15,7 @@
              [product]
              [char "Char/" Ord<Char>]
              maybe
-             [error #- fail]
+             ["E" error #- fail]
              (struct [list "" Functor<List>]))
        host))
 
@@ -28,29 +28,29 @@
   (def: (map f fa)
     (lambda [input]
       (case (fa input)
-        (#;Left msg)              (#;Left msg)
-        (#;Right [input' output]) (#;Right [input' (f output)])))))
+        (#E;Error msg)              (#E;Error msg)
+        (#E;Success [input' output]) (#E;Success [input' (f output)])))))
 
 (struct: #export _ (Applicative Lexer)
   (def: functor Functor<Lexer>)
 
   (def: (wrap a)
     (lambda [input]
-      (#;Right [input a])))
+      (#E;Success [input a])))
 
   (def: (apply ff fa)
     (lambda [input]
       (case (ff input)
-        (#;Right [input' f])
+        (#E;Success [input' f])
         (case (fa input')
-          (#;Right [input'' a])
-          (#;Right [input'' (f a)])
+          (#E;Success [input'' a])
+          (#E;Success [input'' (f a)])
 
-          (#;Left msg)
-          (#;Left msg))
+          (#E;Error msg)
+          (#E;Error msg))
 
-        (#;Left msg)
-        (#;Left msg)))))
+        (#E;Error msg)
+        (#E;Error msg)))))
 
 (struct: #export _ (Monad Lexer)
   (def: applicative Applicative<Lexer>)
@@ -58,31 +58,31 @@
   (def: (join mma)
     (lambda [input]
       (case (mma input)
-        (#;Left msg)          (#;Left msg)
-        (#;Right [input' ma]) (ma input'))))
+        (#E;Error msg)          (#E;Error msg)
+        (#E;Success [input' ma]) (ma input'))))
   )
 
 ## [Values]
 ## Runner
-(def: #export (run' lexer input)
-  (All [a] (-> (Lexer a) Text (Error [Text a])))
+(def: #export (run' input lexer)
+  (All [a] (-> Text (Lexer a) (Error [Text a])))
   (lexer input))
 
-(def: #export (run lexer input)
-  (All [a] (-> (Lexer a) Text (Error a)))
+(def: #export (run input lexer)
+  (All [a] (-> Text (Lexer a) (Error a)))
   (case (lexer input)
-    (#;Left msg)
-    (#;Left msg)
+    (#E;Error msg)
+    (#E;Error msg)
     
-    (#;Right [input' output])
-    (#;Right output)
+    (#E;Success [input' output])
+    (#E;Success output)
     ))
 
 ## Combinators
 (def: #export (fail message)
   (All [a] (-> Text (Lexer a)))
   (lambda [input]
-    (#;Left message)))
+    (#E;Error message)))
 
 (def: #export any
   {#;doc "Just returns the next character without applying any logic."}
@@ -90,10 +90,10 @@
   (lambda [input]
     (case [(text;at +0 input) (text;split +1 input)]
       [(#;Some output) (#;Some [_ input'])]
-      (#;Right [input' output])
+      (#E;Success [input' output])
 
       _
-      (#;Left "Can't parse character from empty text."))
+      (#E;Error "Can't parse character from empty text."))
     ))
 
 (def: #export (seq left right)
@@ -109,45 +109,45 @@
   (All [a b] (-> (Lexer a) (Lexer b) (Lexer (| a b))))
   (lambda [input]
     (case (left input)
-      (#;Left msg)
+      (#E;Error msg)
       (case (right input)
-        (#;Left msg)
-        (#;Left msg)
+        (#E;Error msg)
+        (#E;Error msg)
 
-        (#;Right [input' output])
-        (#;Right [input' (+1 output)]))
+        (#E;Success [input' output])
+        (#E;Success [input' (+1 output)]))
 
-      (#;Right [input' output])
-      (#;Right [input' (+0 output)]))))
+      (#E;Success [input' output])
+      (#E;Success [input' (+0 output)]))))
 
 (def: #export (not! p)
   {#;doc "Ensure a lexer fails."}
   (All [a] (-> (Lexer a) (Lexer Unit)))
   (lambda [input]
     (case (p input)
-      (#;Left msg)
-      (#;Right [input []])
+      (#E;Error msg)
+      (#E;Success [input []])
       
       _
-      (#;Left "Expected to fail; yet succeeded."))))
+      (#E;Error "Expected to fail; yet succeeded."))))
 
 (def: #export (not p)
   {#;doc "Produce a character if the lexer fails."}
   (All [a] (-> (Lexer a) (Lexer Char)))
   (lambda [input]
     (case (p input)
-      (#;Left msg)
+      (#E;Error msg)
       (any input)
       
       _
-      (#;Left "Expected to fail; yet succeeded."))))
+      (#E;Error "Expected to fail; yet succeeded."))))
 
 (def: #export (either left right)
   {#;doc "Homogeneous alternative combinator."}
   (All [a] (-> (Lexer a) (Lexer a) (Lexer a)))
   (lambda [input]
     (case (left input)
-      (#;Left msg)
+      (#E;Error msg)
       (right input)
 
       output
@@ -158,22 +158,22 @@
   (-> Text Bool (Lexer Unit))
   (lambda [input]
     (if test
-      (#;Right [input []])
-      (#;Left message))))
+      (#E;Success [input []])
+      (#E;Error message))))
 
 (def: #export (some p)
   {#;doc "0-or-more combinator."}
   (All [a] (-> (Lexer a) (Lexer (List a))))
   (lambda [input]
     (case (p input)
-      (#;Left msg)
-      (#;Right [input (list)])
+      (#E;Error msg)
+      (#E;Success [input (list)])
       
-      (#;Right [input' x])
-      (run' (do Monad<Lexer>
+      (#E;Success [input' x])
+      (run' input'
+            (do Monad<Lexer>
               [xs (some p)]
-              (wrap (#;Cons x xs)))
-            input'))
+              (wrap (#;Cons x xs)))))
     ))
 
 (def: #export (many p)
@@ -200,14 +200,14 @@
   (if (n.> +0 n)
     (lambda [input]
       (case (p input)
-        (#;Left msg)
-        (#;Right [input (list)])
+        (#E;Error msg)
+        (#E;Success [input (list)])
 
-        (#;Right [input' x])
-        (run' (do Monad<Lexer>
+        (#E;Success [input' x])
+        (run' input'
+              (do Monad<Lexer>
                 [xs (at-most (n.dec n) p)]
-                (wrap (#;Cons x xs)))
-              input')
+                (wrap (#;Cons x xs))))
         ))
     (:: Monad<Lexer> wrap (list))))
 
@@ -232,11 +232,11 @@
   (All [a] (-> (Lexer a) (Lexer (Maybe a))))
   (lambda [input]
     (case (p input)
-      (#;Left msg)
-      (#;Right [input #;None])
+      (#E;Error msg)
+      (#E;Success [input #;None])
 
-      (#;Right [input value])
-      (#;Right [input (#;Some value)])
+      (#E;Success [input value])
+      (#E;Success [input (#;Some value)])
       )))
 
 (def: #export (text test)
@@ -245,9 +245,9 @@
   (lambda [input]
     (if (text;starts-with? test input)
       (case (text;split (text;size test) input)
-        #;None              (#;Left "")
-        (#;Some [_ input']) (#;Right [input' test]))
-      (#;Left (format "Invalid match: " test " @ " (:: text;Codec<Text,Text> encode input))))
+        #;None              (#E;Error "")
+        (#;Some [_ input']) (#E;Success [input' test]))
+      (#E;Error (format "Invalid match: " test " @ " (:: text;Codec<Text,Text> encode input))))
     ))
 
 (def: #export (sep-by sep lexer)
@@ -270,8 +270,8 @@
   (Lexer Unit)
   (lambda [input]
     (case input
-      "" (#;Right [input []])
-      _  (#;Left (format "The text input has not been fully consumed @ " (:: text;Codec<Text,Text> encode input)))
+      "" (#E;Success [input []])
+      _  (#E;Error (format "The text input has not been fully consumed @ " (:: text;Codec<Text,Text> encode input)))
       )))
 
 (def: #export peek
@@ -280,10 +280,10 @@
   (lambda [input]
     (case (text;at +0 input)
       (#;Some output)
-      (#;Right [input output])
+      (#E;Success [input output])
 
       _
-      (#;Left "Can't peek character from empty text."))
+      (#E;Error "Can't peek character from empty text."))
     ))
 
 (def: #export (char test)
@@ -293,19 +293,19 @@
     (case [(text;at +0 input) (text;split +1 input)]
       [(#;Some char') (#;Some [_ input'])]
       (if (Char/= test char')
-        (#;Right [input' test])
-        (#;Left (format "Expected " (:: char;Codec<Text,Char> encode test) " @ " (:: text;Codec<Text,Text> encode input)
-                        " " (Int/encode (c2l test))" " (Int/encode (c2l [char'])))))
+        (#E;Success [input' test])
+        (#E;Error (format "Expected " (:: char;Codec<Text,Char> encode test) " @ " (:: text;Codec<Text,Text> encode input)
+                          " " (Int/encode (c2l test))" " (Int/encode (c2l [char'])))))
 
       _
-      (#;Left "Can't parse character from empty text."))
+      (#E;Error "Can't parse character from empty text."))
     ))
 
 (def: #export get-input
   {#;doc "Get all of the remaining input (without consuming it)."}
   (Lexer Text)
   (lambda [input]
-    (#;Right [input input])))
+    (#E;Success [input input])))
 
 (def: #export (char-range bottom top)
   {#;doc "Only lex characters within a range."}
@@ -357,14 +357,14 @@
       (if (text;contains? init options)
         (case (text;at +0 init)
           (#;Some output)
-          (#;Right [input' output])
+          (#E;Success [input' output])
 
           _
-          (#;Left ""))
-        (#;Left (format "Character (" init ") is not one of: " options " @ " (:: text;Codec<Text,Text> encode input))))
+          (#E;Error ""))
+        (#E;Error (format "Character (" init ") is not one of: " options " @ " (:: text;Codec<Text,Text> encode input))))
 
       _
-      (#;Left "Can't parse character from empty text."))))
+      (#E;Error "Can't parse character from empty text."))))
 
 (def: #export (none-of options)
   {#;doc "Only lex characters that aren't part of a piece of text."}
@@ -375,14 +375,14 @@
       (if (;not (text;contains? init options))
         (case (text;at +0 init)
           (#;Some output)
-          (#;Right [input' output])
+          (#E;Success [input' output])
 
           _
-          (#;Left ""))
-        (#;Left (format "Character (" init ") is one of: " options " @ " (:: text;Codec<Text,Text> encode input))))
+          (#E;Error ""))
+        (#E;Error (format "Character (" init ") is one of: " options " @ " (:: text;Codec<Text,Text> encode input))))
 
       _
-      (#;Left "Can't parse character from empty text."))))
+      (#E;Error "Can't parse character from empty text."))))
 
 (def: #export (satisfies p)
   {#;doc "Only lex characters that satisfy a predicate."}
@@ -395,11 +395,11 @@
                (wrap [input' output])))
       (#;Some [input' output])
       (if (p output)
-        (#;Right [input' output])
-        (#;Left (format "Character does not satisfy predicate: " (:: text;Codec<Text,Text> encode input))))
+        (#E;Success [input' output])
+        (#E;Error (format "Character does not satisfy predicate: " (:: text;Codec<Text,Text> encode input))))
 
       _
-      (#;Left "Can't parse character from empty text."))))
+      (#E;Error "Can't parse character from empty text."))))
 
 (def: #export space
   {#;doc "Only lex white-space."}
@@ -424,7 +424,7 @@
   {#;doc "Ask if the lexer's input is empty."}
   (Lexer Bool)
   (lambda [input]
-    (#;Right [input (text;empty? input)])))
+    (#E;Success [input (text;empty? input)])))
 
 (def: #export (_& left right)
   (All [a b] (-> (Lexer a) (Lexer b) (Lexer b)))
@@ -444,30 +444,49 @@
   (All [a] (-> a (Lexer a) (Lexer a)))
   (lambda [input]
     (case (lexer input)
-      (#;Left error)
-      (#;Right [input value])
+      (#E;Error error)
+      (#E;Success [input value])
 
-      (#;Right input'+value)
-      (#;Right input'+value))))
+      (#E;Success input'+value)
+      (#E;Success input'+value))))
 
 (def: #export (codec codec lexer)
   {#;doc "Lex a token by means of a codec."}
   (All [a] (-> (Codec Text a) (Lexer Text) (Lexer a)))
   (lambda [input]
     (case (lexer input)
-      (#;Left error)
-      (#;Left error)
+      (#E;Error error)
+      (#E;Error error)
 
-      (#;Right [input' to-decode])
+      (#E;Success [input' to-decode])
       (case (:: codec decode to-decode)
-        (#;Left error)
-        (#;Left error)
+        (#E;Error error)
+        (#E;Error error)
         
-        (#;Right value)
-        (#;Right [input' value])))))
+        (#E;Success value)
+        (#E;Success [input' value])))))
 
 (def: #export (enclosed [start end] lexer)
   (All [a] (-> [Text Text] (Lexer a) (Lexer a)))
   (_& (text start)
       (&_ lexer
           (text end))))
+
+(def: #export (rec lexer)
+  (All [a] (-> (-> (Lexer a) (Lexer a))
+               (Lexer a)))
+  (lambda [input]
+    (run' input (lexer (rec lexer)))))
+
+(def: #export (local local-input lexer)
+  {#;doc "Run a lexer with the given input, instead of the real one."}
+  (All [a] (-> Text (Lexer a) (Lexer a)))
+  (lambda [real-input]
+    (case (run' local-input lexer)
+      (#E;Error error)
+      (#E;Error error)
+
+      (#E;Success [unconsumed value])
+      (if (Text/= "" unconsumed)
+        (#E;Success [real-input value])
+        (#E;Error (format "Unconsumed input: " unconsumed))))))
diff --git a/stdlib/source/lux/macro/syntax.lux b/stdlib/source/lux/macro/syntax.lux
index d043a0b29..dd7a3ac06 100644
--- a/stdlib/source/lux/macro/syntax.lux
+++ b/stdlib/source/lux/macro/syntax.lux
@@ -408,6 +408,12 @@
                              (|> (map ast;to-text unconsumed-inputs)
                                  (text;join-with ", "))))))))
 
+(def: #export (rec syntax)
+  {#;doc "Combinator for recursive syntax."}
+  (All [a] (-> (-> (Syntax a) (Syntax a)) (Syntax a)))
+  (lambda [inputs]
+    (run inputs (syntax (rec syntax)))))
+
 ## [Syntax]
 (def: #hidden text.join-with text;join-with)
 
diff --git a/stdlib/source/lux/regex.lux b/stdlib/source/lux/regex.lux
index 417abc086..5684a4465 100644
--- a/stdlib/source/lux/regex.lux
+++ b/stdlib/source/lux/regex.lux
@@ -481,7 +481,8 @@
               )}
   (do @
     [current-module compiler;current-module-name]
-    (case (&;run (&;&_ (regex^ current-module) &;end) pattern)
+    (case (&;run pattern
+                 (&;&_ (regex^ current-module) &;end))
       (#;Left error)
       (compiler;fail error)
 
diff --git a/stdlib/test/test/lux/lexer.lux b/stdlib/test/test/lux/lexer.lux
index 7e7408428..3c459ab8e 100644
--- a/stdlib/test/test/lux/lexer.lux
+++ b/stdlib/test/test/lux/lexer.lux
@@ -73,11 +73,13 @@
 (test: "End"
   ($_ seq
       (assert "Can detect the end of the input."
-              (|> (&;run &;end "")
+              (|> (&;run ""
+                         &;end)
                   (case> (#;Right _) true _ false)))
       
       (assert "Won't mistake non-empty text for no more input."
-              (|> (&;run &;end "YOLO")
+              (|> (&;run "YOLO"
+                         &;end)
                   (case> (#;Left _) true _ false)))
       ))
 
@@ -88,163 +90,231 @@
             (R;filter (|>. (text;starts-with? pre) not)))]
   ($_ seq
       (assert "Can find literal text fragments."
-              (and (|> (&;run (&;text pre) (format pre post))
+              (and (|> (&;run (format pre post)
+                              (&;text pre))
                        (case> (#;Right found) (T/= pre found) _ false))
-                   (|> (&;run (&;text pre) post)
+                   (|> (&;run post
+                              (&;text pre))
                        (case> (#;Left _) true _ false))))
       ))
 
 (test: "Char lexers"
   ($_ seq
       (assert "Can lex characters."
-              (and (|> (&;run (&;char #"Y") "YOLO")
+              (and (|> (&;run "YOLO"
+                              (&;char #"Y"))
                        (case> (#;Right #"Y") true _ false))
-                   (|> (&;run (&;char #"Y") "MEME")
+                   (|> (&;run "MEME"
+                              (&;char #"Y"))
                        (case> (#;Left _) true _ false))))
 
       (assert "Can lex characters ranges."
-              (and (should-passC #"Y" (&;run (&;char-range #"X" #"Z") "YOLO"))
-                   (should-fail (&;run (&;char-range #"X" #"Z") "MEME"))))
+              (and (should-passC #"Y" (&;run "YOLO"
+                                             (&;char-range #"X" #"Z")))
+                   (should-fail (&;run "MEME"
+                                       (&;char-range #"X" #"Z")))))
       ))
 
 (test: "Custom lexers"
   ($_ seq
       (assert "Can lex anything"
-              (and (should-passC #"A" (&;run &;any "A"))
-                   (should-fail (&;run &;any ""))))
+              (and (should-passC #"A" (&;run "A"
+                                             &;any))
+                   (should-fail (&;run ""
+                                       &;any))))
       
       (assert "Can lex upper-case and &;lower-case letters."
-              (and (should-passC #"Y" (&;run &;upper "YOLO"))
-                   (should-fail (&;run &;upper "meme"))
+              (and (should-passC #"Y" (&;run "YOLO"
+                                             &;upper))
+                   (should-fail (&;run "meme"
+                                       &;upper))
                    
-                   (should-passC #"y" (&;run &;lower "yolo"))
-                   (should-fail (&;run &;lower "MEME"))))
+                   (should-passC #"y" (&;run "yolo"
+                                             &;lower))
+                   (should-fail (&;run "MEME"
+                                       &;lower))))
 
       (assert "Can lex numbers."
-              (and (should-passC #"1" (&;run &;digit "1"))
-                   (should-fail (&;run &;digit " "))
+              (and (should-passC #"1" (&;run "1"
+                                             &;digit))
+                   (should-fail (&;run " "
+                                       &;digit))
 
-                   (should-passC #"7" (&;run &;oct-digit "7"))
-                   (should-fail (&;run &;oct-digit "8"))
+                   (should-passC #"7" (&;run "7"
+                                             &;oct-digit))
+                   (should-fail (&;run "8"
+                                       &;oct-digit))
 
-                   (should-passC #"1" (&;run &;hex-digit "1"))
-                   (should-passC #"a" (&;run &;hex-digit "a"))
-                   (should-passC #"A" (&;run &;hex-digit "A"))
-                   (should-fail (&;run &;hex-digit " "))
+                   (should-passC #"1" (&;run "1"
+                                             &;hex-digit))
+                   (should-passC #"a" (&;run "a"
+                                             &;hex-digit))
+                   (should-passC #"A" (&;run "A"
+                                             &;hex-digit))
+                   (should-fail (&;run " "
+                                       &;hex-digit))
                    ))
 
       (assert "Can lex alphabetic characters."
-              (and (should-passC #"A" (&;run &;alpha "A"))
-                   (should-passC #"a" (&;run &;alpha "a"))
-                   (should-fail (&;run &;alpha "1"))))
+              (and (should-passC #"A" (&;run "A"
+                                             &;alpha))
+                   (should-passC #"a" (&;run "a"
+                                             &;alpha))
+                   (should-fail (&;run "1"
+                                       &;alpha))))
 
       (assert "Can lex alphanumeric characters."
-              (and (should-passC #"A" (&;run &;alpha-num "A"))
-                   (should-passC #"a" (&;run &;alpha-num "a"))
-                   (should-passC #"1" (&;run &;alpha-num "1"))
-                   (should-fail (&;run &;alpha-num " "))))
+              (and (should-passC #"A" (&;run "A"
+                                             &;alpha-num))
+                   (should-passC #"a" (&;run "a"
+                                             &;alpha-num))
+                   (should-passC #"1" (&;run "1"
+                                             &;alpha-num))
+                   (should-fail (&;run " "
+                                       &;alpha-num))))
 
       (assert "Can lex white-space."
-              (and (should-passC #" " (&;run &;space " "))
-                   (should-fail (&;run &;space "8"))))
+              (and (should-passC #" " (&;run " "
+                                             &;space))
+                   (should-fail (&;run "8"
+                                       &;space))))
       ))
 
 (test: "Combinators"
   ($_ seq
       (assert "Can combine lexers sequentially."
-              (and (|> (&;run (&;seq &;any &;any) "YOLO")
+              (and (|> (&;run "YOLO"
+                              (&;seq &;any &;any))
                        (case> (#;Right [#"Y" #"O"]) true
                               _ false))
-                   (should-fail (&;run (&;seq &;any &;any) "Y"))))
+                   (should-fail (&;run "Y"
+                                       (&;seq &;any &;any)))))
       
       (assert "Can combine lexers alternatively."
-              (and (should-passE (#;Left #"0") (&;run (&;alt &;digit &;upper) "0"))
-                   (should-passE (#;Right #"A") (&;run (&;alt &;digit &;upper) "A"))
-                   (should-fail (&;run (&;alt &;digit &;upper) "a"))))
+              (and (should-passE (#;Left #"0") (&;run "0"
+                                                      (&;alt &;digit &;upper)))
+                   (should-passE (#;Right #"A") (&;run "A"
+                                                       (&;alt &;digit &;upper)))
+                   (should-fail (&;run "a"
+                                       (&;alt &;digit &;upper)))))
 
       (assert "Can create the opposite of a lexer."
-              (and (should-passC #"a" (&;run (&;not (&;alt &;digit &;upper)) "a"))
-                   (should-fail (&;run (&;not (&;alt &;digit &;upper)) "A"))))
+              (and (should-passC #"a" (&;run "a"
+                                             (&;not (&;alt &;digit &;upper))))
+                   (should-fail (&;run "A"
+                                       (&;not (&;alt &;digit &;upper))))))
       
       (assert "Can use either lexer."
-              (and (should-passC #"0" (&;run (&;either &;digit &;upper) "0"))
-                   (should-passC #"A" (&;run (&;either &;digit &;upper) "A"))
-                   (should-fail (&;run (&;either &;digit &;upper) "a"))))
+              (and (should-passC #"0" (&;run "0"
+                                             (&;either &;digit &;upper)))
+                   (should-passC #"A" (&;run "A"
+                                             (&;either &;digit &;upper)))
+                   (should-fail (&;run "a"
+                                       (&;either &;digit &;upper)))))
       
       (assert "Can select from among a set of characters."
-              (and (should-passC #"C" (&;run (&;one-of "ABC") "C"))
-                   (should-fail (&;run (&;one-of "ABC") "D"))))
+              (and (should-passC #"C" (&;run "C"
+                                             (&;one-of "ABC")))
+                   (should-fail (&;run "D"
+                                       (&;one-of "ABC")))))
 
       (assert "Can avoid a set of characters."
-              (and (should-passC #"D" (&;run (&;none-of "ABC") "D"))
-                   (should-fail (&;run (&;none-of "ABC") "C"))))
+              (and (should-passC #"D" (&;run "D"
+                                             (&;none-of "ABC")))
+                   (should-fail (&;run "C"
+                                       (&;none-of "ABC")))))
       
       (assert "Can lex using arbitrary predicates."
-              (and (should-passC #"D" (&;run (&;satisfies (lambda [c] true)) "D"))
-                   (should-fail (&;run (&;satisfies (lambda [c] false)) "C"))))
+              (and (should-passC #"D" (&;run "D"
+                                             (&;satisfies (lambda [c] true))))
+                   (should-fail (&;run "C"
+                                       (&;satisfies (lambda [c] false))))))
       
       (assert "Can apply a lexer multiple times."
-              (and (should-passT "0123456789ABCDEF" (&;run (&;many' &;hex-digit) "0123456789ABCDEF yolo"))
-                   (should-fail (&;run (&;many' &;hex-digit) "yolo"))
+              (and (should-passT "0123456789ABCDEF" (&;run "0123456789ABCDEF yolo"
+                                                           (&;many' &;hex-digit)))
+                   (should-fail (&;run "yolo"
+                                       (&;many' &;hex-digit)))
 
-                   (should-passT "" (&;run (&;some' &;hex-digit) "yolo"))))
+                   (should-passT "" (&;run "yolo"
+                                           (&;some' &;hex-digit)))))
       ))
 
 (test: "Yet more combinators..."
   ($_ seq
       (assert "Can fail at will."
-              (should-fail (&;run (&;fail "Well, it really SHOULD fail...") "yolo")))
+              (should-fail (&;run "yolo"
+                                  (&;fail "Well, it really SHOULD fail..."))))
       
       (assert "Can make assertions."
-              (and (should-fail (&;run (&;assert "Well, it really SHOULD fail..." false) "yolo"))
-                   (|> (&;run (&;assert "GO, GO, GO!" true) "yolo")
+              (and (should-fail (&;run "yolo"
+                                       (&;assert "Well, it really SHOULD fail..." false)))
+                   (|> (&;run "yolo"
+                              (&;assert "GO, GO, GO!" true))
                        (case> (#;Right []) true
                               _ false))))
 
       (assert "Can apply a lexer multiple times."
               (and (should-passL (list #"0" #"1" #"2" #"3" #"4" #"5" #"6" #"7" #"8" #"9" #"A" #"B" #"C" #"D" #"E" #"F")
-                                 (&;run (&;many &;hex-digit) "0123456789ABCDEF yolo"))
-                   (should-fail (&;run (&;many &;hex-digit) "yolo"))
+                                 (&;run "0123456789ABCDEF yolo"
+                                        (&;many &;hex-digit)))
+                   (should-fail (&;run "yolo"
+                                       (&;many &;hex-digit)))
 
                    (should-passL (list)
-                                 (&;run (&;some &;hex-digit) "yolo"))))
+                                 (&;run "yolo"
+                                        (&;some &;hex-digit)))))
       
       (assert "Can lex exactly N elements."
               (and (should-passL (list #"0" #"1" #"2" #"3" #"4" #"5" #"6" #"7" #"8" #"9" #"A" #"B" #"C" #"D" #"E" #"F")
-                                 (&;run (&;exactly +16 &;hex-digit) "0123456789ABCDEF yolo"))
+                                 (&;run "0123456789ABCDEF yolo"
+                                        (&;exactly +16 &;hex-digit)))
                    (should-passL (list #"0" #"1" #"2")
-                                 (&;run (&;exactly +3 &;hex-digit) "0123456789ABCDEF yolo"))
-                   (should-fail (&;run (&;exactly +17 &;hex-digit) "0123456789ABCDEF yolo"))))
+                                 (&;run "0123456789ABCDEF yolo"
+                                        (&;exactly +3 &;hex-digit)))
+                   (should-fail (&;run "0123456789ABCDEF yolo"
+                                       (&;exactly +17 &;hex-digit)))))
       
       (assert "Can lex at-most N elements."
               (and (should-passL (list #"0" #"1" #"2" #"3" #"4" #"5" #"6" #"7" #"8" #"9" #"A" #"B" #"C" #"D" #"E" #"F")
-                                 (&;run (&;at-most +16 &;hex-digit) "0123456789ABCDEF yolo"))
+                                 (&;run "0123456789ABCDEF yolo"
+                                        (&;at-most +16 &;hex-digit)))
                    (should-passL (list #"0" #"1" #"2")
-                                 (&;run (&;at-most +3 &;hex-digit) "0123456789ABCDEF yolo"))
+                                 (&;run "0123456789ABCDEF yolo"
+                                        (&;at-most +3 &;hex-digit)))
                    (should-passL (list #"0" #"1" #"2" #"3" #"4" #"5" #"6" #"7" #"8" #"9" #"A" #"B" #"C" #"D" #"E" #"F")
-                                 (&;run (&;at-most +17 &;hex-digit) "0123456789ABCDEF yolo"))))
+                                 (&;run "0123456789ABCDEF yolo"
+                                        (&;at-most +17 &;hex-digit)))))
       
       (assert "Can lex tokens between lower and upper boundaries of quantity."
               (and (should-passL (list #"0" #"1" #"2" #"3" #"4" #"5" #"6" #"7" #"8" #"9" #"A" #"B" #"C" #"D" #"E" #"F")
-                                 (&;run (&;between +0 +16 &;hex-digit) "0123456789ABCDEF yolo"))
+                                 (&;run "0123456789ABCDEF yolo"
+                                        (&;between +0 +16 &;hex-digit)))
                    (should-passL (list #"0" #"1" #"2" #"3" #"4" #"5" #"6" #"7" #"8" #"9" #"A" #"B" #"C" #"D" #"E" #"F")
-                                 (&;run (&;between +3 +16 &;hex-digit) "0123456789ABCDEF yolo"))
-                   (should-fail (&;run (&;between +17 +100 &;hex-digit) "0123456789ABCDEF yolo"))
+                                 (&;run "0123456789ABCDEF yolo"
+                                        (&;between +3 +16 &;hex-digit)))
+                   (should-fail (&;run "0123456789ABCDEF yolo"
+                                       (&;between +17 +100 &;hex-digit)))
                    (should-passL (list #"0" #"1" #"2" #"3" #"4" #"5" #"6" #"7" #"8" #"9" #"A" #"B" #"C" #"D" #"E" #"F")
-                                 (&;run (&;between +15 +20 &;hex-digit) "0123456789ABCDEF yolo"))))
+                                 (&;run "0123456789ABCDEF yolo"
+                                        (&;between +15 +20 &;hex-digit)))))
 
       (assert "Can optionally lex a token."
-              (and (|> (&;run (&;opt &;hex-digit) "123abc")
+              (and (|> (&;run "123abc"
+                              (&;opt &;hex-digit))
                        (case> (#;Right (#;Some #"1")) true
                               _ false))
-                   (|> (&;run (&;opt &;hex-digit) "yolo")
+                   (|> (&;run "yolo"
+                              (&;opt &;hex-digit))
                        (case> (#;Right #;None) true
                               _ false))))
 
       (assert "Can take into account separators during lexing."
               (should-passL (list #"0" #"1" #"2" #"3" #"4" #"5" #"6" #"7" #"8" #"9" #"a" #"b" #"c" #"d" #"e" #"f")
-                            (&;run (&;sep-by &;space &;hex-digit) "0 1 2 3 4 5 6 7 8 9 a b c d e f YOLO")))
+                            (&;run "0 1 2 3 4 5 6 7 8 9 a b c d e f YOLO"
+                                   (&;sep-by &;space &;hex-digit))))
       
       (assert "Can obtain the whole of the remaining input."
-              (should-passT "yolo" (&;run &;get-input "yolo")))
+              (should-passT "yolo" (&;run "yolo"
+                                          &;get-input)))
       ))
diff --git a/stdlib/test/test/lux/regex.lux b/stdlib/test/test/lux/regex.lux
index 281e6dbad..6c6854ce0 100644
--- a/stdlib/test/test/lux/regex.lux
+++ b/stdlib/test/test/lux/regex.lux
@@ -23,7 +23,7 @@
 ## [Utils]
 (def: (should-pass regex input)
   (-> (lexer;Lexer Text) Text Bool)
-  (|> (lexer;run regex input)
+  (|> (lexer;run input regex)
       (case> (#;Right parsed)
              (T/= parsed input)
 
@@ -32,7 +32,7 @@
 
 (def: (should-passT test regex input)
   (-> Text (lexer;Lexer Text) Text Bool)
-  (|> (lexer;run regex input)
+  (|> (lexer;run input regex)
       (case> (#;Right parsed)
              (T/= test parsed)
 
@@ -41,11 +41,11 @@
 
 (def: (should-fail regex input)
   (All [a] (-> (lexer;Lexer a) Text Bool))
-  (|> (lexer;run regex input)
+  (|> (lexer;run input regex)
       (case> (#;Left _) true _ false)))
 
 (syntax: (should-check pattern regex input)
-  (wrap (list (` (|> (lexer;run (~ regex) (~ input))
+  (wrap (list (` (|> (lexer;run (~ input) (~ regex))
                      (case> (^ (#;Right (~ pattern)))
                             true