1 files changed, 54 insertions, 28 deletions

diff --git a/src/Result.gleam b/src/Result.gleam
index b5b4185..68869f7 100644
--- a/src/Result.gleam
+++ b/src/Result.gleam
@@ -8,89 +8,115 @@ 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)
+type Result(error, value) {
+  | Ok(value)
   | Error(error)
 
-fn is_ok(result) =
-  case result
+fn is_ok(result) {
+  case result {
   | Error(_) => False
   | Ok(_) => True
+  }
+}
 
-test is_ok =
+test is_ok {
   is_ok(Ok(1)) |> Assert.true
   is_ok(Error(1)) |> Assert.false
+}
 
-fn is_error(result) =
-  case result
+fn is_error(result) {
+  case result {
   | Ok(_) => False
   | Error(_) => True
+  }
+}
 
-test is_error =
+test is_error {
   is_error(Ok(1)) |> Assert.false
   is_error(Error(1)) |> Assert.true
+}
 
-fn map(result, fun) =
-  case result
+fn map(result, fun) {
+  case result {
   | Ok(x) => fun(x)
   | Error(_) => result
+  }
+}
 
-test map =
+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
+fn map_error(result, fun) {
+  case result {
   | Ok(_) => result
   | Error(error) => error |> fun |> Error
+  }
+}
 
-test map_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
+fn flatten(result) {
+  case result {
   | Ok(x) => x
   | Error(_) => result
+  }
+}
 
-test flatten =
+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) =
+fn flat_map(result, fun) {
   result
     |> unwrap(_, fun)
     |> flatten
+}
 
-test flat_map =
+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
+fn unwrap(result, default) {
+  case result {
   | Ok(v) => v
   | Error(_) => default
+  }
+}
 
-test unwrap =
+test unwrap {
   unwrap(Ok(1), 50) |> Assert.equal(_, 1)
   unwrap(Error("nope"), 50) |> Assert.equal(_, 50)
+}
 
-fn to_maybe(result) =
-  case result
+fn to_maybe(result) {
+  case result {
   | Ok(v) => Just(v)
   | Error(_) => Nothing
+  }
+}
 
-test to_maybe =
+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
+fn from_maybe(maybe, error_reason) {
+  case maybe {
   | Just(v) => Ok(v)
   | Nothing => Error(error_reason)
+  }
+}
 
-test from_maybe =
+test from_maybe {
   to_maybe(Just(1), :ok) |> Assert.equal(_, Ok(1))
   to_maybe(Nothing, :ok) |> Assert.equal(_, Error(:ok))
+}