From 8bd1d1b3a4750b26f1540717839c1aa196f2a520 Mon Sep 17 00:00:00 2001 From: Eduardo Julian Date: Wed, 17 May 2017 20:23:02 -0400 Subject: - Renamed "Error" to "Result". --- stdlib/source/lux/cli.lux | 114 +++++++------- stdlib/source/lux/concurrency/actor.lux | 6 +- stdlib/source/lux/concurrency/promise.lux | 3 +- stdlib/source/lux/control/codec.lux | 6 +- stdlib/source/lux/control/effect.lux | 1 - stdlib/source/lux/control/exception.lux | 18 +-- stdlib/source/lux/data/coll/array.lux | 3 +- stdlib/source/lux/data/error.lux | 70 --------- stdlib/source/lux/data/format/json.lux | 218 +++++++++++++------------- stdlib/source/lux/data/format/xml.lux | 14 +- stdlib/source/lux/data/number.lux | 76 ++++----- stdlib/source/lux/data/number/complex.lux | 4 +- stdlib/source/lux/data/number/ratio.lux | 6 +- stdlib/source/lux/data/result.lux | 70 +++++++++ stdlib/source/lux/data/text/lexer.lux | 174 ++++++++++---------- stdlib/source/lux/macro.lux | 122 +++++++------- stdlib/source/lux/macro/poly/functor.lux | 3 +- stdlib/source/lux/macro/poly/text-encoder.lux | 3 +- stdlib/source/lux/macro/syntax.lux | 166 ++++++++++---------- stdlib/source/lux/test.lux | 106 ++++++------- stdlib/source/lux/type/check.lux | 130 +++++++-------- stdlib/test/test/lux/concurrency/actor.lux | 2 +- stdlib/test/test/lux/concurrency/frp.lux | 3 +- stdlib/test/test/lux/concurrency/promise.lux | 3 +- stdlib/test/test/lux/control/exception.lux | 4 +- stdlib/test/test/lux/data/error.lux | 56 ------- stdlib/test/test/lux/data/format/json.lux | 2 +- stdlib/test/test/lux/data/result.lux | 56 +++++++ stdlib/test/test/lux/data/text/lexer.lux | 12 +- stdlib/test/test/lux/data/text/regex.lux | 3 +- stdlib/test/test/lux/macro/syntax.lux | 4 +- stdlib/test/tests.lux | 2 +- 32 files changed, 726 insertions(+), 734 deletions(-) delete mode 100644 stdlib/source/lux/data/error.lux create mode 100644 stdlib/source/lux/data/result.lux delete mode 100644 stdlib/test/test/lux/data/error.lux create mode 100644 stdlib/test/test/lux/data/result.lux (limited to 'stdlib') diff --git a/stdlib/source/lux/cli.lux b/stdlib/source/lux/cli.lux index fd20a208b..6883811a6 100644 --- a/stdlib/source/lux/cli.lux +++ b/stdlib/source/lux/cli.lux @@ -5,7 +5,7 @@ monad) (data (coll (list #as list #open ("List/" Monoid Monad))) (text #as text #open ("Text/" Monoid)) - error + ["R" result] (sum #as sum)) [io] [macro #+ with-gensyms Functor Monad] @@ -15,38 +15,38 @@ ## [Types] (type: #export (CLI a) {#;doc "A command-line interface parser."} - (-> (List Text) (Error [(List Text) a]))) + (-> (List Text) (R;Result [(List Text) a]))) ## [Utils] (def: (run' opt inputs) - (All [a] (-> (CLI a) (List Text) (Error [(List Text) a]))) + (All [a] (-> (CLI a) (List Text) (R;Result [(List Text) a]))) (opt inputs)) ## [Structures] (struct: #export _ (Functor CLI) (def: (map f ma inputs) (case (ma inputs) - (#;Left msg) (#;Left msg) - (#;Right [inputs' datum]) (#;Right [inputs' (f datum)])))) + (#R;Error msg) (#R;Error msg) + (#R;Success [inputs' datum]) (#R;Success [inputs' (f datum)])))) (struct: #export _ (Applicative CLI) (def: functor Functor) (def: (wrap a inputs) - (#;Right [inputs a])) + (#R;Success [inputs a])) (def: (apply ff fa inputs) (case (ff inputs) - (#;Right [inputs' f]) + (#R;Success [inputs' f]) (case (fa inputs') - (#;Right [inputs'' a]) - (#;Right [inputs'' (f a)]) + (#R;Success [inputs'' a]) + (#R;Success [inputs'' (f a)]) - (#;Left msg) - (#;Left msg)) + (#R;Error msg) + (#R;Error msg)) - (#;Left msg) - (#;Left msg)) + (#R;Error msg) + (#R;Error msg)) )) (struct: #export _ (Monad CLI) @@ -54,8 +54,8 @@ (def: (join mma inputs) (case (mma inputs) - (#;Left msg) (#;Left msg) - (#;Right [inputs' ma]) (ma inputs')))) + (#R;Error msg) (#R;Error msg) + (#R;Success [inputs' ma]) (ma inputs')))) ## [Combinators] (def: #export any @@ -64,26 +64,26 @@ (function [inputs] (case inputs (#;Cons arg inputs') - (#;Right [inputs' arg]) + (#R;Success [inputs' arg]) _ - (#;Left "Cannot parse empty arguments.")))) + (#R;Error "Cannot parse empty arguments.")))) (def: #export (parse parser) {#;doc "Parses the next input with a parsing function."} - (All [a] (-> (-> Text (Error a)) (CLI a))) + (All [a] (-> (-> Text (R;Result a)) (CLI a))) (function [inputs] (case inputs (#;Cons arg inputs') (case (parser arg) - (#;Right value) - (#;Right [inputs' value]) + (#R;Success value) + (#R;Success [inputs' value]) - (#;Left parser-error) - (#;Left parser-error)) + (#R;Error parser-error) + (#R;Error parser-error)) _ - (#;Left "Cannot parse empty arguments.")))) + (#R;Error "Cannot parse empty arguments.")))) (def: #export (option names) {#;doc "Checks that a given option (with multiple possible names) has a value."} @@ -92,13 +92,13 @@ (let [[pre post] (list;split-with (. ;not (list;member? text;Eq names)) inputs)] (case post #;Nil - (#;Left ($_ Text/append "Missing option (" (text;join-with " " names) ")")) + (#R;Error ($_ Text/append "Missing option (" (text;join-with " " names) ")")) (^ (list& _ value post')) - (#;Right [(List/append pre post') value]) + (#R;Success [(List/append pre post') value]) _ - (#;Left ($_ Text/append "Option lacks value (" (text;join-with " " names) ")")) + (#R;Error ($_ Text/append "Option lacks value (" (text;join-with " " names) ")")) )))) (def: #export (flag names) @@ -108,18 +108,18 @@ (let [[pre post] (list;split-with (. ;not (list;member? text;Eq names)) inputs)] (case post #;Nil - (#;Right [pre false]) + (#R;Success [pre false]) (#;Cons _ post') - (#;Right [(List/append pre post') true]))))) + (#R;Success [(List/append pre post') true]))))) (def: #export end {#;doc "Ensures there are no more inputs."} (CLI Unit) (function [inputs] (case inputs - #;Nil (#;Right [inputs []]) - _ (#;Left (Text/append "Unknown parameters: " (text;join-with " " inputs)))))) + #;Nil (#R;Success [inputs []]) + _ (#R;Error (Text/append "Unknown parameters: " (text;join-with " " inputs)))))) (def: #export (after param subject) (All [p s] (-> (CLI p) (CLI s) (CLI s))) @@ -139,8 +139,8 @@ (-> Text Bool (CLI Unit)) (function [inputs] (if test - (#;Right [inputs []]) - (#;Left message)))) + (#R;Success [inputs []]) + (#R;Error message)))) (def: #export (opt opt) {#;doc "Optionality combinator."} @@ -148,8 +148,8 @@ (-> (CLI a) (CLI (Maybe a)))) (function [inputs] (case (opt inputs) - (#;Left _) (#;Right [inputs #;None]) - (#;Right [inputs' x]) (#;Right [inputs' (#;Some x)])))) + (#R;Error _) (#R;Success [inputs #;None]) + (#R;Success [inputs' x]) (#R;Success [inputs' (#;Some x)])))) (def: #export (seq optL optR) {#;doc "Sequencing combinator."} @@ -164,27 +164,27 @@ (All [a b] (-> (CLI a) (CLI b) (CLI (| a b)))) (function [inputs] (case (optL inputs) - (#;Left msg) + (#R;Error msg) (case (optR inputs) - (#;Left _) - (#;Left msg) + (#R;Error _) + (#R;Error msg) - (#;Right [inputs' r]) - (#;Right [inputs' (sum;right r)])) + (#R;Success [inputs' r]) + (#R;Success [inputs' (sum;right r)])) - (#;Right [inputs' l]) - (#;Right [inputs' (sum;left l)])))) + (#R;Success [inputs' l]) + (#R;Success [inputs' (sum;left l)])))) (def: #export (not opt) {#;doc "The opposite of the given CLI."} (All [a] (-> (CLI a) (CLI Unit))) (function [inputs] (case (opt inputs) - (#;Left msg) - (#;Right [inputs []]) + (#R;Error msg) + (#R;Success [inputs []]) _ - (#;Left "Expected to fail; yet succeeded.")))) + (#R;Error "Expected to fail; yet succeeded.")))) (def: #export (some opt) {#;doc "0-or-more combinator."} @@ -192,11 +192,11 @@ (-> (CLI a) (CLI (List a)))) (function [inputs] (case (opt inputs) - (#;Left _) (#;Right [inputs (list)]) - (#;Right [inputs' x]) (run' (do Monad - [xs (some opt)] - (wrap (list& x xs))) - inputs')))) + (#R;Error _) (#R;Success [inputs (list)]) + (#R;Success [inputs' x]) (run' (do Monad + [xs (some opt)] + (wrap (list& x xs))) + inputs')))) (def: #export (many opt) {#;doc "1-or-more combinator."} @@ -213,17 +213,17 @@ (-> (CLI a) (CLI a) (CLI a))) (function [inputs] (case (pl inputs) - (#;Left _) (pr inputs) + (#R;Error _) (pr inputs) output output))) (def: #export (run opt inputs) - (All [a] (-> (CLI a) (List Text) (Error a))) + (All [a] (-> (CLI a) (List Text) (R;Result a))) (case (opt inputs) - (#;Left msg) - (#;Left msg) + (#R;Error msg) + (#R;Error msg) - (#;Right [_ value]) - (#;Right value))) + (#R;Success [_ value]) + (#R;Success value))) ## [Syntax] (type: Program-Args @@ -271,10 +271,10 @@ (~ g!_) ;;end] ((~' wrap) (~ body)))) (~ g!args)) - (#;Right [(~ g!_) (~ g!output)]) + (#R;Success [(~ g!_) (~ g!output)]) (~ g!output) - (#;Left (~ g!message)) + (#R;Error (~ g!message)) (error! (~ g!message)) ))) ))) diff --git a/stdlib/source/lux/concurrency/actor.lux b/stdlib/source/lux/concurrency/actor.lux index 42b8908f9..de1c9d745 100644 --- a/stdlib/source/lux/concurrency/actor.lux +++ b/stdlib/source/lux/concurrency/actor.lux @@ -3,7 +3,7 @@ (lux (control monad) [io #- run] function - (data [error #- fail] + (data ["R" result] text/format (coll [list "List/" Monoid Monad]) [product] @@ -26,7 +26,7 @@ (type: #export (Behavior s m) {#;doc "An actor's behavior when messages are received."} - {#step (-> (Actor s m) (-> m s (P;Promise (Error s)))) + {#step (-> (Actor s m) (-> m s (P;Promise (R;Result s)))) #end (-> (Maybe Text) s (P;Promise Unit))}) ## [Values] @@ -225,7 +225,7 @@ protocol-pm (List/map (: (-> Method [Code Code]) (function [(^slots [#name #vars #args #return #body])] (let [arg-names (|> (list;size args) (list;n.range +1) (List/map (|>. Nat/encode [""] code;symbol))) - body-func (` (: (-> (~ g!state-name) (~@ (List/map product;right args)) (P;Promise (Error [(~ g!state-name) (~ return)]))) + body-func (` (: (-> (~ g!state-name) (~@ (List/map product;right args)) (P;Promise (R;Result [(~ g!state-name) (~ return)]))) (function (~ (code;symbol ["" _name])) [(~ g!state) (~@ (List/map (|>. product;left [""] code;symbol) args))] (do P;Monad [] diff --git a/stdlib/source/lux/concurrency/promise.lux b/stdlib/source/lux/concurrency/promise.lux index edca7d05a..a6c814c5a 100644 --- a/stdlib/source/lux/concurrency/promise.lux +++ b/stdlib/source/lux/concurrency/promise.lux @@ -2,8 +2,7 @@ lux (lux (data (coll [list #* "" Functor]) number - text/format - error) + text/format) [io #- run] function (control functor diff --git a/stdlib/source/lux/control/codec.lux b/stdlib/source/lux/control/codec.lux index 18937ede1..63ef0526b 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/error)) + data/result)) ## [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 (Error a)) + (: (-> m (Result a)) decode)) ## [Values] @@ -18,7 +18,7 @@ (def: encode (|>. (:: Codec encode) (:: Codec encode))) (def: (decode cy) - (do Monad + (do Monad [by (:: Codec decode cy)] (:: Codec decode by))) ) diff --git a/stdlib/source/lux/control/effect.lux b/stdlib/source/lux/control/effect.lux index 0c867f4be..447012689 100644 --- a/stdlib/source/lux/control/effect.lux +++ b/stdlib/source/lux/control/effect.lux @@ -7,7 +7,6 @@ (data (coll [list "List/" Monad Monoid]) [number "Nat/" Codec] text/format - error [ident "Ident/" Eq] [text]) [macro] diff --git a/stdlib/source/lux/control/exception.lux b/stdlib/source/lux/control/exception.lux index 66214f90c..fc5cf9c64 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 Error type."} +(;module: {#;doc "Exception-handling functionality built on top of the Result type."} lux (lux (control monad) - (data [error #- fail] + (data [result #- fail] [text]) [macro] (macro [code] @@ -23,8 +23,8 @@ 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) (Error a) - (Error a))) + (-> Exception (-> Text a) (Result a) + (Result a))) (case try (#;Right output) (#;Right output) @@ -37,7 +37,7 @@ (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) (Error a) a)) + (-> (-> Text a) (Result a) a)) (case try (#;Right output) output @@ -46,13 +46,13 @@ (to-do error))) (def: #export (return value) - {#;doc "A way to lift normal values into the error-handling context."} - (All [a] (-> a (Error a))) + {#;doc "A way to lift normal values into the result-handling context."} + (All [a] (-> a (Result a))) (#;Right value)) (def: #export (throw exception message) - {#;doc "Decorate an error message with an Exception and lift it into the error-handling context."} - (All [a] (-> Exception Text (Error a))) + {#;doc "Decorate an error message with an Exception and lift it into the result-handling context."} + (All [a] (-> Exception Text (Result a))) (#;Left (exception message))) (syntax: #export (exception: [_ex-lev common;export-level] [name s;local-symbol]) diff --git a/stdlib/source/lux/data/coll/array.lux b/stdlib/source/lux/data/coll/array.lux index 8631f154d..a8f8d9f00 100644 --- a/stdlib/source/lux/data/coll/array.lux +++ b/stdlib/source/lux/data/coll/array.lux @@ -6,8 +6,7 @@ monad eq fold) - (data error - (coll [list "List/" Fold]) + (data (coll [list "List/" Fold]) [product]) )) diff --git a/stdlib/source/lux/data/error.lux b/stdlib/source/lux/data/error.lux deleted file mode 100644 index f614305e0..000000000 --- a/stdlib/source/lux/data/error.lux +++ /dev/null @@ -1,70 +0,0 @@ -(;module: - lux - (lux (control functor - applicative - ["M" monad #*]))) - -## [Types] -(type: #export (Error a) - (#Error Text) - (#Success a)) - -## [Structures] -(struct: #export _ (Functor Error) - (def: (map f ma) - (case ma - (#Error msg) (#Error msg) - (#Success datum) (#Success (f datum))))) - -(struct: #export _ (Applicative Error) - (def: functor Functor) - - (def: (wrap a) - (#Success a)) - - (def: (apply ff fa) - (case ff - (#Success f) - (case fa - (#Success a) - (#Success (f a)) - - (#Error msg) - (#Error msg)) - - (#Error msg) - (#Error msg)) - )) - -(struct: #export _ (Monad Error) - (def: applicative Applicative) - - (def: (join mma) - (case mma - (#Error msg) (#Error msg) - (#Success ma) ma))) - -(struct: #export (ErrorT Monad) - (All [M] (-> (Monad M) (Monad (All [a] (M (Error a)))))) - (def: applicative (compA (get@ #M;applicative Monad) Applicative)) - (def: (join MeMea) - (do Monad - [eMea MeMea] - (case eMea - (#Error error) - (wrap (#Error error)) - - (#Success Mea) - Mea)))) - -(def: #export (lift-error Monad) - (All [M a] (-> (Monad M) (-> (M a) (M (Error a))))) - (liftM Monad (:: Monad wrap))) - -(def: #export (succeed value) - (All [a] (-> a (Error a))) - (#Success value)) - -(def: #export (fail message) - (All [a] (-> Text (Error a))) - (#Error message)) diff --git a/stdlib/source/lux/data/format/json.lux b/stdlib/source/lux/data/format/json.lux index b75b9dbf7..0919f305f 100644 --- a/stdlib/source/lux/data/format/json.lux +++ b/stdlib/source/lux/data/format/json.lux @@ -14,7 +14,7 @@ [number #* "Real/" Codec] maybe [char "Char/" Eq Codec] - [error #- fail] + ["R" result #- fail] [sum] [product] (coll [list "" Fold "List/" Monad] @@ -54,7 +54,7 @@ (type: #export (Parser a) {#;doc "JSON parsers."} - (-> JSON (Error a))) + (-> JSON (Result a))) (type: #export (Gen a) {#;doc "JSON generators."} @@ -150,52 +150,52 @@ (def: #export (fields json) {#;doc "Get all the fields in a JSON object."} - (-> JSON (Error (List String))) + (-> JSON (Result (List String))) (case json (#Object obj) - (#;Right (dict;keys obj)) + (#R;Success (dict;keys obj)) _ - (#;Left (format "Cannot get the fields of a non-object.")))) + (#R;Error (format "Cannot get the fields of a non-object.")))) (def: #export (get key json) {#;doc "A JSON object field getter."} - (-> String JSON (Error JSON)) + (-> String JSON (Result JSON)) (case json (#Object obj) (case (dict;get key obj) (#;Some value) - (#;Right value) + (#R;Success value) #;None - (#;Left (format "Missing field " (show-string key) " on object."))) + (#R;Error (format "Missing field " (show-string key) " on object."))) _ - (#;Left (format "Cannot get field " (show-string key) " of a non-object.")))) + (#R;Error (format "Cannot get field " (show-string key) " of a non-object.")))) (def: #export (set key value json) {#;doc "A JSON object field setter."} - (-> String JSON JSON (Error JSON)) + (-> String JSON JSON (Result JSON)) (case json (#Object obj) - (#;Right (#Object (dict;put key value obj))) + (#R;Success (#Object (dict;put key value obj))) _ - (#;Left (format "Cannot set field " (show-string key) " of a non-object.")))) + (#R;Error (format "Cannot set field " (show-string key) " of a non-object.")))) (do-template [ ] [(def: #export ( key json) {#;doc (#;TextA (format "A JSON object field getter for " "."))} - (-> Text JSON (Error )) + (-> Text JSON (Result )) (case (get key json) - (#;Right ( value)) - (#;Right value) + (#R;Success ( value)) + (#R;Success value) - (#;Right _) - (#;Left (format "Wrong value type at key " (show-string key))) + (#R;Success _) + (#R;Error (format "Wrong value type at key " (show-string key))) - (#;Left error) - (#;Left error)))] + (#R;Error error) + (#R;Error error)))] [get-boolean #Boolean Boolean "booleans"] [get-number #Number Number "numbers"] @@ -275,12 +275,12 @@ sign (lexer;default "" (lexer;text "-")) offset (lexer;many' lexer;digit)] (wrap (format mark sign offset)))))] - (case (: (Error Real) + (case (: (Result Real) (Real/decode (format ?sign digits "." decimals exp))) - (#;Left message) + (#R;Error message) (lexer;fail message) - (#;Right value) + (#R;Success value) (wrap value)))) (def: (un-escape escaped) @@ -351,31 +351,31 @@ (def: (map f ma) (function [json] (case (ma json) - (#;Left msg) - (#;Left msg) + (#R;Error msg) + (#R;Error msg) - (#;Right a) - (#;Right (f a)))))) + (#R;Success a) + (#R;Success (f a)))))) (struct: #export _ (Applicative Parser) (def: functor Functor) (def: (wrap x json) - (#;Right x)) + (#R;Success x)) (def: (apply ff fa) (function [json] (case (ff json) - (#;Right f) + (#R;Success f) (case (fa json) - (#;Right a) - (#;Right (f a)) + (#R;Success a) + (#R;Success (f a)) - (#;Left msg) - (#;Left msg)) + (#R;Error msg) + (#R;Error msg)) - (#;Left msg) - (#;Left msg))))) + (#R;Error msg) + (#R;Error msg))))) (struct: #export _ (Monad Parser) (def: applicative Applicative) @@ -383,10 +383,10 @@ (def: (join mma) (function [json] (case (mma json) - (#;Left msg) - (#;Left msg) + (#R;Error msg) + (#R;Error msg) - (#;Right ma) + (#R;Success ma) (ma json))))) ## [Values] @@ -397,10 +397,10 @@ (Parser ) (case json ( value) - (#;Right (
 value))
+       (#R;Success (
 value))
 
        _
-       (#;Left (format "JSON value is not "  ": " (show-json json)))))]
+       (#R;Error (format "JSON value is not "  ": " (show-json json)))))]
 
   [unit Unit #Null    "unit"    id]
   [bool Bool #Boolean "bool" id]
@@ -415,10 +415,10 @@
      (->  (Parser Bool))
      (case json
        ( value)
-       (#;Right (::  = test (
 value)))
+       (#R;Success (::  = test (
 value)))
 
        _
-       (#;Left (format "JSON value is not a "  ": " (show-json json)))))
+       (#R;Error (format "JSON value is not a "  ": " (show-json json)))))
 
    (def: #export ( test json)
      {#;doc (#;TextA (format "Ensures a JSON value is a "  "."))}
@@ -427,12 +427,12 @@
        ( value)
        (let [value (
 value)]
          (if (::  = test value)
-           (#;Right [])
-           (#;Left (format "Value mismatch: "
-                           (::  encode test) "=/=" (::  encode value)))))
+           (#R;Success [])
+           (#R;Error (format "Value mismatch: "
+                             (::  encode test) "=/=" (::  encode value)))))
 
        _
-       (#;Left (format "JSON value is not a "  ": " (show-json json)))))]
+       (#R;Error (format "JSON value is not a "  ": " (show-json json)))))]
 
   [bool? bool! Bool bool;Eq   bool;Codec   #Boolean "boolean" id]
   [int?  int!  Int  number;Eq  number;Codec  #Number  "number"  real-to-int]
@@ -446,14 +446,14 @@
   (case json
     (#String input)
     (case (Char/decode (format "#\"" input "\""))
-      (#;Right value)
-      (#;Right value)
+      (#R;Success value)
+      (#R;Success value)
 
-      (#;Left _)
-      (#;Left (format "Invalid format for char: " input)))
+      (#R;Error _)
+      (#R;Error (format "Invalid format for char: " input)))
 
     _
-    (#;Left (format "JSON value is not a " "string" ": " (show-json json)))))
+    (#R;Error (format "JSON value is not a " "string" ": " (show-json json)))))
 
 (def: #export (char? test json)
   {#;doc "Asks whether a JSON value is a single-character string with the specified character."}
@@ -461,17 +461,17 @@
   (case json
     (#String input)
     (case (Char/decode (format "#\"" input "\""))
-      (#;Right value)
+      (#R;Success value)
       (if (:: char;Eq = test value)
-        (#;Right true)
-        (#;Left (format "Value mismatch: "
-                        (:: char;Codec encode test) "=/=" (:: char;Codec encode value))))
+        (#R;Success true)
+        (#R;Error (format "Value mismatch: "
+                          (:: char;Codec encode test) "=/=" (:: char;Codec encode value))))
 
-      (#;Left _)
-      (#;Left (format "Invalid format for char: " input)))
+      (#R;Error _)
+      (#R;Error (format "Invalid format for char: " input)))
 
     _
-    (#;Left (format "JSON value is not a " "string" ": " (show-json json)))))
+    (#R;Error (format "JSON value is not a " "string" ": " (show-json json)))))
 
 (def: #export (char! test json)
   {#;doc "Ensures a JSON value is a single-character string with the specified character."}
@@ -479,17 +479,17 @@
   (case json
     (#String input)
     (case (Char/decode (format "#\"" input "\""))
-      (#;Right value)
+      (#R;Success value)
       (if (:: char;Eq = test value)
-        (#;Right [])
-        (#;Left (format "Value mismatch: "
-                        (:: char;Codec encode test) "=/=" (:: char;Codec encode value))))
+        (#R;Success [])
+        (#R;Error (format "Value mismatch: "
+                          (:: char;Codec encode test) "=/=" (:: char;Codec encode value))))
 
-      (#;Left _)
-      (#;Left (format "Invalid format for char: " input)))
+      (#R;Error _)
+      (#R;Error (format "Invalid format for char: " input)))
 
     _
-    (#;Left (format "JSON value is not a " "string" ": " (show-json json)))))
+    (#R;Error (format "JSON value is not a " "string" ": " (show-json json)))))
 
 (def: #export (nullable parser)
   {#;doc "A parser that can handle the presence of null values."}
@@ -497,15 +497,15 @@
   (function [json]
     (case json
       #Null
-      (#;Right #;None)
+      (#R;Success #;None)
       
       _
       (case (parser json)
-        (#;Left error)
-        (#;Left error)
+        (#R;Error error)
+        (#R;Error error)
 
-        (#;Right value)
-        (#;Right (#;Some value)))
+        (#R;Success value)
+        (#R;Success (#;Some value)))
       )))
 
 (def: #export (array parser)
@@ -514,12 +514,12 @@
   (function [json]
     (case json
       (#Array values)
-      (do Monad
+      (do Monad
         [elems (mapM @ parser (vector;to-list values))]
         (wrap elems))
 
       _
-      (#;Left (format "JSON value is not an array: " (show-json json))))))
+      (#R;Error (format "JSON value is not an array: " (show-json json))))))
 
 (def: #export (object parser)
   {#;doc "Parses a JSON object, assuming that every field's value can be parsed the same way."}
@@ -527,7 +527,7 @@
   (function [json]
     (case json
       (#Object fields)
-      (do Monad
+      (do Monad
         [kvs (mapM @
                    (function [[key val']]
                      (do @
@@ -537,7 +537,7 @@
         (wrap (dict;from-list text;Hash kvs)))
 
       _
-      (#;Left (format "JSON value is not an object: " (show-json json))))))
+      (#R;Error (format "JSON value is not an object: " (show-json json))))))
 
 (def: #export (nth idx parser)
   {#;doc "Parses an element inside a JSON array."}
@@ -548,17 +548,17 @@
       (case (vector;nth idx values)
         (#;Some value)
         (case (parser value)
-          (#;Right output)
-          (#;Right output)
+          (#R;Success output)
+          (#R;Success output)
 
-          (#;Left error)
-          (#;Left (format "JSON array index [" (%n idx) "]: (" error ") @ " (show-json json))))
+          (#R;Error error)
+          (#R;Error (format "JSON array index [" (%n idx) "]: (" error ") @ " (show-json json))))
 
         #;None
-        (#;Left (format "JSON array does not have index " (%n idx) " @ " (show-json json))))
+        (#R;Error (format "JSON array does not have index " (%n idx) " @ " (show-json json))))
       
       _
-      (#;Left (format "JSON value is not an array: " (show-json json))))))
+      (#R;Error (format "JSON value is not an array: " (show-json json))))))
 
 (def: #export (field field-name parser)
   {#;doc "Parses a field inside a JSON object."}
@@ -567,20 +567,20 @@
     (case (get field-name json)
       (#;Some value)
       (case (parser value)
-        (#;Right output)
-        (#;Right output)
+        (#R;Success output)
+        (#R;Success output)
 
-        (#;Left error)
-        (#;Left (format "Failed to get JSON object field " (show-string field-name) ": (" error ") @ " (show-json json))))
+        (#R;Error error)
+        (#R;Error (format "Failed to get JSON object field " (show-string field-name) ": (" error ") @ " (show-json json))))
 
-      (#;Left _)
-      (#;Left (format "JSON object does not have field " (show-string field-name) " @ " (show-json json))))))
+      (#R;Error _)
+      (#R;Error (format "JSON object does not have field " (show-string field-name) " @ " (show-json json))))))
 
 (def: #export any
   {#;doc "Just returns the JSON input without applying any logic."}
   (Parser JSON)
   (function [json]
-    (#;Right json)))
+    (#R;Success json)))
 
 (def: #export (seq pa pb)
   {#;doc "Sequencing combinator."}
@@ -594,23 +594,23 @@
   {#;doc "Heterogeneous alternative combinator."}
   (All [a b] (-> (Parser a) (Parser b) (Parser (| a b))))
   (case (pa json)
-    (#;Right a)
+    (#R;Success a)
     (sum;right (sum;left a))
 
-    (#;Left message0)
+    (#R;Error message0)
     (case (pb json)
-      (#;Right b)
+      (#R;Success b)
       (sum;right (sum;right b))
 
-      (#;Left message1)
-      (#;Left message0))))
+      (#R;Error message1)
+      (#R;Error message0))))
 
 (def: #export (either pl pr json)
   {#;doc "Homogeneous alternative combinator."}
   (All [a] (-> (Parser a) (Parser a) (Parser a)))
   (case (pl json)
-    (#;Right x)
-    (#;Right x)
+    (#R;Success x)
+    (#R;Success x)
 
     _
     (pr json)))
@@ -620,22 +620,22 @@
   (All [a]
     (-> (Parser a) (Parser (Maybe a))))
   (case (p json)
-    (#;Left _)  (#;Right #;None)
-    (#;Right x) (#;Right (#;Some x))))
+    (#R;Error _)  (#R;Success #;None)
+    (#R;Success x) (#R;Success (#;Some x))))
 
 (def: #export (run json parser)
-  (All [a] (-> JSON (Parser a) (Error a)))
+  (All [a] (-> JSON (Parser a) (Result a)))
   (parser json))
 
 (def: #export (ensure test parser json)
   {#;doc "Only parses a JSON if it passes a test (which is also a parser)."}
   (All [a] (-> (Parser Unit) (Parser a) (Parser a)))
   (case (test json)
-    (#;Right _)
+    (#R;Success _)
     (parser json)
 
-    (#;Left error)
-    (#;Left error)))
+    (#R;Error error)
+    (#R;Error error)))
 
 (def: #export (array-size! size json)
   {#;doc "Ensures a JSON array has the specified size."}
@@ -643,11 +643,11 @@
   (case json
     (#Array parts)
     (if (n.= size (vector;size parts))
-      (#;Right [])
-      (#;Left (format "JSON array does no have size " (%n size) " " (show-json json))))
+      (#R;Success [])
+      (#R;Error (format "JSON array does no have size " (%n size) " " (show-json json))))
 
     _
-    (#;Left (format "JSON value is not an array: " (show-json json)))))
+    (#R;Error (format "JSON value is not an array: " (show-json json)))))
 
 (def: #export (object-fields! wanted-fields json)
   {#;doc "Ensures that every field in the list of wanted-fields is present in a JSON object."}
@@ -658,11 +658,11 @@
       (if (and (n.= (list;size wanted-fields) (list;size actual-fields))
                (list;every? (list;member? text;Eq wanted-fields)
                             actual-fields))
-        (#;Right [])
-        (#;Left (format "JSON object has wrong field-set. Expected: [" (text;join-with ", " wanted-fields) "]. Actual: [" (text;join-with ", " actual-fields) "]"))))
+        (#R;Success [])
+        (#R;Error (format "JSON object has wrong field-set. Expected: [" (text;join-with ", " wanted-fields) "]. Actual: [" (text;join-with ", " actual-fields) "]"))))
 
     _
-    (#;Left (format "JSON value is not an object: " (show-json json)))))
+    (#R;Error (format "JSON value is not an object: " (show-json json)))))
 
 ## [Structures]
 (struct: #export _ (Eq JSON)
@@ -924,7 +924,7 @@
 
 (poly: #hidden (Codec//decode *env* :x:)
   (let [->Codec//decode (: (-> Code Code)
-                           (function [.type.] (` (-> JSON (Error (~ .type.))))))]
+                           (function [.type.] (` (-> JSON (Result (~ .type.))))))]
     (with-expansions
       [ (do-template [  ]
                  [(do @ [_ ( :x:)] (wrap (` (: (~ (->Codec//decode (` ))) ))))]
@@ -971,11 +971,11 @@
                                      (~ (->Codec//decode (` ((~ (type;to-ast :x:)) (~@ g!vars)))))))))]]
               (wrap (` (: (~ :x:+)
                           (function [(~@ g!vars) (~ g!input)]
-                            (do Monad
+                            (do Monad
                               [(~ g!key) (;;fields (~ g!input))]
                               (mapM (~ (' %))
                                     (function [(~ g!key)]
-                                      (do Monad
+                                      (do Monad
                                         [(~ g!val) (;;get (~ g!key) (~ g!input))
                                          (~ g!val) (;;run (~ g!val) (~ .val.))]
                                         ((~ (' wrap)) [(~ g!key) (~ g!val)])))
@@ -1043,7 +1043,7 @@
                                      (~ (->Codec//decode (` ((~ (type;to-ast :x:)) (~@ g!vars)))))))))]]
               (wrap (` (: (~ :x:+)
                           (function [(~@ g!vars) (~ g!input)]
-                            (do Monad
+                            (do Monad
                               [(~@ (List/join extraction))]
                               ((~ (' wrap)) (~ (code;record (List/map (function [[name :slot:]]
                                                                         [(code;tag name) (code;symbol ["" (product;right name)])])
diff --git a/stdlib/source/lux/data/format/xml.lux b/stdlib/source/lux/data/format/xml.lux
index 2494fa1b8..db68fbf29 100644
--- a/stdlib/source/lux/data/format/xml.lux
+++ b/stdlib/source/lux/data/format/xml.lux
@@ -7,7 +7,7 @@
              text/format
              (text ["l" lexer "lex/" Monad])
              [number]
-             error
+             ["R" result]
              [char "c/" Eq]
              [product]
              [maybe "m/" Monad]
@@ -180,16 +180,16 @@
       (l;after (l;opt xml-header^))))
 
 (def: #export (read-xml input)
-  (-> Text (Error XML))
+  (-> Text (R;Result XML))
   (case (l;run' input xml^)
-    (#;Right ["" output])
-    (#;Right output)
+    (#R;Success ["" output])
+    (#R;Success output)
 
     (#;Some [input-left output])
-    (#;Left (format "Unconsumed input: " (%t input-left)))
+    (#R;Error (format "Unconsumed input: " (%t input-left)))
 
-    (#;Left error)
-    (#;Left error)))
+    (#R;Error error)
+    (#R;Error error)))
 
 ## [Generation]
 (def: (sanitize-value input)
diff --git a/stdlib/source/lux/data/number.lux b/stdlib/source/lux/data/number.lux
index cb98f5624..ad37a01ca 100644
--- a/stdlib/source/lux/data/number.lux
+++ b/stdlib/source/lux/data/number.lux
@@ -8,7 +8,7 @@
                 enum
                 interval
                 codec)
-       (data ["E" error])))
+       (data ["R" result])))
 
 (def: (clean-separators input)
   (-> Text Text)
@@ -159,10 +159,10 @@
      (def: (decode input)
        (case (_lux_proc  [input])
          (#;Some value)
-         (#;Right value)
+         (#R;Success value)
 
          #;None
-         (#;Left ))))]
+         (#R;Error ))))]
 
   [Real ["real" "encode"] ["real" "decode"] "Could not decode Real"]
   )
@@ -214,16 +214,16 @@
                                        (_lux_proc ["char" "to-text"] [digit])
                                        +0])
                        #;None
-                       (#;Left (_lux_proc ["text" "append"] [ repr]))
+                       (#R;Error (_lux_proc ["text" "append"] [ repr]))
 
                        (#;Some index)
                        (recur (n.inc idx)
                               (|> output (n.* ) (n.+ index)))))
-                   (#;Right output))))
+                   (#R;Success output))))
 
              _
-             (#;Left (_lux_proc ["text" "append"] [ repr])))
-           (#;Left (_lux_proc ["text" "append"] [ repr]))))))]
+             (#R;Error (_lux_proc ["text" "append"] [ repr])))
+           (#R;Error (_lux_proc ["text" "append"] [ repr]))))))]
 
   [Binary@Codec +2  "01"               "Invalid binary syntax for Nat: "]
   [Octal@Codec  +8  "01234567"         "Invalid octal syntax for Nat: "]
@@ -271,13 +271,13 @@
                                      (_lux_proc ["char" "to-text"] [digit])
                                      +0])
                      #;None
-                     (#;Left )
+                     (#R;Error )
 
                      (#;Some index)
                      (recur (n.inc idx)
                             (|> output (i.* ) (i.+ (:! Int index))))))
-                 (#;Right (i.* sign output)))))
-           (#;Left )))))]
+                 (#R;Success (i.* sign output)))))
+           (#R;Error )))))]
 
   [Binary@Codec 2  "01"               "Invalid binary syntax for Int: "]
   [Octal@Codec  8  "01234567"         "Invalid octal syntax for Int: "]
@@ -311,11 +311,11 @@
              (^=> (#;Some #".")
                   [(::  decode (_lux_proc ["text" "append"] ["+" (de-prefix repr)]))
                    (#;Some output)])
-             (#;Right (:! Deg output))
+             (#R;Success (:! Deg output))
 
              _
-             (#;Left (_lux_proc ["text" "append"] [ repr])))
-           (#;Left (_lux_proc ["text" "append"] [ repr]))))))]
+             (#R;Error (_lux_proc ["text" "append"] [ repr])))
+           (#R;Error (_lux_proc ["text" "append"] [ repr]))))))]
 
   [Binary@Codec Binary@Codec +1 "Invalid binary syntax: "]
   [Octal@Codec  Octal@Codec  +3 "Invalid octal syntax: "]
@@ -362,19 +362,19 @@
                                         (r.*  output))))
                    adjusted-decimal (|> decimal int-to-real (r./ div-power))
                    dec-deg (case (:: Hex@Codec decode (_lux_proc ["text" "append"] ["." decimal-part]))
-                             (#;Right dec-deg)
+                             (#R;Success dec-deg)
                              dec-deg
 
-                             (#;Left error)
+                             (#R;Error error)
                              (error! error))]
-               (#;Right (r.+ (int-to-real whole)
-                             (r.* sign adjusted-decimal))))
+               (#R;Success (r.+ (int-to-real whole)
+                                (r.* sign adjusted-decimal))))
 
              _
-             (#;Left (_lux_proc ["text" "append"] [ repr]))))
+             (#R;Error (_lux_proc ["text" "append"] [ repr]))))
 
          _
-         (#;Left (_lux_proc ["text" "append"] [ repr])))))]
+         (#R;Error (_lux_proc ["text" "append"] [ repr])))))]
 
   [Binary@Codec Binary@Codec 2.0 "01" "Invalid binary syntax: "]
   )
@@ -552,14 +552,14 @@
                                [(if (r.= -1.0 sign) "-" "")]
                                (_lux_proc ["text" "append"]))]
              (case (:: Binary@Codec decode as-binary)
-               (#;Left _)
-               (#;Left (_lux_proc ["text" "append"] [ repr]))
+               (#R;Error _)
+               (#R;Error (_lux_proc ["text" "append"] [ repr]))
 
                output
                output))
 
            _
-           (#;Left (_lux_proc ["text" "append"] [ repr]))))))]
+           (#R;Error (_lux_proc ["text" "append"] [ repr]))))))]
 
   [Octal@Codec "Invalid octaladecimal syntax: " binary-to-octal octal-to-binary]
   [Hex@Codec   "Invalid hexadecimal syntax: "   binary-to-hex   hex-to-binary]
@@ -571,26 +571,26 @@
      (case tokens
        (#;Cons [meta (#;Text repr)] #;Nil)
        (case (::  decode repr)
-         (#;Right value)
-         (#;Right [state (list [meta (#;Nat value)])])
+         (#R;Success value)
+         (#R;Success [state (list [meta (#;Nat value)])])
 
-         (^=> (#;Left _)
-              [(::  decode repr) (#;Right value)])
-         (#;Right [state (list [meta (#;Int value)])])
+         (^=> (#R;Error _)
+              [(::  decode repr) (#R;Success value)])
+         (#R;Success [state (list [meta (#;Int value)])])
 
-         (^=> (#;Left _)
-              [(::  decode repr) (#;Right value)])
-         (#;Right [state (list [meta (#;Deg value)])])
+         (^=> (#R;Error _)
+              [(::  decode repr) (#R;Success value)])
+         (#R;Success [state (list [meta (#;Deg value)])])
 
-         (^=> (#;Left _)
-              [(::  decode repr) (#;Right value)])
-         (#;Right [state (list [meta (#;Real value)])])
+         (^=> (#R;Error _)
+              [(::  decode repr) (#R;Success value)])
+         (#R;Success [state (list [meta (#;Real value)])])
 
          _
-         (#;Left ))
+         (#R;Error ))
 
        _
-       (#;Left )))]
+       (#R;Error )))]
 
   [bin Binary@Codec Binary@Codec Binary@Codec Binary@Codec
    "Invalid binary syntax."
@@ -811,9 +811,9 @@
                   (recur (digits-sub! power digits)
                          (n.inc idx)
                          (bit-set (n.- idx (n.dec deg-bits)) output))))
-              (#E;Success (:! Deg output))))
+              (#R;Success (:! Deg output))))
 
           #;None
-          (#E;Error (_lux_proc ["text" "append"] ["Wrong syntax for Deg: " input])))
-        (#E;Error (_lux_proc ["text" "append"] ["Wrong syntax for Deg: " input]))))
+          (#R;Error (_lux_proc ["text" "append"] ["Wrong syntax for Deg: " input])))
+        (#R;Error (_lux_proc ["text" "append"] ["Wrong syntax for Deg: " input]))))
     ))
diff --git a/stdlib/source/lux/data/number/complex.lux b/stdlib/source/lux/data/number/complex.lux
index 5f002e9df..94276e5f8 100644
--- a/stdlib/source/lux/data/number/complex.lux
+++ b/stdlib/source/lux/data/number/complex.lux
@@ -8,7 +8,7 @@
        (data [number "r/" Number Codec]
              [text "Text/" Monoid]
              text/format
-             error
+             ["R" result]
              maybe
              (coll [list "List/" Monad]))
        [macro]
@@ -322,7 +322,7 @@
       (#;Left (Text/append "Wrong syntax for complex numbers: " input))
 
       (#;Some [r' i'])
-      (do Monad
+      (do R;Monad
         [r (r/decode (text;trim r'))
          i (r/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 b5cc0e4b2..8497b3c5d 100644
--- a/stdlib/source/lux/data/number/ratio.lux
+++ b/stdlib/source/lux/data/number/ratio.lux
@@ -9,7 +9,7 @@
        (data [number "n/" Number Codec]
              [text "Text/" Monoid]
              text/format
-             error
+             ["R" result]
              [product])
        [macro]
        (macro [code]
@@ -129,7 +129,7 @@
   (|>. n/encode (text;split +1) (default (undefined)) product;right))
 
 (def: part-decode
-  (-> Text (Error Nat))
+  (-> Text (R;Result Nat))
   (|>. (format "+") n/decode))
 
 (struct: #export _ (Codec Text Ratio)
@@ -139,7 +139,7 @@
   (def: (decode input)
     (case (text;split-with separator input)
       (#;Some [num denom])
-      (do Monad
+      (do R;Monad
         [numerator (part-decode num)
          denominator (part-decode denom)]
         (wrap (normalize {#numerator numerator
diff --git a/stdlib/source/lux/data/result.lux b/stdlib/source/lux/data/result.lux
new file mode 100644
index 000000000..3a713a174
--- /dev/null
+++ b/stdlib/source/lux/data/result.lux
@@ -0,0 +1,70 @@
+(;module:
+  lux
+  (lux (control functor
+                applicative
+                ["M" monad #*])))
+
+## [Types]
+(type: #export (Result a)
+  (#Error Text)
+  (#Success a))
+
+## [Structures]
+(struct: #export _ (Functor Result)
+  (def: (map f ma)
+    (case ma
+      (#Error msg)     (#Error msg)
+      (#Success datum) (#Success (f datum)))))
+
+(struct: #export _ (Applicative Result)
+  (def: functor Functor)
+
+  (def: (wrap a)
+    (#Success a))
+
+  (def: (apply ff fa)
+    (case ff
+      (#Success f)
+      (case fa
+        (#Success a)
+        (#Success (f a))
+
+        (#Error msg)
+        (#Error msg))
+
+      (#Error msg)
+      (#Error msg))
+    ))
+
+(struct: #export _ (Monad Result)
+  (def: applicative Applicative)
+
+  (def: (join mma)
+    (case mma
+      (#Error msg) (#Error msg)
+      (#Success ma) ma)))
+
+(struct: #export (ResultT Monad)
+  (All [M] (-> (Monad M) (Monad (All [a] (M (Result a))))))
+  (def: applicative (compA (get@ #M;applicative Monad) Applicative))
+  (def: (join MeMea)
+    (do Monad
+      [eMea MeMea]
+      (case eMea
+        (#Error error)
+        (wrap (#Error error))
+
+        (#Success Mea)
+        Mea))))
+
+(def: #export (lift-result Monad)
+  (All [M a] (-> (Monad M) (-> (M a) (M (Result a)))))
+  (liftM Monad (:: Monad wrap)))
+
+(def: #export (succeed value)
+  (All [a] (-> a (Result a)))
+  (#Success value))
+
+(def: #export (fail message)
+  (All [a] (-> Text (Result a)))
+  (#Error message))
diff --git a/stdlib/source/lux/data/text/lexer.lux b/stdlib/source/lux/data/text/lexer.lux
index 34614c545..58e636b53 100644
--- a/stdlib/source/lux/data/text/lexer.lux
+++ b/stdlib/source/lux/data/text/lexer.lux
@@ -9,41 +9,41 @@
              [product]
              [char "Char/" Order]
              maybe
-             ["E" error #- fail]
+             ["R" result]
              (coll [list "" Functor]))))
 
 ## [Types]
 (type: #export (Lexer a)
-  (-> Text (Error [Text a])))
+  (-> Text (R;Result [Text a])))
 
 ## [Structures]
 (struct: #export _ (Functor Lexer)
   (def: (map f fa)
     (function [input]
       (case (fa input)
-        (#E;Error msg)               (#E;Error msg)
-        (#E;Success [input' output]) (#E;Success [input' (f output)])))))
+        (#R;Error msg)               (#R;Error msg)
+        (#R;Success [input' output]) (#R;Success [input' (f output)])))))
 
 (struct: #export _ (Applicative Lexer)
   (def: functor Functor)
 
   (def: (wrap a)
     (function [input]
-      (#E;Success [input a])))
+      (#R;Success [input a])))
 
   (def: (apply ff fa)
     (function [input]
       (case (ff input)
-        (#E;Success [input' f])
+        (#R;Success [input' f])
         (case (fa input')
-          (#E;Success [input'' a])
-          (#E;Success [input'' (f a)])
+          (#R;Success [input'' a])
+          (#R;Success [input'' (f a)])
 
-          (#E;Error msg)
-          (#E;Error msg))
+          (#R;Error msg)
+          (#R;Error msg))
 
-        (#E;Error msg)
-        (#E;Error msg)))))
+        (#R;Error msg)
+        (#R;Error msg)))))
 
 (struct: #export _ (Monad Lexer)
   (def: applicative Applicative)
@@ -51,31 +51,31 @@
   (def: (join mma)
     (function [input]
       (case (mma input)
-        (#E;Error msg)          (#E;Error msg)
-        (#E;Success [input' ma]) (ma input'))))
+        (#R;Error msg)          (#R;Error msg)
+        (#R;Success [input' ma]) (ma input'))))
   )
 
 ## [Values]
 ## Runner
 (def: #export (run' input lexer)
-  (All [a] (-> Text (Lexer a) (Error [Text a])))
+  (All [a] (-> Text (Lexer a) (R;Result [Text a])))
   (lexer input))
 
 (def: #export (run input lexer)
-  (All [a] (-> Text (Lexer a) (Error a)))
+  (All [a] (-> Text (Lexer a) (R;Result a)))
   (case (lexer input)
-    (#E;Error msg)
-    (#E;Error msg)
+    (#R;Error msg)
+    (#R;Error msg)
     
-    (#E;Success [input' output])
-    (#E;Success output)
+    (#R;Success [input' output])
+    (#R;Success output)
     ))
 
 ## Combinators
 (def: #export (fail message)
   (All [a] (-> Text (Lexer a)))
   (function [input]
-    (#E;Error message)))
+    (#R;Error message)))
 
 (def: #export any
   {#;doc "Just returns the next character without applying any logic."}
@@ -83,10 +83,10 @@
   (function [input]
     (case [(text;nth +0 input) (text;split +1 input)]
       [(#;Some output) (#;Some [_ input'])]
-      (#E;Success [input' output])
+      (#R;Success [input' output])
 
       _
-      (#E;Error "Cannot parse character from empty text."))
+      (#R;Error "Cannot parse character from empty text."))
     ))
 
 (def: #export (seq left right)
@@ -102,45 +102,45 @@
   (All [a b] (-> (Lexer a) (Lexer b) (Lexer (| a b))))
   (function [input]
     (case (left input)
-      (#E;Error msg)
+      (#R;Error msg)
       (case (right input)
-        (#E;Error msg)
-        (#E;Error msg)
+        (#R;Error msg)
+        (#R;Error msg)
 
-        (#E;Success [input' output])
-        (#E;Success [input' (+1 output)]))
+        (#R;Success [input' output])
+        (#R;Success [input' (+1 output)]))
 
-      (#E;Success [input' output])
-      (#E;Success [input' (+0 output)]))))
+      (#R;Success [input' output])
+      (#R;Success [input' (+0 output)]))))
 
 (def: #export (not! p)
   {#;doc "Ensure a lexer fails."}
   (All [a] (-> (Lexer a) (Lexer Unit)))
   (function [input]
     (case (p input)
-      (#E;Error msg)
-      (#E;Success [input []])
+      (#R;Error msg)
+      (#R;Success [input []])
       
       _
-      (#E;Error "Expected to fail; yet succeeded."))))
+      (#R;Error "Expected to fail; yet succeeded."))))
 
 (def: #export (not p)
   {#;doc "Produce a character if the lexer fails."}
   (All [a] (-> (Lexer a) (Lexer Char)))
   (function [input]
     (case (p input)
-      (#E;Error msg)
+      (#R;Error msg)
       (any input)
       
       _
-      (#E;Error "Expected to fail; yet succeeded."))))
+      (#R;Error "Expected to fail; yet succeeded."))))
 
 (def: #export (either left right)
   {#;doc "Homogeneous alternative combinator."}
   (All [a] (-> (Lexer a) (Lexer a) (Lexer a)))
   (function [input]
     (case (left input)
-      (#E;Error msg)
+      (#R;Error msg)
       (right input)
 
       output
@@ -151,18 +151,18 @@
   (-> Text Bool (Lexer Unit))
   (function [input]
     (if test
-      (#E;Success [input []])
-      (#E;Error message))))
+      (#R;Success [input []])
+      (#R;Error message))))
 
 (def: #export (some p)
   {#;doc "0-or-more combinator."}
   (All [a] (-> (Lexer a) (Lexer (List a))))
   (function [input]
     (case (p input)
-      (#E;Error msg)
-      (#E;Success [input (list)])
+      (#R;Error msg)
+      (#R;Success [input (list)])
       
-      (#E;Success [input' x])
+      (#R;Success [input' x])
       (run' input'
             (do Monad
               [xs (some p)]
@@ -193,10 +193,10 @@
   (if (n.> +0 n)
     (function [input]
       (case (p input)
-        (#E;Error msg)
-        (#E;Success [input (list)])
+        (#R;Error msg)
+        (#R;Success [input (list)])
 
-        (#E;Success [input' x])
+        (#R;Success [input' x])
         (run' input'
               (do Monad
                 [xs (at-most (n.dec n) p)]
@@ -225,11 +225,11 @@
   (All [a] (-> (Lexer a) (Lexer (Maybe a))))
   (function [input]
     (case (p input)
-      (#E;Error msg)
-      (#E;Success [input #;None])
+      (#R;Error msg)
+      (#R;Success [input #;None])
 
-      (#E;Success [input value])
-      (#E;Success [input (#;Some value)])
+      (#R;Success [input value])
+      (#R;Success [input (#;Some value)])
       )))
 
 (def: #export (text test)
@@ -238,10 +238,10 @@
   (function [input]
     (if (text;starts-with? test input)
       (case (text;split (text;size test) input)
-        #;None              (#E;Error "")
-        (#;Some [_ input']) (#E;Success [input' test]))
+        #;None              (#R;Error "")
+        (#;Some [_ input']) (#R;Success [input' test]))
       (let [(^open "T/") text;Codec]
-        (#E;Error ($_ Text/append "Invalid match: " (T/encode test) " @ " (T/encode input)))))
+        (#R;Error ($_ Text/append "Invalid match: " (T/encode test) " @ " (T/encode input)))))
     ))
 
 (def: #export (sep-by sep lexer)
@@ -264,8 +264,8 @@
   (Lexer Unit)
   (function [input]
     (case input
-      "" (#E;Success [input []])
-      _  (#E;Error ($_ Text/append "The text input has not been fully consumed @ " (:: text;Codec encode input)))
+      "" (#R;Success [input []])
+      _  (#R;Error ($_ Text/append "The text input has not been fully consumed @ " (:: text;Codec encode input)))
       )))
 
 (def: #export peek
@@ -274,10 +274,10 @@
   (function [input]
     (case (text;nth +0 input)
       (#;Some output)
-      (#E;Success [input output])
+      (#R;Success [input output])
 
       _
-      (#E;Error "Cannot peek character from empty text."))
+      (#R;Error "Cannot peek character from empty text."))
     ))
 
 (def: #export (char test)
@@ -287,18 +287,18 @@
     (case [(text;nth +0 input) (text;split +1 input)]
       [(#;Some char') (#;Some [_ input'])]
       (if (Char/= test char')
-        (#E;Success [input' test])
-        (#E;Error ($_ Text/append "Expected " (:: char;Codec encode test) " @ " (:: text;Codec encode input))))
+        (#R;Success [input' test])
+        (#R;Error ($_ Text/append "Expected " (:: char;Codec encode test) " @ " (:: text;Codec encode input))))
 
       _
-      (#E;Error "Cannot parse character from empty text."))
+      (#R;Error "Cannot parse character from empty text."))
     ))
 
 (def: #export get-input
   {#;doc "Get all of the remaining input (without consuming it)."}
   (Lexer Text)
   (function [input]
-    (#E;Success [input input])))
+    (#R;Success [input input])))
 
 (def: #export (char-range bottom top)
   {#;doc "Only lex characters within a range."}
@@ -350,14 +350,14 @@
       (if (text;contains? init options)
         (case (text;nth +0 init)
           (#;Some output)
-          (#E;Success [input' output])
+          (#R;Success [input' output])
 
           _
-          (#E;Error ""))
-        (#E;Error ($_ Text/append "Character (" init ") is not one of: " options " @ " (:: text;Codec encode input))))
+          (#R;Error ""))
+        (#R;Error ($_ Text/append "Character (" init ") is not one of: " options " @ " (:: text;Codec encode input))))
 
       _
-      (#E;Error "Cannot parse character from empty text."))))
+      (#R;Error "Cannot parse character from empty text."))))
 
 (def: #export (none-of options)
   {#;doc "Only lex characters that are not part of a piece of text."}
@@ -368,14 +368,14 @@
       (if (;not (text;contains? init options))
         (case (text;nth +0 init)
           (#;Some output)
-          (#E;Success [input' output])
+          (#R;Success [input' output])
 
           _
-          (#E;Error ""))
-        (#E;Error ($_ Text/append "Character (" init ") is one of: " options " @ " (:: text;Codec encode input))))
+          (#R;Error ""))
+        (#R;Error ($_ Text/append "Character (" init ") is one of: " options " @ " (:: text;Codec encode input))))
 
       _
-      (#E;Error "Cannot parse character from empty text."))))
+      (#R;Error "Cannot parse character from empty text."))))
 
 (def: #export (satisfies p)
   {#;doc "Only lex characters that satisfy a predicate."}
@@ -388,11 +388,11 @@
                (wrap [input' output])))
       (#;Some [input' output])
       (if (p output)
-        (#E;Success [input' output])
-        (#E;Error ($_ Text/append "Character does not satisfy predicate: " (:: text;Codec encode input))))
+        (#R;Success [input' output])
+        (#R;Error ($_ Text/append "Character does not satisfy predicate: " (:: text;Codec encode input))))
 
       _
-      (#E;Error "Cannot parse character from empty text."))))
+      (#R;Error "Cannot parse character from empty text."))))
 
 (def: #export space
   {#;doc "Only lex white-space."}
@@ -445,7 +445,7 @@
   {#;doc "Ask if the lexer's input is empty."}
   (Lexer Bool)
   (function [input]
-    (#E;Success [input (text;empty? input)])))
+    (#R;Success [input (text;empty? input)])))
 
 (def: #export (after param subject)
   (All [p s] (-> (Lexer p) (Lexer s) (Lexer s)))
@@ -465,27 +465,27 @@
   (All [a] (-> a (Lexer a) (Lexer a)))
   (function [input]
     (case (lexer input)
-      (#E;Error error)
-      (#E;Success [input value])
+      (#R;Error error)
+      (#R;Success [input value])
 
-      (#E;Success input'+value)
-      (#E;Success input'+value))))
+      (#R;Success input'+value)
+      (#R;Success input'+value))))
 
 (def: #export (codec codec lexer)
   {#;doc "Lex a token by means of a codec."}
   (All [a] (-> (Codec Text a) (Lexer Text) (Lexer a)))
   (function [input]
     (case (lexer input)
-      (#E;Error error)
-      (#E;Error error)
+      (#R;Error error)
+      (#R;Error error)
 
-      (#E;Success [input' to-decode])
+      (#R;Success [input' to-decode])
       (case (:: codec decode to-decode)
-        (#E;Error error)
-        (#E;Error error)
+        (#R;Error error)
+        (#R;Error error)
         
-        (#E;Success value)
-        (#E;Success [input' value])))))
+        (#R;Success value)
+        (#R;Success [input' value])))))
 
 (def: #export (enclosed [start end] lexer)
   (All [a] (-> [Text Text] (Lexer a) (Lexer a)))
@@ -504,13 +504,13 @@
   (All [a] (-> Text (Lexer a) (Lexer a)))
   (function [real-input]
     (case (run' local-input lexer)
-      (#E;Error error)
-      (#E;Error error)
+      (#R;Error error)
+      (#R;Error error)
 
-      (#E;Success [unconsumed value])
+      (#R;Success [unconsumed value])
       (if (Text/= "" unconsumed)
-        (#E;Success [real-input value])
-        (#E;Error ($_ Text/append "Unconsumed input: " unconsumed))))))
+        (#R;Success [real-input value])
+        (#R;Error ($_ Text/append "Unconsumed input: " unconsumed))))))
 
 (def: #export (seq' left right)
   (-> (Lexer Text) (Lexer Text) (Lexer Text))
diff --git a/stdlib/source/lux/macro.lux b/stdlib/source/lux/macro.lux
index 5ff8b5073..75ba9d587 100644
--- a/stdlib/source/lux/macro.lux
+++ b/stdlib/source/lux/macro.lux
@@ -10,41 +10,41 @@
              [product]
              [ident "Ident/" Codec]
              maybe
-             ["E" error #- fail])))
+             ["R" result])))
 
 ## (type: (Lux a)
-##   (-> Compiler (Error [Compiler a])))
+##   (-> Compiler (R;Result [Compiler a])))
 
 (struct: #export _ (Functor Lux)
   (def: (map f fa)
     (function [state]
       (case (fa state)
-        (#;Left msg)
-        (#;Left msg)
+        (#R;Error msg)
+        (#R;Error msg)
 
-        (#;Right [state' a])
-        (#;Right [state' (f a)])))))
+        (#R;Success [state' a])
+        (#R;Success [state' (f a)])))))
 
 (struct: #export _ (Applicative Lux)
   (def: functor Functor)
 
   (def: (wrap x)
     (function [state]
-      (#;Right [state x])))
+      (#R;Success [state x])))
 
   (def: (apply ff fa)
     (function [state]
       (case (ff state)
-        (#;Right [state' f])
+        (#R;Success [state' f])
         (case (fa state')
-          (#;Right [state'' a])
-          (#;Right [state'' (f a)])
+          (#R;Success [state'' a])
+          (#R;Success [state'' (f a)])
 
-          (#;Left msg)
-          (#;Left msg))
+          (#R;Error msg)
+          (#R;Error msg))
 
-        (#;Left msg)
-        (#;Left msg)))))
+        (#R;Error msg)
+        (#R;Error msg)))))
 
 (struct: #export _ (Monad Lux)
   (def: applicative Applicative)
@@ -52,10 +52,10 @@
   (def: (join mma)
     (function [state]
       (case (mma state)
-        (#;Left msg)
-        (#;Left msg)
+        (#R;Error msg)
+        (#R;Error msg)
 
-        (#;Right [state' ma])
+        (#R;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) (Error [Compiler a])))
+  (All [a] (-> Compiler (Lux a) (R;Result [Compiler a])))
   (action compiler))
 
 (def: #export (run compiler action)
-  (All [a] (-> Compiler (Lux a) (Error a)))
+  (All [a] (-> Compiler (Lux a) (R;Result a)))
   (case (action compiler)
-    (#;Left error)
-    (#;Left error)
+    (#R;Error error)
+    (#R;Error error)
 
-    (#;Right [_ output])
-    (#;Right output)))
+    (#R;Success [_ output])
+    (#R;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)
-      (#;Left error)
+      (#R;Error error)
       (right compiler)
 
-      (#;Right [compiler' output])
-      (#;Right [compiler' output]))))
+      (#R;Success [compiler' output])
+      (#R;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
-      (#;Right [compiler []])
-      (#;Left message))))
+      (#R;Success [compiler []])
+      (#R;Error message))))
 
 (def: #export (fail msg)
   {#;doc "Fails with the given message."}
   (All [a]
     (-> Text (Lux a)))
   (function [_]
-    (#;Left msg)))
+    (#R;Error msg)))
 
 (def: #export (find-module name)
   (-> Text (Lux Module))
   (function [state]
     (case (get name (get@ #;modules state))
       (#;Some module)
-      (#;Right [state module])
+      (#R;Success [state module])
 
       _
-      (#;Left ($_ Text/append "Unknown module: " name)))))
+      (#R;Error ($_ Text/append "Unknown module: " name)))))
 
 (def: #export current-module-name
   (Lux Text)
@@ -126,13 +126,13 @@
       (#;Some scope)
       (case (get@ #;name scope)
         (#;Cons m-name #;Nil)
-        (#;Right [state m-name])
+        (#R;Success [state m-name])
 
         _
-        (#;Left "Improper name for scope."))
+        (#R;Error "Improper name for scope."))
 
       _
-      (#;Left "Empty environment!")
+      (#R;Error "Empty environment!")
       )))
 
 (def: #export current-module
@@ -256,7 +256,7 @@
     (let [[module name] ident]
       (: (Lux (Maybe Macro))
          (function [state]
-           (#;Right [state (find-macro' (get@ #;modules state) this-module module name)]))))))
+           (#R;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.
@@ -355,8 +355,8 @@
           A prefix can be given (or just be empty text \"\") to better identify the code for debugging purposes."}
   (-> Text (Lux Code))
   (function [state]
-    (#;Right [(update@ #;seed n.inc state)
-              (code;symbol ["" ($_ Text/append "__gensym__" prefix (:: number;Codec encode (get@ #;seed state)))])])))
+    (#R;Success [(update@ #;seed n.inc state)
+                 (code;symbol ["" ($_ Text/append "__gensym__" prefix (:: number;Codec encode (get@ #;seed state)))])])))
 
 (def: (get-local-symbol ast)
   (-> Code (Lux Text))
@@ -406,12 +406,12 @@
 (def: #export (module-exists? module)
   (-> Text (Lux Bool))
   (function [state]
-    (#;Right [state (case (get module (get@ #;modules state))
-                      (#;Some _)
-                      true
-                      
-                      #;None
-                      false)])))
+    (#R;Success [state (case (get module (get@ #;modules state))
+                         (#;Some _)
+                         true
+                         
+                         #;None
+                         false)])))
 
 (def: (try-both f x1 x2)
   (All [a b]
@@ -440,10 +440,10 @@
                                          (get@ [#;captured #;mappings] scope)))]
               (wrap type))
         (#;Some var-type)
-        (#;Right [state var-type])
+        (#R;Success [state var-type])
 
         #;None
-        (#;Left ($_ Text/append "Unknown variable: " name))))))
+        (#R;Error ($_ Text/append "Unknown variable: " name))))))
 
 (def: #export (find-def name)
   {#;doc "Looks-up a definition's whole data in the available modules (including the current one)."}
@@ -455,10 +455,10 @@
                 (^slots [#;defs]) (get v-prefix (get@ #;modules state))]
                (get v-name defs)))
       (#;Some _anns)
-      (#;Right [state _anns])
+      (#R;Success [state _anns])
 
       _
-      (#;Left ($_ Text/append "Unknown definition: " (Ident/encode name))))))
+      (#R;Error ($_ Text/append "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)."}
@@ -489,8 +489,8 @@
   (-> Text (Lux (List [Text Def])))
   (function [state]
     (case (get module-name (get@ #;modules state))
-      #;None          (#;Left ($_ Text/append "Unknown module: " module-name))
-      (#;Some module) (#;Right [state (get@ #;defs module)])
+      #;None          (#R;Error ($_ Text/append "Unknown module: " module-name))
+      (#;Some module) (#R;Success [state (get@ #;defs module)])
       )))
 
 (def: #export (exports module-name)
@@ -510,7 +510,7 @@
     (|> state
         (get@ #;modules)
         [state]
-        #;Right)))
+        #R;Success)))
 
 (def: #export (tags-of type-name)
   {#;doc "All the tags associated with a type definition."}
@@ -529,7 +529,7 @@
   {#;doc "The cursor of the current expression being analyzed."}
   (Lux Cursor)
   (function [state]
-    (#;Right [state (get@ #;cursor state)])))
+    (#R;Success [state (get@ #;cursor state)])))
 
 (def: #export expected-type
   {#;doc "The expected type of the current expression being analyzed."}
@@ -537,10 +537,10 @@
   (function [state]
     (case (get@ #;expected state)
       (#;Some type)
-      (#;Right [state type])
+      (#R;Success [state type])
 
       #;None
-      (#;Left "Not expecting any type."))))
+      (#R;Error "Not expecting any type."))))
 
 (def: #export (imported-modules module-name)
   {#;doc "All the modules imported by a specified module."}
@@ -585,14 +585,14 @@
   (function [state]
     (case (list;inits (get@ #;scopes state))
       #;None
-      (#;Left "No local environment")
+      (#R;Error "No local environment")
 
       (#;Some scopes)
-      (#;Right [state
-                (List/map (|>. (get@ [#;locals #;mappings])
-                               (List/map (function [[name [type _]]]
-                                           [name type])))
-                          scopes)]))))
+      (#R;Success [state
+                   (List/map (|>. (get@ [#;locals #;mappings])
+                                  (List/map (function [[name [type _]]]
+                                              [name type])))
+                             scopes)]))))
 
 (def: #export (un-alias def-name)
   {#;doc "Given an aliased definition's name, returns the original definition being referenced."}
@@ -611,12 +611,12 @@
   {#;doc "Obtains the current state of the compiler."}
   (Lux Compiler)
   (function [compiler]
-    (#;Right [compiler compiler])))
+    (#R;Success [compiler compiler])))
 
 (def: #export type-context
   (Lux Type-Context)
   (function [compiler]
-    (#;Right [compiler (get@ #;type-context compiler)])))
+    (#R;Success [compiler (get@ #;type-context compiler)])))
 
 (do-template [  ]
   [(macro: #export ( tokens)
diff --git a/stdlib/source/lux/macro/poly/functor.lux b/stdlib/source/lux/macro/poly/functor.lux
index 06ebe60e4..136080fa7 100644
--- a/stdlib/source/lux/macro/poly/functor.lux
+++ b/stdlib/source/lux/macro/poly/functor.lux
@@ -11,8 +11,7 @@
              [bool]
              [char]
              [maybe]
-             [ident "Ident/" Codec]
-             error)
+             [ident "Ident/" Codec])
        [macro #+ Monad with-gensyms]
        (macro [code]
               [syntax #+ syntax: Syntax]
diff --git a/stdlib/source/lux/macro/poly/text-encoder.lux b/stdlib/source/lux/macro/poly/text-encoder.lux
index 2dde16640..e1250c9e7 100644
--- a/stdlib/source/lux/macro/poly/text-encoder.lux
+++ b/stdlib/source/lux/macro/poly/text-encoder.lux
@@ -11,8 +11,7 @@
              [bool]
              [char]
              [maybe]
-             [ident "Ident/" Codec]
-             error)
+             [ident "Ident/" Codec])
        [macro #+ Monad with-gensyms]
        (macro [code]
               [syntax #+ syntax: Syntax]
diff --git a/stdlib/source/lux/macro/syntax.lux b/stdlib/source/lux/macro/syntax.lux
index c0fda8a62..53ec26009 100644
--- a/stdlib/source/lux/macro/syntax.lux
+++ b/stdlib/source/lux/macro/syntax.lux
@@ -12,7 +12,7 @@
              [ident]
              (coll [list #* "" Functor Fold "List/" Monoid])
              [product]
-             [error #- fail]))
+             ["R" result]))
   (.. [code "Code/" Eq]))
 
 ## [Utils]
@@ -25,38 +25,38 @@
 ## [Types]
 (type: #export (Syntax a)
   {#;doc "A Lux syntax parser."}
-  (-> (List Code) (Error [(List Code) a])))
+  (-> (List Code) (R;Result [(List Code) a])))
 
 ## [Structures]
 (struct: #export _ (Functor Syntax)
   (def: (map f ma)
     (function [tokens]
       (case (ma tokens)
-        (#;Left msg)
-        (#;Left msg)
+        (#R;Error msg)
+        (#R;Error msg)
 
-        (#;Right [tokens' a])
-        (#;Right [tokens' (f a)])))))
+        (#R;Success [tokens' a])
+        (#R;Success [tokens' (f a)])))))
 
 (struct: #export _ (Applicative Syntax)
   (def: functor Functor)
 
   (def: (wrap x tokens)
-    (#;Right [tokens x]))
+    (#R;Success [tokens x]))
 
   (def: (apply ff fa)
     (function [tokens]
       (case (ff tokens)
-        (#;Right [tokens' f])
+        (#R;Success [tokens' f])
         (case (fa tokens')
-          (#;Right [tokens'' a])
-          (#;Right [tokens'' (f a)])
+          (#R;Success [tokens'' a])
+          (#R;Success [tokens'' (f a)])
 
-          (#;Left msg)
-          (#;Left msg))
+          (#R;Error msg)
+          (#R;Error msg))
 
-        (#;Left msg)
-        (#;Left msg)))))
+        (#R;Error msg)
+        (#R;Error msg)))))
 
 (struct: #export _ (Monad Syntax)
   (def: applicative Applicative)
@@ -64,10 +64,10 @@
   (def: (join mma)
     (function [tokens]
       (case (mma tokens)
-        (#;Left msg)
-        (#;Left msg)
+        (#R;Error msg)
+        (#R;Error msg)
 
-        (#;Right [tokens' ma])
+        (#R;Success [tokens' ma])
         (ma tokens')))))
 
 ## [Utils]
@@ -82,8 +82,8 @@
   (Syntax Code)
   (function [tokens]
     (case tokens
-      #;Nil                (#;Left "There are no tokens to parse!")
-      (#;Cons [t tokens']) (#;Right [tokens' t]))))
+      #;Nil                (#R;Error "There are no tokens to parse!")
+      (#;Cons [t tokens']) (#R;Success [tokens' t]))))
 
 (do-template [    ]
   [(def: #export 
@@ -92,10 +92,10 @@
      (function [tokens]
        (case tokens
          (#;Cons [[_ ( x)] tokens'])
-         (#;Right [tokens' x])
+         (#R;Success [tokens' x])
 
          _
-         (#;Left ($_ Text/append "Cannot parse "  (remaining-inputs tokens))))))]
+         (#R;Error ($_ Text/append "Cannot parse "  (remaining-inputs tokens))))))]
 
   [  bool  Bool   #;Bool   bool;Eq "bool"]
   [   nat   Nat    #;Nat  number;Eq "nat"]
@@ -118,10 +118,10 @@
             remaining (if is-it?
                         tokens'
                         tokens)]
-        (#;Right [remaining is-it?]))
+        (#R;Success [remaining is-it?]))
 
       _
-      (#;Right [tokens false]))))
+      (#R;Success [tokens false]))))
 
 (def: #export (this! ast)
   {#;doc "Ensures the given Code is the next input."}
@@ -130,20 +130,20 @@
     (case tokens
       (#;Cons [token tokens'])
       (if (Code/= ast token)
-        (#;Right [tokens' []])
-        (#;Left ($_ Text/append "Expected a " (code;to-text ast) " but instead got " (code;to-text token)
-                    (remaining-inputs tokens))))
+        (#R;Success [tokens' []])
+        (#R;Error ($_ Text/append "Expected a " (code;to-text ast) " but instead got " (code;to-text token)
+                      (remaining-inputs tokens))))
 
       _
-      (#;Left "There are no tokens to parse!"))))
+      (#R;Error "There are no tokens to parse!"))))
 
 (def: #export (assert message test)
   {#;doc "Fails with the given message if the test is false."}
   (-> Text Bool (Syntax Unit))
   (function [tokens]
     (if test
-      (#;Right [tokens []])
-      (#;Left ($_ Text/append message (remaining-inputs tokens))))))
+      (#R;Success [tokens []])
+      (#R;Error ($_ Text/append message (remaining-inputs tokens))))))
 
 (do-template [  ]
   [(def: #export 
@@ -164,10 +164,10 @@
      (function [tokens]
        (case tokens
          (#;Cons [[_ ( ["" x])] tokens'])
-         (#;Right [tokens' x])
+         (#R;Success [tokens' x])
 
          _
-         (#;Left ($_ Text/append "Cannot parse local "  (remaining-inputs tokens))))))]
+         (#R;Error ($_ Text/append "Cannot parse local "  (remaining-inputs tokens))))))]
 
   [local-symbol #;Symbol "symbol"]
   [   local-tag #;Tag    "tag"]
@@ -182,11 +182,11 @@
        (case tokens
          (#;Cons [[_ ( members)] tokens'])
          (case (p members)
-           (#;Right [#;Nil x]) (#;Right [tokens' x])
-           _                   (#;Left ($_ Text/append "Syntax was expected to fully consume "  (remaining-inputs tokens))))
+           (#R;Success [#;Nil x]) (#R;Success [tokens' x])
+           _                   (#R;Error ($_ Text/append "Syntax was expected to fully consume "  (remaining-inputs tokens))))
 
          _
-         (#;Left ($_ Text/append "Cannot parse "  (remaining-inputs tokens))))))]
+         (#R;Error ($_ Text/append "Cannot parse "  (remaining-inputs tokens))))))]
 
   [ form  #;Form "form"]
   [tuple #;Tuple "tuple"]
@@ -200,11 +200,11 @@
     (case tokens
       (#;Cons [[_ (#;Record pairs)] tokens'])
       (case (p (join-pairs pairs))
-        (#;Right [#;Nil x]) (#;Right [tokens' x])
-        _                   (#;Left ($_ Text/append "Syntax was expected to fully consume record" (remaining-inputs tokens))))
+        (#R;Success [#;Nil x]) (#R;Success [tokens' x])
+        _                   (#R;Error ($_ Text/append "Syntax was expected to fully consume record" (remaining-inputs tokens))))
 
       _
-      (#;Left ($_ Text/append "Cannot parse record" (remaining-inputs tokens))))))
+      (#R;Error ($_ Text/append "Cannot parse record" (remaining-inputs tokens))))))
 
 (def: #export (opt p)
   {#;doc "Optionality combinator."}
@@ -212,12 +212,12 @@
     (-> (Syntax a) (Syntax (Maybe a))))
   (function [tokens]
     (case (p tokens)
-      (#;Left _)            (#;Right [tokens #;None])
-      (#;Right [tokens' x]) (#;Right [tokens' (#;Some x)]))))
+      (#R;Error _)            (#R;Success [tokens #;None])
+      (#R;Success [tokens' x]) (#R;Success [tokens' (#;Some x)]))))
 
 (def: #export (run tokens p)
   (All [a]
-    (-> (List Code) (Syntax a) (Error [(List Code) a])))
+    (-> (List Code) (Syntax a) (R;Result [(List Code) a])))
   (p tokens))
 
 (def: #export (some p)
@@ -226,12 +226,12 @@
     (-> (Syntax a) (Syntax (List a))))
   (function [tokens]
     (case (p tokens)
-      (#;Left _)            (#;Right [tokens (list)])
-      (#;Right [tokens' x]) (run tokens'
-                                 (do Monad
-                                   [xs (some p)]
-                                   (wrap (list& x xs)))
-                                 ))))
+      (#R;Error _)            (#R;Success [tokens (list)])
+      (#R;Success [tokens' x]) (run tokens'
+                                    (do Monad
+                                      [xs (some p)]
+                                      (wrap (list& x xs)))
+                                    ))))
 
 (def: #export (many p)
   {#;doc "1-or-more combinator."}
@@ -257,11 +257,11 @@
     (-> (Syntax a) (Syntax b) (Syntax (| a b))))
   (function [tokens]
     (case (p1 tokens)
-      (#;Right [tokens' x1]) (#;Right [tokens' (+0 x1)])
-      (#;Left _)             (run tokens
-                                  (do Monad
-                                    [x2 p2]
-                                    (wrap (+1 x2))))
+      (#R;Success [tokens' x1]) (#R;Success [tokens' (+0 x1)])
+      (#R;Error _)             (run tokens
+                                    (do Monad
+                                      [x2 p2]
+                                      (wrap (+1 x2))))
       )))
 
 (def: #export (either pl pr)
@@ -270,7 +270,7 @@
     (-> (Syntax a) (Syntax a) (Syntax a)))
   (function [tokens]
     (case (pl tokens)
-      (#;Left _) (pr tokens)
+      (#R;Error _) (pr tokens)
       output     output
       )))
 
@@ -279,16 +279,16 @@
   (Syntax Unit)
   (function [tokens]
     (case tokens
-      #;Nil (#;Right [tokens []])
-      _     (#;Left ($_ Text/append "Expected list of tokens to be empty!" (remaining-inputs tokens))))))
+      #;Nil (#R;Success [tokens []])
+      _     (#R;Error ($_ Text/append "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 (#;Right [tokens true])
-      _     (#;Right [tokens false]))))
+      #;Nil (#R;Success [tokens true])
+      _     (#R;Success [tokens false]))))
 
 (def: #export (exactly n p)
   {#;doc "Parse exactly N times."}
@@ -314,10 +314,10 @@
   (if (n.> +0 n)
     (function [input]
       (case (p input)
-        (#;Left msg)
-        (#;Right [input (list)])
+        (#R;Error msg)
+        (#R;Success [input (list)])
 
-        (#;Right [input' x])
+        (#R;Success [input' x])
         (run input'
              (do Monad
                [xs (at-most (n.dec n) p)]
@@ -352,38 +352,38 @@
   (All [a] (-> (Syntax a) (Syntax Unit)))
   (function [input]
     (case (p input)
-      (#;Left msg)
-      (#;Right [input []])
+      (#R;Error msg)
+      (#R;Success [input []])
       
       _
-      (#;Left "Expected to fail; yet succeeded."))))
+      (#R;Error "Expected to fail; yet succeeded."))))
 
 (def: #export (fail message)
   (All [a] (-> Text (Syntax a)))
   (function [input]
-    (#;Left message)))
+    (#R;Error message)))
 
 (def: #export (default value parser)
   {#;doc "If the given parser fails, returns the default value."}
   (All [a] (-> a (Syntax a) (Syntax a)))
   (function [input]
     (case (parser input)
-      (#;Left error)
-      (#;Right [input value])
+      (#R;Error error)
+      (#R;Success [input value])
 
-      (#;Right [input' output])
-      (#;Right [input' output]))))
+      (#R;Success [input' output])
+      (#R;Success [input' output]))))
 
 (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)
-      (#;Left error)
-      (#;Left error)
+      (#R;Error error)
+      (#R;Error error)
 
-      (#;Right value)
-      (#;Right [input value])
+      (#R;Success value)
+      (#R;Success [input value])
       )))
 
 (def: #export (local local-inputs syntax)
@@ -391,18 +391,18 @@
   (All [a] (-> (List Code) (Syntax a) (Syntax a)))
   (function [real-inputs]
     (case (syntax local-inputs)
-      (#;Left error)
-      (#;Left error)
+      (#R;Error error)
+      (#R;Error error)
 
-      (#;Right [unconsumed-inputs value])
+      (#R;Success [unconsumed-inputs value])
       (case unconsumed-inputs
         #;Nil
-        (#;Right [real-inputs value])
+        (#R;Success [real-inputs value])
 
         _
-        (#;Left (Text/append "Unconsumed inputs: "
-                             (|> (map code;to-text unconsumed-inputs)
-                                 (text;join-with ", "))))))))
+        (#R;Error (Text/append "Unconsumed inputs: "
+                               (|> (map code;to-text unconsumed-inputs)
+                                   (text;join-with ", "))))))))
 
 (def: #export (rec syntax)
   {#;doc "Combinator for recursive syntax."}
@@ -473,10 +473,10 @@
                  g!end (code;symbol ["" ""])
                  error-msg (code;text (Text/append "Wrong syntax for " name))
                  export-ast (: (List Code) (case exported?
-                                             (#;Some #;Left)
+                                             (#;Some #R;Error)
                                              (list (' #hidden))
 
-                                             (#;Some #;Right)
+                                             (#;Some #R;Success)
                                              (list (' #export))
 
                                              _
@@ -492,11 +492,11 @@
                                                    ((~' wrap) (do Monad
                                                                 []
                                                                 (~ body))))))
-                               (#;Right [(~ g!tokens) (~ g!body)])
+                               (#R;Success [(~ g!tokens) (~ g!body)])
                                ((~ g!body) (~ g!state))
 
-                               (#;Left (~ g!msg))
-                               (#;Left (text.join-with ": " (list (~ error-msg) (~ g!msg))))))))))))
+                               (#R;Error (~ g!msg))
+                               (#R;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 e9e979ad2..4e63a8b28 100644
--- a/stdlib/source/lux/test.lux
+++ b/stdlib/source/lux/test.lux
@@ -7,11 +7,11 @@
                 applicative
                 monad)
        (concurrency [promise #+ Promise Monad])
-       (data (coll [list "List/" Monad Fold])
+       (data (coll [list "L/" Monad Fold])
              [product]
              [text]
              text/format
-             [error #- fail "Error/" Monad])
+             ["E" result])
        [io #- run]
        ["R" math/random]))
 
@@ -31,41 +31,41 @@
 ## [Types]
 (type: #export Test
   {#;doc "Tests are asynchronous process which may fail."}
-  (Promise (Error Unit)))
+  (Promise (E;Result Unit)))
 
 ## [Values]
 (def: #export (fail message)
   (All [a] (-> Text Test))
-  (:: Monad wrap (#;Left message)))
+  (:: Monad wrap (#E;Error message)))
 
 (def: #export (assert message condition)
   {#;doc "Check that a condition is true, and fail with the given message otherwise."}
   (-> Text Bool Test)
   (if condition
-    (:: Monad wrap (#;Right []))
+    (:: Monad wrap (#E;Success []))
     (fail message)))
 
 (def: #hidden (run' tests)
   (-> (List [Text (IO Test) Text]) (Promise Nat))
   (do Monad
-    [#let [test-runs (List/map (: (-> [Text (IO Test) Text] (Promise Nat))
-                                  (function [[module test description]]
-                                    (do @
-                                      [#let [pre (io;run now)]
-                                       outcome (io;run test)
-                                       #let [post (io;run now)
-                                             description+ (:: text;Codec encode description)]]
-                                      (case outcome
-                                        (#;Left error)
-                                        (exec (log! (format "Error: " description+ " @ " module "\n" error "\n"))
-                                          (wrap +0))
-                                        
-                                        _
-                                        (exec (log! (format "Success: " description+ " @ " module " in " (%i (i.- pre post)) "ms"))
-                                          (wrap +1))))))
-                               tests)]
+    [#let [test-runs (L/map (: (-> [Text (IO Test) Text] (Promise Nat))
+                               (function [[module test description]]
+                                 (do @
+                                   [#let [pre (io;run now)]
+                                    outcome (io;run test)
+                                    #let [post (io;run now)
+                                          description+ (:: text;Codec encode description)]]
+                                   (case outcome
+                                     (#E;Error error)
+                                     (exec (log! (format "Error: " description+ " @ " module "\n" error "\n"))
+                                       (wrap +0))
+                                     
+                                     _
+                                     (exec (log! (format "Success: " description+ " @ " module " in " (%i (i.- pre post)) "ms"))
+                                       (wrap +1))))))
+                            tests)]
      test-runs (seqM @ test-runs)]
-    (wrap (List/fold n.+ +0 test-runs))))
+    (wrap (L/fold n.+ +0 test-runs))))
 
 (def: pcg-32-magic-inc Nat +12345)
 
@@ -74,7 +74,7 @@
   Nat)
 
 (def: (try seed random-test)
-  (-> Seed (R;Random Test) (Promise (Error Seed)))
+  (-> Seed (R;Random Test) (Promise (E;Result Seed)))
   (let [[prng [new-seed test]] (R;run (R;pcg-32 [pcg-32-magic-inc seed])
                                       (do R;Monad
                                         [test random-test
@@ -83,11 +83,11 @@
     (do Monad
       [result test]
       (case result
-        (#;Left error)
-        (wrap (#;Left error))
+        (#E;Error error)
+        (wrap (#E;Error error))
 
-        (#;Right _)
-        (wrap (#;Right new-seed))))))
+        (#E;Success _)
+        (wrap (#E;Success new-seed))))))
 
 (def: (repeat' seed times random-test)
   (-> Seed Nat (R;Random Test) Test)
@@ -96,12 +96,12 @@
     (do Monad
       [output (try seed random-test)]
       (case output
-        (#;Left error)
+        (#E;Error error)
         (fail (format "Test failed with this seed: " (%n seed) "\n" error))
 
-        (#;Right seed')
+        (#E;Success seed')
         (if (n.= +1 times)
-          (wrap (#;Right []))
+          (wrap (#E;Success []))
           (repeat' seed' (n.dec times) random-test))
         ))))
 
@@ -156,10 +156,10 @@
 (def: #hidden (try-body lazy-body)
   (-> (IO Test) Test)
   (case (_lux_proc ["lux" "try"] [lazy-body])
-    (#;Right output)
+    (#E;Success output)
     output
 
-    (#;Left error)
+    (#E;Error error)
     (assert error false)))
 
 (syntax: #export (test: description [body test^])
@@ -231,7 +231,7 @@
 
                                       (#;Some (#Times value))
                                       [(` #;None) value])
-                     bindings' (|> bindings (List/map pair-to-list) List/join)]
+                     bindings' (|> bindings (L/map pair-to-list) L/join)]
                  (` (repeat (~ =seed)
                             (~ (code;nat =times))
                             (do R;Monad
@@ -251,15 +251,15 @@
   (do Monad
     [defs (macro;exports module-name)]
     (wrap (|> defs
-              (List/map (function [[def-name [_ def-anns _]]]
-                          (case (macro;get-text-ann (ident-for #;;test) def-anns)
-                            (#;Some description)
-                            [true module-name def-name description]
+              (L/map (function [[def-name [_ def-anns _]]]
+                       (case (macro;get-text-ann (ident-for #;;test) def-anns)
+                         (#;Some description)
+                         [true module-name def-name description]
 
-                            _
-                            [false module-name def-name ""])))
+                         _
+                         [false module-name def-name ""])))
               (list;filter product;left)
-              (List/map product;right)))))
+              (L/map product;right)))))
 
 (def: #hidden _appendT_ (-> Text Text Text) (:: text;Monoid append))
 (def: #hidden _%i_ (-> Int Text) %i)
@@ -275,19 +275,19 @@
                 (|> (#;Cons current-module modules)
                     list;reverse
                     (mapM @ exported-tests)
-                    (:: @ map List/join)))
-       #let [tests+ (List/map (function [[module-name test desc]]
-                                (` [(~ (code;text module-name)) (~ (code;symbol [module-name test])) (~ (code;text desc))]))
-                              tests)
+                    (:: @ map L/join)))
+       #let [tests+ (L/map (function [[module-name test desc]]
+                             (` [(~ (code;text module-name)) (~ (code;symbol [module-name test])) (~ (code;text desc))]))
+                           tests)
              num-tests (list;size tests+)
              groups (list;split-all promise;concurrency-level tests+)]]
       (wrap (list (` (: (IO Unit)
                         (io (exec (do Monad
                                     [(~' #let) [(~ g!accum) +0]
-                                     (~@ (List/join (List/map (function [group]
-                                                                (list g!_ (` (run' (list (~@ group))))
-                                                                      (' #let) (` [(~ g!accum) (n.+ (~ g!_) (~ g!accum))])))
-                                                              groups)))
+                                     (~@ (L/join (L/map (function [group]
+                                                          (list g!_ (` (run' (list (~@ group))))
+                                                                (' #let) (` [(~ g!accum) (n.+ (~ g!_) (~ g!accum))])))
+                                                        groups)))
                                      (~' #let) [(~ g!_) (n.- (~ g!accum) (~ (code;nat num-tests)))]]
                                     (exec (log! ($_ _appendT_
                                                     "Test-suite finished."
@@ -310,12 +310,12 @@
     [=left left
      =right right]
     (case [=left =right]
-      (^or [(#;Left error) _]
-           [_ (#;Left error)])
-      (wrap (#;Left error))
+      (^or [(#E;Error error) _]
+           [_ (#E;Error error)])
+      (wrap (#E;Error error))
 
       _
-      (wrap (#;Right [])))))
+      (wrap (#E;Success [])))))
 
 (def: #export (alt left right)
   {#;doc "Alternative combinator."}
@@ -324,7 +324,7 @@
     [=left left
      =right right]
     (case =left
-      (#;Right _)
+      (#E;Success _)
       (wrap =left)
 
       _
diff --git a/stdlib/source/lux/type/check.lux b/stdlib/source/lux/type/check.lux
index 56198f5ab..e8f24102c 100644
--- a/stdlib/source/lux/type/check.lux
+++ b/stdlib/source/lux/type/check.lux
@@ -10,14 +10,14 @@
              maybe
              [product]
              (coll [list])
-             [error #- fail])
+             ["R" result])
        [type "Type/" Eq]
        ))
 
 (type: #export Fixed (List [[Type Type] Bool]))
 
 (type: #export (Check a)
-  (-> Type-Context (Error [Type-Context a])))
+  (-> Type-Context (R;Result [Type-Context a])))
 
 (type: #export Type-Vars
   (List [Nat (Maybe Type)]))
@@ -26,11 +26,11 @@
   (def: (map f fa)
     (function [context]
       (case (fa context)
-        (#;Left error)
-        (#;Left error)
+        (#R;Error error)
+        (#R;Error error)
 
-        (#;Right [context' output])
-        (#;Right [context' (f output)])
+        (#R;Success [context' output])
+        (#R;Success [context' (f output)])
         ))))
 
 (struct: #export _ (Applicative Check)
@@ -38,21 +38,21 @@
 
   (def: (wrap x)
     (function [context]
-      (#;Right [context x])))
+      (#R;Success [context x])))
 
   (def: (apply ff fa)
     (function [context]
       (case (ff context)
-        (#;Right [context' f])
+        (#R;Success [context' f])
         (case (fa context')
-          (#;Right [context'' a])
-          (#;Right [context'' (f a)])
+          (#R;Success [context'' a])
+          (#R;Success [context'' (f a)])
 
-          (#;Left error)
-          (#;Left error))
+          (#R;Error error)
+          (#R;Error error))
 
-        (#;Left error)
-        (#;Left error)
+        (#R;Error error)
+        (#R;Error error)
         )))
   )
 
@@ -62,16 +62,16 @@
   (def: (join ffa)
     (function [context]
       (case (ffa context)
-        (#;Right [context' fa])
+        (#R;Success [context' fa])
         (case (fa context')
-          (#;Right [context'' a])
-          (#;Right [context'' a])
+          (#R;Success [context'' a])
+          (#R;Success [context'' a])
 
-          (#;Left error)
-          (#;Left error))
+          (#R;Error error)
+          (#R;Error error))
 
-        (#;Left error)
-        (#;Left error)
+        (#R;Error error)
+        (#R;Error error)
         )))
   )
 
@@ -121,93 +121,93 @@
 
 ## [[Logic]]
 (def: #export (run context proc)
-  (All [a] (-> Type-Context (Check a) (Error a)))
+  (All [a] (-> Type-Context (Check a) (R;Result a)))
   (case (proc context)
-    (#;Left error)
-    (#;Left error)
+    (#R;Error error)
+    (#R;Error error)
 
-    (#;Right [context' output])
-    (#;Right output)))
+    (#R;Success [context' output])
+    (#R;Success output)))
 
 (def: (apply-type! t-func t-arg)
   (-> Type Type (Check Type))
   (function [context]
     (case (type;apply-type t-func t-arg)
       #;None
-      (#;Left (format "Invalid type application: " (%type t-func) " on " (%type t-arg)))
+      (#R;Error (format "Invalid type application: " (%type t-func) " on " (%type t-arg)))
 
       (#;Some output)
-      (#;Right [context output]))))
+      (#R;Success [context output]))))
 
 (def: #export existential
   {#;doc "A producer of existential types."}
   (Check [Nat Type])
   (function [context]
     (let [id (get@ #;ex-counter context)]
-      (#;Right [(update@ #;ex-counter n.inc context)
-                [id (#;Ex id)]]))))
+      (#R;Success [(update@ #;ex-counter n.inc context)
+                   [id (#;Ex id)]]))))
 
 (def: #export (bound? id)
   (-> Nat (Check Bool))
   (function [context]
     (case (|> context (get@ #;var-bindings) (var::get id))
       (#;Some (#;Some _))
-      (#;Right [context true])
+      (#R;Success [context true])
 
       (#;Some #;None)
-      (#;Right [context false])
+      (#R;Success [context false])
       
       #;None
-      (#;Left (format "Unknown type-var: " (%n id))))))
+      (#R;Error (format "Unknown type-var: " (%n id))))))
 
 (def: #export (read-var id)
   (-> Nat (Check Type))
   (function [context]
     (case (|> context (get@ #;var-bindings) (var::get id))
       (#;Some (#;Some type))
-      (#;Right [context type])
+      (#R;Success [context type])
 
       (#;Some #;None)
-      (#;Left (format "Unbound type-var: " (%n id)))
+      (#R;Error (format "Unbound type-var: " (%n id)))
       
       #;None
-      (#;Left (format "Unknown type-var: " (%n id))))))
+      (#R;Error (format "Unknown type-var: " (%n id))))))
 
 (def: #export (write-var id type)
   (-> Nat Type (Check Unit))
   (function [context]
     (case (|> context (get@ #;var-bindings) (var::get id))
       (#;Some (#;Some bound))
-      (#;Left (format "Cannot rebind type-var: " (%n id) " | Current type: " (%type bound)))
+      (#R;Error (format "Cannot rebind type-var: " (%n id) " | Current type: " (%type bound)))
       
       (#;Some #;None)
-      (#;Right [(update@ #;var-bindings (var::put id (#;Some type)) context)
-                []])
+      (#R;Success [(update@ #;var-bindings (var::put id (#;Some type)) context)
+                   []])
 
       #;None
-      (#;Left (format "Unknown type-var: " (%n id))))))
+      (#R;Error (format "Unknown type-var: " (%n id))))))
 
 (def: (rewrite-var id type)
   (-> Nat Type (Check Unit))
   (function [context]
     (case (|> context (get@ #;var-bindings) (var::get id))
       (#;Some _)
-      (#;Right [(update@ #;var-bindings (var::put id (#;Some type)) context)
-                []])
+      (#R;Success [(update@ #;var-bindings (var::put id (#;Some type)) context)
+                   []])
       
       #;None
-      (#;Left (format "Unknown type-var: " (%n id))))))
+      (#R;Error (format "Unknown type-var: " (%n id))))))
 
 (def: #export (clear-var id)
   (-> Nat (Check Unit))
   (function [context]
     (case (|> context (get@ #;var-bindings) (var::get id))
       (#;Some _)
-      (#;Right [(update@ #;var-bindings (var::put id #;None) context)
-                []])
+      (#R;Success [(update@ #;var-bindings (var::put id #;None) context)
+                   []])
       
       #;None
-      (#;Left (format "Unknown type-var: " (%n id))))))
+      (#R;Error (format "Unknown type-var: " (%n id))))))
 
 (def: #export (clean t-id type)
   (-> Nat Type (Check Type))
@@ -274,22 +274,22 @@
   (Check [Nat Type])
   (function [context]
     (let [id (get@ #;var-counter context)]
-      (#;Right [(|> context
-                    (update@ #;var-counter n.inc)
-                    (update@ #;var-bindings (var::put id #;None)))
-                [id (#;Var id)]]))))
+      (#R;Success [(|> context
+                       (update@ #;var-counter n.inc)
+                       (update@ #;var-bindings (var::put id #;None)))
+                   [id (#;Var id)]]))))
 
 (def: get-bindings
   (Check (List [Nat (Maybe Type)]))
   (function [context]
-    (#;Right [context
-              (get@ #;var-bindings context)])))
+    (#R;Success [context
+                 (get@ #;var-bindings context)])))
 
 (def: (set-bindings value)
   (-> (List [Nat (Maybe Type)]) (Check Unit))
   (function [context]
-    (#;Right [(set@ #;var-bindings value context)
-              []])))
+    (#R;Success [(set@ #;var-bindings value context)
+                 []])))
 
 (def: #export (delete-var id)
   (-> Nat (Check Unit))
@@ -343,16 +343,16 @@
   (All [a] (-> (Check a) (Check (Maybe a))))
   (function [context]
     (case (op context)
-      (#;Right [context' output])
-      (#;Right [context' (#;Some output)])
+      (#R;Success [context' output])
+      (#R;Success [context' (#;Some output)])
 
-      (#;Left _)
-      (#;Right [context #;None]))))
+      (#R;Error _)
+      (#R;Success [context #;None]))))
 
 (def: #export (fail message)
   (All [a] (-> Text (Check a)))
   (function [context]
-    (#;Left message)))
+    (#R;Error message)))
 
 (def: (fail-check expected actual)
   (All [a] (-> Type Type (Check a)))
@@ -363,10 +363,10 @@
   (All [a] (-> (Check a) (Check a) (Check a)))
   (function [context]
     (case (left context)
-      (#;Right [context' output])
-      (#;Right [context' output])
+      (#R;Success [context' output])
+      (#R;Success [context' output])
 
-      (#;Left _)
+      (#R;Error _)
       (right context))))
 
 (def: (fx-get [e a] fixed)
@@ -555,13 +555,13 @@
   {#;doc "A simple type-checking function that just returns a yes/no answer."}
   (-> Type Type Bool)
   (case (run fresh-context (check expected actual))
-    (#;Left error)
+    (#R;Error error)
     false
 
-    (#;Right _)
+    (#R;Success _)
     true))
 
 (def: #export get-context
   (Check Type-Context)
   (function [context]
-    (#;Right [context context])))
+    (#R;Success [context context])))
diff --git a/stdlib/test/test/lux/concurrency/actor.lux b/stdlib/test/test/lux/concurrency/actor.lux
index a4c69a880..a92c2c376 100644
--- a/stdlib/test/test/lux/concurrency/actor.lux
+++ b/stdlib/test/test/lux/concurrency/actor.lux
@@ -4,7 +4,7 @@
        (control monad)
        (data [number]
              text/format
-             [error #- fail])
+             ["R" result])
        (concurrency [promise #+ Promise Monad "Promise/" Monad]
                     ["&" actor #+ actor:]))
   lux/test)
diff --git a/stdlib/test/test/lux/concurrency/frp.lux b/stdlib/test/test/lux/concurrency/frp.lux
index a141753a8..245428f38 100644
--- a/stdlib/test/test/lux/concurrency/frp.lux
+++ b/stdlib/test/test/lux/concurrency/frp.lux
@@ -3,8 +3,7 @@
   (lux [io #- run]
        (control monad)
        (data [number]
-             text/format
-             [error #- fail])
+             text/format)
        (concurrency [promise #+ Promise Monad "Promise/" Monad]
                     ["&" frp]))
   lux/test)
diff --git a/stdlib/test/test/lux/concurrency/promise.lux b/stdlib/test/test/lux/concurrency/promise.lux
index 7ad25fc46..8c4e623e4 100644
--- a/stdlib/test/test/lux/concurrency/promise.lux
+++ b/stdlib/test/test/lux/concurrency/promise.lux
@@ -4,8 +4,7 @@
        (control monad
                 pipe)
        (data [number]
-             text/format
-             [error #- fail])
+             text/format)
        (concurrency ["&" promise])
        ["R" math/random])
   lux/test)
diff --git a/stdlib/test/test/lux/control/exception.lux b/stdlib/test/test/lux/control/exception.lux
index 80267cedd..bef3ae4cd 100644
--- a/stdlib/test/test/lux/control/exception.lux
+++ b/stdlib/test/test/lux/control/exception.lux
@@ -3,7 +3,7 @@
   (lux [io]
        (control monad
                 ["&" exception #+ exception:])
-       (data [error #- fail]
+       (data ["E" result]
              [text]
              text/format
              [number])
@@ -36,7 +36,7 @@
                         another-val)
                       otherwise-val)
                     default-val)
-         actual (|> (: (Error Nat)
+         actual (|> (: (E;Result Nat)
                        (if should-throw?
                          (&;throw this-ex "Uh-oh...")
                          (&;return default-val)))
diff --git a/stdlib/test/test/lux/data/error.lux b/stdlib/test/test/lux/data/error.lux
deleted file mode 100644
index d90387c89..000000000
--- a/stdlib/test/test/lux/data/error.lux
+++ /dev/null
@@ -1,56 +0,0 @@
-(;module:
-  lux
-  (lux [io]
-       (control monad
-                pipe)
-       (data text/format
-             ["&" error]))
-  lux/test)
-
-(test: "Errors"
-  (let [(^open "&/") &;Monad]
-    ($_ seq
-        (assert "Functor correctly handles both cases."
-                (and (|> (: (&;Error Int) (#&;Success 10))
-                         (&/map i.inc)
-                         (case> (#&;Success 11) true _ false))
-
-                     (|> (: (&;Error Int) (#&;Error "YOLO"))
-                         (&/map i.inc)
-                         (case> (#&;Error "YOLO") true _ false))
-                     ))
-        
-        (assert "Applicative correctly handles both cases."
-                (and (|> (&/wrap 20)
-                         (case> (#&;Success 20) true _ false))
-                     (|> (&/apply (&/wrap i.inc) (&/wrap 10))
-                         (case> (#&;Success 11) true _ false))
-                     (|> (&/apply (&/wrap i.inc) (#&;Error "YOLO"))
-                         (case> (#&;Error "YOLO") true _ false))))
-        
-        (assert "Monad correctly handles both cases."
-                (and (|> (do &;Monad
-                           [f (wrap i.+)
-                            a (wrap 10)
-                            b (wrap 20)]
-                           (wrap (f a b)))
-                         (case> (#&;Success 30) true _ false))
-                     (|> (do &;Monad
-                           [f (wrap i.+)
-                            a (#&;Error "YOLO")
-                            b (wrap 20)]
-                           (wrap (f a b)))
-                         (case> (#&;Error "YOLO") true _ false))
-                     ))
-        )))
-
-(test: "Monad transformer"
-  (let [lift (&;lift-error io;Monad)
-        (^open "io/") io;Monad]
-    (assert "Can add error functionality to any monad."
-            (|> (io;run (do (&;ErrorT io;Monad)
-                          [a (lift (io/wrap 123))
-                           b (wrap 456)]
-                          (wrap (i.+ a b))))
-                (case> (#&;Success 579) true
-                       _ false)))))
diff --git a/stdlib/test/test/lux/data/format/json.lux b/stdlib/test/test/lux/data/format/json.lux
index 7acddf750..b52b72635 100644
--- a/stdlib/test/test/lux/data/format/json.lux
+++ b/stdlib/test/test/lux/data/format/json.lux
@@ -7,7 +7,7 @@
                 pipe)
        (data [text "Text/" Monoid]
              text/format
-             [error #- fail]
+             [result]
              [bool]
              [char]
              [maybe]
diff --git a/stdlib/test/test/lux/data/result.lux b/stdlib/test/test/lux/data/result.lux
new file mode 100644
index 000000000..aee931279
--- /dev/null
+++ b/stdlib/test/test/lux/data/result.lux
@@ -0,0 +1,56 @@
+(;module:
+  lux
+  (lux [io]
+       (control monad
+                pipe)
+       (data text/format
+             ["&" result]))
+  lux/test)
+
+(test: "Results"
+  (let [(^open "&/") &;Monad]
+    ($_ seq
+        (assert "Functor correctly handles both cases."
+                (and (|> (: (&;Result Int) (#&;Success 10))
+                         (&/map i.inc)
+                         (case> (#&;Success 11) true _ false))
+
+                     (|> (: (&;Result Int) (#&;Error "YOLO"))
+                         (&/map i.inc)
+                         (case> (#&;Error "YOLO") true _ false))
+                     ))
+        
+        (assert "Applicative correctly handles both cases."
+                (and (|> (&/wrap 20)
+                         (case> (#&;Success 20) true _ false))
+                     (|> (&/apply (&/wrap i.inc) (&/wrap 10))
+                         (case> (#&;Success 11) true _ false))
+                     (|> (&/apply (&/wrap i.inc) (#&;Error "YOLO"))
+                         (case> (#&;Error "YOLO") true _ false))))
+        
+        (assert "Monad correctly handles both cases."
+                (and (|> (do &;Monad
+                           [f (wrap i.+)
+                            a (wrap 10)
+                            b (wrap 20)]
+                           (wrap (f a b)))
+                         (case> (#&;Success 30) true _ false))
+                     (|> (do &;Monad
+                           [f (wrap i.+)
+                            a (#&;Error "YOLO")
+                            b (wrap 20)]
+                           (wrap (f a b)))
+                         (case> (#&;Error "YOLO") true _ false))
+                     ))
+        )))
+
+(test: "Monad transformer"
+  (let [lift (&;lift-result io;Monad)
+        (^open "io/") io;Monad]
+    (assert "Can add result functionality to any monad."
+            (|> (io;run (do (&;ResultT io;Monad)
+                          [a (lift (io/wrap 123))
+                           b (wrap 456)]
+                          (wrap (i.+ a b))))
+                (case> (#&;Success 579) true
+                       _ false)))))
diff --git a/stdlib/test/test/lux/data/text/lexer.lux b/stdlib/test/test/lux/data/text/lexer.lux
index 8a63cf573..f9b6bdc79 100644
--- a/stdlib/test/test/lux/data/text/lexer.lux
+++ b/stdlib/test/test/lux/data/text/lexer.lux
@@ -3,7 +3,7 @@
   (lux (control monad
                 pipe)
        [io]
-       (data [error #- fail]
+       (data ["E" result]
              [text "T/" Eq]
              text/format
              ["&" text/lexer]
@@ -14,13 +14,13 @@
 
 ## [Utils]
 (def: (should-fail input)
-  (All [a] (-> (Error a) Bool))
+  (All [a] (-> (E;Result a) Bool))
   (case input
     (#;Left _) true
     _          false))
 
 (def: (should-passC test input)
-  (-> Char (Error Char) Bool)
+  (-> Char (E;Result Char) Bool)
   (case input
     (#;Right output)
     (C/= test output)
@@ -29,7 +29,7 @@
     false))
 
 (def: (should-passT test input)
-  (-> Text (Error Text) Bool)
+  (-> Text (E;Result Text) Bool)
   (case input
     (#;Right output)
     (T/= test output)
@@ -38,7 +38,7 @@
     false))
 
 (def: (should-passL test input)
-  (-> (List Char) (Error (List Char)) Bool)
+  (-> (List Char) (E;Result (List Char)) Bool)
   (let [(^open "L/") (list;Eq char;Eq)]
     (case input
       (#;Right output)
@@ -48,7 +48,7 @@
       false)))
 
 (def: (should-passE test input)
-  (-> (Either Char Char) (Error (Either Char Char)) Bool)
+  (-> (Either Char Char) (E;Result (Either Char Char)) Bool)
   (case input
     (#;Right output)
     (case [test output]
diff --git a/stdlib/test/test/lux/data/text/regex.lux b/stdlib/test/test/lux/data/text/regex.lux
index 62953b20b..e4cfa2e10 100644
--- a/stdlib/test/test/lux/data/text/regex.lux
+++ b/stdlib/test/test/lux/data/text/regex.lux
@@ -3,8 +3,7 @@
   (lux [io]
        (control monad
                 pipe)
-       (data [error #- fail]
-             [product]
+       (data [product]
              [text "T/" Eq]
              text/format
              (text [lexer]
diff --git a/stdlib/test/test/lux/macro/syntax.lux b/stdlib/test/test/lux/macro/syntax.lux
index f75a7117e..0badc67f3 100644
--- a/stdlib/test/test/lux/macro/syntax.lux
+++ b/stdlib/test/test/lux/macro/syntax.lux
@@ -9,7 +9,7 @@
              [bool]
              [char]
              [ident]
-             [error #- fail])
+             ["E" result])
        ["R" math/random]
        [macro]
        (macro [code]
@@ -45,7 +45,7 @@
     false))
 
 (def: (fails? input)
-  (All [a] (-> (Error a) Bool))
+  (All [a] (-> (E;Result a) Bool))
   (case input
     (#;Left _)
     true
diff --git a/stdlib/test/tests.lux b/stdlib/test/tests.lux
index b3eaeb22c..b55373330 100644
--- a/stdlib/test/tests.lux
+++ b/stdlib/test/tests.lux
@@ -25,7 +25,7 @@
              (data ["_;" bit]
                    ["_;" bool]
                    ["_;" char]
-                   ["_;" error]
+                   ["_;" result]
                    ["_;" ident]
                    ["_;" identity]
                    ["_;" log]
-- 
cgit v1.2.3