From fecfb6c1dd653e491e541233395ea4a7d8ae7409 Mon Sep 17 00:00:00 2001 From: Eduardo Julian Date: Mon, 16 Oct 2017 19:28:04 -0400 Subject: - Re-named "Result" type back to "Error". --- stdlib/source/lux/cli.lux | 48 ++++---- stdlib/source/lux/concurrency/task.lux | 30 ++--- stdlib/source/lux/control/codec.lux | 6 +- stdlib/source/lux/control/exception.lux | 36 +++--- stdlib/source/lux/control/parser.lux | 92 ++++++++-------- stdlib/source/lux/data/coll/tree/parser.lux | 18 +-- stdlib/source/lux/data/error.lux | 98 +++++++++++++++++ stdlib/source/lux/data/format/context.lux | 12 +- stdlib/source/lux/data/format/json.lux | 74 ++++++------- stdlib/source/lux/data/format/xml.lux | 26 ++--- stdlib/source/lux/data/number.lux | 74 ++++++------- stdlib/source/lux/data/number/complex.lux | 4 +- stdlib/source/lux/data/number/ratio.lux | 6 +- stdlib/source/lux/data/result.lux | 98 ----------------- stdlib/source/lux/data/text/lexer.lux | 68 ++++++------ stdlib/source/lux/data/text/regex.lux | 40 +++---- stdlib/source/lux/macro.lux | 102 ++++++++--------- stdlib/source/lux/macro/poly.lux | 54 ++++----- stdlib/source/lux/macro/poly/json.lux | 6 +- stdlib/source/lux/macro/syntax.lux | 74 ++++++------- stdlib/source/lux/test.lux | 24 ++-- stdlib/source/lux/time/date.lux | 4 +- stdlib/source/lux/time/duration.lux | 4 +- stdlib/source/lux/time/instant.lux | 4 +- stdlib/source/lux/type/check.lux | 164 ++++++++++++++-------------- stdlib/source/lux/type/opaque.lux | 6 +- stdlib/source/lux/world/blob.jvm.lux | 40 +++---- stdlib/source/lux/world/file.lux | 12 +- stdlib/source/lux/world/net/tcp.jvm.lux | 22 ++-- stdlib/source/lux/world/net/udp.jvm.lux | 16 +-- 30 files changed, 631 insertions(+), 631 deletions(-) create mode 100644 stdlib/source/lux/data/error.lux delete mode 100644 stdlib/source/lux/data/result.lux (limited to 'stdlib/source') diff --git a/stdlib/source/lux/cli.lux b/stdlib/source/lux/cli.lux index ba0689e89..ef8b05e41 100644 --- a/stdlib/source/lux/cli.lux +++ b/stdlib/source/lux/cli.lux @@ -5,7 +5,7 @@ (data (coll [list "L/" Monoid Monad]) [text "T/" Monoid] text/format - ["R" result] + ["E" error] [sum]) [io] [macro #+ with-gensyms Functor Monad] @@ -19,18 +19,18 @@ ## [Combinators] (def: #export (run inputs parser) - (All [a] (-> (List Text) (CLI a) (R;Result a))) + (All [a] (-> (List Text) (CLI a) (E;Error a))) (case (p;run inputs parser) - (#R;Success [remaining output]) + (#E;Success [remaining output]) (case remaining #;Nil - (#R;Success output) + (#E;Success output) _ - (#R;Error (format "Remaining CLI inputs: " (text;join-with " " remaining)))) + (#E;Error (format "Remaining CLI inputs: " (text;join-with " " remaining)))) - (#R;Error error) - (#R;Error error))) + (#E;Error error) + (#E;Error error))) (def: #export any {#;doc "Just returns the next input without applying any logic."} @@ -38,26 +38,26 @@ (function [inputs] (case inputs (#;Cons arg inputs') - (#R;Success [inputs' arg]) + (#E;Success [inputs' arg]) _ - (#R;Error "Cannot parse empty arguments.")))) + (#E;Error "Cannot parse empty arguments.")))) (def: #export (parse parser) {#;doc "Parses the next input with a parsing function."} - (All [a] (-> (-> Text (R;Result a)) (CLI a))) + (All [a] (-> (-> Text (E;Error a)) (CLI a))) (function [inputs] (case inputs (#;Cons arg inputs') (case (parser arg) - (#R;Success value) - (#R;Success [inputs' value]) + (#E;Success value) + (#E;Success [inputs' value]) - (#R;Error parser-error) - (#R;Error parser-error)) + (#E;Error parser-error) + (#E;Error parser-error)) _ - (#R;Error "Cannot parse empty arguments.")))) + (#E;Error "Cannot parse empty arguments.")))) (def: #export (option names) {#;doc "Checks that a given option (with multiple possible names) has a value."} @@ -66,13 +66,13 @@ (let [[pre post] (list;split-with (. ;not (list;member? text;Eq names)) inputs)] (case post #;Nil - (#R;Error ($_ T/compose "Missing option (" (text;join-with " " names) ")")) + (#E;Error ($_ T/compose "Missing option (" (text;join-with " " names) ")")) (^ (list& _ value post')) - (#R;Success [(L/compose pre post') value]) + (#E;Success [(L/compose pre post') value]) _ - (#R;Error ($_ T/compose "Option lacks value (" (text;join-with " " names) ")")) + (#E;Error ($_ T/compose "Option lacks value (" (text;join-with " " names) ")")) )))) (def: #export (flag names) @@ -82,18 +82,18 @@ (let [[pre post] (list;split-with (. ;not (list;member? text;Eq names)) inputs)] (case post #;Nil - (#R;Success [pre false]) + (#E;Success [pre false]) (#;Cons _ post') - (#R;Success [(L/compose pre post') true]))))) + (#E;Success [(L/compose pre post') true]))))) (def: #export end {#;doc "Ensures there are no more inputs."} (CLI Unit) (function [inputs] (case inputs - #;Nil (#R;Success [inputs []]) - _ (#R;Error (T/compose "Unknown parameters: " (text;join-with " " inputs)))))) + #;Nil (#E;Success [inputs []]) + _ (#E;Error (T/compose "Unknown parameters: " (text;join-with " " inputs)))))) ## [Syntax] (type: Program-Args @@ -145,10 +145,10 @@ [] (~ body))))) (~ g!args)) - (#R;Success [(~ g!_) (~ g!output)]) + (#E;Success [(~ g!_) (~ g!output)]) (~ g!output) - (#R;Error (~ g!message)) + (#E;Error (~ g!message)) (error! (~ g!message)) ))) ))) diff --git a/stdlib/source/lux/concurrency/task.lux b/stdlib/source/lux/concurrency/task.lux index 4be7ead9d..374acee46 100644 --- a/stdlib/source/lux/concurrency/task.lux +++ b/stdlib/source/lux/concurrency/task.lux @@ -1,6 +1,6 @@ (;module: lux - (lux (data ["R" result]) + (lux (data ["E" error]) (control ["F" functor] ["A" applicative] monad @@ -11,11 +11,11 @@ )) (type: #export (Task a) - (P;Promise (R;Result a))) + (P;Promise (E;Error a))) (def: #export (fail error) (All [a] (-> Text (Task a))) - (:: P;Applicative wrap (#R;Error error))) + (:: P;Applicative wrap (#E;Error error))) (def: #export (throw exception message) (All [a] (-> Exception Text (Task a))) @@ -23,22 +23,22 @@ (def: #export (return value) (All [a] (-> a (Task a))) - (:: P;Applicative wrap (#R;Success value))) + (:: P;Applicative wrap (#E;Success value))) (def: #export (try computation) - (All [a] (-> (Task a) (Task (R;Result a)))) - (:: P;Functor map (|>. #R;Success) computation)) + (All [a] (-> (Task a) (Task (E;Error a)))) + (:: P;Functor map (|>. #E;Success) computation)) (struct: #export _ (F;Functor Task) (def: (map f fa) (:: P;Functor map (function [fa'] (case fa' - (#R;Error error) - (#R;Error error) + (#E;Error error) + (#E;Error error) - (#R;Success a) - (#R;Success (f a)))) + (#E;Success a) + (#E;Success (f a)))) fa))) (struct: #export _ (A;Applicative Task) @@ -50,7 +50,7 @@ (do P;Monad [ff' ff fa' fa] - (wrap (do R;Monad + (wrap (do E;Monad [f ff' a fa'] (wrap (f a))))))) @@ -62,10 +62,10 @@ (do P;Monad [mma' mma] (case mma' - (#R;Error error) - (wrap (#R;Error error)) + (#E;Error error) + (wrap (#E;Error error)) - (#R;Success ma) + (#E;Success ma) ma)))) (syntax: #export (task [type s;any]) @@ -76,4 +76,4 @@ (def: #export (from-promise promise) (All [a] (-> (P;Promise a) (Task a))) - (:: P;Functor map (|>. #R;Success) promise)) + (:: P;Functor map (|>. #E;Success) promise)) diff --git a/stdlib/source/lux/control/codec.lux b/stdlib/source/lux/control/codec.lux index e11f08016..55095ee3c 100644 --- a/stdlib/source/lux/control/codec.lux +++ b/stdlib/source/lux/control/codec.lux @@ -1,14 +1,14 @@ (;module: lux (lux (control monad) - (data ["R" result]))) + (data ["E" error]))) ## [Signatures] (sig: #export (Codec m a) {#;doc "A way to move back-and-forth between a type and an alternative representation for it."} (: (-> a m) encode) - (: (-> m (R;Result a)) + (: (-> m (E;Error a)) decode)) ## [Values] @@ -22,7 +22,7 @@ (:: Codec encode))) (def: (decode cy) - (do R;Monad + (do E;Monad [by (:: Codec decode cy)] (:: Codec decode by))) ) diff --git a/stdlib/source/lux/control/exception.lux b/stdlib/source/lux/control/exception.lux index fda8103f2..b8be7b70d 100644 --- a/stdlib/source/lux/control/exception.lux +++ b/stdlib/source/lux/control/exception.lux @@ -1,7 +1,7 @@ -(;module: {#;doc "Exception-handling functionality built on top of the Result type."} +(;module: {#;doc "Exception-handling functionality built on top of the Error type."} lux (lux (control monad) - (data ["R" result] + (data ["E" error] [maybe] [text "text/" Monoid]) [macro] @@ -30,41 +30,41 @@ If no exception was detected, or a different one from the one being checked, then pass along the original value."} (All [a] - (-> Exception (-> Text a) (R;Result a) - (R;Result a))) + (-> Exception (-> Text a) (E;Error a) + (E;Error a))) (case try - (#R;Success output) - (#R;Success output) + (#E;Success output) + (#E;Success output) - (#R;Error error) + (#E;Error error) (let [reference (exception "")] (if (text;starts-with? reference error) - (#R;Success (|> error + (#E;Success (|> error (text;clip (text;size reference) (text;size error)) maybe;assume then)) - (#R;Error error))))) + (#E;Error error))))) (def: #export (otherwise to-do try) {#;doc "If no handler could be found to catch the exception, then run a function as a last-resort measure."} (All [a] - (-> (-> Text a) (R;Result a) a)) + (-> (-> Text a) (E;Error a) a)) (case try - (#R;Success output) + (#E;Success output) output - (#R;Error error) + (#E;Error error) (to-do error))) (def: #export (return value) - {#;doc "A way to lift normal values into the result-handling context."} - (All [a] (-> a (R;Result a))) - (#R;Success value)) + {#;doc "A way to lift normal values into the error-handling context."} + (All [a] (-> a (E;Error a))) + (#E;Success value)) (def: #export (throw exception message) - {#;doc "Decorate an error message with an Exception and lift it into the result-handling context."} - (All [a] (-> Exception Text (R;Result a))) - (#R;Error (exception message))) + {#;doc "Decorate an error message with an Exception and lift it into the error-handling context."} + (All [a] (-> Exception Text (E;Error a))) + (#E;Error (exception message))) (syntax: #export (exception: [_ex-lev csr;export] [name s;local-symbol]) {#;doc (doc "Define a new exception type." diff --git a/stdlib/source/lux/control/parser.lux b/stdlib/source/lux/control/parser.lux index 606d8d448..166826519 100644 --- a/stdlib/source/lux/control/parser.lux +++ b/stdlib/source/lux/control/parser.lux @@ -6,43 +6,43 @@ [codec]) (data (coll [list "list/" Functor Monoid]) [product] - ["R" result]))) + ["E" error]))) (type: #export (Parser s a) {#;doc "A generic parser."} - (-> s (R;Result [s a]))) + (-> s (E;Error [s a]))) ## [Structures] (struct: #export Functor (All [s] (Functor (Parser s))) (def: (map f ma) (function [input] (case (ma input) - (#R;Error msg) - (#R;Error msg) + (#E;Error msg) + (#E;Error msg) - (#R;Success [input' a]) - (#R;Success [input' (f a)]))))) + (#E;Success [input' a]) + (#E;Success [input' (f a)]))))) (struct: #export Applicative (All [s] (Applicative (Parser s))) (def: functor Functor) (def: (wrap x) (function [input] - (#R;Success [input x]))) + (#E;Success [input x]))) (def: (apply ff fa) (function [input] (case (ff input) - (#R;Success [input' f]) + (#E;Success [input' f]) (case (fa input') - (#R;Success [input'' a]) - (#R;Success [input'' (f a)]) + (#E;Success [input'' a]) + (#E;Success [input'' (f a)]) - (#R;Error msg) - (#R;Error msg)) + (#E;Error msg) + (#E;Error msg)) - (#R;Error msg) - (#R;Error msg))))) + (#E;Error msg) + (#E;Error msg))))) (struct: #export Monad (All [s] (Monad (Parser s))) (def: applicative Applicative) @@ -50,10 +50,10 @@ (def: (join mma) (function [input] (case (mma input) - (#R;Error msg) - (#R;Error msg) + (#E;Error msg) + (#E;Error msg) - (#R;Success [input' ma]) + (#E;Success [input' ma]) (ma input'))))) ## [Parsers] @@ -62,8 +62,8 @@ (All [s] (-> Text Bool (Parser s Unit))) (function [input] (if test - (#R;Success [input []]) - (#R;Error message)))) + (#E;Success [input []]) + (#E;Error message)))) (def: #export (maybe p) {#;doc "Optionality combinator."} @@ -71,12 +71,12 @@ (-> (Parser s a) (Parser s (Maybe a)))) (function [input] (case (p input) - (#R;Error _) (#R;Success [input #;None]) - (#R;Success [input' x]) (#R;Success [input' (#;Some x)])))) + (#E;Error _) (#E;Success [input #;None]) + (#E;Success [input' x]) (#E;Success [input' (#;Some x)])))) (def: #export (run input p) (All [s a] - (-> s (Parser s a) (R;Result [s a]))) + (-> s (Parser s a) (E;Error [s a]))) (p input)) (def: #export (some p) @@ -85,8 +85,8 @@ (-> (Parser s a) (Parser s (List a)))) (function [input] (case (p input) - (#R;Error _) (#R;Success [input (list)]) - (#R;Success [input' x]) (run input' + (#E;Error _) (#E;Success [input (list)]) + (#E;Success [input' x]) (run input' (do Monad [xs (some p)] (wrap (list& x xs))) @@ -116,8 +116,8 @@ (-> (Parser s a) (Parser s b) (Parser s (| a b)))) (function [tokens] (case (p1 tokens) - (#R;Success [tokens' x1]) (#R;Success [tokens' (+0 x1)]) - (#R;Error _) (run tokens + (#E;Success [tokens' x1]) (#E;Success [tokens' (+0 x1)]) + (#E;Error _) (run tokens (do Monad [x2 p2] (wrap (+1 x2)))) @@ -129,7 +129,7 @@ (-> (Parser s a) (Parser s a) (Parser s a))) (function [tokens] (case (pl tokens) - (#R;Error _) (pr tokens) + (#E;Error _) (pr tokens) output output ))) @@ -157,10 +157,10 @@ (if (n.> +0 n) (function [input] (case (p input) - (#R;Error msg) - (#R;Success [input (list)]) + (#E;Error msg) + (#E;Success [input (list)]) - (#R;Success [input' x]) + (#E;Success [input' x]) (run input' (do Monad [xs (at-most (n.dec n) p)] @@ -195,32 +195,32 @@ (All [s a] (-> (Parser s a) (Parser s Unit))) (function [input] (case (p input) - (#R;Error msg) - (#R;Success [input []]) + (#E;Error msg) + (#E;Success [input []]) _ - (#R;Error "Expected to fail; yet succeeded.")))) + (#E;Error "Expected to fail; yet succeeded.")))) (def: #export (fail message) (All [s a] (-> Text (Parser s a))) (function [input] - (#R;Error message))) + (#E;Error message))) (def: #export (default value parser) {#;doc "If the given parser fails, returns the default value."} (All [s a] (-> a (Parser s a) (Parser s a))) (function [input] (case (parser input) - (#R;Error error) - (#R;Success [input value]) + (#E;Error error) + (#E;Success [input value]) - (#R;Success [input' output]) - (#R;Success [input' output])))) + (#E;Success [input' output]) + (#E;Success [input' output])))) (def: #export remaining (All [s] (Parser s s)) (function [inputs] - (#R;Success [inputs inputs]))) + (#E;Success [inputs inputs]))) (def: #export (rec parser) {#;doc "Combinator for recursive parser."} @@ -252,13 +252,13 @@ (All [s a z] (-> (codec;Codec a z) (Parser s a) (Parser s z))) (function [input] (case (parser input) - (#R;Error error) - (#R;Error error) + (#E;Error error) + (#E;Error error) - (#R;Success [input' to-decode]) + (#E;Success [input' to-decode]) (case (:: Codec decode to-decode) - (#R;Error error) - (#R;Error error) + (#E;Error error) + (#E;Error error) - (#R;Success value) - (#R;Success [input' value]))))) + (#E;Success value) + (#E;Success [input' value]))))) diff --git a/stdlib/source/lux/data/coll/tree/parser.lux b/stdlib/source/lux/data/coll/tree/parser.lux index 203f55b16..3b2400b92 100644 --- a/stdlib/source/lux/data/coll/tree/parser.lux +++ b/stdlib/source/lux/data/coll/tree/parser.lux @@ -2,7 +2,7 @@ lux (lux (control ["p" parser] ["ex" exception #+ exception:]) - (data ["R" result])) + (data ["E" error])) (.. ["T" rose] ["Z" zipper])) @@ -10,22 +10,22 @@ (p;Parser (Z;Zipper t) a)) (def: #export (run-zipper zipper parser) - (All [t a] (-> (Z;Zipper t) (Parser t a) (R;Result a))) + (All [t a] (-> (Z;Zipper t) (Parser t a) (E;Error a))) (case (p;run zipper parser) - (#R;Success [zipper output]) - (#R;Success output) + (#E;Success [zipper output]) + (#E;Success output) - (#R;Error error) - (#R;Error error))) + (#E;Error error) + (#E;Error error))) (def: #export (run tree parser) - (All [t a] (-> (T;Tree t) (Parser t a) (R;Result a))) + (All [t a] (-> (T;Tree t) (Parser t a) (E;Error a))) (run-zipper (Z;zip tree) parser)) (def: #export value (All [t] (Parser t t)) (function [zipper] - (#R;Success [zipper (Z;value zipper)]))) + (#E;Success [zipper (Z;value zipper)]))) (exception: #export Cannot-Move-Further) @@ -36,7 +36,7 @@ (let [next ( zipper)] (if (is zipper next) (ex;throw Cannot-Move-Further "") - (#R;Success [next []])))))] + (#E;Success [next []])))))] [up Z;up] [down Z;down] diff --git a/stdlib/source/lux/data/error.lux b/stdlib/source/lux/data/error.lux new file mode 100644 index 000000000..e433d7454 --- /dev/null +++ b/stdlib/source/lux/data/error.lux @@ -0,0 +1,98 @@ +(;module: + lux + (lux (control ["F" functor] + ["A" applicative] + ["M" monad #+ do Monad]))) + +## [Types] +(type: #export (Error a) + (#Error Text) + (#Success a)) + +## [Structures] +(struct: #export _ (F;Functor Error) + (def: (map f ma) + (case ma + (#Error msg) (#Error msg) + (#Success datum) (#Success (f datum))))) + +(struct: #export _ (A;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 (A;compose (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 Monad) + (All [M a] (-> (Monad M) (-> (M a) (M (Error a))))) + (M;lift 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)) + +(def: #export (assume error) + (All [a] (-> (Error a) a)) + (case error + (#Success value) + value + + (#Error message) + (error! message))) + +(macro: #export (default tokens compiler) + {#;doc (doc "Allows you to provide a default value that will be used" + "if a (Error x) value turns out to be #Error." + (is 10 + (default 20 (#Success 10))) + (is 20 + (default 20 (#Error "KABOOM!"))))} + (case tokens + (^ (list else error)) + (#Success [compiler (list (` (case (~ error) + (#;;Success (~' g!temp)) + (~' g!temp) + + (#;;Error (~ [dummy-cursor (#;Symbol ["" ""])])) + (~ else))))]) + + _ + (#Error "Wrong syntax for default"))) diff --git a/stdlib/source/lux/data/format/context.lux b/stdlib/source/lux/data/format/context.lux index a515052c6..5f0d29b11 100644 --- a/stdlib/source/lux/data/format/context.lux +++ b/stdlib/source/lux/data/format/context.lux @@ -3,7 +3,7 @@ (lux (control ["p" parser] ["ex" exception #+ exception:] [monad #+ do]) - (data ["R" result] + (data ["E" error] (coll ["d" dict])))) (exception: #export Unknown-Property) @@ -25,10 +25,10 @@ (ex;throw Unknown-Property name)))) (def: #export (run context property) - (All [a] (-> Context (Property a) (R;Result a))) + (All [a] (-> Context (Property a) (E;Error a))) (case (property context) - (#R;Success [_ output]) - (#R;Success output) + (#E;Success [_ output]) + (#E;Success output) - (#R;Error error) - (#R;Error error))) + (#E;Error error) + (#E;Error error))) diff --git a/stdlib/source/lux/data/format/json.lux b/stdlib/source/lux/data/format/json.lux index 867cec189..7eac167e1 100644 --- a/stdlib/source/lux/data/format/json.lux +++ b/stdlib/source/lux/data/format/json.lux @@ -11,7 +11,7 @@ (text ["l" lexer]) [number "frac/" Codec "nat/" Codec] [maybe] - ["R" result] + ["E" error] [sum] [product] (coll [list "list/" Fold Monad] @@ -96,52 +96,52 @@ (def: #export (get-fields json) {#;doc "Get all the fields in a JSON object."} - (-> JSON (R;Result (List String))) + (-> JSON (E;Error (List String))) (case json (#Object obj) - (#R;Success (dict;keys obj)) + (#E;Success (dict;keys obj)) _ - (#R;Error ($_ text/compose "Cannot get the fields of a non-object.")))) + (#E;Error ($_ text/compose "Cannot get the fields of a non-object.")))) (def: #export (get key json) {#;doc "A JSON object field getter."} - (-> String JSON (R;Result JSON)) + (-> String JSON (E;Error JSON)) (case json (#Object obj) (case (dict;get key obj) (#;Some value) - (#R;Success value) + (#E;Success value) #;None - (#R;Error ($_ text/compose "Missing field \"" key "\" on object."))) + (#E;Error ($_ text/compose "Missing field \"" key "\" on object."))) _ - (#R;Error ($_ text/compose "Cannot get field \"" key "\" of a non-object.")))) + (#E;Error ($_ text/compose "Cannot get field \"" key "\" of a non-object.")))) (def: #export (set key value json) {#;doc "A JSON object field setter."} - (-> String JSON JSON (R;Result JSON)) + (-> String JSON JSON (E;Error JSON)) (case json (#Object obj) - (#R;Success (#Object (dict;put key value obj))) + (#E;Success (#Object (dict;put key value obj))) _ - (#R;Error ($_ text/compose "Cannot set field \"" key "\" of a non-object.")))) + (#E;Error ($_ text/compose "Cannot set field \"" key "\" of a non-object.")))) (do-template [ ] [(def: #export ( key json) {#;doc (code;text ($_ text/compose "A JSON object field getter for " "."))} - (-> Text JSON (R;Result )) + (-> Text JSON (E;Error )) (case (get key json) - (#R;Success ( value)) - (#R;Success value) + (#E;Success ( value)) + (#E;Success value) - (#R;Success _) - (#R;Error ($_ text/compose "Wrong value type at key: " key)) + (#E;Success _) + (#E;Error ($_ text/compose "Wrong value type at key: " key)) - (#R;Error error) - (#R;Error error)))] + (#E;Error error) + (#E;Error error)))] [get-boolean #Boolean Boolean "booleans"] [get-number #Number Number "numbers"] @@ -195,23 +195,23 @@ (def: unconsumed-input-error Text "Unconsumed JSON.") (def: #export (run json parser) - (All [a] (-> JSON (Reader a) (R;Result a))) + (All [a] (-> JSON (Reader a) (E;Error a))) (case (p;run (list json) parser) - (#R;Success [remainder output]) + (#E;Success [remainder output]) (case remainder #;Nil - (#R;Success output) + (#E;Success output) _ - (#R;Error unconsumed-input-error)) + (#E;Error unconsumed-input-error)) - (#R;Error error) - (#R;Error error))) + (#E;Error error) + (#E;Error error))) (def: #export (fail error) (All [a] (-> Text (Reader a))) (function [inputs] - (#R;Error error))) + (#E;Error error))) (def: #export any {#;doc "Just returns the JSON input without applying any logic."} @@ -219,10 +219,10 @@ (<| (function [inputs]) (case inputs #;Nil - (#R;Error "Empty JSON stream.") + (#E;Error "Empty JSON stream.") (#;Cons head tail) - (#R;Success [tail head])))) + (#E;Success [tail head])))) (do-template [ ] [(def: #export @@ -289,10 +289,10 @@ (case head (#Array values) (case (p;run (vector;to-list values) parser) - (#R;Error error) + (#E;Error error) (fail error) - (#R;Success [remainder output]) + (#E;Success [remainder output]) (case remainder #;Nil (wrap output) @@ -310,7 +310,7 @@ [head any] (case head (#Object object) - (case (do R;Monad + (case (do E;Monad [] (|> (dict;entries object) (monad;map @ (function [[key val]] @@ -318,10 +318,10 @@ [val (run val parser)] (wrap [key val])))) (:: @ map (dict;from-list text;Hash)))) - (#R;Success table) + (#E;Success table) (wrap table) - (#R;Error error) + (#E;Error error) (fail error)) _ @@ -337,13 +337,13 @@ (case (dict;get field-name object) (#;Some value) (case (run value parser) - (#R;Success output) + (#E;Success output) (function [tail] - (#R;Success [(#;Cons (#Object (dict;remove field-name object)) + (#E;Success [(#;Cons (#Object (dict;remove field-name object)) tail) output])) - (#R;Error error) + (#E;Error error) (fail error)) _ @@ -438,10 +438,10 @@ offset (l;many l;decimal)] (wrap ($_ text/compose mark (if signed?' "-" "") offset))))] (case (frac/decode ($_ text/compose (if signed? "-" "") digits "." decimals exp)) - (#R;Error message) + (#E;Error message) (p;fail message) - (#R;Success value) + (#E;Success value) (wrap value)))) (def: escaped~ diff --git a/stdlib/source/lux/data/format/xml.lux b/stdlib/source/lux/data/format/xml.lux index 2be7afdd3..f2d1eb056 100644 --- a/stdlib/source/lux/data/format/xml.lux +++ b/stdlib/source/lux/data/format/xml.lux @@ -8,7 +8,7 @@ (data [text "text/" Eq Monoid] (text ["l" lexer]) [number] - ["R" result] + ["E" error] [product] [maybe "m/" Monad] [ident "ident/" Eq Codec] @@ -170,7 +170,7 @@ (p;after (p;maybe xml-header^)))) (def: #export (read input) - (-> Text (R;Result XML)) + (-> Text (E;Error XML)) (l;run input xml^)) (def: (sanitize-value input) @@ -262,7 +262,7 @@ (#;Cons head tail) (case head (#Text value) - (#R;Success [tail value]) + (#E;Success [tail value]) (#Node _) (ex;throw Unexpected-Input ""))))) @@ -285,20 +285,20 @@ (ex;throw Unknown-Attribute "") (#;Some value) - (#R;Success [docs value])))))) + (#E;Success [docs value])))))) (def: (run' docs reader) - (All [a] (-> (List XML) (Reader a) (R;Result a))) + (All [a] (-> (List XML) (Reader a) (E;Error a))) (case (p;run docs reader) - (#R;Success [remaining output]) + (#E;Success [remaining output]) (if (list;empty? remaining) - (#R;Success output) + (#E;Success output) (ex;throw Unconsumed-Inputs (|> remaining (L/map (:: Codec encode)) (text;join-with "\n\n")))) - (#R;Error error) - (#R;Error error))) + (#E;Error error) + (#E;Error error))) (def: #export (node tag) (-> Ident (Reader Unit)) @@ -314,7 +314,7 @@ (#Node _tag _attrs _children) (if (ident/= tag _tag) - (#R;Success [docs []]) + (#E;Success [docs []]) (ex;throw Wrong-Tag (ident/encode tag))))))) (def: #export (children reader) @@ -330,7 +330,7 @@ (ex;throw Unexpected-Input "") (#Node _tag _attrs _children) - (do R;Monad + (do E;Monad [output (run' _children reader)] (wrap [tail output])))))) @@ -342,8 +342,8 @@ (ex;throw Empty-Input "") (#;Cons head tail) - (#R;Success [tail []])))) + (#E;Success [tail []])))) (def: #export (run document reader) - (All [a] (-> XML (Reader a) (R;Result a))) + (All [a] (-> XML (Reader a) (E;Error a))) (run' (list document) reader)) diff --git a/stdlib/source/lux/data/number.lux b/stdlib/source/lux/data/number.lux index 4f0c2b9d9..729c83979 100644 --- a/stdlib/source/lux/data/number.lux +++ b/stdlib/source/lux/data/number.lux @@ -8,7 +8,7 @@ enum interval codec) - (data ["R" result] + (data ["E" error] [maybe] [bit]))) @@ -163,10 +163,10 @@ (def: (decode input) (case (_lux_proc [input]) (#;Some value) - (#R;Success value) + (#E;Success value) #;None - (#R;Error ))))] + (#E;Error ))))] [Frac ["frac" "encode"] ["frac" "decode"] "Could not decode Frac"] ) @@ -200,16 +200,16 @@ (let [digit (maybe;assume (get-char input idx))] (case (_lux_proc ["text" "index"] [ digit +0]) #;None - (#R;Error (_lux_proc ["text" "append"] [ repr])) + (#E;Error (_lux_proc ["text" "append"] [ repr])) (#;Some index) (recur (n.inc idx) (|> output (n.* ) (n.+ index))))) - (#R;Success output)))) + (#E;Success output)))) _ - (#R;Error (_lux_proc ["text" "append"] [ repr]))) - (#R;Error (_lux_proc ["text" "append"] [ repr]))))))] + (#E;Error (_lux_proc ["text" "append"] [ repr]))) + (#E;Error (_lux_proc ["text" "append"] [ repr]))))))] [Binary@Codec +2 "01" "Invalid binary syntax for Nat: "] [Octal@Codec +8 "01234567" "Invalid octal syntax for Nat: "] @@ -251,13 +251,13 @@ (let [digit (maybe;assume (get-char input idx))] (case (_lux_proc ["text" "index"] [ digit +0]) #;None - (#R;Error ) + (#E;Error ) (#;Some index) (recur (n.inc idx) (|> output (i.* ) (i.+ (:! Int index)))))) - (#R;Success (i.* sign output))))) - (#R;Error )))))] + (#E;Success (i.* sign output))))) + (#E;Error )))))] [Binary@Codec 2 "01" "Invalid binary syntax for Int: "] [Octal@Codec 8 "01234567" "Invalid octal syntax for Int: "] @@ -291,11 +291,11 @@ (^multi (^ (#;Some (char "."))) [(:: decode (_lux_proc ["text" "append"] ["+" (de-prefix repr)])) (#;Some output)]) - (#R;Success (:! Deg output)) + (#E;Success (:! Deg output)) _ - (#R;Error (_lux_proc ["text" "append"] [ repr]))) - (#R;Error (_lux_proc ["text" "append"] [ repr]))))))] + (#E;Error (_lux_proc ["text" "append"] [ repr]))) + (#E;Error (_lux_proc ["text" "append"] [ repr]))))))] [Binary@Codec Binary@Codec +1 "Invalid binary syntax: "] [Octal@Codec Octal@Codec +3 "Invalid octal syntax: "] @@ -341,19 +341,19 @@ (f.* output)))) adjusted-decimal (|> decimal int-to-frac (f./ div-power)) dec-deg (case (:: Hex@Codec decode (_lux_proc ["text" "append"] ["." decimal-part])) - (#R;Success dec-deg) + (#E;Success dec-deg) dec-deg - (#R;Error error) + (#E;Error error) (error! error))] - (#R;Success (f.+ (int-to-frac whole) + (#E;Success (f.+ (int-to-frac whole) (f.* sign adjusted-decimal)))) _ - (#R;Error (_lux_proc ["text" "append"] [ repr])))) + (#E;Error (_lux_proc ["text" "append"] [ repr])))) _ - (#R;Error (_lux_proc ["text" "append"] [ repr])))))] + (#E;Error (_lux_proc ["text" "append"] [ repr])))))] [Binary@Codec Binary@Codec 2.0 "01" "Invalid binary syntax: "] ) @@ -531,14 +531,14 @@ [(if (f.= -1.0 sign) "-" "")] (_lux_proc ["text" "append"]))] (case (:: Binary@Codec decode as-binary) - (#R;Error _) - (#R;Error (_lux_proc ["text" "append"] [ repr])) + (#E;Error _) + (#E;Error (_lux_proc ["text" "append"] [ repr])) output output)) _ - (#R;Error (_lux_proc ["text" "append"] [ repr]))))))] + (#E;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] @@ -550,26 +550,26 @@ (case tokens (#;Cons [meta (#;Text repr)] #;Nil) (case (:: decode repr) - (#R;Success value) - (#R;Success [state (list [meta (#;Nat value)])]) + (#E;Success value) + (#E;Success [state (list [meta (#;Nat value)])]) - (^multi (#R;Error _) - [(:: decode repr) (#R;Success value)]) - (#R;Success [state (list [meta (#;Int value)])]) + (^multi (#E;Error _) + [(:: decode repr) (#E;Success value)]) + (#E;Success [state (list [meta (#;Int value)])]) - (^multi (#R;Error _) - [(:: decode repr) (#R;Success value)]) - (#R;Success [state (list [meta (#;Deg value)])]) + (^multi (#E;Error _) + [(:: decode repr) (#E;Success value)]) + (#E;Success [state (list [meta (#;Deg value)])]) - (^multi (#R;Error _) - [(:: decode repr) (#R;Success value)]) - (#R;Success [state (list [meta (#;Frac value)])]) + (^multi (#E;Error _) + [(:: decode repr) (#E;Success value)]) + (#E;Success [state (list [meta (#;Frac value)])]) _ - (#R;Error )) + (#E;Error )) _ - (#R;Error )))] + (#E;Error )))] [bin Binary@Codec Binary@Codec Binary@Codec Binary@Codec "Invalid binary syntax." @@ -764,11 +764,11 @@ (recur (digits-sub! power digits) (n.inc idx) (bit;set (n.- idx (n.dec bit;width)) output)))) - (#R;Success (:! Deg output)))) + (#E;Success (:! Deg output)))) #;None - (#R;Error (_lux_proc ["text" "append"] ["Wrong syntax for Deg: " input]))) - (#R;Error (_lux_proc ["text" "append"] ["Wrong syntax for Deg: " input])))) + (#E;Error (_lux_proc ["text" "append"] ["Wrong syntax for Deg: " input]))) + (#E;Error (_lux_proc ["text" "append"] ["Wrong syntax for Deg: " input])))) )) (def: (log2 input) diff --git a/stdlib/source/lux/data/number/complex.lux b/stdlib/source/lux/data/number/complex.lux index d2933a1ab..e1fbccb36 100644 --- a/stdlib/source/lux/data/number/complex.lux +++ b/stdlib/source/lux/data/number/complex.lux @@ -9,7 +9,7 @@ (data [number "f/" Number Codec] [text "text/" Monoid] text/format - ["R" result] + ["E" error] [maybe] (coll [list "L/" Monad])) [macro] @@ -323,7 +323,7 @@ (#;Left (text/compose "Wrong syntax for complex numbers: " input)) (#;Some [r' i']) - (do R;Monad + (do E;Monad [r (f/decode (text;trim r')) i (f/decode (text;trim i'))] (wrap {#real r diff --git a/stdlib/source/lux/data/number/ratio.lux b/stdlib/source/lux/data/number/ratio.lux index 391242a32..8db271d7d 100644 --- a/stdlib/source/lux/data/number/ratio.lux +++ b/stdlib/source/lux/data/number/ratio.lux @@ -10,7 +10,7 @@ (data [number "n/" Number Codec] [text "Text/" Monoid] text/format - ["R" result] + ["E" error] [product] [maybe]) [macro] @@ -131,7 +131,7 @@ (|>. n/encode (text;split +1) maybe;assume product;right)) (def: part-decode - (-> Text (R;Result Nat)) + (-> Text (E;Error Nat)) (|>. (format "+") n/decode)) (struct: #export _ (Codec Text Ratio) @@ -141,7 +141,7 @@ (def: (decode input) (case (text;split-with separator input) (#;Some [num denom]) - (do R;Monad + (do E;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 deleted file mode 100644 index df52522af..000000000 --- a/stdlib/source/lux/data/result.lux +++ /dev/null @@ -1,98 +0,0 @@ -(;module: - lux - (lux (control ["F" functor] - ["A" applicative] - ["M" monad #+ do Monad]))) - -## [Types] -(type: #export (Result a) - (#Error Text) - (#Success a)) - -## [Structures] -(struct: #export _ (F;Functor Result) - (def: (map f ma) - (case ma - (#Error msg) (#Error msg) - (#Success datum) (#Success (f datum))))) - -(struct: #export _ (A;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 (A;compose (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 Monad) - (All [M a] (-> (Monad M) (-> (M a) (M (Result a))))) - (M;lift 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)) - -(def: #export (assume result) - (All [a] (-> (Result a) a)) - (case result - (#Success value) - value - - (#Error message) - (error! message))) - -(macro: #export (default tokens compiler) - {#;doc (doc "Allows you to provide a default value that will be used" - "if a (Result x) value turns out to be #Error." - (is 10 - (default 20 (#Success 10))) - (is 20 - (default 20 (#Error "KABOOM!"))))} - (case tokens - (^ (list else result)) - (#Success [compiler (list (` (case (~ result) - (#;;Success (~' g!temp)) - (~' g!temp) - - (#;;Error (~ [dummy-cursor (#;Symbol ["" ""])])) - (~ else))))]) - - _ - (#Error "Wrong syntax for default"))) diff --git a/stdlib/source/lux/data/text/lexer.lux b/stdlib/source/lux/data/text/lexer.lux index 1f76e833a..3803414e4 100644 --- a/stdlib/source/lux/data/text/lexer.lux +++ b/stdlib/source/lux/data/text/lexer.lux @@ -5,7 +5,7 @@ (data [text "text/" Monoid] [product] [maybe] - ["R" result] + ["E" error] (coll [list])) (macro [code]))) @@ -27,15 +27,15 @@ ($_ text/compose "Unconsumed input: " (remaining offset tape))) (def: #export (run input lexer) - (All [a] (-> Text (Lexer a) (R;Result a))) + (All [a] (-> Text (Lexer a) (E;Error a))) (case (lexer [start-offset input]) - (#R;Error msg) - (#R;Error msg) + (#E;Error msg) + (#E;Error msg) - (#R;Success [[end-offset _] output]) + (#E;Success [[end-offset _] output]) (if (n.= end-offset (text;size input)) - (#R;Success output) - (#R;Error (unconsumed-input-error end-offset input))) + (#E;Success output) + (#E;Error (unconsumed-input-error end-offset input))) )) (def: #export any @@ -44,10 +44,10 @@ (function [[offset tape]] (case (text;nth offset tape) (#;Some output) - (#R;Success [[(n.inc offset) tape] (text;from-code output)]) + (#E;Success [[(n.inc offset) tape] (text;from-code output)]) _ - (#R;Error cannot-lex-error)) + (#E;Error cannot-lex-error)) )) (def: #export (not p) @@ -55,11 +55,11 @@ (All [a] (-> (Lexer a) (Lexer Text))) (function [input] (case (p input) - (#R;Error msg) + (#E;Error msg) (any input) _ - (#R;Error "Expected to fail; yet succeeded.")))) + (#E;Error "Expected to fail; yet succeeded.")))) (def: #export (this reference) {#;doc "Lex a text if it matches the given sample."} @@ -67,10 +67,10 @@ (function [[offset tape]] (case (text;index-of reference offset tape) (^multi (#;Some where) (n.= offset where)) - (#R;Success [[(n.+ (text;size reference) offset) tape] []]) + (#E;Success [[(n.+ (text;size reference) offset) tape] []]) _ - (#R;Error ($_ text/compose "Could not match: " (text;encode reference) " @ " tape))))) + (#E;Error ($_ text/compose "Could not match: " (text;encode reference) " @ " tape))))) (def: #export (this? reference) {#;doc "Lex a text if it matches the given sample."} @@ -78,24 +78,24 @@ (function [(^@ input [offset tape])] (case (text;index-of reference offset tape) (^multi (#;Some where) (n.= offset where)) - (#R;Success [[(n.+ (text;size reference) offset) tape] true]) + (#E;Success [[(n.+ (text;size reference) offset) tape] true]) _ - (#R;Success [input false])))) + (#E;Success [input false])))) (def: #export end {#;doc "Ensure the lexer's input is empty."} (Lexer Unit) (function [(^@ input [offset tape])] (if (n.= offset (text;size tape)) - (#R;Success [input []]) - (#R;Error (unconsumed-input-error offset tape))))) + (#E;Success [input []]) + (#E;Error (unconsumed-input-error offset tape))))) (def: #export end? {#;doc "Ask if the lexer's input is empty."} (Lexer Bool) (function [(^@ input [offset tape])] - (#R;Success [input (n.= offset (text;size tape))]))) + (#E;Success [input (n.= offset (text;size tape))]))) (def: #export peek {#;doc "Lex the next character (without consuming it from the input)."} @@ -103,17 +103,17 @@ (function [(^@ input [offset tape])] (case (text;nth offset tape) (#;Some output) - (#R;Success [input (text;from-code output)]) + (#E;Success [input (text;from-code output)]) _ - (#R;Error cannot-lex-error)) + (#E;Error cannot-lex-error)) )) (def: #export get-input {#;doc "Get all of the remaining input (without consuming it)."} (Lexer Text) (function [(^@ input [offset tape])] - (#R;Success [input (remaining offset tape)]))) + (#E;Success [input (remaining offset tape)]))) (def: #export (range bottom top) {#;doc "Only lex characters within a range."} @@ -164,11 +164,11 @@ (#;Some output) (let [output (text;from-code output)] (if (text;contains? output options) - (#R;Success [[(n.inc offset) tape] output]) - (#R;Error ($_ text/compose "Character (" output ") is not one of: " options)))) + (#E;Success [[(n.inc offset) tape] output]) + (#E;Error ($_ text/compose "Character (" output ") is not one of: " options)))) _ - (#R;Error cannot-lex-error)))) + (#E;Error cannot-lex-error)))) (def: #export (none-of options) {#;doc "Only lex characters that are not part of a piece of text."} @@ -178,11 +178,11 @@ (#;Some output) (let [output (text;from-code output)] (if (;not (text;contains? output options)) - (#R;Success [[(n.inc offset) tape] output]) - (#R;Error ($_ text/compose "Character (" output ") is one of: " options)))) + (#E;Success [[(n.inc offset) tape] output]) + (#E;Error ($_ text/compose "Character (" output ") is one of: " options)))) _ - (#R;Error cannot-lex-error)))) + (#E;Error cannot-lex-error)))) (def: #export (satisfies p) {#;doc "Only lex characters that satisfy a predicate."} @@ -191,11 +191,11 @@ (case (text;nth offset tape) (#;Some output) (if (p output) - (#R;Success [[(n.inc offset) tape] (text;from-code output)]) - (#R;Error ($_ text/compose "Character does not satisfy predicate: " (text;from-code output)))) + (#E;Success [[(n.inc offset) tape] (text;from-code output)]) + (#E;Error ($_ text/compose "Character does not satisfy predicate: " (text;from-code output)))) _ - (#R;Error cannot-lex-error)))) + (#E;Error cannot-lex-error)))) (def: #export space {#;doc "Only lex white-space."} @@ -248,8 +248,8 @@ (All [a] (-> Text (Lexer a) (Lexer a))) (function [real-input] (case (run local-input lexer) - (#R;Error error) - (#R;Error error) + (#E;Error error) + (#E;Error error) - (#R;Success value) - (#R;Success [real-input value])))) + (#E;Success value) + (#E;Success [real-input value])))) diff --git a/stdlib/source/lux/data/text/regex.lux b/stdlib/source/lux/data/text/regex.lux index 11139cd6a..a425224cb 100644 --- a/stdlib/source/lux/data/text/regex.lux +++ b/stdlib/source/lux/data/text/regex.lux @@ -7,7 +7,7 @@ text/format [number "Int/" Codec] [product] - ["R" result] + ["E" error] [maybe] (coll [list "L/" Fold Monad])) [macro #- run] @@ -276,14 +276,14 @@ [Int (List Code) (List (List Code))]) (function [part [idx names steps]] (case part - (^or (#R;Error complex) (#R;Success [#Non-Capturing complex])) + (^or (#E;Error complex) (#E;Success [#Non-Capturing complex])) [idx names (list& (list g!temp complex (' #let) (` [(~ g!total) (_Text/compose_ (~ g!total) (~ g!temp))])) steps)] - (#R;Success [(#Capturing [?name num-captures]) scoped]) + (#E;Success [(#Capturing [?name num-captures]) scoped]) (let [[idx! name!] (case ?name (#;Some _name) [idx (code;symbol ["" _name])] @@ -320,31 +320,31 @@ (All [l r] (-> (l;Lexer [Text l]) (l;Lexer [Text r]) (l;Lexer [Text (| l r)]))) (function [input] (case (left input) - (#R;Success [input' [lt lv]]) - (#R;Success [input' [lt (+0 lv)]]) + (#E;Success [input' [lt lv]]) + (#E;Success [input' [lt (+0 lv)]]) - (#R;Error _) + (#E;Error _) (case (right input) - (#R;Success [input' [rt rv]]) - (#R;Success [input' [rt (+1 rv)]]) + (#E;Success [input' [rt rv]]) + (#E;Success [input' [rt (+1 rv)]]) - (#R;Error error) - (#R;Error error))))) + (#E;Error error) + (#E;Error error))))) (def: #hidden (|||_^ left right) (All [l r] (-> (l;Lexer [Text l]) (l;Lexer [Text r]) (l;Lexer Text))) (function [input] (case (left input) - (#R;Success [input' [lt lv]]) - (#R;Success [input' lt]) + (#E;Success [input' [lt lv]]) + (#E;Success [input' lt]) - (#R;Error _) + (#E;Error _) (case (right input) - (#R;Success [input' [rt rv]]) - (#R;Success [input' rt]) + (#E;Success [input' [rt rv]]) + (#E;Success [input' rt]) - (#R;Error error) - (#R;Error error))))) + (#E;Error error) + (#E;Error error))))) (def: (prep-alternative [num-captures alt]) (-> [Nat Code] Code) @@ -462,11 +462,11 @@ (case (|> (regex^ current-module) (p;before l;end) (l;run pattern)) - (#R;Error error) + (#E;Error error) (macro;fail (format "Error while parsing regular-expression:\n" error)) - (#R;Success regex) + (#E;Success regex) (wrap (list regex)) ))) @@ -488,7 +488,7 @@ [g!temp (macro;gensym "temp")] (wrap (list& (` (^multi (~ g!temp) [(l;run (~ g!temp) (regex (~ (code;text pattern)))) - (#R;Success (~ (maybe;default g!temp + (#E;Success (~ (maybe;default g!temp bindings)))])) body branches)))) diff --git a/stdlib/source/lux/macro.lux b/stdlib/source/lux/macro.lux index 9f691c964..4fb0b08a4 100644 --- a/stdlib/source/lux/macro.lux +++ b/stdlib/source/lux/macro.lux @@ -8,43 +8,43 @@ [product] [ident "ident/" Codec Eq] [maybe] - ["R" result] + ["E" error] [text "text/" Monoid Eq] (coll [list "list/" Monoid Monad])))) ## (type: (Lux a) -## (-> Compiler (R;Result [Compiler a]))) +## (-> Compiler (E;Error [Compiler a]))) (struct: #export _ (F;Functor Lux) (def: (map f fa) (function [state] (case (fa state) - (#R;Error msg) - (#R;Error msg) + (#E;Error msg) + (#E;Error msg) - (#R;Success [state' a]) - (#R;Success [state' (f a)]))))) + (#E;Success [state' a]) + (#E;Success [state' (f a)]))))) (struct: #export _ (A;Applicative Lux) (def: functor Functor) (def: (wrap x) (function [state] - (#R;Success [state x]))) + (#E;Success [state x]))) (def: (apply ff fa) (function [state] (case (ff state) - (#R;Success [state' f]) + (#E;Success [state' f]) (case (fa state') - (#R;Success [state'' a]) - (#R;Success [state'' (f a)]) + (#E;Success [state'' a]) + (#E;Success [state'' (f a)]) - (#R;Error msg) - (#R;Error msg)) + (#E;Error msg) + (#E;Error msg)) - (#R;Error msg) - (#R;Error msg))))) + (#E;Error msg) + (#E;Error msg))))) (struct: #export _ (Monad Lux) (def: applicative Applicative) @@ -52,10 +52,10 @@ (def: (join mma) (function [state] (case (mma state) - (#R;Error msg) - (#R;Error msg) + (#E;Error msg) + (#E;Error msg) - (#R;Success [state' ma]) + (#E;Success [state' ma]) (ma state'))))) (def: (get k plist) @@ -71,53 +71,53 @@ (get k plist')))) (def: #export (run' compiler action) - (All [a] (-> Compiler (Lux a) (R;Result [Compiler a]))) + (All [a] (-> Compiler (Lux a) (E;Error [Compiler a]))) (action compiler)) (def: #export (run compiler action) - (All [a] (-> Compiler (Lux a) (R;Result a))) + (All [a] (-> Compiler (Lux a) (E;Error a))) (case (action compiler) - (#R;Error error) - (#R;Error error) + (#E;Error error) + (#E;Error error) - (#R;Success [_ output]) - (#R;Success output))) + (#E;Success [_ output]) + (#E;Success output))) (def: #export (either left right) {#;doc "Pick whichever computation succeeds."} (All [a] (-> (Lux a) (Lux a) (Lux a))) (function [compiler] (case (left compiler) - (#R;Error error) + (#E;Error error) (right compiler) - (#R;Success [compiler' output]) - (#R;Success [compiler' output])))) + (#E;Success [compiler' output]) + (#E;Success [compiler' output])))) (def: #export (assert message test) {#;doc "Fails with the given message if the test is false."} (-> Text Bool (Lux Unit)) (function [compiler] (if test - (#R;Success [compiler []]) - (#R;Error message)))) + (#E;Success [compiler []]) + (#E;Error message)))) (def: #export (fail msg) {#;doc "Fails with the given message."} (All [a] (-> Text (Lux a))) (function [_] - (#R;Error msg))) + (#E;Error msg))) (def: #export (find-module name) (-> Text (Lux Module)) (function [state] (case (get name (get@ #;modules state)) (#;Some module) - (#R;Success [state module]) + (#E;Success [state module]) _ - (#R;Error ($_ text/compose "Unknown module: " name))))) + (#E;Error ($_ text/compose "Unknown module: " name))))) (def: #export current-module-name (Lux Text) @@ -126,13 +126,13 @@ (#;Some scope) (case (get@ #;name scope) (#;Cons m-name #;Nil) - (#R;Success [state m-name]) + (#E;Success [state m-name]) _ - (#R;Error "Improper name for scope.")) + (#E;Error "Improper name for scope.")) _ - (#R;Error "Empty environment!") + (#E;Error "Empty environment!") ))) (def: #export current-module @@ -261,7 +261,7 @@ (let [[module name] ident] (: (Lux (Maybe Macro)) (function [state] - (#R;Success [state (find-macro' (get@ #;modules state) this-module module name)])))))) + (#E;Success [state (find-macro' (get@ #;modules state) this-module module name)])))))) (def: #export (normalize ident) {#;doc "If given an identifier without a module prefix, gives it the current module's name as prefix. @@ -360,7 +360,7 @@ A prefix can be given (or just be empty text \"\") to better identify the code for debugging purposes."} (-> Text (Lux Code)) (function [state] - (#R;Success [(update@ #;seed n.inc state) + (#E;Success [(update@ #;seed n.inc state) (code;symbol ["" ($_ text/compose "__gensym__" prefix (:: number;Codec encode (get@ #;seed state)))])]))) (def: (get-local-symbol ast) @@ -411,7 +411,7 @@ (def: #export (module-exists? module) (-> Text (Lux Bool)) (function [state] - (#R;Success [state (case (get module (get@ #;modules state)) + (#E;Success [state (case (get module (get@ #;modules state)) (#;Some _) true @@ -445,10 +445,10 @@ (get@ [#;captured #;mappings] scope)))] (wrap type)) (#;Some var-type) - (#R;Success [state var-type]) + (#E;Success [state var-type]) #;None - (#R;Error ($_ text/compose "Unknown variable: " name)))))) + (#E;Error ($_ text/compose "Unknown variable: " name)))))) (def: #export (find-def name) {#;doc "Looks-up a definition's whole data in the available modules (including the current one)."} @@ -460,10 +460,10 @@ (^slots [#;defs]) (get v-prefix (get@ #;modules state))] (get v-name defs))) (#;Some _anns) - (#R;Success [state _anns]) + (#E;Success [state _anns]) _ - (#R;Error ($_ text/compose "Unknown definition: " (ident/encode name)))))) + (#E;Error ($_ text/compose "Unknown definition: " (ident/encode name)))))) (def: #export (find-def-type name) {#;doc "Looks-up a definition's type in the available modules (including the current one)."} @@ -494,8 +494,8 @@ (-> Text (Lux (List [Text Def]))) (function [state] (case (get module-name (get@ #;modules state)) - #;None (#R;Error ($_ text/compose "Unknown module: " module-name)) - (#;Some module) (#R;Success [state (get@ #;defs module)]) + #;None (#E;Error ($_ text/compose "Unknown module: " module-name)) + (#;Some module) (#E;Success [state (get@ #;defs module)]) ))) (def: #export (exports module-name) @@ -515,7 +515,7 @@ (|> state (get@ #;modules) [state] - #R;Success))) + #E;Success))) (def: #export (tags-of type-name) {#;doc "All the tags associated with a type definition."} @@ -534,7 +534,7 @@ {#;doc "The cursor of the current expression being analyzed."} (Lux Cursor) (function [state] - (#R;Success [state (get@ #;cursor state)]))) + (#E;Success [state (get@ #;cursor state)]))) (def: #export expected-type {#;doc "The expected type of the current expression being analyzed."} @@ -542,10 +542,10 @@ (function [state] (case (get@ #;expected state) (#;Some type) - (#R;Success [state type]) + (#E;Success [state type]) #;None - (#R;Error "Not expecting any type.")))) + (#E;Error "Not expecting any type.")))) (def: #export (imported-modules module-name) {#;doc "All the modules imported by a specified module."} @@ -590,10 +590,10 @@ (function [state] (case (list;inits (get@ #;scopes state)) #;None - (#R;Error "No local environment") + (#E;Error "No local environment") (#;Some scopes) - (#R;Success [state + (#E;Success [state (list/map (|>. (get@ [#;locals #;mappings]) (list/map (function [[name [type _]]] [name type]))) @@ -616,12 +616,12 @@ {#;doc "Obtains the current state of the compiler."} (Lux Compiler) (function [compiler] - (#R;Success [compiler compiler]))) + (#E;Success [compiler compiler]))) (def: #export type-context (Lux Type-Context) (function [compiler] - (#R;Success [compiler (get@ #;type-context compiler)]))) + (#E;Success [compiler (get@ #;type-context compiler)]))) (do-template [ ] [(macro: #export ( tokens) diff --git a/stdlib/source/lux/macro/poly.lux b/stdlib/source/lux/macro/poly.lux index d744a28f7..fc6c7120f 100644 --- a/stdlib/source/lux/macro/poly.lux +++ b/stdlib/source/lux/macro/poly.lux @@ -12,7 +12,7 @@ [bool] [maybe] [ident "ident/" Eq Codec] - ["R" result]) + ["E" error]) [macro #+ with-gensyms] (macro [code] ["s" syntax #+ syntax: Syntax] @@ -31,70 +31,70 @@ (def: #export fresh Env (dict;new number;Hash)) (def: (run' env types poly) - (All [a] (-> Env (List Type) (Poly a) (R;Result a))) + (All [a] (-> Env (List Type) (Poly a) (E;Error a))) (case (p;run [env types] poly) - (#R;Error error) - (#R;Error error) + (#E;Error error) + (#E;Error error) - (#R;Success [[env' remaining] output]) + (#E;Success [[env' remaining] output]) (case remaining #;Nil - (#R;Success output) + (#E;Success output) _ - (#R;Error (|> remaining + (#E;Error (|> remaining (list/map type;to-text) (text;join-with ", ") (text/compose "Unconsumed types: ")))))) (def: #export (run type poly) - (All [a] (-> Type (Poly a) (R;Result a))) + (All [a] (-> Type (Poly a) (E;Error a))) (run' fresh (list type) poly)) (def: #export env (Poly Env) (;function [[env inputs]] - (#R;Success [[env inputs] env]))) + (#E;Success [[env inputs] env]))) (def: (with-env temp poly) (All [a] (-> Env (Poly a) (Poly a))) (;function [[env inputs]] (case (p;run [temp inputs] poly) - (#R;Error error) - (#R;Error error) + (#E;Error error) + (#E;Error error) - (#R;Success [[_ remaining] output]) - (#R;Success [[env remaining] output])))) + (#E;Success [[_ remaining] output]) + (#E;Success [[env remaining] output])))) (def: #export peek (Poly Type) (;function [[env inputs]] (case inputs #;Nil - (#R;Error "Empty stream of types.") + (#E;Error "Empty stream of types.") (#;Cons headT tail) - (#R;Success [[env inputs] headT])))) + (#E;Success [[env inputs] headT])))) (def: #export any (Poly Type) (;function [[env inputs]] (case inputs #;Nil - (#R;Error "Empty stream of types.") + (#E;Error "Empty stream of types.") (#;Cons headT tail) - (#R;Success [[env tail] headT])))) + (#E;Success [[env tail] headT])))) (def: #export (local types poly) (All [a] (-> (List Type) (Poly a) (Poly a))) (;function [[env pass-through]] (case (run' env types poly) - (#R;Error error) - (#R;Error error) + (#E;Error error) + (#E;Error error) - (#R;Success output) - (#R;Success [[env pass-through] output])))) + (#E;Success output) + (#E;Success [[env pass-through] output])))) (def: (label idx) (-> Nat Code) @@ -108,11 +108,11 @@ (case (p;run [(dict;put current-id [type g!var] env) inputs] poly) - (#R;Error error) - (#R;Error error) + (#E;Error error) + (#E;Error error) - (#R;Success [[_ inputs'] output]) - (#R;Success [[env inputs'] [g!var output]]))))) + (#E;Success [[_ inputs'] output]) + (#E;Success [[env inputs'] [g!var output]]))))) (do-template [ ] [(def: #export @@ -149,10 +149,10 @@ deg frac text)) - (#R;Error error) + (#E;Error error) (p;fail error) - (#R;Success _) + (#E;Success _) (wrap headT)))) (do-template [ ] diff --git a/stdlib/source/lux/macro/poly/json.lux b/stdlib/source/lux/macro/poly/json.lux index 1c3510b85..1b66e39f5 100644 --- a/stdlib/source/lux/macro/poly/json.lux +++ b/stdlib/source/lux/macro/poly/json.lux @@ -10,7 +10,7 @@ (text ["l" lexer]) [number "frac/" Codec "nat/" Codec] maybe - ["R" result] + ["E" error] [sum] [product] (coll [list "list/" Fold Monad] @@ -63,7 +63,7 @@ (struct: #hidden _ (Codec JSON Int) (def: encode (|>. int-to-nat (:: Codec encode))) (def: decode - (|>. (:: Codec decode) (:: R;Functor map nat-to-int)))) + (|>. (:: Codec decode) (:: E;Functor map nat-to-int)))) (def: #hidden (nullable writer) {#;doc "Builds a JSON generator for potentially inexistent values."} @@ -78,7 +78,7 @@ (def: encode (|>. unit;out (:: Codec encode))) (def: decode - (|>. (:: Codec decode) (:: R;Functor map (unit;in carrier))))) + (|>. (:: Codec decode) (:: E;Functor map (unit;in carrier))))) (poly: #hidden Codec//encode (with-expansions diff --git a/stdlib/source/lux/macro/syntax.lux b/stdlib/source/lux/macro/syntax.lux index 4e431de82..a31eb8c6e 100644 --- a/stdlib/source/lux/macro/syntax.lux +++ b/stdlib/source/lux/macro/syntax.lux @@ -11,7 +11,7 @@ (coll [list "list/" Functor]) [product] [maybe] - ["R" result])) + ["E" error])) (.. [code "code/" Eq])) ## [Utils] @@ -38,8 +38,8 @@ (Syntax Code) (function [tokens] (case tokens - #;Nil (#R;Error "There are no tokens to parse!") - (#;Cons [t tokens']) (#R;Success [tokens' t])))) + #;Nil (#E;Error "There are no tokens to parse!") + (#;Cons [t tokens']) (#E;Success [tokens' t])))) (do-template [ ] [(def: #export @@ -48,10 +48,10 @@ (function [tokens] (case tokens (#;Cons [[_ ( x)] tokens']) - (#R;Success [tokens' x]) + (#E;Success [tokens' x]) _ - (#R;Error ($_ text/compose "Cannot parse " (remaining-inputs tokens))))))] + (#E;Error ($_ text/compose "Cannot parse " (remaining-inputs tokens))))))] [ bool Bool #;Bool bool;Eq "bool"] [ nat Nat #;Nat number;Eq "nat"] @@ -73,10 +73,10 @@ remaining (if is-it? tokens' tokens)] - (#R;Success [remaining is-it?])) + (#E;Success [remaining is-it?])) _ - (#R;Success [tokens false])))) + (#E;Success [tokens false])))) (def: #export (this ast) {#;doc "Ensures the given Code is the next input."} @@ -85,12 +85,12 @@ (case tokens (#;Cons [token tokens']) (if (code/= ast token) - (#R;Success [tokens' []]) - (#R;Error ($_ text/compose "Expected a " (code;to-text ast) " but instead got " (code;to-text token) + (#E;Success [tokens' []]) + (#E;Error ($_ text/compose "Expected a " (code;to-text ast) " but instead got " (code;to-text token) (remaining-inputs tokens)))) _ - (#R;Error "There are no tokens to parse!")))) + (#E;Error "There are no tokens to parse!")))) (do-template [ ] [(def: #export @@ -111,10 +111,10 @@ (function [tokens] (case tokens (#;Cons [[_ ( ["" x])] tokens']) - (#R;Success [tokens' x]) + (#E;Success [tokens' x]) _ - (#R;Error ($_ text/compose "Cannot parse local " (remaining-inputs tokens))))))] + (#E;Error ($_ text/compose "Cannot parse local " (remaining-inputs tokens))))))] [local-symbol #;Symbol "symbol"] [ local-tag #;Tag "tag"] @@ -129,11 +129,11 @@ (case tokens (#;Cons [[_ ( members)] tokens']) (case (p members) - (#R;Success [#;Nil x]) (#R;Success [tokens' x]) - _ (#R;Error ($_ text/compose "Syntax was expected to fully consume " (remaining-inputs tokens)))) + (#E;Success [#;Nil x]) (#E;Success [tokens' x]) + _ (#E;Error ($_ text/compose "Syntax was expected to fully consume " (remaining-inputs tokens)))) _ - (#R;Error ($_ text/compose "Cannot parse " (remaining-inputs tokens))))))] + (#E;Error ($_ text/compose "Cannot parse " (remaining-inputs tokens))))))] [ form #;Form "form"] [tuple #;Tuple "tuple"] @@ -147,38 +147,38 @@ (case tokens (#;Cons [[_ (#;Record pairs)] tokens']) (case (p (join-pairs pairs)) - (#R;Success [#;Nil x]) (#R;Success [tokens' x]) - _ (#R;Error ($_ text/compose "Syntax was expected to fully consume record" (remaining-inputs tokens)))) + (#E;Success [#;Nil x]) (#E;Success [tokens' x]) + _ (#E;Error ($_ text/compose "Syntax was expected to fully consume record" (remaining-inputs tokens)))) _ - (#R;Error ($_ text/compose "Cannot parse record" (remaining-inputs tokens)))))) + (#E;Error ($_ text/compose "Cannot parse record" (remaining-inputs tokens)))))) (def: #export end! {#;doc "Ensures there are no more inputs."} (Syntax Unit) (function [tokens] (case tokens - #;Nil (#R;Success [tokens []]) - _ (#R;Error ($_ text/compose "Expected list of tokens to be empty!" (remaining-inputs tokens)))))) + #;Nil (#E;Success [tokens []]) + _ (#E;Error ($_ text/compose "Expected list of tokens to be empty!" (remaining-inputs tokens)))))) (def: #export end? {#;doc "Checks whether there are no more inputs."} (Syntax Bool) (function [tokens] (case tokens - #;Nil (#R;Success [tokens true]) - _ (#R;Success [tokens false])))) + #;Nil (#E;Success [tokens true]) + _ (#E;Success [tokens false])))) (def: #export (on compiler action) {#;doc "Run a Lux operation as if it was a Syntax parser."} (All [a] (-> Compiler (Lux a) (Syntax a))) (function [input] (case (macro;run compiler action) - (#R;Error error) - (#R;Error error) + (#E;Error error) + (#E;Error error) - (#R;Success value) - (#R;Success [input value]) + (#E;Success value) + (#E;Success [input value]) ))) (def: #export (local local-inputs syntax) @@ -186,16 +186,16 @@ (All [a] (-> (List Code) (Syntax a) (Syntax a))) (function [real-inputs] (case (syntax local-inputs) - (#R;Error error) - (#R;Error error) + (#E;Error error) + (#E;Error error) - (#R;Success [unconsumed-inputs value]) + (#E;Success [unconsumed-inputs value]) (case unconsumed-inputs #;Nil - (#R;Success [real-inputs value]) + (#E;Success [real-inputs value]) _ - (#R;Error (text/compose "Unconsumed inputs: " + (#E;Error (text/compose "Unconsumed inputs: " (|> (list/map code;to-text unconsumed-inputs) (text;join-with ", ")))))))) @@ -265,10 +265,10 @@ g!end (code;symbol ["" ""]) error-msg (code;text (text/compose "Wrong syntax for " name)) export-ast (: (List Code) (case exported? - (#;Some #R;Error) + (#;Some #E;Error) (list (' #hidden)) - (#;Some #R;Success) + (#;Some #E;Success) (list (' #export)) _ @@ -280,15 +280,15 @@ (: (Syntax (Lux (List Code))) (do ;;_Monad_ [(~@ (join-pairs vars+parsers)) - (~ g!end) end!] + (~ g!end) ;;end!] ((~' wrap) (do macro;Monad [] (~ body)))))) - (#R;Success [(~ g!tokens) (~ g!body)]) + (#E;Success [(~ g!tokens) (~ g!body)]) ((~ g!body) (~ g!state)) - (#R;Error (~ g!msg)) - (#R;Error (text.join-with ": " (list (~ error-msg) (~ g!msg)))))))))))) + (#E;Error (~ g!msg)) + (#E;Error (text.join-with ": " (list (~ error-msg) (~ g!msg)))))))))))) _ (macro;fail "Wrong syntax for syntax:")))) diff --git a/stdlib/source/lux/test.lux b/stdlib/source/lux/test.lux index 6d21a074b..e25f685cf 100644 --- a/stdlib/source/lux/test.lux +++ b/stdlib/source/lux/test.lux @@ -11,11 +11,11 @@ [maybe] [text] text/format - ["E" result]) + ["E" error]) [io #- run] (time [instant] [duration]) - ["R" math/random])) + ["r" math/random])) ## [Host] (do-template [ ] @@ -83,18 +83,18 @@ (|>. product;right (n.> +0))) (def: (try seed random-test) - (-> Seed (R;Random Test) (Promise [Seed [Counters Text]])) - (let [[prng [new-seed test]] (R;run (R;pcg-32 [pcg-32-magic-inc seed]) - (do R;Monad + (-> Seed (r;Random Test) (Promise [Seed [Counters Text]])) + (let [[prng [new-seed test]] (r;run (r;pcg-32 [pcg-32-magic-inc seed]) + (do r;Monad [test random-test - next-seed R;nat] + next-seed r;nat] (wrap [next-seed test])))] (do Monad [result test] (wrap [new-seed result])))) (def: (repeat' seed times random-test) - (-> Seed Nat (R;Random Test) Test) + (-> Seed Nat (r;Random Test) Test) (if (n.= +0 times) (fail "Cannot try a test 0 times.") (do Monad @@ -110,9 +110,9 @@ (repeat' seed' (n.dec times) random-test))))) (def: #hidden (repeat ?seed times random-test) - (-> (Maybe Nat) Nat (R;Random Test) Test) + (-> (Maybe Nat) Nat (r;Random Test) Test) (repeat' (maybe;default (|> (io;run instant;now) instant;to-millis int-to-nat) - ?seed) + ?seed) (case ?seed #;None times (#;Some _) +1) @@ -197,10 +197,10 @@ (test "Can have defaults for Maybe values." (and (is "yolo" (maybe;default "yolo" - #;None)) + #;None)) (is "lol" (maybe;default "yolo" - (#;Some "lol"))))) + (#;Some "lol"))))) )) "Also works with random generation of values for property-based testing." (context: "Addition & Substraction" @@ -240,7 +240,7 @@ bindings' (|> bindings (L/map pair-to-list) L/join)] (` (repeat (~ =seed) (~ (code;nat =times)) - (do R;Monad + (do r;Monad [(~@ bindings')] ((~' wrap) (;;try-body (io;io (~ body)))))))) diff --git a/stdlib/source/lux/time/date.lux b/stdlib/source/lux/time/date.lux index 9f2d2972b..b513ef07c 100644 --- a/stdlib/source/lux/time/date.lux +++ b/stdlib/source/lux/time/date.lux @@ -6,7 +6,7 @@ codec ["p" parser] [monad #+ do]) - (data ["R" result] + (data ["E" error] [maybe] [number "int/" Codec] [text "text/" Monoid] @@ -311,7 +311,7 @@ #day (int-to-nat utc-day)}))) (def: (decode input) - (-> Text (R;Result Date)) + (-> Text (E;Error Date)) (l;run input lex-date)) (struct: #export _ diff --git a/stdlib/source/lux/time/duration.lux b/stdlib/source/lux/time/duration.lux index 003a84a97..35911a6cc 100644 --- a/stdlib/source/lux/time/duration.lux +++ b/stdlib/source/lux/time/duration.lux @@ -8,7 +8,7 @@ (data [number "int/" Codec Number] [text "text/" Monoid] (text ["l" lexer]) - ["R" result]) + ["E" error]) (type opaque))) (opaque: #export Duration @@ -134,7 +134,7 @@ (merge (scale (sign utc-millis) milli)))))) (def: (decode input) - (-> Text (R;Result Duration)) + (-> Text (E;Error Duration)) (l;run input lex-duration)) (struct: #export _ diff --git a/stdlib/source/lux/time/instant.lux b/stdlib/source/lux/time/instant.lux index c76f108fb..31da7dc29 100644 --- a/stdlib/source/lux/time/instant.lux +++ b/stdlib/source/lux/time/instant.lux @@ -10,7 +10,7 @@ (data [text "text/" Monoid] (text ["l" lexer]) [number "int/" Codec] - ["R" result] + ["E" error] [maybe] (coll [list "L/" Fold Functor] ["v" vector "v/" Functor Fold])) @@ -296,7 +296,7 @@ (shift (duration;scale utc-millis duration;milli)))))) (def: (decode input) - (-> Text (R;Result Instant)) + (-> Text (E;Error Instant)) (l;run input lex-instant)) (struct: #export _ diff --git a/stdlib/source/lux/type/check.lux b/stdlib/source/lux/type/check.lux index 769b45391..f51ba5a15 100644 --- a/stdlib/source/lux/type/check.lux +++ b/stdlib/source/lux/type/check.lux @@ -2,57 +2,57 @@ Very useful for writing advanced macros."} lux - (lux (control ["F" functor] - ["A" applicative] - ["M" monad #+ do Monad]) + (lux (control [functor #+ Functor] + [applicative #+ Applicative] + [monad #+ do Monad]) (data [text "text/" Monoid Eq] [number "nat/" Codec] maybe [product] (coll [list]) - ["R" result]) - [type "Type/" Eq] + ["E" error]) + [type "type/" Eq] )) (type: #export Assumptions (List [[Type Type] Bool])) (type: #export (Check a) - (-> Type-Context (R;Result [Type-Context a]))) + (-> Type-Context (E;Error [Type-Context a]))) (type: #export Type-Vars (List [Nat (Maybe Type)])) -(struct: #export _ (F;Functor Check) +(struct: #export _ (Functor Check) (def: (map f fa) (function [context] (case (fa context) - (#R;Error error) - (#R;Error error) + (#E;Error error) + (#E;Error error) - (#R;Success [context' output]) - (#R;Success [context' (f output)]) + (#E;Success [context' output]) + (#E;Success [context' (f output)]) )))) -(struct: #export _ (A;Applicative Check) +(struct: #export _ (Applicative Check) (def: functor Functor) (def: (wrap x) (function [context] - (#R;Success [context x]))) + (#E;Success [context x]))) (def: (apply ff fa) (function [context] (case (ff context) - (#R;Success [context' f]) + (#E;Success [context' f]) (case (fa context') - (#R;Success [context'' a]) - (#R;Success [context'' (f a)]) + (#E;Success [context'' a]) + (#E;Success [context'' (f a)]) - (#R;Error error) - (#R;Error error)) + (#E;Error error) + (#E;Error error)) - (#R;Error error) - (#R;Error error) + (#E;Error error) + (#E;Error error) ))) ) @@ -62,20 +62,20 @@ (def: (join ffa) (function [context] (case (ffa context) - (#R;Success [context' fa]) + (#E;Success [context' fa]) (case (fa context') - (#R;Success [context'' a]) - (#R;Success [context'' a]) + (#E;Success [context'' a]) + (#E;Success [context'' a]) - (#R;Error error) - (#R;Error error)) + (#E;Error error) + (#E;Error error)) - (#R;Error error) - (#R;Error error) + (#E;Error error) + (#E;Error error) ))) ) -(open Monad "Check/") +(open Monad "check/") (def: (var::get id plist) (-> Nat Type-Vars (Maybe (Maybe Type))) @@ -121,30 +121,30 @@ ## [[Logic]] (def: #export (run context proc) - (All [a] (-> Type-Context (Check a) (R;Result a))) + (All [a] (-> Type-Context (Check a) (E;Error a))) (case (proc context) - (#R;Error error) - (#R;Error error) + (#E;Error error) + (#E;Error error) - (#R;Success [context' output]) - (#R;Success output))) + (#E;Success [context' output]) + (#E;Success output))) (def: (apply-type! t-func t-arg) (-> Type Type (Check Type)) (function [context] (case (type;apply (list t-arg) t-func) #;None - (#R;Error ($_ text/compose "Invalid type application: " (type;to-text t-func) " on " (type;to-text t-arg))) + (#E;Error ($_ text/compose "Invalid type application: " (type;to-text t-func) " on " (type;to-text t-arg))) (#;Some output) - (#R;Success [context output])))) + (#E;Success [context output])))) (def: #export existential {#;doc "A producer of existential types."} (Check [Nat Type]) (function [context] (let [id (get@ #;ex-counter context)] - (#R;Success [(update@ #;ex-counter n.inc context) + (#E;Success [(update@ #;ex-counter n.inc context) [id (#;Ex id)]])))) (def: #export (bound? id) @@ -152,62 +152,62 @@ (function [context] (case (|> context (get@ #;var-bindings) (var::get id)) (#;Some (#;Some _)) - (#R;Success [context true]) + (#E;Success [context true]) (#;Some #;None) - (#R;Success [context false]) + (#E;Success [context false]) #;None - (#R;Error ($_ text/compose "Unknown type-var: " (nat/encode id)))))) + (#E;Error ($_ text/compose "Unknown type-var: " (nat/encode id)))))) (def: #export (read id) (-> Nat (Check Type)) (function [context] (case (|> context (get@ #;var-bindings) (var::get id)) (#;Some (#;Some type)) - (#R;Success [context type]) + (#E;Success [context type]) (#;Some #;None) - (#R;Error ($_ text/compose "Unbound type-var: " (nat/encode id))) + (#E;Error ($_ text/compose "Unbound type-var: " (nat/encode id))) #;None - (#R;Error ($_ text/compose "Unknown type-var: " (nat/encode id)))))) + (#E;Error ($_ text/compose "Unknown type-var: " (nat/encode id)))))) (def: #export (write id type) (-> Nat Type (Check Unit)) (function [context] (case (|> context (get@ #;var-bindings) (var::get id)) (#;Some (#;Some bound)) - (#R;Error ($_ text/compose "Cannot rebind type-var: " (nat/encode id) " | Current type: " (type;to-text bound))) + (#E;Error ($_ text/compose "Cannot rebind type-var: " (nat/encode id) " | Current type: " (type;to-text bound))) (#;Some #;None) - (#R;Success [(update@ #;var-bindings (var::put id (#;Some type)) context) + (#E;Success [(update@ #;var-bindings (var::put id (#;Some type)) context) []]) #;None - (#R;Error ($_ text/compose "Unknown type-var: " (nat/encode id)))))) + (#E;Error ($_ text/compose "Unknown type-var: " (nat/encode id)))))) (def: (update id type) (-> Nat Type (Check Unit)) (function [context] (case (|> context (get@ #;var-bindings) (var::get id)) (#;Some _) - (#R;Success [(update@ #;var-bindings (var::put id (#;Some type)) context) + (#E;Success [(update@ #;var-bindings (var::put id (#;Some type)) context) []]) #;None - (#R;Error ($_ text/compose "Unknown type-var: " (nat/encode id)))))) + (#E;Error ($_ text/compose "Unknown type-var: " (nat/encode id)))))) (def: #export (clear id) (-> Nat (Check Unit)) (function [context] (case (|> context (get@ #;var-bindings) (var::get id)) (#;Some _) - (#R;Success [(update@ #;var-bindings (var::put id #;None) context) + (#E;Success [(update@ #;var-bindings (var::put id #;None) context) []]) #;None - (#R;Error ($_ text/compose "Unknown type-var: " (nat/encode id)))))) + (#E;Error ($_ text/compose "Unknown type-var: " (nat/encode id)))))) (def: #export (clean t-id type) (-> Nat Type (Check Type)) @@ -243,7 +243,7 @@ (#;Host name params) (do Monad - [=params (M;map @ (clean t-id) params)] + [=params (monad;map @ (clean t-id) params)] (wrap (#;Host name =params))) (^template [] @@ -260,7 +260,7 @@ (^template [] ( env body) (do Monad - [=env (M;map @ (clean t-id) env) + [=env (monad;map @ (clean t-id) env) =body (clean t-id body)] ## TODO: DO NOT CLEAN THE BODY (wrap ( =env =body)))) ([#;UnivQ] @@ -274,7 +274,7 @@ (Check [Nat Type]) (function [context] (let [id (get@ #;var-counter context)] - (#R;Success [(|> context + (#E;Success [(|> context (update@ #;var-counter n.inc) (update@ #;var-bindings (var::put id #;None))) [id (#;Var id)]])))) @@ -282,19 +282,19 @@ (def: get-bindings (Check (List [Nat (Maybe Type)])) (function [context] - (#R;Success [context + (#E;Success [context (get@ #;var-bindings context)]))) (def: (set-bindings value) (-> (List [Nat (Maybe Type)]) (Check Unit)) (function [context] - (#R;Success [(set@ #;var-bindings value context) + (#E;Success [(set@ #;var-bindings value context) []]))) (def: #export (delete id) (-> Nat (Check Unit)) (function [context] - (#R;Success [(update@ #;var-bindings (var::remove id) context) + (#E;Success [(update@ #;var-bindings (var::remove id) context) []]))) (def: #export (with k) @@ -316,16 +316,16 @@ (All [a] (-> (Check a) (Check (Maybe a)))) (function [context] (case (op context) - (#R;Success [context' output]) - (#R;Success [context' (#;Some output)]) + (#E;Success [context' output]) + (#E;Success [context' (#;Some output)]) - (#R;Error _) - (#R;Success [context #;None])))) + (#E;Error _) + (#E;Success [context #;None])))) (def: #export (fail message) (All [a] (-> Text (Check a))) (function [context] - (#R;Error message))) + (#E;Error message))) (def: (fail-check expected actual) (All [a] (-> Type Type (Check a))) @@ -337,18 +337,18 @@ (All [a] (-> (Check a) (Check a) (Check a))) (function [context] (case (left context) - (#R;Success [context' output]) - (#R;Success [context' output]) + (#E;Success [context' output]) + (#E;Success [context' output]) - (#R;Error _) + (#E;Error _) (right context)))) (def: (assumed? [e a] assumptions) (-> [Type Type] Assumptions (Maybe Bool)) (:: Monad map product;right (list;find (function [[[fe fa] status]] - (and (Type/= e fe) - (Type/= a fa))) + (and (type/= e fe) + (type/= a fa))) assumptions))) (def: (assume! ea status assumptions) @@ -370,11 +370,11 @@ {#;doc "Type-check to ensure that the 'expected' type subsumes the 'actual' type."} (-> Type Type Assumptions (Check Assumptions)) (if (is expected actual) - (Check/wrap assumptions) + (check/wrap assumptions) (case [expected actual] [(#;Var e-id) (#;Var a-id)] (if (n.= e-id a-id) - (Check/wrap assumptions) + (check/wrap assumptions) (do Monad [ebound (attempt (read e-id)) abound (attempt (read a-id))] @@ -394,12 +394,12 @@ (check' etype atype assumptions)))) [(#;Var id) _] - (on id actual (Check/wrap assumptions) + (on id actual (check/wrap assumptions) (function [bound] (check' bound actual assumptions))) [_ (#;Var id)] - (on id expected (Check/wrap assumptions) + (on id expected (check/wrap assumptions) (function [bound] (check' expected bound assumptions))) @@ -433,7 +433,7 @@ (case (assumed? fx-pair assumptions) (#;Some ?) (if ? - (Check/wrap assumptions) + (check/wrap assumptions) (fail-check expected actual)) #;None @@ -459,7 +459,7 @@ [actual' (apply-type! actual var) assumptions (check' expected actual' assumptions) _ (clean var-id expected)] - (Check/wrap assumptions)))) + (check/wrap assumptions)))) [(#;ExQ e!env e!def) _] (with @@ -468,7 +468,7 @@ [expected' (apply-type! expected var) assumptions (check' expected' actual assumptions) _ (clean var-id actual)] - (Check/wrap assumptions)))) + (check/wrap assumptions)))) [_ (#;ExQ a!env a!def)] (do Monad @@ -481,16 +481,16 @@ (n.= (list;size e-params) (list;size a-params))) (do Monad - [assumptions (M;fold Monad - (function [[e a] assumptions] (check' e a assumptions)) - assumptions - (list;zip2 e-params a-params))] - (Check/wrap assumptions)) + [assumptions (monad;fold Monad + (function [[e a] assumptions] (check' e a assumptions)) + assumptions + (list;zip2 e-params a-params))] + (check/wrap assumptions)) (fail-check expected actual)) (^template [ ] [ ] - (Check/wrap assumptions) + (check/wrap assumptions) [( eL eR) ( aL aR)] (do Monad @@ -506,7 +506,7 @@ [(#;Ex e!id) (#;Ex a!id)] (if (n.= e!id a!id) - (Check/wrap assumptions) + (check/wrap assumptions) (fail-check expected actual)) [(#;Named _ ?etype) _] @@ -529,13 +529,13 @@ {#;doc "A simple type-checking function that just returns a yes/no answer."} (-> Type Type Bool) (case (run fresh-context (check expected actual)) - (#R;Error error) + (#E;Error error) false - (#R;Success _) + (#E;Success _) true)) (def: #export get-context (Check Type-Context) (function [context] - (#R;Success [context context]))) + (#E;Success [context context]))) diff --git a/stdlib/source/lux/type/opaque.lux b/stdlib/source/lux/type/opaque.lux index b58e8d32e..00a27333a 100644 --- a/stdlib/source/lux/type/opaque.lux +++ b/stdlib/source/lux/type/opaque.lux @@ -4,7 +4,7 @@ [monad #+ do Monad] ["p" parser]) (data [text "text/" Eq Monoid] - ["R" result] + ["E" error] (coll [list "list/" Functor Monoid])) [macro] (macro [code] @@ -91,7 +91,7 @@ _ (macro;fail ($_ text/compose "Wrong syntax for " up-cast))))]))))]] (function [compiler] - (#R;Success [(update@ #;modules (put this-module-name this-module) compiler) + (#E;Success [(update@ #;modules (put this-module-name this-module) compiler) []])))) (def: (un-install-casts' this-module-name) @@ -102,7 +102,7 @@ (update@ #;defs (remove down-cast)) (update@ #;defs (remove up-cast)))]] (function [compiler] - (#R;Success [(update@ #;modules (put this-module-name this-module) compiler) + (#E;Success [(update@ #;modules (put this-module-name this-module) compiler) []])))) (syntax: #hidden (install-casts [name s;local-symbol] diff --git a/stdlib/source/lux/world/blob.jvm.lux b/stdlib/source/lux/world/blob.jvm.lux index 4d35a5658..88efc1859 100644 --- a/stdlib/source/lux/world/blob.jvm.lux +++ b/stdlib/source/lux/world/blob.jvm.lux @@ -5,7 +5,7 @@ [eq]) (data [bit] [maybe] - ["R" result] + ["E" error] text/format) [host])) @@ -31,23 +31,23 @@ (host;array byte size)) (def: #export (read-8 idx blob) - (-> Nat Blob (R;Result Nat)) + (-> Nat Blob (E;Error Nat)) (if (n.< (host;array-length blob) idx) - (|> (host;array-read idx blob) byte-to-nat #R;Success) + (|> (host;array-read idx blob) byte-to-nat #E;Success) (ex;throw Index-Out-Of-Bounds (%n idx)))) (def: #export (read-16 idx blob) - (-> Nat Blob (R;Result Nat)) + (-> Nat Blob (E;Error Nat)) (if (n.< (host;array-length blob) (n.+ +1 idx)) - (#R;Success ($_ bit;or + (#E;Success ($_ bit;or (bit;shift-left +8 (byte-to-nat (host;array-read idx blob))) (byte-to-nat (host;array-read (n.+ +1 idx) blob)))) (ex;throw Index-Out-Of-Bounds (%n idx)))) (def: #export (read-32 idx blob) - (-> Nat Blob (R;Result Nat)) + (-> Nat Blob (E;Error Nat)) (if (n.< (host;array-length blob) (n.+ +3 idx)) - (#R;Success ($_ bit;or + (#E;Success ($_ bit;or (bit;shift-left +24 (byte-to-nat (host;array-read idx blob))) (bit;shift-left +16 (byte-to-nat (host;array-read (n.+ +1 idx) blob))) (bit;shift-left +8 (byte-to-nat (host;array-read (n.+ +2 idx) blob))) @@ -55,9 +55,9 @@ (ex;throw Index-Out-Of-Bounds (%n idx)))) (def: #export (read-64 idx blob) - (-> Nat Blob (R;Result Nat)) + (-> Nat Blob (E;Error Nat)) (if (n.< (host;array-length blob) (n.+ +7 idx)) - (#R;Success ($_ bit;or + (#E;Success ($_ bit;or (bit;shift-left +56 (byte-to-nat (host;array-read idx blob))) (bit;shift-left +48 (byte-to-nat (host;array-read (n.+ +1 idx) blob))) (bit;shift-left +40 (byte-to-nat (host;array-read (n.+ +2 idx) blob))) @@ -69,35 +69,35 @@ (ex;throw Index-Out-Of-Bounds (%n idx)))) (def: #export (write-8 idx value blob) - (-> Nat Nat Blob (R;Result Unit)) + (-> Nat Nat Blob (E;Error Unit)) (if (n.< (host;array-length blob) idx) (exec (|> blob (host;array-write idx (host;l2b (:! Int value)))) - (#R;Success [])) + (#E;Success [])) (ex;throw Index-Out-Of-Bounds (%n idx)))) (def: #export (write-16 idx value blob) - (-> Nat Nat Blob (R;Result Unit)) + (-> Nat Nat Blob (E;Error Unit)) (if (n.< (host;array-length blob) (n.+ +1 idx)) (exec (|> blob (host;array-write idx (host;l2b (:! Int (bit;shift-right +8 value)))) (host;array-write (n.+ +1 idx) (host;l2b (:! Int value)))) - (#R;Success [])) + (#E;Success [])) (ex;throw Index-Out-Of-Bounds (%n idx)))) (def: #export (write-32 idx value blob) - (-> Nat Nat Blob (R;Result Unit)) + (-> Nat Nat Blob (E;Error Unit)) (if (n.< (host;array-length blob) (n.+ +3 idx)) (exec (|> blob (host;array-write idx (host;l2b (:! Int (bit;shift-right +24 value)))) (host;array-write (n.+ +1 idx) (host;l2b (:! Int (bit;shift-right +16 value)))) (host;array-write (n.+ +2 idx) (host;l2b (:! Int (bit;shift-right +8 value)))) (host;array-write (n.+ +3 idx) (host;l2b (:! Int value)))) - (#R;Success [])) + (#E;Success [])) (ex;throw Index-Out-Of-Bounds (%n idx)))) (def: #export (write-64 idx value blob) - (-> Nat Nat Blob (R;Result Unit)) + (-> Nat Nat Blob (E;Error Unit)) (if (n.< (host;array-length blob) (n.+ +7 idx)) (exec (|> blob (host;array-write idx (host;l2b (:! Int (bit;shift-right +56 value)))) @@ -108,7 +108,7 @@ (host;array-write (n.+ +5 idx) (host;l2b (:! Int (bit;shift-right +16 value)))) (host;array-write (n.+ +6 idx) (host;l2b (:! Int (bit;shift-right +8 value)))) (host;array-write (n.+ +7 idx) (host;l2b (:! Int value)))) - (#R;Success [])) + (#E;Success [])) (ex;throw Index-Out-Of-Bounds (%n idx)))) (def: #export (size blob) @@ -116,7 +116,7 @@ (host;array-length blob)) (def: #export (slice from to blob) - (-> Nat Nat Blob (R;Result Blob)) + (-> Nat Nat Blob (E;Error Blob)) (with-expansions [ (as-is (format "from = " (%n from) " | " "to = " (%n to)))] (let [size (host;array-length blob)] (cond (not (n.<= to from)) @@ -127,10 +127,10 @@ (ex;throw Index-Out-Of-Bounds ) ## else - (#R;Success (Arrays.copyOfRange [blob (:! Int from) (:! Int (n.inc to))])))))) + (#E;Success (Arrays.copyOfRange [blob (:! Int from) (:! Int (n.inc to))])))))) (def: #export (slice' from blob) - (-> Nat Blob (R;Result Blob)) + (-> Nat Blob (E;Error Blob)) (slice from (n.dec (host;array-length blob)) blob)) (struct: #export _ (eq;Eq Blob) diff --git a/stdlib/source/lux/world/file.lux b/stdlib/source/lux/world/file.lux index 4c0881e04..1c968b888 100644 --- a/stdlib/source/lux/world/file.lux +++ b/stdlib/source/lux/world/file.lux @@ -4,7 +4,7 @@ ["ex" exception #+ exception:]) (concurrency ["P" promise] ["T" task]) - (data ["R" result] + (data ["E" error] (coll [array])) (time ["i" instant] ["d" duration]) @@ -52,7 +52,7 @@ (do-template [ ] [(def: #export ( data file) (-> Blob File (T;Task Unit)) - (P;future (do (R;ResultT io;Monad) + (P;future (do (E;ErrorT io;Monad) [stream (FileOutputStream.new [(java.io.File.new file) ]) _ (OutputStream.write [data] stream) _ (OutputStream.flush [] stream)] @@ -64,7 +64,7 @@ (def: #export (read file) (-> File (T;Task Blob)) - (P;future (do (R;ResultT io;Monad) + (P;future (do (E;ErrorT io;Monad) [#let [file' (java.io.File.new file)] size (java.io.File.length [] file') #let [data (blob;create (int-to-nat size))] @@ -77,13 +77,13 @@ (def: #export (size file) (-> File (T;Task Nat)) - (P;future (do (R;ResultT io;Monad) + (P;future (do (E;ErrorT io;Monad) [size (java.io.File.length [] (java.io.File.new file))] (wrap (int-to-nat size))))) (def: #export (files dir) (-> File (T;Task (List File))) - (P;future (do (R;ResultT io;Monad) + (P;future (do (E;ErrorT io;Monad) [files (java.io.File.listFiles [] (java.io.File.new dir))] (monad;map @ (java.io.File.getAbsolutePath []) (array;to-list files))))) @@ -110,7 +110,7 @@ (def: #export (get-last-modified file) (-> File (T;Task i;Instant)) - (P;future (do (R;ResultT io;Monad) + (P;future (do (E;ErrorT io;Monad) [millis (java.io.File.lastModified [] (java.io.File.new file))] (wrap (|> millis d;from-millis i;absolute))))) diff --git a/stdlib/source/lux/world/net/tcp.jvm.lux b/stdlib/source/lux/world/net/tcp.jvm.lux index fec65e387..e8832b67e 100644 --- a/stdlib/source/lux/world/net/tcp.jvm.lux +++ b/stdlib/source/lux/world/net/tcp.jvm.lux @@ -4,7 +4,7 @@ (concurrency ["P" promise] ["T" task] [frp]) - (data ["R" result]) + (data ["E" error]) (type opaque) (world [blob #+ Blob]) [io] @@ -44,7 +44,7 @@ (def: #export (read data offset length self) (let [in (get@ #in (@repr self))] (P;future - (do (R;ResultT io;Monad) + (do (E;ErrorT io;Monad) [bytes-read (InputStream.read [data (nat-to-int offset) (nat-to-int length)] in)] (wrap (int-to-nat bytes-read)))))) @@ -52,7 +52,7 @@ (def: #export (write data offset length self) (let [out (get@ #out (@repr self))] (P;future - (do (R;ResultT io;Monad) + (do (E;ErrorT io;Monad) [_ (OutputStream.write [data (nat-to-int offset) (nat-to-int length)] out)] (Flushable.flush [] out))))) @@ -60,14 +60,14 @@ (def: #export (close self) (let [(^open) (@repr self)] (P;future - (do (R;ResultT io;Monad) + (do (E;ErrorT io;Monad) [_ (AutoCloseable.close [] in) _ (AutoCloseable.close [] out)] (AutoCloseable.close [] socket))))) (def: (tcp-client socket) - (-> Socket (io;IO (R;Result TCP))) - (do (R;ResultT io;Monad) + (-> Socket (io;IO (E;Error TCP))) + (do (E;ErrorT io;Monad) [input (Socket.getInputStream [] socket) output (Socket.getOutputStream [] socket)] (wrap (@opaque {#socket socket @@ -77,7 +77,7 @@ (def: #export (client address port) (-> ..;Address ..;Port (T;Task TCP)) (P;future - (do (R;ResultT io;Monad) + (do (E;ErrorT io;Monad) [socket (Socket.new [address (nat-to-int port)])] (tcp-client socket)))) @@ -102,21 +102,21 @@ (def: #export (server port) (-> ..;Port (T;Task (frp;Channel TCP))) (P;future - (do (R;ResultT io;Monad) + (do (E;ErrorT io;Monad) [server (ServerSocket.new [(nat-to-int port)]) #let [output (frp;channel TCP) _ (: (P;Promise Bool) (P;future (loop [tail output] (do io;Monad - [?client (do (R;ResultT io;Monad) + [?client (do (E;ErrorT io;Monad) [socket (ServerSocket.accept [] server)] (tcp-client socket))] (case ?client - (#R;Error error) + (#E;Error error) (frp;close tail) - (#R;Success client) + (#E;Success client) (do @ [?tail' (frp;write client tail)] (case ?tail' diff --git a/stdlib/source/lux/world/net/udp.jvm.lux b/stdlib/source/lux/world/net/udp.jvm.lux index 89eaba448..29be4a920 100644 --- a/stdlib/source/lux/world/net/udp.jvm.lux +++ b/stdlib/source/lux/world/net/udp.jvm.lux @@ -5,7 +5,7 @@ (concurrency ["P" promise] ["T" task] [frp]) - (data ["R" result] + (data ["E" error] [maybe] (coll [array])) (type opaque) @@ -45,10 +45,10 @@ (exception: #export Multiple-Candidate-Addresses) (def: (resolve address) - (-> ..;Address (io;IO (R;Result InetAddress))) - (do (R;ResultT io;Monad) + (-> ..;Address (io;IO (E;Error InetAddress))) + (do (E;ErrorT io;Monad) [addresses (InetAddress.getAllByName [address])] - (: (io;IO (R;Result InetAddress)) + (: (io;IO (E;Error InetAddress)) (case (array;size addresses) +0 (io;io (ex;throw Cannot-Resolve-Address address)) +1 (wrap (maybe;assume (array;read +0 addresses))) @@ -62,7 +62,7 @@ (let [(^open) (@repr self) packet (DatagramPacket.new|receive [data (nat-to-int offset) (nat-to-int length)])] (P;future - (do (R;ResultT io;Monad) + (do (E;ErrorT io;Monad) [_ (DatagramSocket.receive [packet] socket) #let [bytes-read (int-to-nat (DatagramPacket.getLength [] packet))]] (wrap [bytes-read @@ -72,7 +72,7 @@ (def: #export (write address port data offset length self) (-> ..;Address ..;Port Blob Nat Nat UDP (T;Task Unit)) (P;future - (do (R;ResultT io;Monad) + (do (E;ErrorT io;Monad) [address (resolve address) #let [(^open) (@repr self)]] (DatagramSocket.send (DatagramPacket.new|send [data (nat-to-int offset) (nat-to-int length) address (nat-to-int port)]) @@ -87,14 +87,14 @@ (def: #export (client _) (-> Unit (T;Task UDP)) (P;future - (do (R;ResultT io;Monad) + (do (E;ErrorT io;Monad) [socket (DatagramSocket.new|client [])] (wrap (@opaque (#socket socket)))))) (def: #export (server port) (-> ..;Port (T;Task UDP)) (P;future - (do (R;ResultT io;Monad) + (do (E;ErrorT io;Monad) [socket (DatagramSocket.new|server [(nat-to-int port)])] (wrap (@opaque (#socket socket)))))) ) -- cgit v1.2.3