- Re-named "Result" type back to "Error".

75 files changed, 927 insertions, 927 deletions

diff --git a/stdlib/source/lux/cli.lux b/stdlib/source/lux/cli.lux
index ba0689e89..ef8b05e41 100644
--- a/stdlib/source/lux/cli.lux
+++ b/stdlib/source/lux/cli.lux
@@ -5,7 +5,7 @@
        (data (coll [list "L/" Monoid<List> Monad<List>])
              [text "T/" Monoid<Text>]
              text/format
-             ["R" result]
+             ["E" error]
              [sum])
        [io]
        [macro #+ with-gensyms Functor<Lux> Monad<Lux>]
@@ -19,18 +19,18 @@
 
 ## [Combinators]
 (def: #export (run inputs parser)
-  (All [a] (-> (List Text) (CLI a) (R;Result a)))
+  (All [a] (-> (List Text) (CLI a) (E;Error a)))
   (case (p;run inputs parser)
-    (#R;Success [remaining output])
+    (#E;Success [remaining output])
     (case remaining
       #;Nil
-      (#R;Success output)
+      (#E;Success output)
 
       _
-      (#R;Error (format "Remaining CLI inputs: " (text;join-with " " remaining))))
+      (#E;Error (format "Remaining CLI inputs: " (text;join-with " " remaining))))
 
-    (#R;Error error)
-    (#R;Error error)))
+    (#E;Error error)
+    (#E;Error error)))
 
 (def: #export any
   {#;doc "Just returns the next input without applying any logic."}
@@ -38,26 +38,26 @@
   (function [inputs]
     (case inputs
       (#;Cons arg inputs')
-      (#R;Success [inputs' arg])
+      (#E;Success [inputs' arg])
       
       _
-      (#R;Error "Cannot parse empty arguments."))))
+      (#E;Error "Cannot parse empty arguments."))))
 
 (def: #export (parse parser)
   {#;doc "Parses the next input with a parsing function."}
-  (All [a] (-> (-> Text (R;Result a)) (CLI a)))
+  (All [a] (-> (-> Text (E;Error a)) (CLI a)))
   (function [inputs]
     (case inputs
       (#;Cons arg inputs')
       (case (parser arg)
-        (#R;Success value)
-        (#R;Success [inputs' value])
+        (#E;Success value)
+        (#E;Success [inputs' value])
 
-        (#R;Error parser-error)
-        (#R;Error parser-error))
+        (#E;Error parser-error)
+        (#E;Error parser-error))
       
       _
-      (#R;Error "Cannot parse empty arguments."))))
+      (#E;Error "Cannot parse empty arguments."))))
 
 (def: #export (option names)
   {#;doc "Checks that a given option (with multiple possible names) has a value."}
@@ -66,13 +66,13 @@
     (let [[pre post] (list;split-with (. ;not (list;member? text;Eq<Text> names)) inputs)]
       (case post
         #;Nil
-        (#R;Error ($_ T/compose "Missing option (" (text;join-with " " names) ")"))
+        (#E;Error ($_ T/compose "Missing option (" (text;join-with " " names) ")"))
 
         (^ (list& _ value post'))
-        (#R;Success [(L/compose pre post') value])
+        (#E;Success [(L/compose pre post') value])
 
         _
-        (#R;Error ($_ T/compose "Option lacks value (" (text;join-with " " names) ")"))
+        (#E;Error ($_ T/compose "Option lacks value (" (text;join-with " " names) ")"))
         ))))
 
 (def: #export (flag names)
@@ -82,18 +82,18 @@
     (let [[pre post] (list;split-with (. ;not (list;member? text;Eq<Text> names)) inputs)]
       (case post
         #;Nil
-        (#R;Success [pre false])
+        (#E;Success [pre false])
 
         (#;Cons _ post')
-        (#R;Success [(L/compose pre post') true])))))
+        (#E;Success [(L/compose pre post') true])))))
 
 (def: #export end
   {#;doc "Ensures there are no more inputs."}
   (CLI Unit)
   (function [inputs]
     (case inputs
-      #;Nil (#R;Success [inputs []])
-      _     (#R;Error (T/compose "Unknown parameters: " (text;join-with " " inputs))))))
+      #;Nil (#E;Success [inputs []])
+      _     (#E;Error (T/compose "Unknown parameters: " (text;join-with " " inputs))))))
 
 ## [Syntax]
 (type: Program-Args
@@ -145,10 +145,10 @@
                                                              []
                                                              (~ body)))))
                                            (~ g!args))
-                                      (#R;Success [(~ g!_) (~ g!output)])
+                                      (#E;Success [(~ g!_) (~ g!output)])
                                       (~ g!output)
 
-                                      (#R;Error (~ g!message))
+                                      (#E;Error (~ g!message))
                                       (error! (~ g!message))
                                       )))
                   )))
diff --git a/stdlib/source/lux/concurrency/task.lux b/stdlib/source/lux/concurrency/task.lux
index 4be7ead9d..374acee46 100644
--- a/stdlib/source/lux/concurrency/task.lux
+++ b/stdlib/source/lux/concurrency/task.lux
@@ -1,6 +1,6 @@
 (;module:
   lux
-  (lux (data ["R" result])
+  (lux (data ["E" error])
        (control ["F" functor]
                 ["A" applicative]
                 monad
@@ -11,11 +11,11 @@
        ))
 
 (type: #export (Task a)
-  (P;Promise (R;Result a)))
+  (P;Promise (E;Error a)))
 
 (def: #export (fail error)
   (All [a] (-> Text (Task a)))
-  (:: P;Applicative<Promise> wrap (#R;Error error)))
+  (:: P;Applicative<Promise> wrap (#E;Error error)))
 
 (def: #export (throw exception message)
   (All [a] (-> Exception Text (Task a)))
@@ -23,22 +23,22 @@
 
 (def: #export (return value)
   (All [a] (-> a (Task a)))
-  (:: P;Applicative<Promise> wrap (#R;Success value)))
+  (:: P;Applicative<Promise> wrap (#E;Success value)))
 
 (def: #export (try computation)
-  (All [a] (-> (Task a) (Task (R;Result a))))
-  (:: P;Functor<Promise> map (|>. #R;Success) computation))
+  (All [a] (-> (Task a) (Task (E;Error a))))
+  (:: P;Functor<Promise> map (|>. #E;Success) computation))
 
 (struct: #export _ (F;Functor Task)
   (def: (map f fa)
     (:: P;Functor<Promise> map
         (function [fa']
           (case fa'
-            (#R;Error error)
-            (#R;Error error)
+            (#E;Error error)
+            (#E;Error error)
 
-            (#R;Success a)
-            (#R;Success (f a))))
+            (#E;Success a)
+            (#E;Success (f a))))
         fa)))
 
 (struct: #export _ (A;Applicative Task)
@@ -50,7 +50,7 @@
     (do P;Monad<Promise>
       [ff' ff
        fa' fa]
-      (wrap (do R;Monad<Result>
+      (wrap (do E;Monad<Error>
               [f ff'
                a fa']
               (wrap (f a)))))))
@@ -62,10 +62,10 @@
     (do P;Monad<Promise>
       [mma' mma]
       (case mma'
-        (#R;Error error)
-        (wrap (#R;Error error))
+        (#E;Error error)
+        (wrap (#E;Error error))
 
-        (#R;Success ma)
+        (#E;Success ma)
         ma))))
 
 (syntax: #export (task [type s;any])
@@ -76,4 +76,4 @@
 
 (def: #export (from-promise promise)
   (All [a] (-> (P;Promise a) (Task a)))
-  (:: P;Functor<Promise> map (|>. #R;Success) promise))
+  (:: P;Functor<Promise> map (|>. #E;Success) promise))
diff --git a/stdlib/source/lux/control/codec.lux b/stdlib/source/lux/control/codec.lux
index e11f08016..55095ee3c 100644
--- a/stdlib/source/lux/control/codec.lux
+++ b/stdlib/source/lux/control/codec.lux
@@ -1,14 +1,14 @@
 (;module:
   lux
   (lux (control monad)
-       (data ["R" result])))
+       (data ["E" error])))
 
 ## [Signatures]
 (sig: #export (Codec m a)
   {#;doc "A way to move back-and-forth between a type and an alternative representation for it."}
   (: (-> a m)
      encode)
-  (: (-> m (R;Result a))
+  (: (-> m (E;Error a))
      decode))
 
 ## [Values]
@@ -22,7 +22,7 @@
          (:: Codec<c,b> encode)))
 
   (def: (decode cy)
-    (do R;Monad<Result>
+    (do E;Monad<Error>
       [by (:: Codec<c,b> decode cy)]
       (:: Codec<b,a> decode by)))
   )
diff --git a/stdlib/source/lux/control/exception.lux b/stdlib/source/lux/control/exception.lux
index fda8103f2..b8be7b70d 100644
--- a/stdlib/source/lux/control/exception.lux
+++ b/stdlib/source/lux/control/exception.lux
@@ -1,7 +1,7 @@
-(;module: {#;doc "Exception-handling functionality built on top of the Result type."}
+(;module: {#;doc "Exception-handling functionality built on top of the Error type."}
   lux
   (lux (control monad)
-       (data ["R" result]
+       (data ["E" error]
              [maybe]
              [text "text/" Monoid<Text>])
        [macro]
@@ -30,41 +30,41 @@
 
           If no exception was detected, or a different one from the one being checked, then pass along the original value."}
   (All [a]
-    (-> Exception (-> Text a) (R;Result a)
-        (R;Result a)))
+    (-> Exception (-> Text a) (E;Error a)
+        (E;Error a)))
   (case try
-    (#R;Success output)
-    (#R;Success output)
+    (#E;Success output)
+    (#E;Success output)
 
-    (#R;Error error)
+    (#E;Error error)
     (let [reference (exception "")]
       (if (text;starts-with? reference error)
-        (#R;Success (|> error
+        (#E;Success (|> error
                         (text;clip (text;size reference) (text;size error))
                         maybe;assume
                         then))
-        (#R;Error error)))))
+        (#E;Error error)))))
 
 (def: #export (otherwise to-do try)
   {#;doc "If no handler could be found to catch the exception, then run a function as a last-resort measure."}
   (All [a]
-    (-> (-> Text a) (R;Result a) a))
+    (-> (-> Text a) (E;Error a) a))
   (case try
-    (#R;Success output)
+    (#E;Success output)
     output
 
-    (#R;Error error)
+    (#E;Error error)
     (to-do error)))
 
 (def: #export (return value)
-  {#;doc "A way to lift normal values into the result-handling context."}
-  (All [a] (-> a (R;Result a)))
-  (#R;Success value))
+  {#;doc "A way to lift normal values into the error-handling context."}
+  (All [a] (-> a (E;Error a)))
+  (#E;Success value))
 
 (def: #export (throw exception message)
-  {#;doc "Decorate an error message with an Exception and lift it into the result-handling context."}
-  (All [a] (-> Exception Text (R;Result a)))
-  (#R;Error (exception message)))
+  {#;doc "Decorate an error message with an Exception and lift it into the error-handling context."}
+  (All [a] (-> Exception Text (E;Error a)))
+  (#E;Error (exception message)))
 
 (syntax: #export (exception: [_ex-lev csr;export] [name s;local-symbol])
   {#;doc (doc "Define a new exception type."
diff --git a/stdlib/source/lux/control/parser.lux b/stdlib/source/lux/control/parser.lux
index 606d8d448..166826519 100644
--- a/stdlib/source/lux/control/parser.lux
+++ b/stdlib/source/lux/control/parser.lux
@@ -6,43 +6,43 @@
                 [codec])
        (data (coll [list "list/" Functor<List> Monoid<List>])
              [product]
-             ["R" result])))
+             ["E" error])))
 
 (type: #export (Parser s a)
   {#;doc "A generic parser."}
-  (-> s (R;Result [s a])))
+  (-> s (E;Error [s a])))
 
 ## [Structures]
 (struct: #export Functor<Parser> (All [s] (Functor (Parser s)))
   (def: (map f ma)
     (function [input]
       (case (ma input)
-        (#R;Error msg)
-        (#R;Error msg)
+        (#E;Error msg)
+        (#E;Error msg)
 
-        (#R;Success [input' a])
-        (#R;Success [input' (f a)])))))
+        (#E;Success [input' a])
+        (#E;Success [input' (f a)])))))
 
 (struct: #export Applicative<Parser> (All [s] (Applicative (Parser s)))
   (def: functor Functor<Parser>)
 
   (def: (wrap x)
     (function [input]
-      (#R;Success [input x])))
+      (#E;Success [input x])))
 
   (def: (apply ff fa)
     (function [input]
       (case (ff input)
-        (#R;Success [input' f])
+        (#E;Success [input' f])
         (case (fa input')
-          (#R;Success [input'' a])
-          (#R;Success [input'' (f a)])
+          (#E;Success [input'' a])
+          (#E;Success [input'' (f a)])
 
-          (#R;Error msg)
-          (#R;Error msg))
+          (#E;Error msg)
+          (#E;Error msg))
 
-        (#R;Error msg)
-        (#R;Error msg)))))
+        (#E;Error msg)
+        (#E;Error msg)))))
 
 (struct: #export Monad<Parser> (All [s] (Monad (Parser s)))
   (def: applicative Applicative<Parser>)
@@ -50,10 +50,10 @@
   (def: (join mma)
     (function [input]
       (case (mma input)
-        (#R;Error msg)
-        (#R;Error msg)
+        (#E;Error msg)
+        (#E;Error msg)
 
-        (#R;Success [input' ma])
+        (#E;Success [input' ma])
         (ma input')))))
 
 ## [Parsers]
@@ -62,8 +62,8 @@
   (All [s] (-> Text Bool (Parser s Unit)))
   (function [input]
     (if test
-      (#R;Success [input []])
-      (#R;Error message))))
+      (#E;Success [input []])
+      (#E;Error message))))
 
 (def: #export (maybe p)
   {#;doc "Optionality combinator."}
@@ -71,12 +71,12 @@
     (-> (Parser s a) (Parser s (Maybe a))))
   (function [input]
     (case (p input)
-      (#R;Error _)            (#R;Success [input #;None])
-      (#R;Success [input' x]) (#R;Success [input' (#;Some x)]))))
+      (#E;Error _)            (#E;Success [input #;None])
+      (#E;Success [input' x]) (#E;Success [input' (#;Some x)]))))
 
 (def: #export (run input p)
   (All [s a]
-    (-> s (Parser s a) (R;Result [s a])))
+    (-> s (Parser s a) (E;Error [s a])))
   (p input))
 
 (def: #export (some p)
@@ -85,8 +85,8 @@
     (-> (Parser s a) (Parser s (List a))))
   (function [input]
     (case (p input)
-      (#R;Error _)            (#R;Success [input (list)])
-      (#R;Success [input' x]) (run input'
+      (#E;Error _)            (#E;Success [input (list)])
+      (#E;Success [input' x]) (run input'
                                    (do Monad<Parser>
                                      [xs (some p)]
                                      (wrap (list& x xs)))
@@ -116,8 +116,8 @@
     (-> (Parser s a) (Parser s b) (Parser s (| a b))))
   (function [tokens]
     (case (p1 tokens)
-      (#R;Success [tokens' x1]) (#R;Success [tokens' (+0 x1)])
-      (#R;Error _)             (run tokens
+      (#E;Success [tokens' x1]) (#E;Success [tokens' (+0 x1)])
+      (#E;Error _)             (run tokens
                                     (do Monad<Parser>
                                       [x2 p2]
                                       (wrap (+1 x2))))
@@ -129,7 +129,7 @@
     (-> (Parser s a) (Parser s a) (Parser s a)))
   (function [tokens]
     (case (pl tokens)
-      (#R;Error _) (pr tokens)
+      (#E;Error _) (pr tokens)
       output     output
       )))
 
@@ -157,10 +157,10 @@
   (if (n.> +0 n)
     (function [input]
       (case (p input)
-        (#R;Error msg)
-        (#R;Success [input (list)])
+        (#E;Error msg)
+        (#E;Success [input (list)])
 
-        (#R;Success [input' x])
+        (#E;Success [input' x])
         (run input'
              (do Monad<Parser>
                [xs (at-most (n.dec n) p)]
@@ -195,32 +195,32 @@
   (All [s a] (-> (Parser s a) (Parser s Unit)))
   (function [input]
     (case (p input)
-      (#R;Error msg)
-      (#R;Success [input []])
+      (#E;Error msg)
+      (#E;Success [input []])
       
       _
-      (#R;Error "Expected to fail; yet succeeded."))))
+      (#E;Error "Expected to fail; yet succeeded."))))
 
 (def: #export (fail message)
   (All [s a] (-> Text (Parser s a)))
   (function [input]
-    (#R;Error message)))
+    (#E;Error message)))
 
 (def: #export (default value parser)
   {#;doc "If the given parser fails, returns the default value."}
   (All [s a] (-> a (Parser s a) (Parser s a)))
   (function [input]
     (case (parser input)
-      (#R;Error error)
-      (#R;Success [input value])
+      (#E;Error error)
+      (#E;Success [input value])
 
-      (#R;Success [input' output])
-      (#R;Success [input' output]))))
+      (#E;Success [input' output])
+      (#E;Success [input' output]))))
 
 (def: #export remaining
   (All [s] (Parser s s))
   (function [inputs]
-    (#R;Success [inputs inputs])))
+    (#E;Success [inputs inputs])))
 
 (def: #export (rec parser)
   {#;doc "Combinator for recursive parser."}
@@ -252,13 +252,13 @@
   (All [s a z] (-> (codec;Codec a z) (Parser s a) (Parser s z)))
   (function [input]
     (case (parser input)
-      (#R;Error error)
-      (#R;Error error)
+      (#E;Error error)
+      (#E;Error error)
 
-      (#R;Success [input' to-decode])
+      (#E;Success [input' to-decode])
       (case (:: Codec<a,z> decode to-decode)
-        (#R;Error error)
-        (#R;Error error)
+        (#E;Error error)
+        (#E;Error error)
         
-        (#R;Success value)
-        (#R;Success [input' value])))))
+        (#E;Success value)
+        (#E;Success [input' value])))))
diff --git a/stdlib/source/lux/data/coll/tree/parser.lux b/stdlib/source/lux/data/coll/tree/parser.lux
index 203f55b16..3b2400b92 100644
--- a/stdlib/source/lux/data/coll/tree/parser.lux
+++ b/stdlib/source/lux/data/coll/tree/parser.lux
@@ -2,7 +2,7 @@
   lux
   (lux (control ["p" parser]
                 ["ex" exception #+ exception:])
-       (data ["R" result]))
+       (data ["E" error]))
   (.. ["T" rose]
       ["Z" zipper]))
 
@@ -10,22 +10,22 @@
   (p;Parser (Z;Zipper t) a))
 
 (def: #export (run-zipper zipper parser)
-  (All [t a] (-> (Z;Zipper t) (Parser t a) (R;Result a)))
+  (All [t a] (-> (Z;Zipper t) (Parser t a) (E;Error a)))
   (case (p;run zipper parser)
-    (#R;Success [zipper output])
-    (#R;Success output)
+    (#E;Success [zipper output])
+    (#E;Success output)
 
-    (#R;Error error)
-    (#R;Error error)))
+    (#E;Error error)
+    (#E;Error error)))
 
 (def: #export (run tree parser)
-  (All [t a] (-> (T;Tree t) (Parser t a) (R;Result a)))
+  (All [t a] (-> (T;Tree t) (Parser t a) (E;Error a)))
   (run-zipper (Z;zip tree) parser))
 
 (def: #export value
   (All [t] (Parser t t))
   (function [zipper]
-    (#R;Success [zipper (Z;value zipper)])))
+    (#E;Success [zipper (Z;value zipper)])))
 
 (exception: #export Cannot-Move-Further)
 
@@ -36,7 +36,7 @@
        (let [next (<direction> zipper)]
          (if (is zipper next)
            (ex;throw Cannot-Move-Further "")
-           (#R;Success [next []])))))]
+           (#E;Success [next []])))))]
 
   [up        Z;up]
   [down      Z;down]
diff --git a/stdlib/source/lux/data/result.lux b/stdlib/source/lux/data/error.lux
index df52522af..e433d7454 100644
--- a/stdlib/source/lux/data/result.lux
+++ b/stdlib/source/lux/data/error.lux
@@ -5,19 +5,19 @@
                 ["M" monad #+ do Monad])))
 
 ## [Types]
-(type: #export (Result a)
+(type: #export (Error a)
   (#Error Text)
   (#Success a))
 
 ## [Structures]
-(struct: #export _ (F;Functor Result)
+(struct: #export _ (F;Functor Error)
   (def: (map f ma)
     (case ma
       (#Error msg)     (#Error msg)
       (#Success datum) (#Success (f datum)))))
 
-(struct: #export _ (A;Applicative Result)
-  (def: functor Functor<Result>)
+(struct: #export _ (A;Applicative Error)
+  (def: functor Functor<Error>)
 
   (def: (wrap a)
     (#Success a))
@@ -36,17 +36,17 @@
       (#Error msg))
     ))
 
-(struct: #export _ (Monad Result)
-  (def: applicative Applicative<Result>)
+(struct: #export _ (Monad Error)
+  (def: applicative Applicative<Error>)
 
   (def: (join mma)
     (case mma
       (#Error msg) (#Error msg)
       (#Success ma) ma)))
 
-(struct: #export (ResultT Monad<M>)
-  (All [M] (-> (Monad M) (Monad (All [a] (M (Result a))))))
-  (def: applicative (A;compose (get@ #M;applicative Monad<M>) Applicative<Result>))
+(struct: #export (ErrorT Monad<M>)
+  (All [M] (-> (Monad M) (Monad (All [a] (M (Error a))))))
+  (def: applicative (A;compose (get@ #M;applicative Monad<M>) Applicative<Error>))
   (def: (join MeMea)
     (do Monad<M>
       [eMea MeMea]
@@ -58,20 +58,20 @@
         Mea))))
 
 (def: #export (lift Monad<M>)
-  (All [M a] (-> (Monad M) (-> (M a) (M (Result a)))))
-  (M;lift Monad<M> (:: Monad<Result> wrap)))
+  (All [M a] (-> (Monad M) (-> (M a) (M (Error a)))))
+  (M;lift Monad<M> (:: Monad<Error> wrap)))
 
 (def: #export (succeed value)
-  (All [a] (-> a (Result a)))
+  (All [a] (-> a (Error a)))
   (#Success value))
 
 (def: #export (fail message)
-  (All [a] (-> Text (Result a)))
+  (All [a] (-> Text (Error a)))
   (#Error message))
 
-(def: #export (assume result)
-  (All [a] (-> (Result a) a))
-  (case result
+(def: #export (assume error)
+  (All [a] (-> (Error a) a))
+  (case error
     (#Success value)
     value
 
@@ -80,14 +80,14 @@
 
 (macro: #export (default tokens compiler)
   {#;doc (doc "Allows you to provide a default value that will be used"
-              "if a (Result x) value turns out to be #Error."
+              "if a (Error x) value turns out to be #Error."
               (is 10
                   (default 20 (#Success 10)))
               (is 20
                   (default 20 (#Error "KABOOM!"))))}
   (case tokens
-    (^ (list else result))
-    (#Success [compiler (list (` (case (~ result)
+    (^ (list else error))
+    (#Success [compiler (list (` (case (~ error)
                                    (#;;Success (~' g!temp))
                                    (~' g!temp)
 
diff --git a/stdlib/source/lux/data/format/context.lux b/stdlib/source/lux/data/format/context.lux
index a515052c6..5f0d29b11 100644
--- a/stdlib/source/lux/data/format/context.lux
+++ b/stdlib/source/lux/data/format/context.lux
@@ -3,7 +3,7 @@
   (lux (control ["p" parser]
                 ["ex" exception #+ exception:]
                 [monad #+ do])
-       (data ["R" result]
+       (data ["E" error]
              (coll ["d" dict]))))
 
 (exception: #export Unknown-Property)
@@ -25,10 +25,10 @@
       (ex;throw Unknown-Property name))))
 
 (def: #export (run context property)
-  (All [a] (-> Context (Property a) (R;Result a)))
+  (All [a] (-> Context (Property a) (E;Error a)))
   (case (property context)
-    (#R;Success [_ output])
-    (#R;Success output)
+    (#E;Success [_ output])
+    (#E;Success output)
 
-    (#R;Error error)
-    (#R;Error error)))
+    (#E;Error error)
+    (#E;Error error)))
diff --git a/stdlib/source/lux/data/format/json.lux b/stdlib/source/lux/data/format/json.lux
index 867cec189..7eac167e1 100644
--- a/stdlib/source/lux/data/format/json.lux
+++ b/stdlib/source/lux/data/format/json.lux
@@ -11,7 +11,7 @@
              (text ["l" lexer])
              [number "frac/" Codec<Text,Frac> "nat/" Codec<Text,Nat>]
              [maybe]
-             ["R" result]
+             ["E" error]
              [sum]
              [product]
              (coll [list "list/" Fold<List> Monad<List>]
@@ -96,52 +96,52 @@
 
 (def: #export (get-fields json)
   {#;doc "Get all the fields in a JSON object."}
-  (-> JSON (R;Result (List String)))
+  (-> JSON (E;Error (List String)))
   (case json
     (#Object obj)
-    (#R;Success (dict;keys obj))
+    (#E;Success (dict;keys obj))
 
     _
-    (#R;Error ($_ text/compose "Cannot get the fields of a non-object."))))
+    (#E;Error ($_ text/compose "Cannot get the fields of a non-object."))))
 
 (def: #export (get key json)
   {#;doc "A JSON object field getter."}
-  (-> String JSON (R;Result JSON))
+  (-> String JSON (E;Error JSON))
   (case json
     (#Object obj)
     (case (dict;get key obj)
       (#;Some value)
-      (#R;Success value)
+      (#E;Success value)
 
       #;None
-      (#R;Error ($_ text/compose "Missing field \"" key "\" on object.")))
+      (#E;Error ($_ text/compose "Missing field \"" key "\" on object.")))
 
     _
-    (#R;Error ($_ text/compose "Cannot get field \"" key "\" of a non-object."))))
+    (#E;Error ($_ text/compose "Cannot get field \"" key "\" of a non-object."))))
 
 (def: #export (set key value json)
   {#;doc "A JSON object field setter."}
-  (-> String JSON JSON (R;Result JSON))
+  (-> String JSON JSON (E;Error JSON))
   (case json
     (#Object obj)
-    (#R;Success (#Object (dict;put key value obj)))
+    (#E;Success (#Object (dict;put key value obj)))
 
     _
-    (#R;Error ($_ text/compose "Cannot set field \"" key "\" of a non-object."))))
+    (#E;Error ($_ text/compose "Cannot set field \"" key "\" of a non-object."))))
 
 (do-template [<name> <tag> <type> <desc>]
   [(def: #export (<name> key json)
      {#;doc (code;text ($_ text/compose "A JSON object field getter for " <desc> "."))}
-     (-> Text JSON (R;Result <type>))
+     (-> Text JSON (E;Error <type>))
      (case (get key json)
-       (#R;Success (<tag> value))
-       (#R;Success value)
+       (#E;Success (<tag> value))
+       (#E;Success value)
 
-       (#R;Success _)
-       (#R;Error ($_ text/compose "Wrong value type at key: " key))
+       (#E;Success _)
+       (#E;Error ($_ text/compose "Wrong value type at key: " key))
 
-       (#R;Error error)
-       (#R;Error error)))]
+       (#E;Error error)
+       (#E;Error error)))]
 
   [get-boolean #Boolean Boolean "booleans"]
   [get-number  #Number  Number  "numbers"]
@@ -195,23 +195,23 @@
 (def: unconsumed-input-error Text "Unconsumed JSON.")
 
 (def: #export (run json parser)
-  (All [a] (-> JSON (Reader a) (R;Result a)))
+  (All [a] (-> JSON (Reader a) (E;Error a)))
   (case (p;run (list json) parser)
-    (#R;Success [remainder output])
+    (#E;Success [remainder output])
     (case remainder
       #;Nil
-      (#R;Success output)
+      (#E;Success output)
 
       _
-      (#R;Error unconsumed-input-error))
+      (#E;Error unconsumed-input-error))
     
-    (#R;Error error)
-    (#R;Error error)))
+    (#E;Error error)
+    (#E;Error error)))
 
 (def: #export (fail error)
   (All [a] (-> Text (Reader a)))
   (function [inputs]
-    (#R;Error error)))
+    (#E;Error error)))
 
 (def: #export any
   {#;doc "Just returns the JSON input without applying any logic."}
@@ -219,10 +219,10 @@
   (<| (function [inputs])
       (case inputs
         #;Nil
-        (#R;Error "Empty JSON stream.")
+        (#E;Error "Empty JSON stream.")
         
         (#;Cons head tail)
-        (#R;Success [tail head]))))
+        (#E;Success [tail head]))))
 
 (do-template [<name> <type> <tag> <desc>]
   [(def: #export <name>
@@ -289,10 +289,10 @@
     (case head
       (#Array values)
       (case (p;run (vector;to-list values) parser)
-        (#R;Error error)
+        (#E;Error error)
         (fail error)
 
-        (#R;Success [remainder output])
+        (#E;Success [remainder output])
         (case remainder
           #;Nil
           (wrap output)
@@ -310,7 +310,7 @@
     [head any]
     (case head
       (#Object object)
-      (case (do R;Monad<Result>
+      (case (do E;Monad<Error>
               []
               (|> (dict;entries object)
                   (monad;map @ (function [[key val]]
@@ -318,10 +318,10 @@
                                    [val (run val parser)]
                                    (wrap [key val]))))
                   (:: @ map (dict;from-list text;Hash<Text>))))
-        (#R;Success table)
+        (#E;Success table)
         (wrap table)
 
-        (#R;Error error)
+        (#E;Error error)
         (fail error))
 
       _
@@ -337,13 +337,13 @@
       (case (dict;get field-name object)
         (#;Some value)
         (case (run value parser)
-          (#R;Success output)
+          (#E;Success output)
           (function [tail]
-            (#R;Success [(#;Cons (#Object (dict;remove field-name object))
+            (#E;Success [(#;Cons (#Object (dict;remove field-name object))
                                  tail)
                          output]))
 
-          (#R;Error error)
+          (#E;Error error)
           (fail error))
 
         _
@@ -438,10 +438,10 @@
                        offset (l;many l;decimal)]
                       (wrap ($_ text/compose mark (if signed?' "-" "") offset))))]
     (case (frac/decode ($_ text/compose (if signed? "-" "") digits "." decimals exp))
-      (#R;Error message)
+      (#E;Error message)
       (p;fail message)
       
-      (#R;Success value)
+      (#E;Success value)
       (wrap value))))
 
 (def: escaped~
diff --git a/stdlib/source/lux/data/format/xml.lux b/stdlib/source/lux/data/format/xml.lux
index 2be7afdd3..f2d1eb056 100644
--- a/stdlib/source/lux/data/format/xml.lux
+++ b/stdlib/source/lux/data/format/xml.lux
@@ -8,7 +8,7 @@
        (data [text "text/" Eq<Text> Monoid<Text>]
              (text ["l" lexer])
              [number]
-             ["R" result]
+             ["E" error]
              [product]
              [maybe "m/" Monad<Maybe>]
              [ident "ident/" Eq<Ident> Codec<Text,Ident>]
@@ -170,7 +170,7 @@
       (p;after (p;maybe xml-header^))))
 
 (def: #export (read input)
-  (-> Text (R;Result XML))
+  (-> Text (E;Error XML))
   (l;run input xml^))
 
 (def: (sanitize-value input)
@@ -262,7 +262,7 @@
       (#;Cons head tail)
       (case head
         (#Text value)
-        (#R;Success [tail value])
+        (#E;Success [tail value])
         
         (#Node _)
         (ex;throw Unexpected-Input "")))))
@@ -285,20 +285,20 @@
           (ex;throw Unknown-Attribute "")
           
           (#;Some value)
-          (#R;Success [docs value]))))))
+          (#E;Success [docs value]))))))
 
 (def: (run' docs reader)
-  (All [a] (-> (List XML) (Reader a) (R;Result a)))
+  (All [a] (-> (List XML) (Reader a) (E;Error a)))
   (case (p;run docs reader)
-    (#R;Success [remaining output])
+    (#E;Success [remaining output])
     (if (list;empty? remaining)
-      (#R;Success output)
+      (#E;Success output)
       (ex;throw Unconsumed-Inputs (|> remaining
                                       (L/map (:: Codec<Text,XML> encode))
                                       (text;join-with "\n\n"))))
     
-    (#R;Error error)
-    (#R;Error error)))
+    (#E;Error error)
+    (#E;Error error)))
 
 (def: #export (node tag)
   (-> Ident (Reader Unit))
@@ -314,7 +314,7 @@
         
         (#Node _tag _attrs _children)
         (if (ident/= tag _tag)
-          (#R;Success [docs []])
+          (#E;Success [docs []])
           (ex;throw Wrong-Tag (ident/encode tag)))))))
 
 (def: #export (children reader)
@@ -330,7 +330,7 @@
         (ex;throw Unexpected-Input "")
         
         (#Node _tag _attrs _children)
-        (do R;Monad<Result>
+        (do E;Monad<Error>
           [output (run' _children reader)]
           (wrap [tail output]))))))
 
@@ -342,8 +342,8 @@
       (ex;throw Empty-Input "")
       
       (#;Cons head tail)
-      (#R;Success [tail []]))))
+      (#E;Success [tail []]))))
 
 (def: #export (run document reader)
-  (All [a] (-> XML (Reader a) (R;Result a)))
+  (All [a] (-> XML (Reader a) (E;Error a)))
   (run' (list document) reader))
diff --git a/stdlib/source/lux/data/number.lux b/stdlib/source/lux/data/number.lux
index 4f0c2b9d9..729c83979 100644
--- a/stdlib/source/lux/data/number.lux
+++ b/stdlib/source/lux/data/number.lux
@@ -8,7 +8,7 @@
                 enum
                 interval
                 codec)
-       (data ["R" result]
+       (data ["E" error]
              [maybe]
              [bit])))
 
@@ -163,10 +163,10 @@
      (def: (decode input)
        (case (_lux_proc <decoder> [input])
          (#;Some value)
-         (#R;Success value)
+         (#E;Success value)
 
          #;None
-         (#R;Error <error>))))]
+         (#E;Error <error>))))]
 
   [Frac ["frac" "encode"] ["frac" "decode"] "Could not decode Frac"]
   )
@@ -200,16 +200,16 @@
                    (let [digit (maybe;assume (get-char input idx))]
                      (case (_lux_proc ["text" "index"] [<char-set> digit +0])
                        #;None
-                       (#R;Error (_lux_proc ["text" "append"] [<error> repr]))
+                       (#E;Error (_lux_proc ["text" "append"] [<error> repr]))
 
                        (#;Some index)
                        (recur (n.inc idx)
                               (|> output (n.* <base>) (n.+ index)))))
-                   (#R;Success output))))
+                   (#E;Success output))))
 
              _
-             (#R;Error (_lux_proc ["text" "append"] [<error> repr])))
-           (#R;Error (_lux_proc ["text" "append"] [<error> repr]))))))]
+             (#E;Error (_lux_proc ["text" "append"] [<error> repr])))
+           (#E;Error (_lux_proc ["text" "append"] [<error> repr]))))))]
 
   [Binary@Codec<Text,Nat> +2  "01"               "Invalid binary syntax for Nat: "]
   [Octal@Codec<Text,Nat>  +8  "01234567"         "Invalid octal syntax for Nat: "]
@@ -251,13 +251,13 @@
                  (let [digit (maybe;assume (get-char input idx))]
                    (case (_lux_proc ["text" "index"] [<char-set> digit +0])
                      #;None
-                     (#R;Error <error>)
+                     (#E;Error <error>)
 
                      (#;Some index)
                      (recur (n.inc idx)
                             (|> output (i.* <base>) (i.+ (:! Int index))))))
-                 (#R;Success (i.* sign output)))))
-           (#R;Error <error>)))))]
+                 (#E;Success (i.* sign output)))))
+           (#E;Error <error>)))))]
 
   [Binary@Codec<Text,Int> 2  "01"               "Invalid binary syntax for Int: "]
   [Octal@Codec<Text,Int>  8  "01234567"         "Invalid octal syntax for Int: "]
@@ -291,11 +291,11 @@
              (^multi (^ (#;Some (char ".")))
                      [(:: <nat> decode (_lux_proc ["text" "append"] ["+" (de-prefix repr)]))
                       (#;Some output)])
-             (#R;Success (:! Deg output))
+             (#E;Success (:! Deg output))
 
              _
-             (#R;Error (_lux_proc ["text" "append"] [<error> repr])))
-           (#R;Error (_lux_proc ["text" "append"] [<error> repr]))))))]
+             (#E;Error (_lux_proc ["text" "append"] [<error> repr])))
+           (#E;Error (_lux_proc ["text" "append"] [<error> repr]))))))]
 
   [Binary@Codec<Text,Deg> Binary@Codec<Text,Nat> +1 "Invalid binary syntax: "]
   [Octal@Codec<Text,Deg>  Octal@Codec<Text,Nat>  +3 "Invalid octal syntax: "]
@@ -341,19 +341,19 @@
                                         (f.* <base> output))))
                    adjusted-decimal (|> decimal int-to-frac (f./ div-power))
                    dec-deg (case (:: Hex@Codec<Text,Deg> decode (_lux_proc ["text" "append"] ["." decimal-part]))
-                             (#R;Success dec-deg)
+                             (#E;Success dec-deg)
                              dec-deg
 
-                             (#R;Error error)
+                             (#E;Error error)
                              (error! error))]
-               (#R;Success (f.+ (int-to-frac whole)
+               (#E;Success (f.+ (int-to-frac whole)
                                 (f.* sign adjusted-decimal))))
 
              _
-             (#R;Error (_lux_proc ["text" "append"] [<error> repr]))))
+             (#E;Error (_lux_proc ["text" "append"] [<error> repr]))))
 
          _
-         (#R;Error (_lux_proc ["text" "append"] [<error> repr])))))]
+         (#E;Error (_lux_proc ["text" "append"] [<error> repr])))))]
 
   [Binary@Codec<Text,Frac> Binary@Codec<Text,Int> 2.0 "01" "Invalid binary syntax: "]
   )
@@ -531,14 +531,14 @@
                                [(if (f.= -1.0 sign) "-" "")]
                                (_lux_proc ["text" "append"]))]
              (case (:: Binary@Codec<Text,Frac> decode as-binary)
-               (#R;Error _)
-               (#R;Error (_lux_proc ["text" "append"] [<error> repr]))
+               (#E;Error _)
+               (#E;Error (_lux_proc ["text" "append"] [<error> repr]))
 
                output
                output))
 
            _
-           (#R;Error (_lux_proc ["text" "append"] [<error> repr]))))))]
+           (#E;Error (_lux_proc ["text" "append"] [<error> repr]))))))]
 
   [Octal@Codec<Text,Frac> "Invalid octaladecimal syntax: " binary-to-octal octal-to-binary]
   [Hex@Codec<Text,Frac>   "Invalid hexadecimal syntax: "   binary-to-hex   hex-to-binary]
@@ -550,26 +550,26 @@
      (case tokens
        (#;Cons [meta (#;Text repr)] #;Nil)
        (case (:: <nat> decode repr)
-         (#R;Success value)
-         (#R;Success [state (list [meta (#;Nat value)])])
+         (#E;Success value)
+         (#E;Success [state (list [meta (#;Nat value)])])
 
-         (^multi (#R;Error _)
-                 [(:: <int> decode repr) (#R;Success value)])
-         (#R;Success [state (list [meta (#;Int value)])])
+         (^multi (#E;Error _)
+                 [(:: <int> decode repr) (#E;Success value)])
+         (#E;Success [state (list [meta (#;Int value)])])
 
-         (^multi (#R;Error _)
-                 [(:: <deg> decode repr) (#R;Success value)])
-         (#R;Success [state (list [meta (#;Deg value)])])
+         (^multi (#E;Error _)
+                 [(:: <deg> decode repr) (#E;Success value)])
+         (#E;Success [state (list [meta (#;Deg value)])])
 
-         (^multi (#R;Error _)
-                 [(:: <frac> decode repr) (#R;Success value)])
-         (#R;Success [state (list [meta (#;Frac value)])])
+         (^multi (#E;Error _)
+                 [(:: <frac> decode repr) (#E;Success value)])
+         (#E;Success [state (list [meta (#;Frac value)])])
 
          _
-         (#R;Error <error>))
+         (#E;Error <error>))
 
        _
-       (#R;Error <error>)))]
+       (#E;Error <error>)))]
 
   [bin Binary@Codec<Text,Nat> Binary@Codec<Text,Int> Binary@Codec<Text,Deg> Binary@Codec<Text,Frac>
    "Invalid binary syntax."
@@ -764,11 +764,11 @@
                   (recur (digits-sub! power digits)
                          (n.inc idx)
                          (bit;set (n.- idx (n.dec bit;width)) output))))
-              (#R;Success (:! Deg output))))
+              (#E;Success (:! Deg output))))
 
           #;None
-          (#R;Error (_lux_proc ["text" "append"] ["Wrong syntax for Deg: " input])))
-        (#R;Error (_lux_proc ["text" "append"] ["Wrong syntax for Deg: " input]))))
+          (#E;Error (_lux_proc ["text" "append"] ["Wrong syntax for Deg: " input])))
+        (#E;Error (_lux_proc ["text" "append"] ["Wrong syntax for Deg: " input]))))
     ))
 
 (def: (log2 input)
diff --git a/stdlib/source/lux/data/number/complex.lux b/stdlib/source/lux/data/number/complex.lux
index d2933a1ab..e1fbccb36 100644
--- a/stdlib/source/lux/data/number/complex.lux
+++ b/stdlib/source/lux/data/number/complex.lux
@@ -9,7 +9,7 @@
        (data [number "f/" Number<Frac> Codec<Text,Frac>]
              [text "text/" Monoid<Text>]
              text/format
-             ["R" result]
+             ["E" error]
              [maybe]
              (coll [list "L/" Monad<List>]))
        [macro]
@@ -323,7 +323,7 @@
       (#;Left (text/compose "Wrong syntax for complex numbers: " input))
 
       (#;Some [r' i'])
-      (do R;Monad<Result>
+      (do E;Monad<Error>
         [r (f/decode (text;trim r'))
          i (f/decode (text;trim i'))]
         (wrap {#real r
diff --git a/stdlib/source/lux/data/number/ratio.lux b/stdlib/source/lux/data/number/ratio.lux
index 391242a32..8db271d7d 100644
--- a/stdlib/source/lux/data/number/ratio.lux
+++ b/stdlib/source/lux/data/number/ratio.lux
@@ -10,7 +10,7 @@
        (data [number "n/" Number<Nat> Codec<Text,Nat>]
              [text "Text/" Monoid<Text>]
              text/format
-             ["R" result]
+             ["E" error]
              [product]
              [maybe])
        [macro]
@@ -131,7 +131,7 @@
   (|>. n/encode (text;split +1) maybe;assume product;right))
 
 (def: part-decode
-  (-> Text (R;Result Nat))
+  (-> Text (E;Error Nat))
   (|>. (format "+") n/decode))
 
 (struct: #export _ (Codec Text Ratio)
@@ -141,7 +141,7 @@
   (def: (decode input)
     (case (text;split-with separator input)
       (#;Some [num denom])
-      (do R;Monad<Result>
+      (do E;Monad<Error>
         [numerator (part-decode num)
          denominator (part-decode denom)]
         (wrap (normalize {#numerator numerator
diff --git a/stdlib/source/lux/data/text/lexer.lux b/stdlib/source/lux/data/text/lexer.lux
index 1f76e833a..3803414e4 100644
--- a/stdlib/source/lux/data/text/lexer.lux
+++ b/stdlib/source/lux/data/text/lexer.lux
@@ -5,7 +5,7 @@
        (data [text "text/" Monoid<Text>]
              [product]
              [maybe]
-             ["R" result]
+             ["E" error]
              (coll [list]))
        (macro [code])))
 
@@ -27,15 +27,15 @@
   ($_ text/compose "Unconsumed input: " (remaining offset tape)))
 
 (def: #export (run input lexer)
-  (All [a] (-> Text (Lexer a) (R;Result a)))
+  (All [a] (-> Text (Lexer a) (E;Error a)))
   (case (lexer [start-offset input])
-    (#R;Error msg)
-    (#R;Error msg)
+    (#E;Error msg)
+    (#E;Error msg)
     
-    (#R;Success [[end-offset _] output])
+    (#E;Success [[end-offset _] output])
     (if (n.= end-offset (text;size input))
-      (#R;Success output)
-      (#R;Error (unconsumed-input-error end-offset input)))
+      (#E;Success output)
+      (#E;Error (unconsumed-input-error end-offset input)))
     ))
 
 (def: #export any
@@ -44,10 +44,10 @@
   (function [[offset tape]]
     (case (text;nth offset tape)
       (#;Some output)
-      (#R;Success [[(n.inc offset) tape] (text;from-code output)])
+      (#E;Success [[(n.inc offset) tape] (text;from-code output)])
 
       _
-      (#R;Error cannot-lex-error))
+      (#E;Error cannot-lex-error))
     ))
 
 (def: #export (not p)
@@ -55,11 +55,11 @@
   (All [a] (-> (Lexer a) (Lexer Text)))
   (function [input]
     (case (p input)
-      (#R;Error msg)
+      (#E;Error msg)
       (any input)
       
       _
-      (#R;Error "Expected to fail; yet succeeded."))))
+      (#E;Error "Expected to fail; yet succeeded."))))
 
 (def: #export (this reference)
   {#;doc "Lex a text if it matches the given sample."}
@@ -67,10 +67,10 @@
   (function [[offset tape]]
     (case (text;index-of reference offset tape)
       (^multi (#;Some where) (n.= offset where))
-      (#R;Success [[(n.+ (text;size reference) offset) tape] []])
+      (#E;Success [[(n.+ (text;size reference) offset) tape] []])
 
       _
-      (#R;Error ($_ text/compose "Could not match: " (text;encode reference) " @ " tape)))))
+      (#E;Error ($_ text/compose "Could not match: " (text;encode reference) " @ " tape)))))
 
 (def: #export (this? reference)
   {#;doc "Lex a text if it matches the given sample."}
@@ -78,24 +78,24 @@
   (function [(^@ input [offset tape])]
     (case (text;index-of reference offset tape)
       (^multi (#;Some where) (n.= offset where))
-      (#R;Success [[(n.+ (text;size reference) offset) tape] true])
+      (#E;Success [[(n.+ (text;size reference) offset) tape] true])
 
       _
-      (#R;Success [input false]))))
+      (#E;Success [input false]))))
 
 (def: #export end
   {#;doc "Ensure the lexer's input is empty."}
   (Lexer Unit)
   (function [(^@ input [offset tape])]
     (if (n.= offset (text;size tape))
-      (#R;Success [input []])
-      (#R;Error (unconsumed-input-error offset tape)))))
+      (#E;Success [input []])
+      (#E;Error (unconsumed-input-error offset tape)))))
 
 (def: #export end?
   {#;doc "Ask if the lexer's input is empty."}
   (Lexer Bool)
   (function [(^@ input [offset tape])]
-    (#R;Success [input (n.= offset (text;size tape))])))
+    (#E;Success [input (n.= offset (text;size tape))])))
 
 (def: #export peek
   {#;doc "Lex the next character (without consuming it from the input)."}
@@ -103,17 +103,17 @@
   (function [(^@ input [offset tape])]
     (case (text;nth offset tape)
       (#;Some output)
-      (#R;Success [input (text;from-code output)])
+      (#E;Success [input (text;from-code output)])
 
       _
-      (#R;Error cannot-lex-error))
+      (#E;Error cannot-lex-error))
     ))
 
 (def: #export get-input
   {#;doc "Get all of the remaining input (without consuming it)."}
   (Lexer Text)
   (function [(^@ input [offset tape])]
-    (#R;Success [input (remaining offset tape)])))
+    (#E;Success [input (remaining offset tape)])))
 
 (def: #export (range bottom top)
   {#;doc "Only lex characters within a range."}
@@ -164,11 +164,11 @@
       (#;Some output)
       (let [output (text;from-code output)]
         (if (text;contains? output options)
-          (#R;Success [[(n.inc offset) tape] output])
-          (#R;Error ($_ text/compose "Character (" output ") is not one of: " options))))
+          (#E;Success [[(n.inc offset) tape] output])
+          (#E;Error ($_ text/compose "Character (" output ") is not one of: " options))))
 
       _
-      (#R;Error cannot-lex-error))))
+      (#E;Error cannot-lex-error))))
 
 (def: #export (none-of options)
   {#;doc "Only lex characters that are not part of a piece of text."}
@@ -178,11 +178,11 @@
       (#;Some output)
       (let [output (text;from-code output)]
         (if (;not (text;contains? output options))
-          (#R;Success [[(n.inc offset) tape] output])
-          (#R;Error ($_ text/compose "Character (" output ") is one of: " options))))
+          (#E;Success [[(n.inc offset) tape] output])
+          (#E;Error ($_ text/compose "Character (" output ") is one of: " options))))
 
       _
-      (#R;Error cannot-lex-error))))
+      (#E;Error cannot-lex-error))))
 
 (def: #export (satisfies p)
   {#;doc "Only lex characters that satisfy a predicate."}
@@ -191,11 +191,11 @@
     (case (text;nth offset tape)
       (#;Some output)
       (if (p output)
-        (#R;Success [[(n.inc offset) tape] (text;from-code output)])
-        (#R;Error ($_ text/compose "Character does not satisfy predicate: " (text;from-code output))))
+        (#E;Success [[(n.inc offset) tape] (text;from-code output)])
+        (#E;Error ($_ text/compose "Character does not satisfy predicate: " (text;from-code output))))
 
       _
-      (#R;Error cannot-lex-error))))
+      (#E;Error cannot-lex-error))))
 
 (def: #export space
   {#;doc "Only lex white-space."}
@@ -248,8 +248,8 @@
   (All [a] (-> Text (Lexer a) (Lexer a)))
   (function [real-input]
     (case (run local-input lexer)
-      (#R;Error error)
-      (#R;Error error)
+      (#E;Error error)
+      (#E;Error error)
 
-      (#R;Success value)
-      (#R;Success [real-input value]))))
+      (#E;Success value)
+      (#E;Success [real-input value]))))
diff --git a/stdlib/source/lux/data/text/regex.lux b/stdlib/source/lux/data/text/regex.lux
index 11139cd6a..a425224cb 100644
--- a/stdlib/source/lux/data/text/regex.lux
+++ b/stdlib/source/lux/data/text/regex.lux
@@ -7,7 +7,7 @@
              text/format
              [number "Int/" Codec<Text,Int>]
              [product]
-             ["R" result]
+             ["E" error]
              [maybe]
              (coll [list "L/" Fold<List> Monad<List>]))
        [macro #- run]
@@ -276,14 +276,14 @@
                                           [Int (List Code) (List (List Code))])
                                       (function [part [idx names steps]]
                                         (case part
-                                          (^or (#R;Error complex) (#R;Success [#Non-Capturing complex]))
+                                          (^or (#E;Error complex) (#E;Success [#Non-Capturing complex]))
                                           [idx
                                            names
                                            (list& (list g!temp complex
                                                         (' #let) (` [(~ g!total) (_Text/compose_ (~ g!total) (~ g!temp))]))
                                                   steps)]
                                           
-                                          (#R;Success [(#Capturing [?name num-captures]) scoped])
+                                          (#E;Success [(#Capturing [?name num-captures]) scoped])
                                           (let [[idx! name!] (case ?name
                                                                (#;Some _name)
                                                                [idx (code;symbol ["" _name])]
@@ -320,31 +320,31 @@
   (All [l r] (-> (l;Lexer [Text l]) (l;Lexer [Text r]) (l;Lexer [Text (| l r)])))
   (function [input]
     (case (left input)
-      (#R;Success [input' [lt lv]])
-      (#R;Success [input' [lt (+0 lv)]])
+      (#E;Success [input' [lt lv]])
+      (#E;Success [input' [lt (+0 lv)]])
 
-      (#R;Error _)
+      (#E;Error _)
       (case (right input)
-        (#R;Success [input' [rt rv]])
-        (#R;Success [input' [rt (+1 rv)]])
+        (#E;Success [input' [rt rv]])
+        (#E;Success [input' [rt (+1 rv)]])
 
-        (#R;Error error)
-        (#R;Error error)))))
+        (#E;Error error)
+        (#E;Error error)))))
 
 (def: #hidden (|||_^ left right)
   (All [l r] (-> (l;Lexer [Text l]) (l;Lexer [Text r]) (l;Lexer Text)))
   (function [input]
     (case (left input)
-      (#R;Success [input' [lt lv]])
-      (#R;Success [input' lt])
+      (#E;Success [input' [lt lv]])
+      (#E;Success [input' lt])
 
-      (#R;Error _)
+      (#E;Error _)
       (case (right input)
-        (#R;Success [input' [rt rv]])
-        (#R;Success [input' rt])
+        (#E;Success [input' [rt rv]])
+        (#E;Success [input' rt])
 
-        (#R;Error error)
-        (#R;Error error)))))
+        (#E;Error error)
+        (#E;Error error)))))
 
 (def: (prep-alternative [num-captures alt])
   (-> [Nat Code] Code)
@@ -462,11 +462,11 @@
     (case (|> (regex^ current-module)
               (p;before l;end)
               (l;run pattern))
-      (#R;Error error)
+      (#E;Error error)
       (macro;fail (format "Error while parsing regular-expression:\n"
                           error))
 
-      (#R;Success regex)
+      (#E;Success regex)
       (wrap (list regex))
       )))
 
@@ -488,7 +488,7 @@
     [g!temp (macro;gensym "temp")]
     (wrap (list& (` (^multi (~ g!temp)
                             [(l;run (~ g!temp) (regex (~ (code;text pattern))))
-                             (#R;Success (~ (maybe;default g!temp
+                             (#E;Success (~ (maybe;default g!temp
                                               bindings)))]))
                  body
                  branches))))
diff --git a/stdlib/source/lux/macro.lux b/stdlib/source/lux/macro.lux
index 9f691c964..4fb0b08a4 100644
--- a/stdlib/source/lux/macro.lux
+++ b/stdlib/source/lux/macro.lux
@@ -8,43 +8,43 @@
              [product]
              [ident "ident/" Codec<Text,Ident> Eq<Ident>]
              [maybe]
-             ["R" result]
+             ["E" error]
              [text "text/" Monoid<Text> Eq<Text>]
              (coll [list "list/" Monoid<List> Monad<List>]))))
 
 ## (type: (Lux a)
-##   (-> Compiler (R;Result [Compiler a])))
+##   (-> Compiler (E;Error [Compiler a])))
 
 (struct: #export _ (F;Functor Lux)
   (def: (map f fa)
     (function [state]
       (case (fa state)
-        (#R;Error msg)
-        (#R;Error msg)
+        (#E;Error msg)
+        (#E;Error msg)
 
-        (#R;Success [state' a])
-        (#R;Success [state' (f a)])))))
+        (#E;Success [state' a])
+        (#E;Success [state' (f a)])))))
 
 (struct: #export _ (A;Applicative Lux)
   (def: functor Functor<Lux>)
 
   (def: (wrap x)
     (function [state]
-      (#R;Success [state x])))
+      (#E;Success [state x])))
 
   (def: (apply ff fa)
     (function [state]
       (case (ff state)
-        (#R;Success [state' f])
+        (#E;Success [state' f])
         (case (fa state')
-          (#R;Success [state'' a])
-          (#R;Success [state'' (f a)])
+          (#E;Success [state'' a])
+          (#E;Success [state'' (f a)])
 
-          (#R;Error msg)
-          (#R;Error msg))
+          (#E;Error msg)
+          (#E;Error msg))
 
-        (#R;Error msg)
-        (#R;Error msg)))))
+        (#E;Error msg)
+        (#E;Error msg)))))
 
 (struct: #export _ (Monad Lux)
   (def: applicative Applicative<Lux>)
@@ -52,10 +52,10 @@
   (def: (join mma)
     (function [state]
       (case (mma state)
-        (#R;Error msg)
-        (#R;Error msg)
+        (#E;Error msg)
+        (#E;Error msg)
 
-        (#R;Success [state' ma])
+        (#E;Success [state' ma])
         (ma state')))))
 
 (def: (get k plist)
@@ -71,53 +71,53 @@
       (get k plist'))))
 
 (def: #export (run' compiler action)
-  (All [a] (-> Compiler (Lux a) (R;Result [Compiler a])))
+  (All [a] (-> Compiler (Lux a) (E;Error [Compiler a])))
   (action compiler))
 
 (def: #export (run compiler action)
-  (All [a] (-> Compiler (Lux a) (R;Result a)))
+  (All [a] (-> Compiler (Lux a) (E;Error a)))
   (case (action compiler)
-    (#R;Error error)
-    (#R;Error error)
+    (#E;Error error)
+    (#E;Error error)
 
-    (#R;Success [_ output])
-    (#R;Success output)))
+    (#E;Success [_ output])
+    (#E;Success output)))
 
 (def: #export (either left right)
   {#;doc "Pick whichever computation succeeds."}
   (All [a] (-> (Lux a) (Lux a) (Lux a)))
   (function [compiler]
     (case (left compiler)
-      (#R;Error error)
+      (#E;Error error)
       (right compiler)
 
-      (#R;Success [compiler' output])
-      (#R;Success [compiler' output]))))
+      (#E;Success [compiler' output])
+      (#E;Success [compiler' output]))))
 
 (def: #export (assert message test)
   {#;doc "Fails with the given message if the test is false."}
   (-> Text Bool (Lux Unit))
   (function [compiler]
     (if test
-      (#R;Success [compiler []])
-      (#R;Error message))))
+      (#E;Success [compiler []])
+      (#E;Error message))))
 
 (def: #export (fail msg)
   {#;doc "Fails with the given message."}
   (All [a]
     (-> Text (Lux a)))
   (function [_]
-    (#R;Error msg)))
+    (#E;Error msg)))
 
 (def: #export (find-module name)
   (-> Text (Lux Module))
   (function [state]
     (case (get name (get@ #;modules state))
       (#;Some module)
-      (#R;Success [state module])
+      (#E;Success [state module])
 
       _
-      (#R;Error ($_ text/compose "Unknown module: " name)))))
+      (#E;Error ($_ text/compose "Unknown module: " name)))))
 
 (def: #export current-module-name
   (Lux Text)
@@ -126,13 +126,13 @@
       (#;Some scope)
       (case (get@ #;name scope)
         (#;Cons m-name #;Nil)
-        (#R;Success [state m-name])
+        (#E;Success [state m-name])
 
         _
-        (#R;Error "Improper name for scope."))
+        (#E;Error "Improper name for scope."))
 
       _
-      (#R;Error "Empty environment!")
+      (#E;Error "Empty environment!")
       )))
 
 (def: #export current-module
@@ -261,7 +261,7 @@
     (let [[module name] ident]
       (: (Lux (Maybe Macro))
          (function [state]
-           (#R;Success [state (find-macro' (get@ #;modules state) this-module module name)]))))))
+           (#E;Success [state (find-macro' (get@ #;modules state) this-module module name)]))))))
 
 (def: #export (normalize ident)
   {#;doc "If given an identifier without a module prefix, gives it the current module's name as prefix.
@@ -360,7 +360,7 @@
           A prefix can be given (or just be empty text \"\") to better identify the code for debugging purposes."}
   (-> Text (Lux Code))
   (function [state]
-    (#R;Success [(update@ #;seed n.inc state)
+    (#E;Success [(update@ #;seed n.inc state)
                  (code;symbol ["" ($_ text/compose "__gensym__" prefix (:: number;Codec<Text,Nat> encode (get@ #;seed state)))])])))
 
 (def: (get-local-symbol ast)
@@ -411,7 +411,7 @@
 (def: #export (module-exists? module)
   (-> Text (Lux Bool))
   (function [state]
-    (#R;Success [state (case (get module (get@ #;modules state))
+    (#E;Success [state (case (get module (get@ #;modules state))
                          (#;Some _)
                          true
                          
@@ -445,10 +445,10 @@
                                          (get@ [#;captured #;mappings] scope)))]
               (wrap type))
         (#;Some var-type)
-        (#R;Success [state var-type])
+        (#E;Success [state var-type])
 
         #;None
-        (#R;Error ($_ text/compose "Unknown variable: " name))))))
+        (#E;Error ($_ text/compose "Unknown variable: " name))))))
 
 (def: #export (find-def name)
   {#;doc "Looks-up a definition's whole data in the available modules (including the current one)."}
@@ -460,10 +460,10 @@
                 (^slots [#;defs]) (get v-prefix (get@ #;modules state))]
                (get v-name defs)))
       (#;Some _anns)
-      (#R;Success [state _anns])
+      (#E;Success [state _anns])
 
       _
-      (#R;Error ($_ text/compose "Unknown definition: " (ident/encode name))))))
+      (#E;Error ($_ text/compose "Unknown definition: " (ident/encode name))))))
 
 (def: #export (find-def-type name)
   {#;doc "Looks-up a definition's type in the available modules (including the current one)."}
@@ -494,8 +494,8 @@
   (-> Text (Lux (List [Text Def])))
   (function [state]
     (case (get module-name (get@ #;modules state))
-      #;None          (#R;Error ($_ text/compose "Unknown module: " module-name))
-      (#;Some module) (#R;Success [state (get@ #;defs module)])
+      #;None          (#E;Error ($_ text/compose "Unknown module: " module-name))
+      (#;Some module) (#E;Success [state (get@ #;defs module)])
       )))
 
 (def: #export (exports module-name)
@@ -515,7 +515,7 @@
     (|> state
         (get@ #;modules)
         [state]
-        #R;Success)))
+        #E;Success)))
 
 (def: #export (tags-of type-name)
   {#;doc "All the tags associated with a type definition."}
@@ -534,7 +534,7 @@
   {#;doc "The cursor of the current expression being analyzed."}
   (Lux Cursor)
   (function [state]
-    (#R;Success [state (get@ #;cursor state)])))
+    (#E;Success [state (get@ #;cursor state)])))
 
 (def: #export expected-type
   {#;doc "The expected type of the current expression being analyzed."}
@@ -542,10 +542,10 @@
   (function [state]
     (case (get@ #;expected state)
       (#;Some type)
-      (#R;Success [state type])
+      (#E;Success [state type])
 
       #;None
-      (#R;Error "Not expecting any type."))))
+      (#E;Error "Not expecting any type."))))
 
 (def: #export (imported-modules module-name)
   {#;doc "All the modules imported by a specified module."}
@@ -590,10 +590,10 @@
   (function [state]
     (case (list;inits (get@ #;scopes state))
       #;None
-      (#R;Error "No local environment")
+      (#E;Error "No local environment")
 
       (#;Some scopes)
-      (#R;Success [state
+      (#E;Success [state
                    (list/map (|>. (get@ [#;locals #;mappings])
                                   (list/map (function [[name [type _]]]
                                               [name type])))
@@ -616,12 +616,12 @@
   {#;doc "Obtains the current state of the compiler."}
   (Lux Compiler)
   (function [compiler]
-    (#R;Success [compiler compiler])))
+    (#E;Success [compiler compiler])))
 
 (def: #export type-context
   (Lux Type-Context)
   (function [compiler]
-    (#R;Success [compiler (get@ #;type-context compiler)])))
+    (#E;Success [compiler (get@ #;type-context compiler)])))
 
 (do-template [<macro> <func> <desc>]
   [(macro: #export (<macro> tokens)
diff --git a/stdlib/source/lux/macro/poly.lux b/stdlib/source/lux/macro/poly.lux
index d744a28f7..fc6c7120f 100644
--- a/stdlib/source/lux/macro/poly.lux
+++ b/stdlib/source/lux/macro/poly.lux
@@ -12,7 +12,7 @@
              [bool]
              [maybe]
              [ident "ident/" Eq<Ident> Codec<Text,Ident>]
-             ["R" result])
+             ["E" error])
        [macro #+ with-gensyms]
        (macro [code]
               ["s" syntax #+ syntax: Syntax]
@@ -31,70 +31,70 @@
 (def: #export fresh Env (dict;new number;Hash<Nat>))
 
 (def: (run' env types poly)
-  (All [a] (-> Env (List Type) (Poly a) (R;Result a)))
+  (All [a] (-> Env (List Type) (Poly a) (E;Error a)))
   (case (p;run [env types] poly)
-    (#R;Error error)
-    (#R;Error error)
+    (#E;Error error)
+    (#E;Error error)
 
-    (#R;Success [[env' remaining] output])
+    (#E;Success [[env' remaining] output])
     (case remaining
       #;Nil
-      (#R;Success output)
+      (#E;Success output)
 
       _
-      (#R;Error (|> remaining
+      (#E;Error (|> remaining
                     (list/map type;to-text)
                     (text;join-with ", ")
                     (text/compose "Unconsumed types: "))))))
 
 (def: #export (run type poly)
-  (All [a] (-> Type (Poly a) (R;Result a)))
+  (All [a] (-> Type (Poly a) (E;Error a)))
   (run' fresh (list type) poly))
 
 (def: #export env
   (Poly Env)
   (;function [[env inputs]]
-    (#R;Success [[env inputs] env])))
+    (#E;Success [[env inputs] env])))
 
 (def: (with-env temp poly)
   (All [a] (-> Env (Poly a) (Poly a)))
   (;function [[env inputs]]
     (case (p;run [temp inputs] poly)
-      (#R;Error error)
-      (#R;Error error)
+      (#E;Error error)
+      (#E;Error error)
 
-      (#R;Success [[_ remaining] output])
-      (#R;Success [[env remaining] output]))))
+      (#E;Success [[_ remaining] output])
+      (#E;Success [[env remaining] output]))))
 
 (def: #export peek
   (Poly Type)
   (;function [[env inputs]]
     (case inputs
       #;Nil
-      (#R;Error "Empty stream of types.")
+      (#E;Error "Empty stream of types.")
 
       (#;Cons headT tail)
-      (#R;Success [[env inputs] headT]))))
+      (#E;Success [[env inputs] headT]))))
 
 (def: #export any
   (Poly Type)
   (;function [[env inputs]]
     (case inputs
       #;Nil
-      (#R;Error "Empty stream of types.")
+      (#E;Error "Empty stream of types.")
 
       (#;Cons headT tail)
-      (#R;Success [[env tail] headT]))))
+      (#E;Success [[env tail] headT]))))
 
 (def: #export (local types poly)
   (All [a] (-> (List Type) (Poly a) (Poly a)))
   (;function [[env pass-through]]
     (case (run' env types poly)
-      (#R;Error error)
-      (#R;Error error)
+      (#E;Error error)
+      (#E;Error error)
 
-      (#R;Success output)
-      (#R;Success [[env pass-through] output]))))
+      (#E;Success output)
+      (#E;Success [[env pass-through] output]))))
 
 (def: (label idx)
   (-> Nat Code)
@@ -108,11 +108,11 @@
       (case (p;run [(dict;put current-id [type g!var] env)
                     inputs]
                    poly)
-        (#R;Error error)
-        (#R;Error error)
+        (#E;Error error)
+        (#E;Error error)
 
-        (#R;Success [[_ inputs'] output])
-        (#R;Success [[env inputs'] [g!var output]])))))
+        (#E;Success [[_ inputs'] output])
+        (#E;Success [[env inputs'] [g!var output]])))))
 
 (do-template [<combinator> <name> <type>]
   [(def: #export <combinator>
@@ -149,10 +149,10 @@
                          deg
                          frac
                          text))
-      (#R;Error error)
+      (#E;Error error)
       (p;fail error)
 
-      (#R;Success _)
+      (#E;Success _)
       (wrap headT))))
 
 (do-template [<name> <flattener> <tag>]
diff --git a/stdlib/source/lux/macro/poly/json.lux b/stdlib/source/lux/macro/poly/json.lux
index 1c3510b85..1b66e39f5 100644
--- a/stdlib/source/lux/macro/poly/json.lux
+++ b/stdlib/source/lux/macro/poly/json.lux
@@ -10,7 +10,7 @@
              (text ["l" lexer])
              [number "frac/" Codec<Text,Frac> "nat/" Codec<Text,Nat>]
              maybe
-             ["R" result]
+             ["E" error]
              [sum]
              [product]
              (coll [list "list/" Fold<List> Monad<List>]
@@ -63,7 +63,7 @@
 (struct: #hidden _ (Codec JSON Int)
   (def: encode (|>. int-to-nat (:: Codec<JSON,Nat> encode)))
   (def: decode
-    (|>. (:: Codec<JSON,Nat> decode) (:: R;Functor<Result> map nat-to-int))))
+    (|>. (:: Codec<JSON,Nat> decode) (:: E;Functor<Error> map nat-to-int))))
 
 (def: #hidden (nullable writer)
   {#;doc "Builds a JSON generator for potentially inexistent values."}
@@ -78,7 +78,7 @@
   (def: encode
     (|>. unit;out (:: Codec<JSON,Int> encode)))
   (def: decode
-    (|>. (:: Codec<JSON,Int> decode) (:: R;Functor<Result> map (unit;in carrier)))))
+    (|>. (:: Codec<JSON,Int> decode) (:: E;Functor<Error> map (unit;in carrier)))))
 
 (poly: #hidden Codec<JSON,?>//encode
   (with-expansions
diff --git a/stdlib/source/lux/macro/syntax.lux b/stdlib/source/lux/macro/syntax.lux
index 4e431de82..a31eb8c6e 100644
--- a/stdlib/source/lux/macro/syntax.lux
+++ b/stdlib/source/lux/macro/syntax.lux
@@ -11,7 +11,7 @@
              (coll [list "list/" Functor<List>])
              [product]
              [maybe]
-             ["R" result]))
+             ["E" error]))
   (.. [code "code/" Eq<Code>]))
 
 ## [Utils]
@@ -38,8 +38,8 @@
   (Syntax Code)
   (function [tokens]
     (case tokens
-      #;Nil                (#R;Error "There are no tokens to parse!")
-      (#;Cons [t tokens']) (#R;Success [tokens' t]))))
+      #;Nil                (#E;Error "There are no tokens to parse!")
+      (#;Cons [t tokens']) (#E;Success [tokens' t]))))
 
 (do-template [<get-name> <type> <tag> <eq> <desc>]
   [(def: #export <get-name>
@@ -48,10 +48,10 @@
      (function [tokens]
        (case tokens
          (#;Cons [[_ (<tag> x)] tokens'])
-         (#R;Success [tokens' x])
+         (#E;Success [tokens' x])
 
          _
-         (#R;Error ($_ text/compose "Cannot parse " <desc> (remaining-inputs tokens))))))]
+         (#E;Error ($_ text/compose "Cannot parse " <desc> (remaining-inputs tokens))))))]
 
   [  bool  Bool   #;Bool   bool;Eq<Bool> "bool"]
   [   nat   Nat    #;Nat  number;Eq<Nat> "nat"]
@@ -73,10 +73,10 @@
             remaining (if is-it?
                         tokens'
                         tokens)]
-        (#R;Success [remaining is-it?]))
+        (#E;Success [remaining is-it?]))
 
       _
-      (#R;Success [tokens false]))))
+      (#E;Success [tokens false]))))
 
 (def: #export (this ast)
   {#;doc "Ensures the given Code is the next input."}
@@ -85,12 +85,12 @@
     (case tokens
       (#;Cons [token tokens'])
       (if (code/= ast token)
-        (#R;Success [tokens' []])
-        (#R;Error ($_ text/compose "Expected a " (code;to-text ast) " but instead got " (code;to-text token)
+        (#E;Success [tokens' []])
+        (#E;Error ($_ text/compose "Expected a " (code;to-text ast) " but instead got " (code;to-text token)
                       (remaining-inputs tokens))))
 
       _
-      (#R;Error "There are no tokens to parse!"))))
+      (#E;Error "There are no tokens to parse!"))))
 
 (do-template [<name> <comp> <error>]
   [(def: #export <name>
@@ -111,10 +111,10 @@
      (function [tokens]
        (case tokens
          (#;Cons [[_ (<tag> ["" x])] tokens'])
-         (#R;Success [tokens' x])
+         (#E;Success [tokens' x])
 
          _
-         (#R;Error ($_ text/compose "Cannot parse local " <desc> (remaining-inputs tokens))))))]
+         (#E;Error ($_ text/compose "Cannot parse local " <desc> (remaining-inputs tokens))))))]
 
   [local-symbol #;Symbol "symbol"]
   [   local-tag #;Tag    "tag"]
@@ -129,11 +129,11 @@
        (case tokens
          (#;Cons [[_ (<tag> members)] tokens'])
          (case (p members)
-           (#R;Success [#;Nil x]) (#R;Success [tokens' x])
-           _                   (#R;Error ($_ text/compose "Syntax was expected to fully consume " <desc> (remaining-inputs tokens))))
+           (#E;Success [#;Nil x]) (#E;Success [tokens' x])
+           _                      (#E;Error ($_ text/compose "Syntax was expected to fully consume " <desc> (remaining-inputs tokens))))
 
          _
-         (#R;Error ($_ text/compose "Cannot parse " <desc> (remaining-inputs tokens))))))]
+         (#E;Error ($_ text/compose "Cannot parse " <desc> (remaining-inputs tokens))))))]
 
   [ form  #;Form "form"]
   [tuple #;Tuple "tuple"]
@@ -147,38 +147,38 @@
     (case tokens
       (#;Cons [[_ (#;Record pairs)] tokens'])
       (case (p (join-pairs pairs))
-        (#R;Success [#;Nil x]) (#R;Success [tokens' x])
-        _                   (#R;Error ($_ text/compose "Syntax was expected to fully consume record" (remaining-inputs tokens))))
+        (#E;Success [#;Nil x]) (#E;Success [tokens' x])
+        _                      (#E;Error ($_ text/compose "Syntax was expected to fully consume record" (remaining-inputs tokens))))
 
       _
-      (#R;Error ($_ text/compose "Cannot parse record" (remaining-inputs tokens))))))
+      (#E;Error ($_ text/compose "Cannot parse record" (remaining-inputs tokens))))))
 
 (def: #export end!
   {#;doc "Ensures there are no more inputs."}
   (Syntax Unit)
   (function [tokens]
     (case tokens
-      #;Nil (#R;Success [tokens []])
-      _     (#R;Error ($_ text/compose "Expected list of tokens to be empty!" (remaining-inputs tokens))))))
+      #;Nil (#E;Success [tokens []])
+      _     (#E;Error ($_ text/compose "Expected list of tokens to be empty!" (remaining-inputs tokens))))))
 
 (def: #export end?
   {#;doc "Checks whether there are no more inputs."}
   (Syntax Bool)
   (function [tokens]
     (case tokens
-      #;Nil (#R;Success [tokens true])
-      _     (#R;Success [tokens false]))))
+      #;Nil (#E;Success [tokens true])
+      _     (#E;Success [tokens false]))))
 
 (def: #export (on compiler action)
   {#;doc "Run a Lux operation as if it was a Syntax parser."}
   (All [a] (-> Compiler (Lux a) (Syntax a)))
   (function [input]
     (case (macro;run compiler action)
-      (#R;Error error)
-      (#R;Error error)
+      (#E;Error error)
+      (#E;Error error)
 
-      (#R;Success value)
-      (#R;Success [input value])
+      (#E;Success value)
+      (#E;Success [input value])
       )))
 
 (def: #export (local local-inputs syntax)
@@ -186,16 +186,16 @@
   (All [a] (-> (List Code) (Syntax a) (Syntax a)))
   (function [real-inputs]
     (case (syntax local-inputs)
-      (#R;Error error)
-      (#R;Error error)
+      (#E;Error error)
+      (#E;Error error)
 
-      (#R;Success [unconsumed-inputs value])
+      (#E;Success [unconsumed-inputs value])
       (case unconsumed-inputs
         #;Nil
-        (#R;Success [real-inputs value])
+        (#E;Success [real-inputs value])
 
         _
-        (#R;Error (text/compose "Unconsumed inputs: "
+        (#E;Error (text/compose "Unconsumed inputs: "
                                 (|> (list/map code;to-text unconsumed-inputs)
                                     (text;join-with ", "))))))))
 
@@ -265,10 +265,10 @@
                  g!end (code;symbol ["" ""])
                  error-msg (code;text (text/compose "Wrong syntax for " name))
                  export-ast (: (List Code) (case exported?
-                                             (#;Some #R;Error)
+                                             (#;Some #E;Error)
                                              (list (' #hidden))
 
-                                             (#;Some #R;Success)
+                                             (#;Some #E;Success)
                                              (list (' #export))
 
                                              _
@@ -280,15 +280,15 @@
                                                   (: (Syntax (Lux (List Code)))
                                                      (do ;;_Monad<Parser>_
                                                        [(~@ (join-pairs vars+parsers))
-                                                        (~ g!end) end!]
+                                                        (~ g!end) ;;end!]
                                                        ((~' wrap) (do macro;Monad<Lux>
                                                                     []
                                                                     (~ body))))))
-                               (#R;Success [(~ g!tokens) (~ g!body)])
+                               (#E;Success [(~ g!tokens) (~ g!body)])
                                ((~ g!body) (~ g!state))
 
-                               (#R;Error (~ g!msg))
-                               (#R;Error (text.join-with ": " (list (~ error-msg) (~ g!msg))))))))))))
+                               (#E;Error (~ g!msg))
+                               (#E;Error (text.join-with ": " (list (~ error-msg) (~ g!msg))))))))))))
       
       _
       (macro;fail "Wrong syntax for syntax:"))))
diff --git a/stdlib/source/lux/test.lux b/stdlib/source/lux/test.lux
index 6d21a074b..e25f685cf 100644
--- a/stdlib/source/lux/test.lux
+++ b/stdlib/source/lux/test.lux
@@ -11,11 +11,11 @@
              [maybe]
              [text]
              text/format
-             ["E" result])
+             ["E" error])
        [io #- run]
        (time [instant]
              [duration])
-       ["R" math/random]))
+       ["r" math/random]))
 
 ## [Host]
 (do-template [<name> <signal>]
@@ -83,18 +83,18 @@
   (|>. product;right (n.> +0)))
 
 (def: (try seed random-test)
-  (-> Seed (R;Random Test) (Promise [Seed [Counters Text]]))
-  (let [[prng [new-seed test]] (R;run (R;pcg-32 [pcg-32-magic-inc seed])
-                                      (do R;Monad<Random>
+  (-> Seed (r;Random Test) (Promise [Seed [Counters Text]]))
+  (let [[prng [new-seed test]] (r;run (r;pcg-32 [pcg-32-magic-inc seed])
+                                      (do r;Monad<Random>
                                         [test random-test
-                                         next-seed R;nat]
+                                         next-seed r;nat]
                                         (wrap [next-seed test])))]
     (do Monad<Promise>
       [result test]
       (wrap [new-seed result]))))
 
 (def: (repeat' seed times random-test)
-  (-> Seed Nat (R;Random Test) Test)
+  (-> Seed Nat (r;Random Test) Test)
   (if (n.= +0 times)
     (fail "Cannot try a test 0 times.")
     (do Monad<Promise>
@@ -110,9 +110,9 @@
             (repeat' seed' (n.dec times) random-test)))))
 
 (def: #hidden (repeat ?seed times random-test)
-  (-> (Maybe Nat) Nat (R;Random Test) Test)
+  (-> (Maybe Nat) Nat (r;Random Test) Test)
   (repeat' (maybe;default (|> (io;run instant;now) instant;to-millis int-to-nat)
-             ?seed)
+                          ?seed)
            (case ?seed
              #;None times
              (#;Some _) +1)
@@ -197,10 +197,10 @@
 
                     (test "Can have defaults for Maybe values."
                           (and (is "yolo" (maybe;default "yolo"
-                                            #;None))
+                                                         #;None))
                                
                                (is "lol" (maybe;default "yolo"
-                                           (#;Some "lol")))))
+                                                        (#;Some "lol")))))
                     ))
               "Also works with random generation of values for property-based testing."
               (context: "Addition & Substraction"
@@ -240,7 +240,7 @@
                      bindings' (|> bindings (L/map pair-to-list) L/join)]
                  (` (repeat (~ =seed)
                             (~ (code;nat =times))
-                            (do R;Monad<Random>
+                            (do r;Monad<Random>
                               [(~@ bindings')]
                               ((~' wrap) (;;try-body (io;io (~ body))))))))
                
diff --git a/stdlib/source/lux/time/date.lux b/stdlib/source/lux/time/date.lux
index 9f2d2972b..b513ef07c 100644
--- a/stdlib/source/lux/time/date.lux
+++ b/stdlib/source/lux/time/date.lux
@@ -6,7 +6,7 @@
                 codec
                 ["p" parser]
                 [monad #+ do])
-       (data ["R" result]
+       (data ["E" error]
              [maybe]
              [number "int/" Codec<Text,Int>]
              [text "text/" Monoid<Text>]
@@ -311,7 +311,7 @@
            #day (int-to-nat utc-day)})))
 
 (def: (decode input)
-  (-> Text (R;Result Date))
+  (-> Text (E;Error Date))
   (l;run input lex-date))
 
 (struct: #export _
diff --git a/stdlib/source/lux/time/duration.lux b/stdlib/source/lux/time/duration.lux
index 003a84a97..35911a6cc 100644
--- a/stdlib/source/lux/time/duration.lux
+++ b/stdlib/source/lux/time/duration.lux
@@ -8,7 +8,7 @@
        (data [number "int/" Codec<Text,Int> Number<Int>]
              [text "text/" Monoid<Text>]
              (text ["l" lexer])
-             ["R" result])
+             ["E" error])
        (type opaque)))
 
 (opaque: #export Duration
@@ -134,7 +134,7 @@
               (merge (scale (sign utc-millis) milli))))))
 
 (def: (decode input)
-  (-> Text (R;Result Duration))
+  (-> Text (E;Error Duration))
   (l;run input lex-duration))
 
 (struct: #export _
diff --git a/stdlib/source/lux/time/instant.lux b/stdlib/source/lux/time/instant.lux
index c76f108fb..31da7dc29 100644
--- a/stdlib/source/lux/time/instant.lux
+++ b/stdlib/source/lux/time/instant.lux
@@ -10,7 +10,7 @@
        (data [text "text/" Monoid<Text>]
              (text ["l" lexer])
              [number "int/" Codec<Text,Int>]
-             ["R" result]
+             ["E" error]
              [maybe]
              (coll [list "L/" Fold<List> Functor<List>]
                    ["v" vector "v/" Functor<Vector> Fold<Vector>]))
@@ -296,7 +296,7 @@
               (shift (duration;scale utc-millis duration;milli))))))
 
 (def: (decode input)
-  (-> Text (R;Result Instant))
+  (-> Text (E;Error Instant))
   (l;run input lex-instant))
 
 (struct: #export _
diff --git a/stdlib/source/lux/type/check.lux b/stdlib/source/lux/type/check.lux
index 769b45391..f51ba5a15 100644
--- a/stdlib/source/lux/type/check.lux
+++ b/stdlib/source/lux/type/check.lux
@@ -2,57 +2,57 @@
 
                   Very useful for writing advanced macros."}
   lux
-  (lux (control ["F" functor]
-                ["A" applicative]
-                ["M" monad #+ do Monad])
+  (lux (control [functor #+ Functor]
+                [applicative #+ Applicative]
+                [monad #+ do Monad])
        (data [text "text/" Monoid<Text> Eq<Text>]
              [number "nat/" Codec<Text,Nat>]
              maybe
              [product]
              (coll [list])
-             ["R" result])
-       [type "Type/" Eq<Type>]
+             ["E" error])
+       [type "type/" Eq<Type>]
        ))
 
 (type: #export Assumptions (List [[Type Type] Bool]))
 
 (type: #export (Check a)
-  (-> Type-Context (R;Result [Type-Context a])))
+  (-> Type-Context (E;Error [Type-Context a])))
 
 (type: #export Type-Vars
   (List [Nat (Maybe Type)]))
 
-(struct: #export _ (F;Functor Check)
+(struct: #export _ (Functor Check)
   (def: (map f fa)
     (function [context]
       (case (fa context)
-        (#R;Error error)
-        (#R;Error error)
+        (#E;Error error)
+        (#E;Error error)
 
-        (#R;Success [context' output])
-        (#R;Success [context' (f output)])
+        (#E;Success [context' output])
+        (#E;Success [context' (f output)])
         ))))
 
-(struct: #export _ (A;Applicative Check)
+(struct: #export _ (Applicative Check)
   (def: functor Functor<Check>)
 
   (def: (wrap x)
     (function [context]
-      (#R;Success [context x])))
+      (#E;Success [context x])))
 
   (def: (apply ff fa)
     (function [context]
       (case (ff context)
-        (#R;Success [context' f])
+        (#E;Success [context' f])
         (case (fa context')
-          (#R;Success [context'' a])
-          (#R;Success [context'' (f a)])
+          (#E;Success [context'' a])
+          (#E;Success [context'' (f a)])
 
-          (#R;Error error)
-          (#R;Error error))
+          (#E;Error error)
+          (#E;Error error))
 
-        (#R;Error error)
-        (#R;Error error)
+        (#E;Error error)
+        (#E;Error error)
         )))
   )
 
@@ -62,20 +62,20 @@
   (def: (join ffa)
     (function [context]
       (case (ffa context)
-        (#R;Success [context' fa])
+        (#E;Success [context' fa])
         (case (fa context')
-          (#R;Success [context'' a])
-          (#R;Success [context'' a])
+          (#E;Success [context'' a])
+          (#E;Success [context'' a])
 
-          (#R;Error error)
-          (#R;Error error))
+          (#E;Error error)
+          (#E;Error error))
 
-        (#R;Error error)
-        (#R;Error error)
+        (#E;Error error)
+        (#E;Error error)
         )))
   )
 
-(open Monad<Check> "Check/")
+(open Monad<Check> "check/")
 
 (def: (var::get id plist)
   (-> Nat Type-Vars (Maybe (Maybe Type)))
@@ -121,30 +121,30 @@
 
 ## [[Logic]]
 (def: #export (run context proc)
-  (All [a] (-> Type-Context (Check a) (R;Result a)))
+  (All [a] (-> Type-Context (Check a) (E;Error a)))
   (case (proc context)
-    (#R;Error error)
-    (#R;Error error)
+    (#E;Error error)
+    (#E;Error error)
 
-    (#R;Success [context' output])
-    (#R;Success output)))
+    (#E;Success [context' output])
+    (#E;Success output)))
 
 (def: (apply-type! t-func t-arg)
   (-> Type Type (Check Type))
   (function [context]
     (case (type;apply (list t-arg) t-func)
       #;None
-      (#R;Error ($_ text/compose "Invalid type application: " (type;to-text t-func) " on " (type;to-text t-arg)))
+      (#E;Error ($_ text/compose "Invalid type application: " (type;to-text t-func) " on " (type;to-text t-arg)))
 
       (#;Some output)
-      (#R;Success [context output]))))
+      (#E;Success [context output]))))
 
 (def: #export existential
   {#;doc "A producer of existential types."}
   (Check [Nat Type])
   (function [context]
     (let [id (get@ #;ex-counter context)]
-      (#R;Success [(update@ #;ex-counter n.inc context)
+      (#E;Success [(update@ #;ex-counter n.inc context)
                    [id (#;Ex id)]]))))
 
 (def: #export (bound? id)
@@ -152,62 +152,62 @@
   (function [context]
     (case (|> context (get@ #;var-bindings) (var::get id))
       (#;Some (#;Some _))
-      (#R;Success [context true])
+      (#E;Success [context true])
 
       (#;Some #;None)
-      (#R;Success [context false])
+      (#E;Success [context false])
       
       #;None
-      (#R;Error ($_ text/compose "Unknown type-var: " (nat/encode id))))))
+      (#E;Error ($_ text/compose "Unknown type-var: " (nat/encode id))))))
 
 (def: #export (read id)
   (-> Nat (Check Type))
   (function [context]
     (case (|> context (get@ #;var-bindings) (var::get id))
       (#;Some (#;Some type))
-      (#R;Success [context type])
+      (#E;Success [context type])
 
       (#;Some #;None)
-      (#R;Error ($_ text/compose "Unbound type-var: " (nat/encode id)))
+      (#E;Error ($_ text/compose "Unbound type-var: " (nat/encode id)))
       
       #;None
-      (#R;Error ($_ text/compose "Unknown type-var: " (nat/encode id))))))
+      (#E;Error ($_ text/compose "Unknown type-var: " (nat/encode id))))))
 
 (def: #export (write id type)
   (-> Nat Type (Check Unit))
   (function [context]
     (case (|> context (get@ #;var-bindings) (var::get id))
       (#;Some (#;Some bound))
-      (#R;Error ($_ text/compose "Cannot rebind type-var: " (nat/encode id) " | Current type: " (type;to-text bound)))
+      (#E;Error ($_ text/compose "Cannot rebind type-var: " (nat/encode id) " | Current type: " (type;to-text bound)))
       
       (#;Some #;None)
-      (#R;Success [(update@ #;var-bindings (var::put id (#;Some type)) context)
+      (#E;Success [(update@ #;var-bindings (var::put id (#;Some type)) context)
                    []])
 
       #;None
-      (#R;Error ($_ text/compose "Unknown type-var: " (nat/encode id))))))
+      (#E;Error ($_ text/compose "Unknown type-var: " (nat/encode id))))))
 
 (def: (update id type)
   (-> Nat Type (Check Unit))
   (function [context]
     (case (|> context (get@ #;var-bindings) (var::get id))
       (#;Some _)
-      (#R;Success [(update@ #;var-bindings (var::put id (#;Some type)) context)
+      (#E;Success [(update@ #;var-bindings (var::put id (#;Some type)) context)
                    []])
       
       #;None
-      (#R;Error ($_ text/compose "Unknown type-var: " (nat/encode id))))))
+      (#E;Error ($_ text/compose "Unknown type-var: " (nat/encode id))))))
 
 (def: #export (clear id)
   (-> Nat (Check Unit))
   (function [context]
     (case (|> context (get@ #;var-bindings) (var::get id))
       (#;Some _)
-      (#R;Success [(update@ #;var-bindings (var::put id #;None) context)
+      (#E;Success [(update@ #;var-bindings (var::put id #;None) context)
                    []])
       
       #;None
-      (#R;Error ($_ text/compose "Unknown type-var: " (nat/encode id))))))
+      (#E;Error ($_ text/compose "Unknown type-var: " (nat/encode id))))))
 
 (def: #export (clean t-id type)
   (-> Nat Type (Check Type))
@@ -243,7 +243,7 @@
 
     (#;Host name params)
     (do Monad<Check>
-      [=params (M;map @ (clean t-id) params)]
+      [=params (monad;map @ (clean t-id) params)]
       (wrap (#;Host name =params)))
     
     (^template [<tag>]
@@ -260,7 +260,7 @@
     (^template [<tag>]
       (<tag> env body)
       (do Monad<Check>
-        [=env (M;map @ (clean t-id) env)
+        [=env (monad;map @ (clean t-id) env)
          =body (clean t-id body)] ## TODO: DO NOT CLEAN THE BODY
         (wrap (<tag> =env =body))))
     ([#;UnivQ]
@@ -274,7 +274,7 @@
   (Check [Nat Type])
   (function [context]
     (let [id (get@ #;var-counter context)]
-      (#R;Success [(|> context
+      (#E;Success [(|> context
                        (update@ #;var-counter n.inc)
                        (update@ #;var-bindings (var::put id #;None)))
                    [id (#;Var id)]]))))
@@ -282,19 +282,19 @@
 (def: get-bindings
   (Check (List [Nat (Maybe Type)]))
   (function [context]
-    (#R;Success [context
+    (#E;Success [context
                  (get@ #;var-bindings context)])))
 
 (def: (set-bindings value)
   (-> (List [Nat (Maybe Type)]) (Check Unit))
   (function [context]
-    (#R;Success [(set@ #;var-bindings value context)
+    (#E;Success [(set@ #;var-bindings value context)
                  []])))
 
 (def: #export (delete id)
   (-> Nat (Check Unit))
   (function [context]
-    (#R;Success [(update@ #;var-bindings (var::remove id) context)
+    (#E;Success [(update@ #;var-bindings (var::remove id) context)
                  []])))
 
 (def: #export (with k)
@@ -316,16 +316,16 @@
   (All [a] (-> (Check a) (Check (Maybe a))))
   (function [context]
     (case (op context)
-      (#R;Success [context' output])
-      (#R;Success [context' (#;Some output)])
+      (#E;Success [context' output])
+      (#E;Success [context' (#;Some output)])
 
-      (#R;Error _)
-      (#R;Success [context #;None]))))
+      (#E;Error _)
+      (#E;Success [context #;None]))))
 
 (def: #export (fail message)
   (All [a] (-> Text (Check a)))
   (function [context]
-    (#R;Error message)))
+    (#E;Error message)))
 
 (def: (fail-check expected actual)
   (All [a] (-> Type Type (Check a)))
@@ -337,18 +337,18 @@
   (All [a] (-> (Check a) (Check a) (Check a)))
   (function [context]
     (case (left context)
-      (#R;Success [context' output])
-      (#R;Success [context' output])
+      (#E;Success [context' output])
+      (#E;Success [context' output])
 
-      (#R;Error _)
+      (#E;Error _)
       (right context))))
 
 (def: (assumed? [e a] assumptions)
   (-> [Type Type] Assumptions (Maybe Bool))
   (:: Monad<Maybe> map product;right
       (list;find (function [[[fe fa] status]]
-                   (and (Type/= e fe)
-                        (Type/= a fa)))
+                   (and (type/= e fe)
+                        (type/= a fa)))
                  assumptions)))
 
 (def: (assume! ea status assumptions)
@@ -370,11 +370,11 @@
   {#;doc "Type-check to ensure that the 'expected' type subsumes the 'actual' type."}
   (-> Type Type Assumptions (Check Assumptions))
   (if (is expected actual)
-    (Check/wrap assumptions)
+    (check/wrap assumptions)
     (case [expected actual]
       [(#;Var e-id) (#;Var a-id)]
       (if (n.= e-id a-id)
-        (Check/wrap assumptions)
+        (check/wrap assumptions)
         (do Monad<Check>
           [ebound (attempt (read e-id))
            abound (attempt (read a-id))]
@@ -394,12 +394,12 @@
             (check' etype atype assumptions))))
       
       [(#;Var id) _]
-      (on id actual (Check/wrap assumptions)
+      (on id actual (check/wrap assumptions)
           (function [bound]
             (check' bound actual assumptions)))
       
       [_ (#;Var id)]
-      (on id expected (Check/wrap assumptions)
+      (on id expected (check/wrap assumptions)
           (function [bound]
             (check' expected bound assumptions)))
 
@@ -433,7 +433,7 @@
         (case (assumed? fx-pair assumptions)
           (#;Some ?)
           (if ?
-            (Check/wrap assumptions)
+            (check/wrap assumptions)
             (fail-check expected actual))
 
           #;None
@@ -459,7 +459,7 @@
            [actual' (apply-type! actual var)
             assumptions (check' expected actual' assumptions)
             _ (clean var-id expected)]
-           (Check/wrap assumptions))))
+           (check/wrap assumptions))))
 
       [(#;ExQ e!env e!def) _]
       (with
@@ -468,7 +468,7 @@
            [expected' (apply-type! expected var)
             assumptions (check' expected' actual assumptions)
             _ (clean var-id actual)]
-           (Check/wrap assumptions))))
+           (check/wrap assumptions))))
 
       [_ (#;ExQ a!env a!def)]
       (do Monad<Check>
@@ -481,16 +481,16 @@
                (n.= (list;size e-params)
                     (list;size a-params)))
         (do Monad<Check>
-          [assumptions (M;fold Monad<Check>
-                               (function [[e a] assumptions] (check' e a assumptions))
-                               assumptions
-                               (list;zip2 e-params a-params))]
-          (Check/wrap assumptions))
+          [assumptions (monad;fold Monad<Check>
+                                   (function [[e a] assumptions] (check' e a assumptions))
+                                   assumptions
+                                   (list;zip2 e-params a-params))]
+          (check/wrap assumptions))
         (fail-check expected actual))
 
       (^template [<identity> <compose>]
         [<identity> <identity>]
-        (Check/wrap assumptions)
+        (check/wrap assumptions)
         
         [(<compose> eL eR) (<compose> aL aR)]
         (do Monad<Check>
@@ -506,7 +506,7 @@
 
       [(#;Ex e!id) (#;Ex a!id)]
       (if (n.= e!id a!id)
-        (Check/wrap assumptions)
+        (check/wrap assumptions)
         (fail-check expected actual))
 
       [(#;Named _ ?etype) _]
@@ -529,13 +529,13 @@
   {#;doc "A simple type-checking function that just returns a yes/no answer."}
   (-> Type Type Bool)
   (case (run fresh-context (check expected actual))
-    (#R;Error error)
+    (#E;Error error)
     false
 
-    (#R;Success _)
+    (#E;Success _)
     true))
 
 (def: #export get-context
   (Check Type-Context)
   (function [context]
-    (#R;Success [context context])))
+    (#E;Success [context context])))
diff --git a/stdlib/source/lux/type/opaque.lux b/stdlib/source/lux/type/opaque.lux
index b58e8d32e..00a27333a 100644
--- a/stdlib/source/lux/type/opaque.lux
+++ b/stdlib/source/lux/type/opaque.lux
@@ -4,7 +4,7 @@
                 [monad #+ do Monad]
                 ["p" parser])
        (data [text "text/" Eq<Text> Monoid<Text>]
-             ["R" result]
+             ["E" error]
              (coll [list "list/" Functor<List> Monoid<List>]))
        [macro]
        (macro [code]
@@ -91,7 +91,7 @@
                                                                 _
                                                                 (macro;fail ($_ text/compose "Wrong syntax for " up-cast))))]))))]]
     (function [compiler]
-      (#R;Success [(update@ #;modules (put this-module-name this-module) compiler)
+      (#E;Success [(update@ #;modules (put this-module-name this-module) compiler)
                    []]))))
 
 (def: (un-install-casts' this-module-name)
@@ -102,7 +102,7 @@
                            (update@ #;defs (remove down-cast))
                            (update@ #;defs (remove up-cast)))]]
     (function [compiler]
-      (#R;Success [(update@ #;modules (put this-module-name this-module) compiler)
+      (#E;Success [(update@ #;modules (put this-module-name this-module) compiler)
                    []]))))
 
 (syntax: #hidden (install-casts [name s;local-symbol]
diff --git a/stdlib/source/lux/world/blob.jvm.lux b/stdlib/source/lux/world/blob.jvm.lux
index 4d35a5658..88efc1859 100644
--- a/stdlib/source/lux/world/blob.jvm.lux
+++ b/stdlib/source/lux/world/blob.jvm.lux
@@ -5,7 +5,7 @@
                 [eq])
        (data [bit]
              [maybe]
-             ["R" result]
+             ["E" error]
              text/format)
        [host]))
 
@@ -31,23 +31,23 @@
   (host;array byte size))
 
 (def: #export (read-8 idx blob)
-  (-> Nat Blob (R;Result Nat))
+  (-> Nat Blob (E;Error Nat))
   (if (n.< (host;array-length blob) idx)
-    (|> (host;array-read idx blob) byte-to-nat #R;Success)
+    (|> (host;array-read idx blob) byte-to-nat #E;Success)
     (ex;throw Index-Out-Of-Bounds (%n idx))))
 
 (def: #export (read-16 idx blob)
-  (-> Nat Blob (R;Result Nat))
+  (-> Nat Blob (E;Error Nat))
   (if (n.< (host;array-length blob) (n.+ +1 idx))
-    (#R;Success ($_ bit;or
+    (#E;Success ($_ bit;or
                     (bit;shift-left +8 (byte-to-nat (host;array-read idx blob)))
                     (byte-to-nat (host;array-read (n.+ +1 idx) blob))))
     (ex;throw Index-Out-Of-Bounds (%n idx))))
 
 (def: #export (read-32 idx blob)
-  (-> Nat Blob (R;Result Nat))
+  (-> Nat Blob (E;Error Nat))
   (if (n.< (host;array-length blob) (n.+ +3 idx))
-    (#R;Success ($_ bit;or
+    (#E;Success ($_ bit;or
                     (bit;shift-left +24 (byte-to-nat (host;array-read idx blob)))
                     (bit;shift-left +16 (byte-to-nat (host;array-read (n.+ +1 idx) blob)))
                     (bit;shift-left +8 (byte-to-nat (host;array-read (n.+ +2 idx) blob)))
@@ -55,9 +55,9 @@
     (ex;throw Index-Out-Of-Bounds (%n idx))))
 
 (def: #export (read-64 idx blob)
-  (-> Nat Blob (R;Result Nat))
+  (-> Nat Blob (E;Error Nat))
   (if (n.< (host;array-length blob) (n.+ +7 idx))
-    (#R;Success ($_ bit;or
+    (#E;Success ($_ bit;or
                     (bit;shift-left +56 (byte-to-nat (host;array-read idx blob)))
                     (bit;shift-left +48 (byte-to-nat (host;array-read (n.+ +1 idx) blob)))
                     (bit;shift-left +40 (byte-to-nat (host;array-read (n.+ +2 idx) blob)))
@@ -69,35 +69,35 @@
     (ex;throw Index-Out-Of-Bounds (%n idx))))
 
 (def: #export (write-8 idx value blob)
-  (-> Nat Nat Blob (R;Result Unit))
+  (-> Nat Nat Blob (E;Error Unit))
   (if (n.< (host;array-length blob) idx)
     (exec (|> blob
               (host;array-write idx (host;l2b (:! Int value))))
-      (#R;Success []))
+      (#E;Success []))
     (ex;throw Index-Out-Of-Bounds (%n idx))))
 
 (def: #export (write-16 idx value blob)
-  (-> Nat Nat Blob (R;Result Unit))
+  (-> Nat Nat Blob (E;Error Unit))
   (if (n.< (host;array-length blob) (n.+ +1 idx))
     (exec (|> blob
               (host;array-write idx (host;l2b (:! Int (bit;shift-right +8 value))))
               (host;array-write (n.+ +1 idx) (host;l2b (:! Int value))))
-      (#R;Success []))
+      (#E;Success []))
     (ex;throw Index-Out-Of-Bounds (%n idx))))
 
 (def: #export (write-32 idx value blob)
-  (-> Nat Nat Blob (R;Result Unit))
+  (-> Nat Nat Blob (E;Error Unit))
   (if (n.< (host;array-length blob) (n.+ +3 idx))
     (exec (|> blob
               (host;array-write idx (host;l2b (:! Int (bit;shift-right +24 value))))
               (host;array-write (n.+ +1 idx) (host;l2b (:! Int (bit;shift-right +16 value))))
               (host;array-write (n.+ +2 idx) (host;l2b (:! Int (bit;shift-right +8 value))))
               (host;array-write (n.+ +3 idx) (host;l2b (:! Int value))))
-      (#R;Success []))
+      (#E;Success []))
     (ex;throw Index-Out-Of-Bounds (%n idx))))
 
 (def: #export (write-64 idx value blob)
-  (-> Nat Nat Blob (R;Result Unit))
+  (-> Nat Nat Blob (E;Error Unit))
   (if (n.< (host;array-length blob) (n.+ +7 idx))
     (exec (|> blob
               (host;array-write idx (host;l2b (:! Int (bit;shift-right +56 value))))
@@ -108,7 +108,7 @@
               (host;array-write (n.+ +5 idx) (host;l2b (:! Int (bit;shift-right +16 value))))
               (host;array-write (n.+ +6 idx) (host;l2b (:! Int (bit;shift-right +8 value))))
               (host;array-write (n.+ +7 idx) (host;l2b (:! Int value))))
-      (#R;Success []))
+      (#E;Success []))
     (ex;throw Index-Out-Of-Bounds (%n idx))))
 
 (def: #export (size blob)
@@ -116,7 +116,7 @@
   (host;array-length blob))
 
 (def: #export (slice from to blob)
-  (-> Nat Nat Blob (R;Result Blob))
+  (-> Nat Nat Blob (E;Error Blob))
   (with-expansions [<description> (as-is (format "from = " (%n from) " | " "to = " (%n to)))]
     (let [size (host;array-length blob)]
       (cond (not (n.<= to from))
@@ -127,10 +127,10 @@
             (ex;throw Index-Out-Of-Bounds <description>)
 
             ## else
-            (#R;Success (Arrays.copyOfRange [blob (:! Int from) (:! Int (n.inc to))]))))))
+            (#E;Success (Arrays.copyOfRange [blob (:! Int from) (:! Int (n.inc to))]))))))
 
 (def: #export (slice' from blob)
-  (-> Nat Blob (R;Result Blob))
+  (-> Nat Blob (E;Error Blob))
   (slice from (n.dec (host;array-length blob)) blob))
 
 (struct: #export _ (eq;Eq Blob)
diff --git a/stdlib/source/lux/world/file.lux b/stdlib/source/lux/world/file.lux
index 4c0881e04..1c968b888 100644
--- a/stdlib/source/lux/world/file.lux
+++ b/stdlib/source/lux/world/file.lux
@@ -4,7 +4,7 @@
                 ["ex" exception #+ exception:])
        (concurrency ["P" promise]
                     ["T" task])
-       (data ["R" result]
+       (data ["E" error]
              (coll [array]))
        (time ["i" instant]
              ["d" duration])
@@ -52,7 +52,7 @@
 (do-template [<name> <flag>]
   [(def: #export (<name> data file)
      (-> Blob File (T;Task Unit))
-     (P;future (do (R;ResultT io;Monad<IO>)
+     (P;future (do (E;ErrorT io;Monad<IO>)
                  [stream (FileOutputStream.new [(java.io.File.new file) <flag>])
                   _ (OutputStream.write [data] stream)
                   _ (OutputStream.flush [] stream)]
@@ -64,7 +64,7 @@
 
 (def: #export (read file)
   (-> File (T;Task Blob))
-  (P;future (do (R;ResultT io;Monad<IO>)
+  (P;future (do (E;ErrorT io;Monad<IO>)
               [#let [file' (java.io.File.new file)]
                size (java.io.File.length [] file')
                #let [data (blob;create (int-to-nat size))]
@@ -77,13 +77,13 @@
 
 (def: #export (size file)
   (-> File (T;Task Nat))
-  (P;future (do (R;ResultT io;Monad<IO>)
+  (P;future (do (E;ErrorT io;Monad<IO>)
               [size (java.io.File.length [] (java.io.File.new file))]
               (wrap (int-to-nat size)))))
 
 (def: #export (files dir)
   (-> File (T;Task (List File)))
-  (P;future (do (R;ResultT io;Monad<IO>)
+  (P;future (do (E;ErrorT io;Monad<IO>)
               [files (java.io.File.listFiles [] (java.io.File.new dir))]
               (monad;map @ (java.io.File.getAbsolutePath [])
                          (array;to-list files)))))
@@ -110,7 +110,7 @@
 
 (def: #export (get-last-modified file)
   (-> File (T;Task i;Instant))
-  (P;future (do (R;ResultT io;Monad<IO>)
+  (P;future (do (E;ErrorT io;Monad<IO>)
               [millis (java.io.File.lastModified [] (java.io.File.new file))]
               (wrap (|> millis d;from-millis i;absolute)))))
 
diff --git a/stdlib/source/lux/world/net/tcp.jvm.lux b/stdlib/source/lux/world/net/tcp.jvm.lux
index fec65e387..e8832b67e 100644
--- a/stdlib/source/lux/world/net/tcp.jvm.lux
+++ b/stdlib/source/lux/world/net/tcp.jvm.lux
@@ -4,7 +4,7 @@
        (concurrency ["P" promise]
                     ["T" task]
                     [frp])
-       (data ["R" result])
+       (data ["E" error])
        (type opaque)
        (world [blob #+ Blob])
        [io]
@@ -44,7 +44,7 @@
   (def: #export (read data offset length self)
     (let [in (get@ #in (@repr self))]
       (P;future
-       (do (R;ResultT io;Monad<IO>)
+       (do (E;ErrorT io;Monad<IO>)
          [bytes-read (InputStream.read [data (nat-to-int offset) (nat-to-int length)]
                                        in)]
          (wrap (int-to-nat bytes-read))))))
@@ -52,7 +52,7 @@
   (def: #export (write data offset length self)
     (let [out (get@ #out (@repr self))]
       (P;future
-       (do (R;ResultT io;Monad<IO>)
+       (do (E;ErrorT io;Monad<IO>)
          [_ (OutputStream.write [data (nat-to-int offset) (nat-to-int length)]
                                 out)]
          (Flushable.flush [] out)))))
@@ -60,14 +60,14 @@
   (def: #export (close self)
     (let [(^open) (@repr self)]
       (P;future
-       (do (R;ResultT io;Monad<IO>)
+       (do (E;ErrorT io;Monad<IO>)
          [_ (AutoCloseable.close [] in)
           _ (AutoCloseable.close [] out)]
          (AutoCloseable.close [] socket)))))
 
   (def: (tcp-client socket)
-    (-> Socket (io;IO (R;Result TCP)))
-    (do (R;ResultT io;Monad<IO>)
+    (-> Socket (io;IO (E;Error TCP)))
+    (do (E;ErrorT io;Monad<IO>)
       [input (Socket.getInputStream [] socket)
        output (Socket.getOutputStream [] socket)]
       (wrap (@opaque {#socket socket
@@ -77,7 +77,7 @@
   (def: #export (client address port)
     (-> ..;Address ..;Port (T;Task TCP))
     (P;future
-     (do (R;ResultT io;Monad<IO>)
+     (do (E;ErrorT io;Monad<IO>)
        [socket (Socket.new [address (nat-to-int port)])]
        (tcp-client socket))))
 
@@ -102,21 +102,21 @@
   (def: #export (server port)
     (-> ..;Port (T;Task (frp;Channel TCP)))
     (P;future
-     (do (R;ResultT io;Monad<IO>)
+     (do (E;ErrorT io;Monad<IO>)
        [server (ServerSocket.new [(nat-to-int port)])
         #let [output (frp;channel TCP)
               _ (: (P;Promise Bool)
                    (P;future
                     (loop [tail output]
                       (do io;Monad<IO>
-                        [?client (do (R;ResultT io;Monad<IO>)
+                        [?client (do (E;ErrorT io;Monad<IO>)
                                    [socket (ServerSocket.accept [] server)]
                                    (tcp-client socket))]
                         (case ?client
-                          (#R;Error error)
+                          (#E;Error error)
                           (frp;close tail)
                           
-                          (#R;Success client)
+                          (#E;Success client)
                           (do @
                             [?tail' (frp;write client tail)]
                             (case ?tail'
diff --git a/stdlib/source/lux/world/net/udp.jvm.lux b/stdlib/source/lux/world/net/udp.jvm.lux
index 89eaba448..29be4a920 100644
--- a/stdlib/source/lux/world/net/udp.jvm.lux
+++ b/stdlib/source/lux/world/net/udp.jvm.lux
@@ -5,7 +5,7 @@
        (concurrency ["P" promise]
                     ["T" task]
                     [frp])
-       (data ["R" result]
+       (data ["E" error]
              [maybe]
              (coll [array]))
        (type opaque)
@@ -45,10 +45,10 @@
 (exception: #export Multiple-Candidate-Addresses)
 
 (def: (resolve address)
-  (-> ..;Address (io;IO (R;Result InetAddress)))
-  (do (R;ResultT io;Monad<IO>)
+  (-> ..;Address (io;IO (E;Error InetAddress)))
+  (do (E;ErrorT io;Monad<IO>)
     [addresses (InetAddress.getAllByName [address])]
-    (: (io;IO (R;Result InetAddress))
+    (: (io;IO (E;Error InetAddress))
        (case (array;size addresses)
          +0 (io;io (ex;throw Cannot-Resolve-Address address))
          +1 (wrap (maybe;assume (array;read +0 addresses)))
@@ -62,7 +62,7 @@
     (let [(^open) (@repr self)
           packet (DatagramPacket.new|receive [data (nat-to-int offset) (nat-to-int length)])]
       (P;future
-       (do (R;ResultT io;Monad<IO>)
+       (do (E;ErrorT io;Monad<IO>)
          [_ (DatagramSocket.receive [packet] socket)
           #let [bytes-read (int-to-nat (DatagramPacket.getLength [] packet))]]
          (wrap [bytes-read
@@ -72,7 +72,7 @@
   (def: #export (write address port data offset length self)
     (-> ..;Address ..;Port Blob Nat Nat UDP (T;Task Unit))
     (P;future
-     (do (R;ResultT io;Monad<IO>)
+     (do (E;ErrorT io;Monad<IO>)
        [address (resolve address)
         #let [(^open) (@repr self)]]
        (DatagramSocket.send (DatagramPacket.new|send [data (nat-to-int offset) (nat-to-int length) address (nat-to-int port)])
@@ -87,14 +87,14 @@
   (def: #export (client _)
     (-> Unit (T;Task UDP))
     (P;future
-     (do (R;ResultT io;Monad<IO>)
+     (do (E;ErrorT io;Monad<IO>)
        [socket (DatagramSocket.new|client [])]
        (wrap (@opaque (#socket socket))))))
 
   (def: #export (server port)
     (-> ..;Port (T;Task UDP))
     (P;future
-     (do (R;ResultT io;Monad<IO>)
+     (do (E;ErrorT io;Monad<IO>)
        [socket (DatagramSocket.new|server [(nat-to-int port)])]
        (wrap (@opaque (#socket socket))))))
   )
diff --git a/stdlib/test/test/lux.lux b/stdlib/test/test/lux.lux
index 546d7f14f..5ff53793c 100644
--- a/stdlib/test/test/lux.lux
+++ b/stdlib/test/test/lux.lux
@@ -4,7 +4,7 @@
   (lux (control ["M" monad #+ do Monad])
        [io]
        [math]
-       ["R" math/random]
+       ["r" math/random]
        (data [maybe]
              [text "T/" Eq<Text>]
              text/format)
@@ -12,9 +12,9 @@
        (macro ["s" syntax #+ syntax:])))
 
 (context: "Value identity."
-  [size (|> R;nat (:: @ map (|>. (n.% +100) (n.max +10))))
-   x (R;text size)
-   y (R;text size)]
+  [size (|> r;nat (:: @ map (|>. (n.% +100) (n.max +10))))
+   x (r;text size)
+   y (r;text size)]
   ($_ seq
       (test "Every value is identical to itself, and the 'id' function doesn't change values in any way."
             (and (is x x)
@@ -44,8 +44,8 @@
              (and (|> value inc even?)
                   (|> value dec even?)))))]
 
-  ["Nat" R;nat n.inc n.dec n.even? n.odd? n.= n.< n.>]
-  ["Int" R;int i.inc i.dec i.even? i.odd? i.= i.< i.>]
+  ["Nat" r;nat n.inc n.dec n.even? n.odd? n.= n.< n.>]
+  ["Int" r;int i.inc i.dec i.even? i.odd? i.= i.< i.>]
   )
 
 (do-template [category rand-gen = < > <= >= min max]
@@ -68,10 +68,10 @@
                      (>= y (max x y)))
                 )))]
 
-  ["Int"  R;int  i.= i.< i.> i.<= i.>= i.min i.max]
-  ["Nat"  R;nat  n.= n.< n.> n.<= n.>= n.min n.max]
-  ["Frac" R;frac f.= f.< f.> f.<= f.>= f.min f.max]
-  ["Deg" R;deg d.= d.< d.> d.<= d.>= d.min d.max]
+  ["Int"  r;int  i.= i.< i.> i.<= i.>= i.min i.max]
+  ["Nat"  r;nat  n.= n.< n.> n.<= n.>= n.min n.max]
+  ["Frac" r;frac f.= f.< f.> f.<= f.>= f.min f.max]
+  ["Deg"  r;deg  d.= d.< d.> d.<= d.>= d.min d.max]
   )
 
 (do-template [category rand-gen = + - * / <%> > <0> <1> <factor> %x <cap> <prep>]
@@ -104,7 +104,7 @@
      [x (:: @ map <cap> rand-gen)
       y (|> rand-gen
             (:: @ map <cap>)
-            (R;filter (|>. (= <0>) not)))
+            (r;filter (|>. (= <0>) not)))
       #let [r (<%> y x)
             x' (- r x)]]
      (test ""
@@ -116,10 +116,10 @@
                    (|> x' (/ y) (* y) (= x'))))
            ))]
 
-  ["Nat"  R;nat  n.= n.+ n.- n.* n./ n.% n.> +0  +1                                  +1000000                           %n (n.% +1000) id]
-  ["Int"  R;int  i.= i.+ i.- i.* i./ i.% i.>  0   1                                   1000000                           %i (i.%  1000) id]
-  ["Frac" R;frac f.= f.+ f.- f.* f./ f.% f.>  0.0 1.0                                 1000000.0                         %r id          math;floor]
-  ["Deg"  R;deg  d.= d.+ d.- d.* d./ d.% d.>   .0 (_lux_proc ["deg" "max-value"] []) (_lux_proc ["deg" "max-value"] []) %f id          id]
+  ["Nat"  r;nat  n.= n.+ n.- n.* n./ n.% n.> +0  +1                                  +1000000                           %n (n.% +1000) id]
+  ["Int"  r;int  i.= i.+ i.- i.* i./ i.% i.>  0   1                                   1000000                           %i (i.%  1000) id]
+  ["Frac" r;frac f.= f.+ f.- f.* f./ f.% f.>  0.0 1.0                                 1000000.0                         %r id          math;floor]
+  ["Deg"  r;deg  d.= d.+ d.- d.* d./ d.% d.>   .0 (_lux_proc ["deg" "max-value"] []) (_lux_proc ["deg" "max-value"] []) %f id          id]
   )
 
 (do-template [category rand-gen -> <- = <cap> %a %z]
@@ -129,11 +129,11 @@
      (test ""
            (|> value -> <- (= value))))]
 
-  ["Int->Nat"  R;int  int-to-nat  nat-to-int  i.= (i.%  1000000) %i %n]
-  ["Nat->Int"  R;nat  nat-to-int  int-to-nat  n.= (n.% +1000000) %n %i]
-  ["Int->Frac" R;int  int-to-frac frac-to-int i.= (i.%  1000000) %i %r]
-  ["Frac->Int" R;frac frac-to-int int-to-frac f.= math;floor     %r %i]
-  ## [R;frac frac-to-deg deg-to-frac f.= (f.% 1.0) %r %f]
+  ["Int->Nat"  r;int  int-to-nat  nat-to-int  i.= (i.%  1000000) %i %n]
+  ["Nat->Int"  r;nat  nat-to-int  int-to-nat  n.= (n.% +1000000) %n %i]
+  ["Int->Frac" r;int  int-to-frac frac-to-int i.= (i.%  1000000) %i %r]
+  ["Frac->Int" r;frac frac-to-int int-to-frac f.= math;floor     %r %i]
+  ## [r;frac frac-to-deg deg-to-frac f.= (f.% 1.0) %r %f]
   )
 
 (context: "Simple macros and constructs"
@@ -173,8 +173,8 @@
   (i.+ (i.* x x) (i.* y y)))
 
 (context: "Templates"
-  [x R;int
-   y R;int]
+  [x r;int
+   y r;int]
   (test "Template application is a stand-in for the templated code."
         (i.= (i.+ (i.* x x) (i.* y y))
              (hypotenuse x y))))
diff --git a/stdlib/test/test/lux/cli.lux b/stdlib/test/test/lux/cli.lux
index fb7301359..6c6b113ea 100644
--- a/stdlib/test/test/lux/cli.lux
+++ b/stdlib/test/test/lux/cli.lux
@@ -11,14 +11,14 @@
              [sum]
              (coll [list]))
        ["&" cli]
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (context: "CLI"
-  [num-args (|> R;nat (:: @ map (n.% +10)))
+  [num-args (|> r;nat (:: @ map (n.% +10)))
    #let [(^open "Nat/") number;Codec<Text,Nat>
-         gen-arg (:: @ map Nat/encode R;nat)]
-   option-name (R;text +5)
+         gen-arg (:: @ map Nat/encode r;nat)]
+   option-name (r;text +5)
    singleton gen-arg]
   ($_ seq
       (test "Can read any argument."
diff --git a/stdlib/test/test/lux/concurrency/actor.lux b/stdlib/test/test/lux/concurrency/actor.lux
index 41618cb64..f5d230833 100644
--- a/stdlib/test/test/lux/concurrency/actor.lux
+++ b/stdlib/test/test/lux/concurrency/actor.lux
@@ -5,7 +5,7 @@
                 ["ex" exception])
        (data [number]
              text/format
-             ["R" result])
+             ["E" error])
        (concurrency ["P" promise "P/" Monad<Promise>]
                     ["T" task]
                     ["&" actor #+ actor: message:]))
@@ -79,9 +79,9 @@
                              (n.= +3 output-3))))]
         (test "Can send messages to actors."
               (case result
-                (#R;Success outcome)
+                (#E;Success outcome)
                 outcome
 
-                (#R;Error error)
+                (#E;Error error)
                 false)))
       ))
diff --git a/stdlib/test/test/lux/concurrency/atom.lux b/stdlib/test/test/lux/concurrency/atom.lux
index d841a4e84..538e7d676 100644
--- a/stdlib/test/test/lux/concurrency/atom.lux
+++ b/stdlib/test/test/lux/concurrency/atom.lux
@@ -6,13 +6,13 @@
              (coll [list "" Functor<List>])
              text/format)
        (concurrency ["&" atom])
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (context: "Atoms"
-  [value R;nat
-   swap-value R;nat
-   set-value R;nat
+  [value r;nat
+   swap-value r;nat
+   set-value r;nat
    #let [box (&;atom value)]]
   ($_ seq
       (test "Can obtain the value of an atom."
diff --git a/stdlib/test/test/lux/concurrency/promise.lux b/stdlib/test/test/lux/concurrency/promise.lux
index 21e2aa7db..7b8f3fdd3 100644
--- a/stdlib/test/test/lux/concurrency/promise.lux
+++ b/stdlib/test/test/lux/concurrency/promise.lux
@@ -6,7 +6,7 @@
        (data [number]
              text/format)
        (concurrency ["&" promise "&/" Monad<Promise>])
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (context: "Promises"
diff --git a/stdlib/test/test/lux/concurrency/stm.lux b/stdlib/test/test/lux/concurrency/stm.lux
index ade1700b5..52361b85a 100644
--- a/stdlib/test/test/lux/concurrency/stm.lux
+++ b/stdlib/test/test/lux/concurrency/stm.lux
@@ -8,7 +8,7 @@
              text/format)
        (concurrency ["&" stm]
                     [promise])
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (def: iterations/processes Int 100)
diff --git a/stdlib/test/test/lux/control/cont.lux b/stdlib/test/test/lux/control/cont.lux
index 926525942..ea86ccb05 100644
--- a/stdlib/test/test/lux/control/cont.lux
+++ b/stdlib/test/test/lux/control/cont.lux
@@ -8,13 +8,13 @@
              [number]
              [product]
              (coll [list]))
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (context: "Continuations"
-  [sample R;nat
+  [sample r;nat
    #let [(^open "&/") &;Monad<Cont>]
-   elems (R;list +3 R;nat)]
+   elems (r;list +3 r;nat)]
   ($_ seq
       (test "Can run continuations to compute their values."
             (n.= sample (&;run (&/wrap sample))))
diff --git a/stdlib/test/test/lux/control/exception.lux b/stdlib/test/test/lux/control/exception.lux
index 5680b95f1..fc552b69c 100644
--- a/stdlib/test/test/lux/control/exception.lux
+++ b/stdlib/test/test/lux/control/exception.lux
@@ -3,11 +3,11 @@
   (lux [io]
        (control ["M" monad #+ do Monad]
                 ["&" exception #+ exception:])
-       (data ["E" result]
+       (data ["E" error]
              [text]
              text/format
              [number])
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (exception: Some-Exception)
@@ -17,13 +17,13 @@
 (exception: Unknown-Exception)
 
 (context: "Exceptions"
-  [should-throw? R;bool
-   which? R;bool
-   should-catch? R;bool
-   default-val R;nat
-   some-val R;nat
-   another-val R;nat
-   otherwise-val R;nat
+  [should-throw? r;bool
+   which? r;bool
+   should-catch? r;bool
+   default-val r;nat
+   some-val r;nat
+   another-val r;nat
+   otherwise-val r;nat
    #let [this-ex (if should-catch?
                    (if which?
                      Some-Exception
@@ -36,7 +36,7 @@
                         another-val)
                       otherwise-val)
                     default-val)
-         actual (|> (: (E;Result Nat)
+         actual (|> (: (E;Error Nat)
                        (if should-throw?
                          (&;throw this-ex "Uh-oh...")
                          (&;return default-val)))
diff --git a/stdlib/test/test/lux/control/interval.lux b/stdlib/test/test/lux/control/interval.lux
index 8cf46012c..2ba5198bc 100644
--- a/stdlib/test/test/lux/control/interval.lux
+++ b/stdlib/test/test/lux/control/interval.lux
@@ -5,15 +5,15 @@
                 pipe
                 ["&" interval])
        [io]
-       ["R" math/random]
+       ["r" math/random]
        (data text/format
              [number]
              ["S" coll/set]
              ["L" coll/list])))
 
 (context: "Equality."
-  [bottom R;int
-   top R;int
+  [bottom r;int
+   top r;int
    #let [(^open "&/") &;Eq<Interval>]]
   ($_ seq
       (test "Every interval is equal to itself."
@@ -25,8 +25,8 @@
                    (&/= self self))))))
 
 (context: "Boundaries"
-  [bottom R;int
-   top R;int
+  [bottom r;int
+   top r;int
    #let [interval (&;between number;Enum<Int> bottom top)]]
   ($_ seq
       (test "Every boundary value belongs to it's interval."
@@ -53,10 +53,10 @@
 
 (do-template [<name> <cmp>]
   [(def: <name>
-     (R;Random (&;Interval Int))
-     (do R;Monad<Random>
-       [bottom R;int
-        top (|> R;int (R;filter (|>. (i.= bottom) not)))]
+     (r;Random (&;Interval Int))
+     (do r;Monad<Random>
+       [bottom r;int
+        top (|> r;int (r;filter (|>. (i.= bottom) not)))]
        (if (<cmp> top bottom)
          (wrap (&;between number;Enum<Int> bottom top))
          (wrap (&;between number;Enum<Int> top bottom)))))]
@@ -66,14 +66,14 @@
   )
 
 (def: gen-singleton
-  (R;Random (&;Interval Int))
-  (do R;Monad<Random>
-    [point R;int]
+  (r;Random (&;Interval Int))
+  (do r;Monad<Random>
+    [point r;int]
     (wrap (&;singleton number;Enum<Int> point))))
 
 (def: gen-interval
-  (R;Random (&;Interval Int))
-  ($_ R;either
+  (r;Random (&;Interval Int))
+  ($_ r;either
       gen-inner
       gen-outer
       gen-singleton))
@@ -129,7 +129,7 @@
       ))
 
 (context: "Positioning/location"
-  [[l m r] (|> (R;set number;Hash<Int> +3 R;int)
+  [[l m r] (|> (r;set number;Hash<Int> +3 r;int)
                (:: @ map (|>. S;to-list
                               (L;sort i.<)
                               (case> (^ (list b t1 t2))
@@ -149,7 +149,7 @@
       ))
 
 (context: "Touching intervals"
-  [[b t1 t2] (|> (R;set number;Hash<Int> +3 R;int)
+  [[b t1 t2] (|> (r;set number;Hash<Int> +3 r;int)
                  (:: @ map (|>. S;to-list
                                 (L;sort i.<)
                                 (case> (^ (list b t1 t2))
@@ -174,7 +174,7 @@
 
 (context: "Nesting & overlap"
   [some-interval gen-interval
-   [x0 x1 x2 x3] (|> (R;set number;Hash<Int> +4 R;int)
+   [x0 x1 x2 x3] (|> (r;set number;Hash<Int> +4 r;int)
                      (:: @ map (|>. S;to-list
                                     (L;sort i.<)
                                     (case> (^ (list x0 x1 x2 x3))
diff --git a/stdlib/test/test/lux/control/parser.lux b/stdlib/test/test/lux/control/parser.lux
index ae3fc2041..0f6b4a4b1 100644
--- a/stdlib/test/test/lux/control/parser.lux
+++ b/stdlib/test/test/lux/control/parser.lux
@@ -10,7 +10,7 @@
              [number]
              [bool]
              [ident]
-             ["R" result])
+             ["E" error])
        ["r" math/random]
        [macro]
        (macro [code]
@@ -19,15 +19,15 @@
 
 ## [Utils]
 (def: (should-fail input)
-  (All [a] (-> (R;Result a) Bool))
+  (All [a] (-> (E;Error a) Bool))
   (case input
-    (#R;Error _) true
+    (#E;Error _) true
     _          false))
 
 (def: (enforced? parser input)
   (All [s] (-> (&;Parser s Unit) s Bool))
   (case (&;run input parser)
-    (#R;Success [_ []])
+    (#E;Success [_ []])
     true
 
     _
@@ -36,7 +36,7 @@
 (def: (found? parser input)
   (All [s] (-> (&;Parser s Bool) s Bool))
   (case (&;run input parser)
-    (#R;Success [_ true])
+    (#E;Success [_ true])
     true
 
     _
@@ -45,16 +45,16 @@
 (def: (is? Eq<a> test parser input)
   (All [s a] (-> (Eq a) a (&;Parser s a) s Bool))
   (case (&;run input parser)
-    (#R;Success [_ output])
+    (#E;Success [_ output])
     (:: Eq<a> = test output)
 
     _
     false))
 
 (def: (fails? input)
-  (All [a] (-> (R;Result a) Bool))
+  (All [a] (-> (E;Error a) Bool))
   (case input
-    (#R;Error _)
+    (#E;Error _)
     true
 
     _
@@ -62,7 +62,7 @@
 
 (syntax: (match pattern input)
   (wrap (list (` (case (~ input)
-                   (^ (#R;Success [(~' _) (~ pattern)]))
+                   (^ (#E;Success [(~' _) (~ pattern)]))
                    true
 
                    (~' _)
diff --git a/stdlib/test/test/lux/control/pipe.lux b/stdlib/test/test/lux/control/pipe.lux
index 37f76e9af..23e6cfe60 100644
--- a/stdlib/test/test/lux/control/pipe.lux
+++ b/stdlib/test/test/lux/control/pipe.lux
@@ -8,7 +8,7 @@
              [product]
              identity
              [text "T/" Eq<Text>])
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (context: "Pipes"
diff --git a/stdlib/test/test/lux/control/state.lux b/stdlib/test/test/lux/control/state.lux
index 87731de60..1447e61c3 100644
--- a/stdlib/test/test/lux/control/state.lux
+++ b/stdlib/test/test/lux/control/state.lux
@@ -8,7 +8,7 @@
              text/format
              [number]
              [product])
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (def: (with-conditions [state output] computation)
@@ -19,8 +19,8 @@
       (n.= output)))
 
 (context: "Basics"
-  [state R;nat
-   value R;nat]
+  [state r;nat
+   value r;nat]
   ($_ seq
       (test "Can get the state as a value."
             (with-conditions [state state]
@@ -45,8 +45,8 @@
       ))
 
 (context: "Structures"
-  [state R;nat
-   value R;nat]
+  [state r;nat
+   value r;nat]
   ($_ seq
       (test "Can use functor."
             (with-conditions [state (n.inc state)]
@@ -69,9 +69,9 @@
       ))
 
 (context: "Monad transformer"
-  [state R;nat
-   left R;nat
-   right R;nat]
+  [state r;nat
+   left r;nat
+   right r;nat]
   (let [(^open "io/") io;Monad<IO>]
     (test "Can add state functionality to any monad."
           (|> (: (&;State' io;IO Nat Nat)
@@ -87,7 +87,7 @@
     ))
 
 (context: "Loops"
-  [limit (|> R;nat (:: @ map (n.% +10)))
+  [limit (|> r;nat (:: @ map (n.% +10)))
    #let [condition (do &;Monad<State>
                      [state &;get]
                      (wrap (n.< limit state)))]]
diff --git a/stdlib/test/test/lux/data/bit.lux b/stdlib/test/test/lux/data/bit.lux
index 53bebe088..8bbe8e599 100644
--- a/stdlib/test/test/lux/data/bit.lux
+++ b/stdlib/test/test/lux/data/bit.lux
@@ -4,12 +4,12 @@
        (control ["M" monad #+ do Monad])
        (data ["&" bit]
              number)
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (context: "Bitwise operations."
-  [pattern R;nat
-   idx (:: @ map (n.% &;width) R;nat)]
+  [pattern r;nat
+   idx (:: @ map (n.% &;width) r;nat)]
   ($_ seq
       (test "Clearing and settings bits should alter the count."
             (and (n.< (&;count (&;set idx pattern))
diff --git a/stdlib/test/test/lux/data/bool.lux b/stdlib/test/test/lux/data/bool.lux
index bbc867581..69366a3d2 100644
--- a/stdlib/test/test/lux/data/bool.lux
+++ b/stdlib/test/test/lux/data/bool.lux
@@ -3,11 +3,11 @@
   (lux (control ["M" monad #+ do Monad])
        [io]
        (data bool)
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (context: "Boolean operations."
-  [value R;bool]
+  [value r;bool]
   (test "" (and (not (and value (not value)))
                 (or value (not value))
 
diff --git a/stdlib/test/test/lux/data/coll/array.lux b/stdlib/test/test/lux/data/coll/array.lux
index d5fde5a64..e32bf2e0f 100644
--- a/stdlib/test/test/lux/data/coll/array.lux
+++ b/stdlib/test/test/lux/data/coll/array.lux
@@ -7,17 +7,17 @@
                    [list])
              [number]
              [maybe])
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (def: bounded-size
-  (R;Random Nat)
-  (|> R;nat
-      (:: R;Monad<Random> map (|>. (n.% +100) (n.+ +1)))))
+  (r;Random Nat)
+  (|> r;nat
+      (:: r;Monad<Random> map (|>. (n.% +100) (n.+ +1)))))
 
 (context: "Arrays and their copies"
   [size bounded-size
-   original (R;array size R;nat)
+   original (r;array size r;nat)
    #let [clone (@;clone original)
          copy (: (Array Nat)
                  (@;new size))
@@ -49,9 +49,9 @@
 
 (context: "Array mutation"
   [size bounded-size
-   idx (:: @ map (n.% size) R;nat)
-   array (|> (R;array size R;nat)
-             (R;filter (|>. @;to-list (list;any? n.odd?))))
+   idx (:: @ map (n.% size) r;nat)
+   array (|> (r;array size r;nat)
+             (r;filter (|>. @;to-list (list;any? n.odd?))))
    #let [value (maybe;assume (@;read idx array))]]
   ($_ seq
       (test "Shouldn't be able to find a value in an unoccupied cell."
@@ -75,8 +75,8 @@
 
 (context: "Finding values."
   [size bounded-size
-   array (|> (R;array size R;nat)
-             (R;filter (|>. @;to-list (list;any? n.even?))))]
+   array (|> (r;array size r;nat)
+             (r;filter (|>. @;to-list (list;any? n.even?))))]
   ($_ seq
       (test "Can find values inside arrays."
             (|> (@;find n.even? array)
@@ -92,7 +92,7 @@
 
 (context: "Functor"
   [size bounded-size
-   array (R;array size R;nat)]
+   array (r;array size r;nat)]
   (let [(^open) @;Functor<Array>
         (^open) (@;Eq<Array> number;Eq<Nat>)]
     ($_ seq
@@ -109,8 +109,8 @@
 (context: "Monoid"
   [sizeL bounded-size
    sizeR bounded-size
-   left (R;array sizeL R;nat)
-   right (R;array sizeR R;nat)
+   left (r;array sizeL r;nat)
+   right (r;array sizeR r;nat)
    #let [(^open) @;Monoid<Array>
          (^open) (@;Eq<Array> number;Eq<Nat>)
          fusion (compose left right)]]
diff --git a/stdlib/test/test/lux/data/coll/list.lux b/stdlib/test/test/lux/data/coll/list.lux
index a3d091625..2b5146a65 100644
--- a/stdlib/test/test/lux/data/coll/list.lux
+++ b/stdlib/test/test/lux/data/coll/list.lux
@@ -9,21 +9,21 @@
              [bool]
              [product]
              [maybe])
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (def: bounded-size
-  (R;Random Nat)
-  (|> R;nat
-      (:: R;Monad<Random> map (|>. (n.% +100) (n.+ +10)))))
+  (r;Random Nat)
+  (|> r;nat
+      (:: r;Monad<Random> map (|>. (n.% +100) (n.+ +10)))))
 
 (context: "Lists: Part 1"
   [size bounded-size
-   idx (:: @ map (n.% size) R;nat)
-   sample (R;list size R;nat)
+   idx (:: @ map (n.% size) r;nat)
+   sample (r;list size r;nat)
    other-size bounded-size
-   other-sample (R;list other-size R;nat)
-   separator R;nat
+   other-sample (r;list other-size r;nat)
+   separator r;nat
    #let [(^open) (&;Eq<List> number;Eq<Nat>)
          (^open "&/") &;Functor<List>]]
   ($_ seq
@@ -63,11 +63,11 @@
 
 (context: "Lists: Part 2"
   [size bounded-size
-   idx (:: @ map (n.% size) R;nat)
-   sample (R;list size R;nat)
+   idx (:: @ map (n.% size) r;nat)
+   sample (r;list size r;nat)
    other-size bounded-size
-   other-sample (R;list other-size R;nat)
-   separator R;nat
+   other-sample (r;list other-size r;nat)
+   separator r;nat
    #let [(^open) (&;Eq<List> number;Eq<Nat>)
          (^open "&/") &;Functor<List>]]
   ($_ seq
@@ -122,11 +122,11 @@
 
 (context: "Lists: Part 3"
   [size bounded-size
-   idx (:: @ map (n.% size) R;nat)
-   sample (R;list size R;nat)
+   idx (:: @ map (n.% size) r;nat)
+   sample (r;list size r;nat)
    other-size bounded-size
-   other-sample (R;list other-size R;nat)
-   separator R;nat
+   other-sample (r;list other-size r;nat)
+   separator r;nat
    #let [(^open) (&;Eq<List> number;Eq<Nat>)
          (^open "&/") &;Functor<List>]]
   ($_ seq
diff --git a/stdlib/test/test/lux/data/coll/priority-queue.lux b/stdlib/test/test/lux/data/coll/priority-queue.lux
index 51b9aee5e..07a2200a3 100644
--- a/stdlib/test/test/lux/data/coll/priority-queue.lux
+++ b/stdlib/test/test/lux/data/coll/priority-queue.lux
@@ -5,25 +5,25 @@
        (data (coll ["&" priority-queue])
              [number]
              [maybe])
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (def: (gen-queue size)
-  (-> Nat (R;Random (&;Queue Nat)))
-  (do R;Monad<Random>
-    [inputs (R;list size R;nat)]
+  (-> Nat (r;Random (&;Queue Nat)))
+  (do r;Monad<Random>
+    [inputs (r;list size r;nat)]
     (monad;fold @ (function [head tail]
                     (do @
-                      [priority R;nat]
+                      [priority r;nat]
                       (wrap (&;push priority head tail))))
                 &;empty
                 inputs)))
 
 (context: "Queues"
-  [size (|> R;nat (:: @ map (n.% +100)))
+  [size (|> r;nat (:: @ map (n.% +100)))
    sample (gen-queue size)
-   non-member-priority R;nat
-   non-member (|> R;nat (R;filter (|>. (&;member? number;Eq<Nat> sample) not)))]
+   non-member-priority r;nat
+   non-member (|> r;nat (r;filter (|>. (&;member? number;Eq<Nat> sample) not)))]
   ($_ seq
       (test "I can query the size of a queue (and empty queues have size 0)."
             (n.= size (&;size sample)))
diff --git a/stdlib/test/test/lux/data/coll/queue.lux b/stdlib/test/test/lux/data/coll/queue.lux
index 08c905e95..ddccc282b 100644
--- a/stdlib/test/test/lux/data/coll/queue.lux
+++ b/stdlib/test/test/lux/data/coll/queue.lux
@@ -4,14 +4,14 @@
        (control [monad #+ do Monad])
        (data (coll ["&" queue])
              [number])
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (context: "Queues"
-  [size (:: @ map (n.% +100) R;nat)
-   sample (R;queue size R;nat)
-   non-member (|> R;nat
-                  (R;filter (. not (&;member? number;Eq<Nat> sample))))]
+  [size (:: @ map (n.% +100) r;nat)
+   sample (r;queue size r;nat)
+   non-member (|> r;nat
+                  (r;filter (. not (&;member? number;Eq<Nat> sample))))]
   ($_ seq
       (test "I can query the size of a queue (and empty queues have size 0)."
             (if (n.= +0 size)
diff --git a/stdlib/test/test/lux/data/coll/seq.lux b/stdlib/test/test/lux/data/coll/seq.lux
index c6d25a0d8..801c5c2f1 100644
--- a/stdlib/test/test/lux/data/coll/seq.lux
+++ b/stdlib/test/test/lux/data/coll/seq.lux
@@ -11,20 +11,20 @@
              [bool]
              [product]
              maybe)
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (def: bounded-size
-  (R;Random Nat)
-  (|> R;nat
-      (:: R;Monad<Random> map (|>. (n.% +100) (n.+ +10) (n.max +1)))))
+  (r;Random Nat)
+  (|> r;nat
+      (:: r;Monad<Random> map (|>. (n.% +100) (n.+ +10) (n.max +1)))))
 
 (context: "Seqs: Part 1"
   [size bounded-size
-   idx (:: @ map (n.% size) R;nat)
-   sample (|> (R;list size R;nat)
+   idx (:: @ map (n.% size) r;nat)
+   sample (|> (r;list size r;nat)
               (:: @ map &;from-list))
-   extra R;nat
+   extra r;nat
    #let [(^open "&/") (&;Eq<Seq> number;Eq<Nat>)]]
   ($_ seq
       (test "Can convert to/from list."
@@ -75,7 +75,7 @@
 
 (context: "Seqs: Part 2"
   [size bounded-size
-   sample (|> (R;list size R;nat)
+   sample (|> (r;list size r;nat)
               (:: @ map &;from-list))
    #let [(^open "&/") (&;Eq<Seq> number;Eq<Nat>)
          (^open "&/") &;Functor<Seq>]]
@@ -97,13 +97,13 @@
 
 (context: "Seqs: Part 3"
   [size bounded-size
-   idx (:: @ map (n.% size) R;nat)
-   sample (|> (R;list size R;nat)
+   idx (:: @ map (n.% size) r;nat)
+   sample (|> (r;list size r;nat)
               (:: @ map &;from-list))
    other-size bounded-size
-   other-sample (|> (R;list other-size R;nat)
+   other-sample (|> (r;list other-size r;nat)
                     (:: @ map &;from-list))
-   elem R;nat
+   elem r;nat
    #let [(^open "&/") (&;Eq<Seq> number;Eq<Nat>)
          (^open "&/") &;Monad<Seq>]]
   ($_ seq
diff --git a/stdlib/test/test/lux/data/coll/set.lux b/stdlib/test/test/lux/data/coll/set.lux
index 0aafdd580..38ca47f81 100644
--- a/stdlib/test/test/lux/data/coll/set.lux
+++ b/stdlib/test/test/lux/data/coll/set.lux
@@ -5,21 +5,21 @@
        (data (coll ["&" set]
                    [list "" Fold<List>])
              [number])
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (def: gen-nat
-  (R;Random Nat)
-  (|> R;nat
-      (:: R;Monad<Random> map (n.% +100))))
+  (r;Random Nat)
+  (|> r;nat
+      (:: r;Monad<Random> map (n.% +100))))
 
 (context: "Sets"
   [sizeL gen-nat
    sizeR gen-nat
-   setL (R;set number;Hash<Nat> sizeL gen-nat)
-   setR (R;set number;Hash<Nat> sizeR gen-nat)
+   setL (r;set number;Hash<Nat> sizeL gen-nat)
+   setR (r;set number;Hash<Nat> sizeR gen-nat)
    non-member (|> gen-nat
-                  (R;filter (. not (&;member? setL))))
+                  (r;filter (. not (&;member? setL))))
    #let [(^open "&/") &;Eq<Set>]]
   ($_ seq
       (test "I can query the size of a set."
diff --git a/stdlib/test/test/lux/data/coll/stack.lux b/stdlib/test/test/lux/data/coll/stack.lux
index 981d73197..fc7e2f4b2 100644
--- a/stdlib/test/test/lux/data/coll/stack.lux
+++ b/stdlib/test/test/lux/data/coll/stack.lux
@@ -6,17 +6,17 @@
                    [list "" Fold<List>])
              [number]
              [maybe])
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (def: gen-nat
-  (R;Random Nat)
-  (|> R;nat
-      (:: R;Monad<Random> map (n.% +100))))
+  (r;Random Nat)
+  (|> r;nat
+      (:: r;Monad<Random> map (n.% +100))))
 
 (context: "Stacks"
   [size gen-nat
-   sample (R;stack size gen-nat)
+   sample (r;stack size gen-nat)
    new-top gen-nat]
   ($_ seq
       (test "Can query the size of a stack."
diff --git a/stdlib/test/test/lux/data/coll/stream.lux b/stdlib/test/test/lux/data/coll/stream.lux
index 053228278..a5a978f49 100644
--- a/stdlib/test/test/lux/data/coll/stream.lux
+++ b/stdlib/test/test/lux/data/coll/stream.lux
@@ -10,16 +10,16 @@
              (coll [list]
                    ["&" stream])
              [number "Nat/" Codec<Text,Nat>])
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (context: "Streams"
-  [size (|> R;nat (:: @ map (|>. (n.% +100) (n.max +2))))
-   offset (|> R;nat (:: @ map (n.% +100)))
-   factor (|> R;nat (:: @ map (|>. (n.% +100) (n.max +2))))
-   elem R;nat
-   cycle-seed (R;list size R;nat)
-   cycle-sample-idx (|> R;nat (:: @ map (n.% +1000)))
+  [size (|> r;nat (:: @ map (|>. (n.% +100) (n.max +2))))
+   offset (|> r;nat (:: @ map (n.% +100)))
+   factor (|> r;nat (:: @ map (|>. (n.% +100) (n.max +2))))
+   elem r;nat
+   cycle-seed (r;list size r;nat)
+   cycle-sample-idx (|> r;nat (:: @ map (n.% +1000)))
    #let [(^open "List/") (list;Eq<List> number;Eq<Nat>)
          sample0 (&;iterate n.inc +0)
          sample1 (&;iterate n.inc offset)]]
diff --git a/stdlib/test/test/lux/data/coll/vector.lux b/stdlib/test/test/lux/data/coll/vector.lux
index e605805a8..23fe64464 100644
--- a/stdlib/test/test/lux/data/coll/vector.lux
+++ b/stdlib/test/test/lux/data/coll/vector.lux
@@ -8,15 +8,15 @@
              text/format
              [number]
              [maybe])
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (context: "Vectors"
-  [size (|> R;nat (:: @ map (|>. (n.% +100) (n.max +1))))
-   idx (|> R;nat (:: @ map (n.% size)))
-   sample (R;vector size R;nat)
-   other-sample (R;vector size R;nat)
-   non-member (|> R;nat (R;filter (. not (&;member? number;Eq<Nat> sample))))
+  [size (|> r;nat (:: @ map (|>. (n.% +100) (n.max +1))))
+   idx (|> r;nat (:: @ map (n.% size)))
+   sample (r;vector size r;nat)
+   other-sample (r;vector size r;nat)
+   non-member (|> r;nat (r;filter (. not (&;member? number;Eq<Nat> sample))))
    #let [(^open "&/") (&;Eq<Vector> number;Eq<Nat>)
          (^open "&/") &;Monad<Vector>
          (^open "&/") &;Fold<Vector>
diff --git a/stdlib/test/test/lux/data/result.lux b/stdlib/test/test/lux/data/error.lux
index efd1009c8..a72a45403 100644
--- a/stdlib/test/test/lux/data/result.lux
+++ b/stdlib/test/test/lux/data/error.lux
@@ -4,18 +4,18 @@
        (control ["M" monad #+ do Monad]
                 pipe)
        (data text/format
-             ["&" result]))
+             ["&" error]))
   lux/test)
 
-(context: "Results"
-  (let [(^open "&/") &;Monad<Result>]
+(context: "Errors"
+  (let [(^open "&/") &;Monad<Error>]
     ($_ seq
         (test "Functor correctly handles both cases."
-              (and (|> (: (&;Result Int) (#&;Success 10))
+              (and (|> (: (&;Error Int) (#&;Success 10))
                        (&/map i.inc)
                        (case> (#&;Success 11) true _ false))
 
-                   (|> (: (&;Result Int) (#&;Error "YOLO"))
+                   (|> (: (&;Error Int) (#&;Error "YOLO"))
                        (&/map i.inc)
                        (case> (#&;Error "YOLO") true _ false))
                    ))
@@ -29,13 +29,13 @@
                        (case> (#&;Error "YOLO") true _ false))))
         
         (test "Monad correctly handles both cases."
-              (and (|> (do &;Monad<Result>
+              (and (|> (do &;Monad<Error>
                          [f (wrap i.+)
                           a (wrap 10)
                           b (wrap 20)]
                          (wrap (f a b)))
                        (case> (#&;Success 30) true _ false))
-                   (|> (do &;Monad<Result>
+                   (|> (do &;Monad<Error>
                          [f (wrap i.+)
                           a (#&;Error "YOLO")
                           b (wrap 20)]
@@ -47,8 +47,8 @@
 (context: "Monad transformer"
   (let [lift (&;lift io;Monad<IO>)
         (^open "io/") io;Monad<IO>]
-    (test "Can add result functionality to any monad."
-          (|> (io;run (do (&;ResultT io;Monad<IO>)
+    (test "Can add error functionality to any monad."
+          (|> (io;run (do (&;ErrorT io;Monad<IO>)
                         [a (lift (io/wrap 123))
                          b (wrap 456)]
                         (wrap (i.+ a b))))
diff --git a/stdlib/test/test/lux/data/format/json.lux b/stdlib/test/test/lux/data/format/json.lux
index 2eca6febd..89244d6fe 100644
--- a/stdlib/test/test/lux/data/format/json.lux
+++ b/stdlib/test/test/lux/data/format/json.lux
@@ -8,7 +8,7 @@
                 ["p" parser])
        (data [text "Text/" Monoid<Text>]
              text/format
-             ["R" result]
+             ["E" error]
              [bool]
              [maybe]
              [number "i/" Number<Int>]
@@ -166,8 +166,8 @@
          (^open "@/") Codec<JSON,Record>]]
   (test "Can encode/decode arbitrary types."
         (|> sample @/encode @/decode
-            (case> (#R;Success result)
+            (case> (#E;Success result)
                    (@/= sample result)
 
-                   (#R;Error error)
+                   (#E;Error error)
                    false))))
diff --git a/stdlib/test/test/lux/data/format/xml.lux b/stdlib/test/test/lux/data/format/xml.lux
index b43aee394..0a4179040 100644
--- a/stdlib/test/test/lux/data/format/xml.lux
+++ b/stdlib/test/test/lux/data/format/xml.lux
@@ -7,7 +7,7 @@
        (data [text "text/" Eq<Text>]
              text/format
              [ident]
-             ["R" result]
+             ["E" error]
              [maybe]
              (format ["&" xml])
              (coll [dict]
@@ -84,28 +84,28 @@
                        (L/map (|>. #&;Text) children))]]
   ($_ seq
       (test "Can parse text."
-            (R;default false
-              (do R;Monad<Result>
+            (E;default false
+              (do E;Monad<Error>
                 [output (&;run (#&;Text text)
                                &;text)]
                 (wrap (text/= text output)))))
       (test "Can parse attributes."
-            (R;default false
-              (do R;Monad<Result>
+            (E;default false
+              (do E;Monad<Error>
                 [output (|> (&;attr attr)
                             (p;before &;ignore)
                             (&;run node))]
                 (wrap (text/= value output)))))
       (test "Can parse nodes."
-            (R;default false
-              (do R;Monad<Result>
+            (E;default false
+              (do E;Monad<Error>
                 [_ (|> (&;node tag)
                        (p;before &;ignore)
                        (&;run node))]
                 (wrap true))))
       (test "Can parse children."
-            (R;default false
-              (do R;Monad<Result>
+            (E;default false
+              (do E;Monad<Error>
                 [outputs (|> (&;children (p;some &;text))
                              (&;run node))]
                 (wrap (:: (list;Eq<List> text;Eq<Text>) =
diff --git a/stdlib/test/test/lux/data/ident.lux b/stdlib/test/test/lux/data/ident.lux
index 6ca00d09f..cae265a45 100644
--- a/stdlib/test/test/lux/data/ident.lux
+++ b/stdlib/test/test/lux/data/ident.lux
@@ -6,23 +6,23 @@
        (data ["&" ident]
              [text "Text/" Eq<Text>]
              text/format)
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (def: (gen-part size)
-  (-> Nat (R;Random Text))
-  (|> (R;text size) (R;filter (. not (text;contains? ";")))))
+  (-> Nat (r;Random Text))
+  (|> (r;text size) (r;filter (. not (text;contains? ";")))))
 
 (context: "Idents"
   [## First Ident
-   sizeM1 (|> R;nat (:: @ map (n.% +100)))
-   sizeN1 (|> R;nat (:: @ map (|>. (n.% +100) (n.max +1))))
+   sizeM1 (|> r;nat (:: @ map (n.% +100)))
+   sizeN1 (|> r;nat (:: @ map (|>. (n.% +100) (n.max +1))))
    module1 (gen-part sizeM1)
    name1 (gen-part sizeN1)
    #let [ident1 [module1 name1]]
    ## Second Ident
-   sizeM2 (|> R;nat (:: @ map (n.% +100)))
-   sizeN2 (|> R;nat (:: @ map (|>. (n.% +100) (n.max +1))))
+   sizeM2 (|> r;nat (:: @ map (n.% +100)))
+   sizeN2 (|> r;nat (:: @ map (|>. (n.% +100) (n.max +1))))
    module2 (gen-part sizeM2)
    name2 (gen-part sizeN2)
    #let [ident2 [module2 name2]]
diff --git a/stdlib/test/test/lux/data/number.lux b/stdlib/test/test/lux/data/number.lux
index c33d06856..1a33fdc2c 100644
--- a/stdlib/test/test/lux/data/number.lux
+++ b/stdlib/test/test/lux/data/number.lux
@@ -6,7 +6,7 @@
        (data number
              [text "Text/" Monoid<Text> Eq<Text>]
              text/format)
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (do-template [category rand-gen <Eq> <Order>]
@@ -18,10 +18,10 @@
                        (:: <Order> < y x)
                        (:: <Order> > y x)))))]
 
-  ["Nat"  R;nat  Eq<Nat>  Order<Nat>]
-  ["Int"  R;int  Eq<Int>  Order<Int>]
-  ["Frac" R;frac Eq<Frac> Order<Frac>]
-  ["Deg"  R;deg  Eq<Deg>  Order<Deg>]
+  ["Nat"  r;nat  Eq<Nat>  Order<Nat>]
+  ["Int"  r;int  Eq<Int>  Order<Int>]
+  ["Frac" r;frac Eq<Frac> Order<Frac>]
+  ["Deg"  r;deg  Eq<Deg>  Order<Deg>]
   )
 
 (do-template [category rand-gen <Number> <Order>]
@@ -39,10 +39,10 @@
                        (= x (* (signum x)
                                (abs x)))))))]
 
-  ## ["Nat"  R;nat  Number<Nat>]
-  ["Int"  R;int  Number<Int>  Order<Int>]
-  ["Frac" R;frac Number<Frac> Order<Frac>]
-  ["Deg"  R;deg  Number<Deg>  Order<Deg>]
+  ## ["Nat"  r;nat  Number<Nat>]
+  ["Int"  r;int  Number<Int>  Order<Int>]
+  ["Frac" r;frac Number<Frac> Order<Frac>]
+  ["Deg"  r;deg  Number<Deg>  Order<Deg>]
   )
 
 (do-template [category rand-gen <Enum> <Number> <Order>]
@@ -61,28 +61,28 @@
                         (|> x (:: <Enum> succ) (:: <Enum> pred)))
                      ))))]
 
-  ["Nat"  R;nat Enum<Nat> Number<Nat> Order<Nat>]
-  ["Int"  R;int Enum<Int> Number<Int> Order<Int>]
+  ["Nat"  r;nat Enum<Nat> Number<Nat> Order<Nat>]
+  ["Int"  r;int Enum<Int> Number<Int> Order<Int>]
   )
 
 (do-template [category rand-gen <Number> <Order> <Interval> <test>]
   [(context: (format "[" category "] " "Interval")
-     [x (|> rand-gen (R;filter <test>))
+     [x (|> rand-gen (r;filter <test>))
       #let [(^open) <Number>
             (^open) <Order>]]
      (test "" (and (<= x (:: <Interval> bottom))
                    (>= x (:: <Interval> top)))))]
 
-  ["Nat"  R;nat  Number<Nat>  Order<Nat>  Interval<Nat>  (function [_] true)]
-  ["Int"  R;int  Number<Int>  Order<Int>  Interval<Int>  (function [_] true)]
+  ["Nat"  r;nat  Number<Nat>  Order<Nat>  Interval<Nat>  (function [_] true)]
+  ["Int"  r;int  Number<Int>  Order<Int>  Interval<Int>  (function [_] true)]
   ## Both min and max values will be positive (thus, greater than zero)
-  ["Frac" R;frac Number<Frac> Order<Frac> Interval<Frac> (f.> 0.0)]
-  ["Deg"  R;deg  Number<Deg>  Order<Deg>  Interval<Deg>  (function [_] true)]
+  ["Frac" r;frac Number<Frac> Order<Frac> Interval<Frac> (f.> 0.0)]
+  ["Deg"  r;deg  Number<Deg>  Order<Deg>  Interval<Deg>  (function [_] true)]
   )
 
 (do-template [category rand-gen <Number> <Order> <Monoid> <cap> <test>]
   [(context: (format "[" category "] " "Monoid")
-     [x (|> rand-gen (:: @ map (|>. (:: <Number> abs) <cap>)) (R;filter <test>))
+     [x (|> rand-gen (:: @ map (|>. (:: <Number> abs) <cap>)) (r;filter <test>))
       #let [(^open) <Number>
             (^open) <Order>
             (^open) <Monoid>]]
@@ -91,22 +91,22 @@
                 (= x (compose x identity))
                 (= identity (compose identity identity)))))]
 
-  ["Nat/Add"  R;nat  Number<Nat>  Order<Nat>  Add@Monoid<Nat>  (n.% +1000)  (function [_] true)]
-  ["Nat/Mul"  R;nat  Number<Nat>  Order<Nat>  Mul@Monoid<Nat>  (n.% +1000)  (function [_] true)]
-  ["Nat/Min"  R;nat  Number<Nat>  Order<Nat>  Min@Monoid<Nat>  (n.% +1000)  (function [_] true)]
-  ["Nat/Max"  R;nat  Number<Nat>  Order<Nat>  Max@Monoid<Nat>  (n.% +1000)  (function [_] true)]
-  ["Int/Add"  R;int  Number<Int>  Order<Int>  Add@Monoid<Int>  (i.% 1000)   (function [_] true)]
-  ["Int/Mul"  R;int  Number<Int>  Order<Int>  Mul@Monoid<Int>  (i.% 1000)   (function [_] true)]
-  ["Int/Min"  R;int  Number<Int>  Order<Int>  Min@Monoid<Int>  (i.% 1000)   (function [_] true)]
-  ["Int/Max"  R;int  Number<Int>  Order<Int>  Max@Monoid<Int>  (i.% 1000)   (function [_] true)]
-  ["Frac/Add" R;frac Number<Frac> Order<Frac> Add@Monoid<Frac> (f.% 1000.0) (f.> 0.0)]
-  ["Frac/Mul" R;frac Number<Frac> Order<Frac> Mul@Monoid<Frac> (f.% 1000.0) (f.> 0.0)]
-  ["Frac/Min" R;frac Number<Frac> Order<Frac> Min@Monoid<Frac> (f.% 1000.0) (f.> 0.0)]
-  ["Frac/Max" R;frac Number<Frac> Order<Frac> Max@Monoid<Frac> (f.% 1000.0) (f.> 0.0)]
-  ["Deg/Add"  R;deg  Number<Deg>  Order<Deg>  Add@Monoid<Deg>  (d.% .125)   (function [_] true)]
-  ## ["Deg/Mul"  R;deg  Number<Deg>  Order<Deg>  Mul@Monoid<Deg>  (d.% .125)   (function [_] true)]
-  ["Deg/Min" R;deg Number<Deg> Order<Deg> Min@Monoid<Deg> (d.% .125)   (function [_] true)]
-  ["Deg/Max" R;deg Number<Deg> Order<Deg> Max@Monoid<Deg> (d.% .125)   (function [_] true)]
+  ["Nat/Add"  r;nat  Number<Nat>  Order<Nat>  Add@Monoid<Nat>  (n.% +1000)  (function [_] true)]
+  ["Nat/Mul"  r;nat  Number<Nat>  Order<Nat>  Mul@Monoid<Nat>  (n.% +1000)  (function [_] true)]
+  ["Nat/Min"  r;nat  Number<Nat>  Order<Nat>  Min@Monoid<Nat>  (n.% +1000)  (function [_] true)]
+  ["Nat/Max"  r;nat  Number<Nat>  Order<Nat>  Max@Monoid<Nat>  (n.% +1000)  (function [_] true)]
+  ["Int/Add"  r;int  Number<Int>  Order<Int>  Add@Monoid<Int>  (i.% 1000)   (function [_] true)]
+  ["Int/Mul"  r;int  Number<Int>  Order<Int>  Mul@Monoid<Int>  (i.% 1000)   (function [_] true)]
+  ["Int/Min"  r;int  Number<Int>  Order<Int>  Min@Monoid<Int>  (i.% 1000)   (function [_] true)]
+  ["Int/Max"  r;int  Number<Int>  Order<Int>  Max@Monoid<Int>  (i.% 1000)   (function [_] true)]
+  ["Frac/Add" r;frac Number<Frac> Order<Frac> Add@Monoid<Frac> (f.% 1000.0) (f.> 0.0)]
+  ["Frac/Mul" r;frac Number<Frac> Order<Frac> Mul@Monoid<Frac> (f.% 1000.0) (f.> 0.0)]
+  ["Frac/Min" r;frac Number<Frac> Order<Frac> Min@Monoid<Frac> (f.% 1000.0) (f.> 0.0)]
+  ["Frac/Max" r;frac Number<Frac> Order<Frac> Max@Monoid<Frac> (f.% 1000.0) (f.> 0.0)]
+  ["Deg/Add"  r;deg  Number<Deg>  Order<Deg>  Add@Monoid<Deg>  (d.% .125)   (function [_] true)]
+  ## ["Deg/Mul"  r;deg  Number<Deg>  Order<Deg>  Mul@Monoid<Deg>  (d.% .125)   (function [_] true)]
+  ["Deg/Min" r;deg Number<Deg> Order<Deg> Min@Monoid<Deg> (d.% .125)   (function [_] true)]
+  ["Deg/Max" r;deg Number<Deg> Order<Deg> Max@Monoid<Deg> (d.% .125)   (function [_] true)]
   )
 
 (do-template [<category> <rand-gen> <Eq> <Codec>]
@@ -122,30 +122,30 @@
                       (#;Left _)
                       false))))]
 
-  ["Nat/Binary"   R;nat  Eq<Nat>  Binary@Codec<Text,Nat>]
-  ["Nat/Octal"    R;nat  Eq<Nat>  Octal@Codec<Text,Nat>]
-  ["Nat/Decimal"  R;nat  Eq<Nat>  Codec<Text,Nat>]
-  ["Nat/Hex"      R;nat  Eq<Nat>  Hex@Codec<Text,Nat>]
-
-  ["Int/Binary"   R;int  Eq<Int>  Binary@Codec<Text,Int>]
-  ["Int/Octal"    R;int  Eq<Int>  Octal@Codec<Text,Int>]
-  ["Int/Decimal"  R;int  Eq<Int>  Codec<Text,Int>]
-  ["Int/Hex"      R;int  Eq<Int>  Hex@Codec<Text,Int>]
-
-  ["Deg/Binary"   R;deg  Eq<Deg>  Binary@Codec<Text,Deg>]
-  ["Deg/Octal"    R;deg  Eq<Deg>  Octal@Codec<Text,Deg>]
-  ["Deg/Decimal"  R;deg  Eq<Deg>  Codec<Text,Deg>]
-  ["Deg/Hex"      R;deg  Eq<Deg>  Hex@Codec<Text,Deg>]
-
-  ["Frac/Binary"  R;frac Eq<Frac> Binary@Codec<Text,Frac>]
-  ["Frac/Octal"   R;frac Eq<Frac> Octal@Codec<Text,Frac>]
-  ["Frac/Decimal" R;frac Eq<Frac> Codec<Text,Frac>]
-  ["Frac/Hex"     R;frac Eq<Frac> Hex@Codec<Text,Frac>]
+  ["Nat/Binary"   r;nat  Eq<Nat>  Binary@Codec<Text,Nat>]
+  ["Nat/Octal"    r;nat  Eq<Nat>  Octal@Codec<Text,Nat>]
+  ["Nat/Decimal"  r;nat  Eq<Nat>  Codec<Text,Nat>]
+  ["Nat/Hex"      r;nat  Eq<Nat>  Hex@Codec<Text,Nat>]
+
+  ["Int/Binary"   r;int  Eq<Int>  Binary@Codec<Text,Int>]
+  ["Int/Octal"    r;int  Eq<Int>  Octal@Codec<Text,Int>]
+  ["Int/Decimal"  r;int  Eq<Int>  Codec<Text,Int>]
+  ["Int/Hex"      r;int  Eq<Int>  Hex@Codec<Text,Int>]
+
+  ["Deg/Binary"   r;deg  Eq<Deg>  Binary@Codec<Text,Deg>]
+  ["Deg/Octal"    r;deg  Eq<Deg>  Octal@Codec<Text,Deg>]
+  ["Deg/Decimal"  r;deg  Eq<Deg>  Codec<Text,Deg>]
+  ["Deg/Hex"      r;deg  Eq<Deg>  Hex@Codec<Text,Deg>]
+
+  ["Frac/Binary"  r;frac Eq<Frac> Binary@Codec<Text,Frac>]
+  ["Frac/Octal"   r;frac Eq<Frac> Octal@Codec<Text,Frac>]
+  ["Frac/Decimal" r;frac Eq<Frac> Codec<Text,Frac>]
+  ["Frac/Hex"     r;frac Eq<Frac> Hex@Codec<Text,Frac>]
   )
 
 (context: "Can convert frac values to/from their bit patterns."
-  [raw R;frac
-   factor (|> R;nat (:: @ map (|>. (n.% +1000) (n.max +1))))
+  [raw r;frac
+   factor (|> r;nat (:: @ map (|>. (n.% +1000) (n.max +1))))
    #let [sample (|> factor nat-to-int int-to-frac (f.* raw))]]
   (test "Can convert frac values to/from their bit patterns."
         (|> sample frac-to-bits bits-to-frac (f.= sample))))
diff --git a/stdlib/test/test/lux/data/number/complex.lux b/stdlib/test/test/lux/data/number/complex.lux
index 78155e061..5fb5f6cfe 100644
--- a/stdlib/test/test/lux/data/number/complex.lux
+++ b/stdlib/test/test/lux/data/number/complex.lux
@@ -11,7 +11,7 @@
              (coll [list "List/" Fold<List> Functor<List>])
              [product])
        [math]
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 ## Based on org.apache.commons.math4.complex.Complex
@@ -29,16 +29,16 @@
          (f.< margin imgn-dist))))
 
 (def: gen-dim
-  (R;Random Frac)
-  (do R;Monad<Random>
-    [factor (|> R;nat (:: @ map (|>. (n.% +1000) (n.max +1))))
-     measure (|> R;frac (R;filter (f.> 0.0)))]
+  (r;Random Frac)
+  (do r;Monad<Random>
+    [factor (|> r;nat (:: @ map (|>. (n.% +1000) (n.max +1))))
+     measure (|> r;frac (r;filter (f.> 0.0)))]
     (wrap (f.* (|> factor nat-to-int int-to-frac)
                measure))))
 
 (def: gen-complex
-  (R;Random &;Complex)
-  (do R;Monad<Random>
+  (r;Random &;Complex)
+  (do r;Monad<Random>
     [real gen-dim
      imaginary gen-dim]
     (wrap (&;complex real imaginary))))
@@ -180,7 +180,7 @@
 
 (context: "Complex roots"
   [sample gen-complex
-   degree (|> R;nat (:: @ map (|>. (n.max +1) (n.% +5))))]
+   degree (|> r;nat (:: @ map (|>. (n.max +1) (n.% +5))))]
   (test "Can calculate the N roots for any complex number."
         (|> sample
             (&;nth-roots degree)
diff --git a/stdlib/test/test/lux/data/number/ratio.lux b/stdlib/test/test/lux/data/number/ratio.lux
index a2eb4f53d..20090fc8c 100644
--- a/stdlib/test/test/lux/data/number/ratio.lux
+++ b/stdlib/test/test/lux/data/number/ratio.lux
@@ -9,20 +9,20 @@
              ["&" number/ratio "&/" Number<Ratio>]
              (coll [list "List/" Fold<List> Functor<List>])
              [product])
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (def: gen-part
-  (R;Random Nat)
-  (|> R;nat (:: R;Monad<Random> map (|>. (n.% +1000) (n.max +1)))))
+  (r;Random Nat)
+  (|> r;nat (:: r;Monad<Random> map (|>. (n.% +1000) (n.max +1)))))
 
 (def: gen-ratio
-  (R;Random &;Ratio)
-  (do R;Monad<Random>
+  (r;Random &;Ratio)
+  (do r;Monad<Random>
     [numerator gen-part
      denominator (|> gen-part
-                     (R;filter (|>. (n.= +0) not))
-                     (R;filter (. not (n.= numerator))))]
+                     (r;filter (|>. (n.= +0) not))
+                     (r;filter (. not (n.= numerator))))]
     (wrap (&;ratio numerator denominator))))
 
 (context: "Normalization"
diff --git a/stdlib/test/test/lux/data/text/lexer.lux b/stdlib/test/test/lux/data/text/lexer.lux
index 37f915e6c..39c171442 100644
--- a/stdlib/test/test/lux/data/text/lexer.lux
+++ b/stdlib/test/test/lux/data/text/lexer.lux
@@ -4,8 +4,8 @@
                 pipe
                 ["p" parser])
        [io]
-       (data ["R" result]
-             [text "T/" Eq<Text>]
+       (data ["E" error]
+             [text "text/" Eq<Text>]
              text/format
              ["&" text/lexer]
              (coll [list]))
@@ -14,40 +14,40 @@
 
 ## [Utils]
 (def: (should-fail input)
-  (All [a] (-> (R;Result a) Bool))
+  (All [a] (-> (E;Error a) Bool))
   (case input
     (#;Left _) true
     _          false))
 
 (def: (should-passT test input)
-  (-> Text (R;Result Text) Bool)
+  (-> Text (E;Error Text) Bool)
   (case input
     (#;Right output)
-    (T/= test output)
+    (text/= test output)
     
     _
     false))
 
 (def: (should-passL test input)
-  (-> (List Text) (R;Result (List Text)) Bool)
-  (let [(^open "L/") (list;Eq<List> text;Eq<Text>)]
+  (-> (List Text) (E;Error (List Text)) Bool)
+  (let [(^open "list/") (list;Eq<List> text;Eq<Text>)]
     (case input
       (#;Right output)
-      (L/= test output)
+      (list/= test output)
       
       _
       false)))
 
 (def: (should-passE test input)
-  (-> (Either Text Text) (R;Result (Either Text Text)) Bool)
+  (-> (Either Text Text) (E;Error (Either Text Text)) Bool)
   (case input
     (#;Right output)
     (case [test output]
       [(#;Left test) (#;Left output)]
-      (T/= test output)
+      (text/= test output)
 
       [(#;Right test) (#;Right output)]
-      (T/= test output)
+      (text/= test output)
 
       _
       false)
@@ -73,7 +73,7 @@
   [size (|> r;nat (:: @ map (|>. (n.% +100) (n.max +10))))
    sample (r;text size)
    non-sample (|> (r;text size)
-                  (r;filter (|>. (T/= sample) not)))]
+                  (r;filter (|>. (text/= sample) not)))]
   ($_ seq
       (test "Can find literal text fragments."
             (and (|> (&;run sample
diff --git a/stdlib/test/test/lux/host.js.lux b/stdlib/test/test/lux/host.js.lux
index 93e90bbfe..c7d65343a 100644
--- a/stdlib/test/test/lux/host.js.lux
+++ b/stdlib/test/test/lux/host.js.lux
@@ -4,7 +4,7 @@
        (control ["M" monad #+ do Monad])
        (data text/format)
        ["&" host]
-       ["R" math/random])
+       ["r" math/random])
   lux/test)
 
 (context: "JavaScript operations"
diff --git a/stdlib/test/test/lux/macro/code.lux b/stdlib/test/test/lux/macro/code.lux
index ff21fd0c9..64bdf5f1c 100644
--- a/stdlib/test/test/lux/macro/code.lux
+++ b/stdlib/test/test/lux/macro/code.lux
@@ -5,7 +5,7 @@
        (data [text "T/" Eq<Text>]
              text/format
              [number])
-       ["R" math/random]
+       ["r" math/random]
        (macro ["&" code]))
   lux/test)
 
diff --git a/stdlib/test/test/lux/macro/syntax.lux b/stdlib/test/test/lux/macro/syntax.lux
index e988a0103..b159bf999 100644
--- a/stdlib/test/test/lux/macro/syntax.lux
+++ b/stdlib/test/test/lux/macro/syntax.lux
@@ -9,8 +9,8 @@
              [number]
              [bool]
              [ident]
-             ["E" result])
-       ["R" math/random]
+             ["E" error])
+       ["r" math/random]
        [macro]
        (macro [code]
               ["s" syntax #+ syntax: Syntax]))
@@ -45,7 +45,7 @@
     false))
 
 (def: (fails? input)
-  (All [a] (-> (E;Result a) Bool))
+  (All [a] (-> (E;Error a) Bool))
   (case input
     (#;Left _)
     true
diff --git a/stdlib/test/test/lux/math/logic/continuous.lux b/stdlib/test/test/lux/math/logic/continuous.lux
index 4b2af88f3..1c6ed01a4 100644
--- a/stdlib/test/test/lux/math/logic/continuous.lux
+++ b/stdlib/test/test/lux/math/logic/continuous.lux
@@ -2,13 +2,13 @@
   lux
   (lux [io]
        (control [monad #+ do Monad])
-       ["R" math/random]
+       ["r" math/random]
        ["&" math/logic/continuous])
   lux/test)
 
 (context: "Operations"
-  [left R;deg
-   right R;deg]
+  [left r;deg
+   right r;deg]
   ($_ seq
       (test "AND is the minimum."
             (let [result (&;~and left right)]
diff --git a/stdlib/test/test/lux/math/logic/fuzzy.lux b/stdlib/test/test/lux/math/logic/fuzzy.lux
index 5f10696c1..41a8f090a 100644
--- a/stdlib/test/test/lux/math/logic/fuzzy.lux
+++ b/stdlib/test/test/lux/math/logic/fuzzy.lux
@@ -7,14 +7,14 @@
              [bool "B/" Eq<Bool>]
              [number]
              text/format)
-       ["R" math/random]
+       ["r" math/random]
        (math/logic ["&" fuzzy]
                    continuous))
   lux/test)
 
 (do-template [<desc> <hash> <gen> <triangle> <lt> <lte> <gt> <gte>]
   [(context: (format "[" <desc> "] " "Triangles")
-     [values (R;set <hash> +3 <gen>)
+     [values (r;set <hash> +3 <gen>)
       #let [[x y z] (case (set;to-list values)
                       (^ (list x y z))
                       [x y z]
@@ -48,13 +48,13 @@
                         (<gte> top sample))))
          ))]
 
-  ["Frac" number;Hash<Frac> R;frac &;f.triangle f.< f.<= f.> f.>=]
-  ["Deg"  number;Hash<Deg>  R;deg  &;d.triangle d.< d.<= d.> d.>=]
+  ["Frac" number;Hash<Frac> r;frac &;f.triangle f.< f.<= f.> f.>=]
+  ["Deg"  number;Hash<Deg>  r;deg  &;d.triangle d.< d.<= d.> d.>=]
   )
 
 (do-template [<desc> <hash> <gen> <trapezoid> <lt> <lte> <gt> <gte>]
   [(context: (format "[" <desc> "] " "Trapezoids")
-     [values (R;set <hash> +4 <gen>)
+     [values (r;set <hash> +4 <gen>)
       #let [[w x y z] (case (set;to-list values)
                         (^ (list w x y z))
                         [w x y z]
@@ -94,29 +94,29 @@
                         (<gte> top sample))))
          ))]
 
-  ["Frac" number;Hash<Frac> R;frac &;f.trapezoid f.< f.<= f.> f.>=]
-  ["Deg"  number;Hash<Deg>  R;deg  &;d.trapezoid d.< d.<= d.> d.>=]
+  ["Frac" number;Hash<Frac> r;frac &;f.trapezoid f.< f.<= f.> f.>=]
+  ["Deg"  number;Hash<Deg>  r;deg  &;d.trapezoid d.< d.<= d.> d.>=]
   )
 
 (context: "Gaussian"
-  [deviation (|> R;frac (R;filter (f.> 0.0)))
-   center R;frac
+  [deviation (|> r;frac (r;filter (f.> 0.0)))
+   center r;frac
    #let [gaussian (&;gaussian deviation center)]]
   (test "The center value will always have maximum membership."
         (d.= ~true (&;membership center gaussian))))
 
 (def: gen-triangle
-  (R;Random (&;Fuzzy Frac))
-  (do R;Monad<Random>
-    [x R;frac
-     y R;frac
-     z R;frac]
+  (r;Random (&;Fuzzy Frac))
+  (do r;Monad<Random>
+    [x r;frac
+     y r;frac
+     z r;frac]
     (wrap (&;f.triangle x y z))))
 
 (context: "Combinators"
   [left gen-triangle
    right gen-triangle
-   sample R;frac]
+   sample r;frac]
   ($_ seq
       (test "Union membership as as high as membership in any of its members."
             (let [combined (&;union left right)
@@ -147,7 +147,7 @@
 
 (context: "From predicates and sets"
   [#let [set-10 (set;from-list number;Hash<Nat> (list;n.range +0 +10))]
-   sample (|> R;nat (:: @ map (n.% +20)))]
+   sample (|> r;nat (:: @ map (n.% +20)))]
   ($_ seq
       (test "Values that satisfy a predicate have membership = 1.
                Values that don't have membership = 0."
@@ -162,8 +162,8 @@
 
 (context: "Thresholds"
   [fuzzy gen-triangle
-   sample R;frac
-   threshold R;deg
+   sample r;frac
+   threshold r;deg
    #let [vip-fuzzy (&;cut threshold fuzzy)
          member? (&;to-predicate threshold fuzzy)]]
   ($_ seq
diff --git a/stdlib/test/test/lux/time/date.lux b/stdlib/test/test/lux/time/date.lux
index a73001026..baac8d22c 100644
--- a/stdlib/test/test/lux/time/date.lux
+++ b/stdlib/test/test/lux/time/date.lux
@@ -3,7 +3,7 @@
   (lux [io]
        (control [monad #+ do Monad]
                 [pipe])
-       (data ["R" result])
+       (data ["E" error])
        (math ["r" random "r/" Monad<Random>])
        (time ["@;" instant]
              ["@" date]))
@@ -118,8 +118,8 @@
         (|> sample
             @/encode
             @/decode
-            (pipe;case> (#R;Success decoded)
+            (pipe;case> (#E;Success decoded)
                         (@/= sample decoded)
 
-                        (#R;Error error)
+                        (#E;Error error)
                         false))))
diff --git a/stdlib/test/test/lux/time/duration.lux b/stdlib/test/test/lux/time/duration.lux
index 4a674420e..be0637ab7 100644
--- a/stdlib/test/test/lux/time/duration.lux
+++ b/stdlib/test/test/lux/time/duration.lux
@@ -2,7 +2,7 @@
   lux
   (lux [io]
        (control [monad #+ do Monad])
-       (data ["R" result])
+       (data ["E" error])
        (math ["r" random])
        (time ["@" duration]))
   lux/test)
@@ -66,7 +66,7 @@
    #let [(^open "@/") @;Eq<Duration>
          (^open "@/") @;Codec<Text,Duration>]]
   (test "Can encode/decode durations."
-        (R;default false
-          (do R;Monad<Result>
+        (E;default false
+          (do E;Monad<Error>
             [decoded (|> sample @/encode @/decode)]
             (wrap (@/= sample decoded))))))
diff --git a/stdlib/test/test/lux/time/instant.lux b/stdlib/test/test/lux/time/instant.lux
index c686de5b7..df59f0743 100644
--- a/stdlib/test/test/lux/time/instant.lux
+++ b/stdlib/test/test/lux/time/instant.lux
@@ -5,7 +5,7 @@
                 pipe)
        (data [text]
              text/format
-             ["R" result]
+             ["E" error]
              [number "Int/" Number<Int>])
        (math ["r" random])
        (time ["@" instant]
@@ -75,8 +75,8 @@
         (|> sample
             @/encode
             @/decode
-            (case> (#R;Success decoded)
+            (case> (#E;Success decoded)
                    (@/= sample decoded)
 
-                   (#R;Error error)
+                   (#E;Error error)
                    false))))
diff --git a/stdlib/test/test/lux/type.lux b/stdlib/test/test/lux/type.lux
index 8c149e3f4..617921e33 100644
--- a/stdlib/test/test/lux/type.lux
+++ b/stdlib/test/test/lux/type.lux
@@ -8,39 +8,39 @@
              [number]
              [maybe]
              (coll [list]))
-       ["R" math/random]
+       ["r" math/random]
        ["&" type])
   lux/test)
 
 ## [Utils]
 (def: gen-name
-  (R;Random Text)
-  (do R;Monad<Random>
-    [size (|> R;nat (:: @ map (n.% +10)))]
-    (R;text size)))
+  (r;Random Text)
+  (do r;Monad<Random>
+    [size (|> r;nat (:: @ map (n.% +10)))]
+    (r;text size)))
 
 (def: gen-ident
-  (R;Random Ident)
-  (R;seq gen-name gen-name))
+  (r;Random Ident)
+  (r;seq gen-name gen-name))
 
 (def: gen-type
-  (R;Random Type)
-  (let [(^open "R/") R;Monad<Random>]
-    (R;rec (function [gen-type]
-             ($_ R;alt
-                 (R;seq gen-name (R/wrap (list)))
+  (r;Random Type)
+  (let [(^open "R/") r;Monad<Random>]
+    (r;rec (function [gen-type]
+             ($_ r;alt
+                 (r;seq gen-name (R/wrap (list)))
                  (R/wrap [])
                  (R/wrap [])
-                 (R;seq gen-type gen-type)
-                 (R;seq gen-type gen-type)
-                 (R;seq gen-type gen-type)
-                 R;nat
-                 R;nat
-                 R;nat
-                 (R;seq (R/wrap (list)) gen-type)
-                 (R;seq (R/wrap (list)) gen-type)
-                 (R;seq gen-type gen-type)
-                 (R;seq gen-ident gen-type)
+                 (r;seq gen-type gen-type)
+                 (r;seq gen-type gen-type)
+                 (r;seq gen-type gen-type)
+                 r;nat
+                 r;nat
+                 r;nat
+                 (r;seq (R/wrap (list)) gen-type)
+                 (r;seq (R/wrap (list)) gen-type)
+                 (r;seq gen-type gen-type)
+                 (r;seq gen-ident gen-type)
                  )))))
 
 ## [Tests]
@@ -79,9 +79,9 @@
                        (&;un-name aliased)))))))
 
 (context: "Type construction [structs]"
-  [size (|> R;nat (:: @ map (n.% +3)))
+  [size (|> r;nat (:: @ map (n.% +3)))
    members (|> gen-type
-               (R;filter (function [type]
+               (r;filter (function [type]
                            (case type
                              (^or (#;Sum _) (#;Product _))
                              false
@@ -108,10 +108,10 @@
         )))
 
 (context: "Type construction [parameterized]"
-  [size (|> R;nat (:: @ map (n.% +3)))
+  [size (|> r;nat (:: @ map (n.% +3)))
    members (M;seq @ (list;repeat size gen-type))
    extra (|> gen-type
-             (R;filter (function [type]
+             (r;filter (function [type]
                          (case type
                            (^or (#;Function _) (#;Apply _))
                            false
@@ -132,9 +132,9 @@
       ))
 
 (context: "Type construction [higher order]"
-  [size (|> R;nat (:: @ map (n.% +3)))
+  [size (|> r;nat (:: @ map (n.% +3)))
    extra (|> gen-type
-             (R;filter (function [type]
+             (r;filter (function [type]
                          (case type
                            (^or (#;UnivQ _) (#;ExQ _))
                            false
diff --git a/stdlib/test/test/lux/type/auto.lux b/stdlib/test/test/lux/type/auto.lux
index f12d97c75..55e374c50 100644
--- a/stdlib/test/test/lux/type/auto.lux
+++ b/stdlib/test/test/lux/type/auto.lux
@@ -10,14 +10,14 @@
              [bool "B/" Eq<Bool>]
              maybe
              (coll [list]))
-       ["R" math/random]
+       ["r" math/random]
        [type]
        type/auto)
   lux/test)
 
 (context: "Automatic structure selection"
-  [x R;nat
-   y R;nat]
+  [x r;nat
+   y r;nat]
   ($_ seq
       (test "Can automatically select first-order structures."
             (let [(^open "L/") (list;Eq<List> number;Eq<Nat>)]
diff --git a/stdlib/test/test/lux/world/blob.lux b/stdlib/test/test/lux/world/blob.lux
index 23dcd889c..5a616f3e4 100644
--- a/stdlib/test/test/lux/world/blob.lux
+++ b/stdlib/test/test/lux/world/blob.lux
@@ -4,19 +4,19 @@
        (control [monad #+ do]
                 [pipe])
        (data [bit]
-             ["R" result]
+             ["E" error]
              (coll [list]))
        (world ["@" blob])
        ["r" math/random])
   lux/test)
 
 (def: (succeed result)
-  (-> (R;Result Bool) Bool)
+  (-> (E;Error Bool) Bool)
   (case result
-    (#R;Error _)
+    (#E;Error _)
     false
 
-    (#R;Success output)
+    (#E;Success output)
     output))
 
 (def: #export (blob size)
@@ -28,7 +28,7 @@
         (if (n.< size idx)
           (do @
             [byte r;nat]
-            (exec (R;assume (@;write-8 idx byte blob))
+            (exec (E;assume (@;write-8 idx byte blob))
               (recur (n.inc idx))))
           (wrap blob))))))
 
@@ -52,39 +52,39 @@
          value-32 (n.% (bit;shift-left +32 +1) value)
          value-64 value
          slice-size (|> to (n.- from) n.inc)
-         random-slice (R;assume (@;slice from to random-blob))]]
+         random-slice (E;assume (@;slice from to random-blob))]]
   ($_ seq
       (test "Has equality."
             (and (:: @;Eq<Blob> = clean-blob clean-blob)
                  (:: @;Eq<Blob> =
-                     (R;assume (@;slice from to clean-blob))
-                     (R;assume (@;slice from to clean-blob)))))
+                     (E;assume (@;slice from to clean-blob))
+                     (E;assume (@;slice from to clean-blob)))))
       (test "Can get size of blob."
             (n.= blob-size size))
       (test "Can read/write 8-bit values."
             (succeed
-             (do R;Monad<Result>
+             (do E;Monad<Error>
                [_ (@;write-8 idx value-8 clean-blob)
                 output-8 (@;read-8 idx clean-blob)]
                (wrap (n.= value-8 output-8)))))
       (test "Can read/write 16-bit values."
             (or (n.>= size (n.+ +1 idx))
                 (succeed
-                 (do R;Monad<Result>
+                 (do E;Monad<Error>
                    [_ (@;write-16 idx value-16 clean-blob)
                     output-16 (@;read-16 idx clean-blob)]
                    (wrap (n.= value-16 output-16))))))
       (test "Can read/write 32-bit values."
             (or (n.>= size (n.+ +3 idx))
                 (succeed
-                 (do R;Monad<Result>
+                 (do E;Monad<Error>
                    [_ (@;write-32 idx value-32 clean-blob)
                     output-32 (@;read-32 idx clean-blob)]
                    (wrap (n.= value-32 output-32))))))
       (test "Can read/write 64-bit values."
             (or (n.>= size (n.+ +7 idx))
                 (succeed
-                 (do R;Monad<Result>
+                 (do E;Monad<Error>
                    [_ (@;write-64 idx value-64 clean-blob)
                     output-64 (@;read-64 idx clean-blob)]
                    (wrap (n.= value-64 output-64))))))
@@ -94,7 +94,7 @@
                    (let [loop-recur recur]
                      (if (n.< slice-size idx)
                        (and (succeed
-                             (do R;Monad<Result>
+                             (do E;Monad<Error>
                                [reference (@;read-8 (n.+ from idx) random-blob)
                                 sample (@;read-8 idx random-slice)]
                                (wrap (n.= reference sample))))
@@ -103,5 +103,5 @@
       (test "Slicing the whole blob does not change anything."
             (:: @;Eq<Blob> =
                 random-blob
-                (R;assume (@;slice +0 (n.dec blob-size) random-blob))))
+                (E;assume (@;slice +0 (n.dec blob-size) random-blob))))
       ))
diff --git a/stdlib/test/test/lux/world/file.lux b/stdlib/test/test/lux/world/file.lux
index 3e653d0b1..32fa33d7d 100644
--- a/stdlib/test/test/lux/world/file.lux
+++ b/stdlib/test/test/lux/world/file.lux
@@ -4,7 +4,7 @@
        (control [monad #+ do])
        (concurrency ["P" promise]
                     ["T" task])
-       (data ["R" result]
+       (data ["E" error]
              [text]
              text/format
              [number])
@@ -41,7 +41,7 @@
                   (wrap (and (not pre) post
                              deleted? (not remains?))))]
         (test "Can create/delete files."
-              (R;default false result)))
+              (E;default false result)))
       (do P;Monad<Promise>
         [#let [file (format "temp_file_" (%n (n.+ +1 code)))]
          result (do T;Monad<Task>
@@ -50,7 +50,7 @@
                    _ (@;delete file)]
                   (wrap (:: blob;Eq<Blob> = dataL output)))]
         (test "Can write/read files."
-              (R;default false result)))
+              (E;default false result)))
       (do P;Monad<Promise>
         [#let [file (format "temp_file_" (%n (n.+ +2 code)))]
          result (do T;Monad<Task>
@@ -59,7 +59,7 @@
                    _ (@;delete file)]
                   (wrap (n.= file-size read-size)))]
         (test "Can read file size."
-              (R;default false result)))
+              (E;default false result)))
       (do P;Monad<Promise>
         [#let [file (format "temp_file_" (%n (n.+ +3 code)))]
          result (do T;Monad<Task>
@@ -69,10 +69,10 @@
                    read-size (@;size file)
                    _ (@;delete file)]
                   (wrap (and (n.= (n.* +2 file-size) read-size)
-                             (:: blob;Eq<Blob> = dataL (R;assume (blob;slice +0 (n.dec file-size) output)))
-                             (:: blob;Eq<Blob> = dataR (R;assume (blob;slice file-size (n.dec read-size) output))))))]
+                             (:: blob;Eq<Blob> = dataL (E;assume (blob;slice +0 (n.dec file-size) output)))
+                             (:: blob;Eq<Blob> = dataR (E;assume (blob;slice file-size (n.dec read-size) output))))))]
         (test "Can append to files."
-              (R;default false result)))
+              (E;default false result)))
       (do P;Monad<Promise>
         [#let [dir (format "temp_dir_" (%n (n.+ +4 code)))]
          result (do T;Monad<Task>
@@ -84,7 +84,7 @@
                   (wrap (and (not pre) post
                              deleted? (not remains?))))]
         (test "Can create/delete directories."
-              (R;default false result)))
+              (E;default false result)))
       (do P;Monad<Promise>
         [#let [file (format "temp_file_" (%n (n.+ +5 code)))
                dir (format "temp_dir_" (%n (n.+ +5 code)))]
@@ -100,7 +100,7 @@
                   (wrap (and file-is-file (not file-is-directory)
                              (not directory-is-file) directory-is-directory)))]
         (test "Can differentiate files from directories."
-              (R;default false result)))
+              (E;default false result)))
       (do P;Monad<Promise>
         [#let [file (format "temp_file_" (%n (n.+ +6 code)))
                dir (format "temp_dir_" (%n (n.+ +6 code)))]
@@ -115,7 +115,7 @@
                              deleted-file
                              deleted-dir)))]
         (test "Can create files inside of directories."
-              (R;default false result)))
+              (E;default false result)))
       (do P;Monad<Promise>
         [#let [file (format "temp_file_" (%n (n.+ +7 code)))
                dir (format "temp_dir_" (%n (n.+ +7 code)))]
@@ -133,7 +133,7 @@
                           _
                           false)))]
         (test "Can list files inside a directory."
-              (R;default false result)))
+              (E;default false result)))
       (do P;Monad<Promise>
         [#let [file (format "temp_file_" (%n (n.+ +8 code)))]
          result (do T;Monad<Task>
@@ -144,7 +144,7 @@
                   (wrap (and was-modified?
                              (:: i;Eq<Instant> = last-modified time-read))))]
         (test "Can change the time of last modification."
-              (R;default false result)))
+              (E;default false result)))
       (do P;Monad<Promise>
         [#let [file0 (format "temp_file_" (%n (n.+ +9 code)) "0")
                file1 (format "temp_file_" (%n (n.+ +9 code)) "1")]
@@ -158,5 +158,5 @@
                   (wrap (and pre moved? (not post)
                              confirmed? deleted?)))]
         (test "Can move a file from one path to another."
-              (R;default false result)))
+              (E;default false result)))
       ))
diff --git a/stdlib/test/test/lux/world/net/tcp.lux b/stdlib/test/test/lux/world/net/tcp.lux
index 4c975b4dd..cf390ef09 100644
--- a/stdlib/test/test/lux/world/net/tcp.lux
+++ b/stdlib/test/test/lux/world/net/tcp.lux
@@ -6,7 +6,7 @@
        (concurrency ["P" promise]
                     ["T" task]
                     [frp])
-       (data ["R" result]
+       (data ["E" error]
              [text]
              text/format)
        (world [blob]
@@ -66,5 +66,5 @@
                   (wrap (and from-worked?
                              to-worked?)))]
         (test "Can communicate between client and server."
-              (R;default false result)))
+              (E;default false result)))
       ))
diff --git a/stdlib/test/test/lux/world/net/udp.lux b/stdlib/test/test/lux/world/net/udp.lux
index 8af67bcd5..6bd43351e 100644
--- a/stdlib/test/test/lux/world/net/udp.lux
+++ b/stdlib/test/test/lux/world/net/udp.lux
@@ -6,7 +6,7 @@
        (concurrency ["P" promise]
                     ["T" task]
                     [frp])
-       (data ["R" result]
+       (data ["E" error]
              [text]
              text/format)
        (world [blob]
@@ -66,5 +66,5 @@
                   (wrap (and from-worked?
                              to-worked?)))]
         (test "Can communicate between client and server."
-              (R;default false result)))
+              (E;default false result)))
       ))
diff --git a/stdlib/test/tests.lux b/stdlib/test/tests.lux
index e5cf4df6f..085275e62 100644
--- a/stdlib/test/tests.lux
+++ b/stdlib/test/tests.lux
@@ -28,7 +28,7 @@
                       ["_;" parser])
              (data ["_;" bit]
                    ["_;" bool]
-                   ["_;" result]
+                   ["_;" error]
                    ["_;" ident]
                    ["_;" identity]
                    ["_;" maybe]