Merge #862

862: Add a few QoL functions to the standard library r=Marwes a=Etherian

Adds
- `unwrap_or` and `to_result` to `Option`
- `unwrap_ok_or`, `unwrap_err_or`, and `to_option` to `Result`
- Kleisli composition operators (`<=<` and `>=>`)

Co-authored-by: Etherian <[email protected]>

Author: bors[bot]

std/monad.glu

@@ -47,10 +47,19 @@ let (>>=) x f : [Monad m] -> m a -> (a -> m b) -> m b = flat_map f x
 
 let join mm : [Monad m] -> m (m a) -> m a = mm >>= (\x -> x)
 
+// Kleisli composition
+#[infix(right, 9)]
+let (<=<) g f x : [Monad m] -> (b -> m c) -> (a -> m b) -> a -> m c = g =<< f x
+
+#[infix(left, 9)]
+let (>=>) f g x : [Monad m] -> (a -> m b) -> (b -> m c) -> a -> m c = f x >>= g
+
 {
     Monad,
     flat_map,
     (>>=),
     (=<<),
     join,
+    (<=<),
+    (>=>),
 }

std/option.glu

@@ -12,7 +12,7 @@ let { Applicative } = import! std.applicative
 let { Alternative } = import! std.alternative
 let { Show } = import! std.show
 let { Bool } = import! std.bool
-let { Option } = import! std.types
+let { Option, Result } = import! std.types
 let string @ { ? } = import! std.string
 let { Foldable } = import! std.foldable
 let { (<>) } = import! std.semigroup
@@ -23,6 +23,16 @@ let unwrap opt : Option a -> a =
     | Some x -> x
     | None -> error "Option was None"
 
+let unwrap_or default opt : a -> Option a -> a =
+    match opt with
+    | Some x -> x
+    | None -> default
+
+let to_result err opt : e -> Option a -> Result e a =
+    match opt with
+    | Some x -> Ok x
+    | None -> Err err
+
 let former =
     let semigroup : Semigroup (Option a) = {
         append = \l r ->
@@ -148,7 +158,11 @@ let traversable : Traversable Option = {
 
 {
     Option,
+
     unwrap,
+    unwrap_or,
+    to_result,
+
     semigroup,
     monoid,
     former,

std/result.glu

@@ -6,7 +6,7 @@ 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 { Result, Option } = import! std.types
 let { Foldable } = import! std.foldable
 let { Traversable } = import! std.traversable
 let { Bool } = import! std.bool
@@ -20,16 +20,31 @@ let unwrap_ok res : Result e a -> a =
     | Ok x -> x
     | Err _ -> error "Result was an Err"
 
+let unwrap_ok_or default res : a -> Result e a -> a =
+    match res with
+    | Ok x -> x
+    | Err _ -> default
+
 let unwrap_err res : Result e a -> e =
     match res with
     | Ok _ -> error "Result was an Ok"
     | Err x -> x
 
+let unwrap_err_or default res : e -> Result e a -> e =
+    match res with
+    | Ok _ -> default
+    | 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 to_option res : Result e a -> Option a =
+    match res with
+    | Ok x -> Some x
+    | Err _ -> None
+
 let eq : [Eq e] -> [Eq a] -> Eq (Result e a) = {
     (==) = \l r ->
         match (l, r) with
@@ -103,9 +118,14 @@ let show ?e ?t : [Show e] -> [Show t] -> Show (Result e t) =
 
 {
     Result,
+
     unwrap_ok,
+    unwrap_ok_or,
     unwrap_err,
+    unwrap_err_or,
     map_err,
+    to_option,
+
     eq,
     ord,
     functor,