Change decode_field's return type

Author: giacomocavalieri

src/gleam/dynamic.gleam

@@ -476,13 +476,14 @@ if javascript {
 ///
 pub fn field(named name: a, of inner_type: Decoder(t)) -> Decoder(t) {
   fn(value) {
-    case decode_field(value, name) {
-      Error(not_a_map_errors) -> Error(not_a_map_errors)
-      Ok(dynamic_field_result) ->
-        dynamic_field_result
-        |> result.try(inner_type)
-        |> map_errors(push_path(_, name))
-    }
+    let missing_field_error =
+      DecodeError(expected: "field", found: "nothing", path: [])
+
+    use maybe_inner <- result.try(decode_field(value, name))
+    maybe_inner
+    |> option.to_result([missing_field_error])
+    |> result.try(inner_type)
+    |> map_errors(push_path(_, name))
   }
 }
 
@@ -520,16 +521,13 @@ pub fn optional_field(
   of inner_type: Decoder(t),
 ) -> Decoder(Option(t)) {
   fn(value) {
-    case decode_field(value, name) {
-      Error(not_a_map_errors) -> Error(not_a_map_errors)
-      Ok(dynamic_field_result) ->
-        case dynamic_field_result {
-          Error(_) -> Ok(option.None)
-          Ok(dynamic_field) ->
-            dynamic_field
-            |> decode_optional(inner_type)
-            |> map_errors(push_path(_, name))
-        }
+    use maybe_inner <- result.try(decode_field(value, name))
+    case maybe_inner {
+      option.None -> Ok(option.None)
+      option.Some(dynamic_inner) ->
+        dynamic_inner
+        |> decode_optional(inner_type)
+        |> map_errors(push_path(_, name))
     }
   }
 }
@@ -538,15 +536,15 @@ if erlang {
   external fn decode_field(
     Dynamic,
     name,
-  ) -> Result(Result(Dynamic, DecodeErrors), DecodeErrors) =
+  ) -> Result(Option(Dynamic), DecodeErrors) =
     "gleam_stdlib" "decode_field"
 }
 
 if javascript {
   external fn decode_field(
     Dynamic,
     name,
-  ) -> Result(Result(Dynamic, DecodeErrors), DecodeErrors) =
+  ) -> Result(Option(Dynamic), DecodeErrors) =
     "../gleam_stdlib.mjs" "decode_field"
 }
 

src/gleam_stdlib.erl

@@ -80,9 +80,9 @@ decode_list(Data) -> decode_error_msg(<<"List">>, Data).
 
 decode_field(Data, Key) when is_map(Data) ->
     case Data of
-        #{Key := Value} -> {ok, {ok, Value}};
+        #{Key := Value} -> {ok, {some, Value}};
         _ ->
-            {ok, decode_error(<<"field"/utf8>>, <<"nothing"/utf8>>)}
+            {ok, none}
     end;
 decode_field(Data, _) ->
     decode_error_msg(<<"Map">>, Data).

src/gleam_stdlib.mjs

@@ -663,22 +663,21 @@ export function decode_option(data, decoder) {
 }
 
 export function decode_field(value, name) {
-  let missing_field_error = () => decoder_error_no_classify("field", "nothing");
   let not_a_map_error = () => decoder_error("Map", value);
 
   if (value instanceof PMap || value instanceof WeakMap || value instanceof Map) {
     let entry = map_get(value, name);
-    return new Ok(entry.isOk() ? entry : missing_field_error());
+    return new Ok(entry.isOk() ? new Some(entry[0]) : new None());
   } else if (Object.getPrototypeOf(value) == Object.prototype) {
-    return try_get_field(value, name, () => new Ok(missing_field_error()));
+    return try_get_field(value, name, () => new Ok(new None()));
   } else {
     return try_get_field(value, name, not_a_map_error);
   }
 }
 
 function try_get_field(value, field, or_else) {
   try {
-    return field in value ? new Ok(new Ok(value[field])) : or_else();
+    return field in value ? new Ok(new Some(value[field])) : or_else();
   } catch {
     return or_else();
   }