//@NO-IMPLICIT-PRELUDEJ
//! Error handling type.
let { Eq, Ord, Ordering, (==) } = import! std.cmp
let { Show } = import! std.show
let { Functor } = import! std.functor
let { Applicative } = import! std.applicative
let { Monad } = import! std.monad
let { Result } = import! std.types
let { Foldable } = import! std.foldable
let { Traversable } = import! std.traversable
let { Bool } = import! std.bool
let { compare } = import! std.cmp
let string @ { ? } = import! std.string
let { (<>) } = import! std.semigroup
let { error } = import! std.prim
let unwrap_ok res : Result e a -> a =
match res with
| Ok x -> x
| Err _ -> error "Result was an Err"
let unwrap_err res : Result e a -> e =
match res with
| Ok _ -> error "Result was an Ok"
| Err x -> x
let map_err f res : (e -> f) -> Result e a -> Result f a =
match res with
| Ok a -> Ok a
| Err e -> Err (f e)
let eq : [Eq e] -> [Eq a] -> Eq (Result e a) = {
(==) = \l r ->
match (l, r) with
| (Ok l_val, Ok r_val) -> l_val == r_val
| (Err l_val, Err r_val) -> l_val == r_val
| _ -> False,
}
let ord : [Ord e] -> [Ord a] -> Ord (Result e a) = {
eq,
compare = \l r ->
match (l, r) with
| (Ok l_val, Ok r_val) -> compare l_val r_val
| (Err l_val, Err r_val) -> compare l_val r_val
| (Ok _, Err _) -> LT
| (Err _, Ok _) -> GT,
}
let functor : Functor (Result e) = {
map = \f x ->
match x with
| Ok y -> Ok (f y)
| Err e -> Err e,
}
let applicative : Applicative (Result e) = {
functor,
apply = \f x ->
match (f, x) with
| (Ok g, Ok y) -> Ok (g y)
| (Ok _, Err e) -> Err e
| (Err x, _) -> Err x,
wrap = \x -> Ok x,
}
let monad : Monad (Result e) = {
applicative = applicative,
flat_map = \f m ->
match m with
| Ok x -> f x
| Err err -> Err err,
}
let foldable : Foldable (Result e) = {
foldr = \f z r ->
match r with
| Err _ -> z
| Ok x -> f x z,
foldl = \f z r ->
match r with
| Err _ -> z
| Ok x -> f z x,
}
let traversable : Traversable (Result e) = {
functor,
foldable,
traverse = \app f r ->
match r with
| Err e -> app.wrap (Err e)
| Ok x -> app.functor.map Ok (f x),
}
let show ?e ?t : [Show e] -> [Show t] -> Show (Result e t) =
let show o =
match o with
| Ok x -> "Ok (" <> t.show x <> ")"
| Err x -> "Err (" <> e.show x <> ")"
{ show }
{
Result,
unwrap_ok,
unwrap_err,
map_err,
eq,
ord,
functor,
applicative,
monad,
foldable,
traversable,
show,
}