Restructure

1 files changed, 97 insertions, 0 deletions

diff --git a/src/Result.gleam b/src/Result.gleam
new file mode 100644
index 0000000..ff916e8
--- /dev/null
+++ b/src/Result.gleam
@@ -0,0 +1,97 @@
+module Result
+
+export Result(..), is_ok/1, is_none/1, map/2, map_error/2, flatten/1, flat_map/2,
+       unwrap/2, to_maybe/1, from_maybe/1
+
+import Maybe exposing Maybe(..)
+
+doc """
+Result represents the result of something that may succeed or fail.
+`Ok` means it was successful, `Error` means it failed.
+"""
+type Result(error, value)
+  = Ok(value)
+  | Error(error)
+
+fn is_ok(result) =
+  case result
+  | Error(_) => False
+  | Ok(_) => True
+
+test is_ok =
+  is_ok(Ok(1)) |> Assert.true
+  is_ok(Error(1)) |> Assert.false
+
+fn is_error(result) =
+  case result
+  | Ok(_) => False
+  | Error(_) => True
+
+test is_error =
+  is_error(Ok(1)) |> Assert.false
+  is_error(Error(1)) |> Assert.true
+
+fn map(result, fun) =
+  case result
+  | Ok(x) => fun(x)
+  | Error(_) => result
+
+test map =
+  map(Ok(1), |x| x + 1) |> Assert.equal(_, Ok(2))
+  map(Error(1), |x| x + 1) |> Assert.equal(Error(1))
+
+fn map_error(result, fun) =
+  case result
+  | Ok(_) => result
+  | Error(error) => error |> fun |> Error
+
+test map_error =
+  map_error(Ok(1), |x| x + 1) |> Assert.equal(_, Ok(1))
+  map_error(Error(1), |x| x + 1) |> Assert.equal(Error(2))
+
+fn flatten(result) =
+  case result
+  | Ok(x) => x
+  | Error(_) => result
+
+test flatten =
+  flatten(Ok(Ok(1))) |> Assert.equal(_, Ok(1))
+  flatten(Ok(Error(1))) |> Assert.equal(_, Error(1))
+  flatten(Error(1)) |> Assert.equal(_, Error(1))
+
+fn flat_map(result, fun) =
+  result
+    |> unwrap(_, fun)
+    |> flatten
+
+test flat_map =
+  flat_map(Error(1), |x| Ok(x + 1)) |> Assert.equal(_, Error(1))
+  flat_map(Ok(1), |x| Ok(x + 1)) |> Assert.equal(_, Ok(2))
+  flat_map(Ok(1), |_| Error(1)) |> Assert.equal(_, Error(1))
+
+fn unwrap(result, default) =
+  case result
+  | Ok(v) => v
+  | Error(_) => default
+
+test unwrap =
+  unwrap(Ok(1), 50) |> Assert.equal(_, 1)
+  unwrap(Error("nope"), 50) |> Assert.equal(_, 50)
+
+fn to_maybe(result) =
+  case result
+  | Ok(v) => Just(v)
+  | Error(_) => Nothing
+
+test to_maybe =
+  to_maybe(Ok(1)) |> Assert.equal(_, Just(_, 1))
+  to_maybe(Error(1)) |> Assert.equal(_, Nothing)
+
+fn from_maybe(maybe, error_reason) =
+  case maybe
+  | Just(v) => Ok(v)
+  | Nothing => Error(error_reason)
+
+test from_maybe =
+  to_maybe(Just(1), :ok) |> Assert.equal(_, Ok(1))
+  to_maybe(Nothing, :ok) |> Assert.equal(_, Error(:ok))