Curry result

3 files changed, 33 insertions, 21 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a18af10..796964d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Changelog
 
+## v0.19.1 - 2022-01-09
+
+- The `dynamic.dynamic` function now returns a result.
+
 ## v0.19.0 - 2022-01-09
 
 - The `dynamic` module gains the `dynamic` function.
diff --git a/src/gleam/dynamic.gleam b/src/gleam/dynamic.gleam
index 1f56172..44e6852 100644
--- a/src/gleam/dynamic.gleam
+++ b/src/gleam/dynamic.gleam
@@ -61,14 +61,14 @@ if javascript {
     "../gleam_stdlib.mjs" "identity"
 }
 
-/// Converts a `Dynamic` value into a `Dynamic` value.
+/// Decodes a `Dynamic` value from a `Dynamic` value.
 ///
 /// This function doesn't seem very useful at first, but it can be convenient
 /// when you need to give a decoder function but you don't actually care what
 /// the to-decode value is.
 ///
-pub fn dynamic(term: Dynamic) -> Dynamic {
-  unsafe_coerce(term)
+pub fn dynamic(term: Dynamic) -> Decoder(Dynamic) {
+  Ok
 }
 
 /// Checks to see whether a `Dynamic` value is a bit_string, and returns that bit string if
@@ -292,32 +292,40 @@ if javascript {
 /// ## Examples
 ///
 /// ```gleam
-/// > result(of: from(Ok(1)), ok: int, error: string)
+/// > from(Ok(1))
+/// > |> result(ok: int, error: string)
 /// Ok(Ok(1))
 ///
-/// > result(of: from(Error("boom")), ok: int, error: string)
+/// > from(Error("boom"))
+/// > |> result(ok: int, error: string)
 /// Ok(Error("boom"))
 ///
-/// > result(of: from(123), ok: int, error: string)
+/// > from(123)
+/// > |> result(ok: int, error: string)
 /// Error([DecodeError(expected: "2 element tuple", found: "Int", path: [])])
 /// ```
 ///
 pub fn result(
-  of dynamic: Dynamic,
   ok decode_ok: Decoder(a),
   error decode_error: Decoder(e),
-) -> Result(Result(a, e), DecodeErrors) {
-  try inner_result = decode_result(dynamic)
-
-  case inner_result {
-    Ok(raw) ->
-      raw
-      |> decode_ok
-      |> result.map(Ok)
-    Error(raw) ->
-      raw
-      |> decode_error
-      |> result.map(Error)
+) -> Decoder(Result(a, e)) {
+  fn(value) {
+    try inner_result = decode_result(value)
+
+    case inner_result {
+      Ok(raw) -> {
+        try value =
+          decode_ok(raw)
+          |> map_errors(push_path(_, "ok"))
+        Ok(Ok(value))
+      }
+      Error(raw) -> {
+        try value =
+          decode_error(raw)
+          |> map_errors(push_path(_, "error"))
+        Ok(Error(value))
+      }
+    }
   }
 }
 
diff --git a/test/gleam/dynamic_test.gleam b/test/gleam/dynamic_test.gleam
index b94db28..f08f097 100644
--- a/test/gleam/dynamic_test.gleam
+++ b/test/gleam/dynamic_test.gleam
@@ -745,14 +745,14 @@ pub fn result_test() {
   |> dynamic.from
   |> dynamic.result(ok: dynamic.int, error: dynamic.string)
   |> should.equal(Error([
-    DecodeError(expected: "Int", found: "String", path: []),
+    DecodeError(expected: "Int", found: "String", path: ["ok"]),
   ]))
 
   Error(1)
   |> dynamic.from
   |> dynamic.result(ok: dynamic.int, error: dynamic.string)
   |> should.equal(Error([
-    DecodeError(expected: "String", found: "Int", path: []),
+    DecodeError(expected: "String", found: "Int", path: ["error"]),
   ]))
 
   1