-module(gleam@dynamic@decode). -compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]). -define(FILEPATH, "src/gleam/dynamic/decode.gleam"). -export([run/2, success/1, decode_dynamic/1, map/2, map_errors/2, then/2, one_of/2, recursive/1, optional/1, decode_error/2, decode_bool/1, decode_int/1, decode_float/1, decode_bit_array/1, collapse_errors/2, failure/2, new_primitive_decoder/2, decode_string/1, dict/2, list/1, subfield/3, at/2, field/3, optional_field/4, optionally_at/3]). -export_type([decode_error/0, decoder/1]). -if(?OTP_RELEASE >= 27). -define(MODULEDOC(Str), -moduledoc(Str)). -define(DOC(Str), -doc(Str)). -else. -define(MODULEDOC(Str), -compile([])). -define(DOC(Str), -compile([])). -endif. ?MODULEDOC( " The `Dynamic` type is used to represent dynamically typed data. That is, data\n" " that we don't know the precise type of yet, so we need to introspect the data to\n" " see if it is of the desired type before we can use it. Typically data like this\n" " would come from user input or from untyped languages such as Erlang or JavaScript.\n" "\n" " This module provides the `Decoder` type and associated functions, which provides\n" " a type-safe and composable way to convert dynamic data into some desired type,\n" " or into errors if the data doesn't have the desired structure.\n" "\n" " The `Decoder` type is generic and has 1 type parameter, which is the type that\n" " it attempts to decode. A `Decoder(String)` can be used to decode strings, and a\n" " `Decoder(Option(Int))` can be used to decode `Option(Int)`s\n" "\n" " Decoders work using _runtime reflection_ and the data structures of the target\n" " platform. Differences between Erlang and JavaScript data structures may impact\n" " your decoders, so it is important to test your decoders on all supported\n" " platforms.\n" "\n" " The decoding technique used by this module was inspired by Juraj Petráš'\n" " [Toy](https://github.com/Hackder/toy), Go's `encoding/json`, and Elm's\n" " `Json.Decode`. Thank you to them!\n" "\n" " # Examples\n" "\n" " Dynamic data may come from various sources and so many different syntaxes could\n" " be used to describe or construct them. In these examples a pseudocode\n" " syntax is used to describe the data.\n" "\n" " ## Simple types\n" "\n" " This module defines decoders for simple data types such as [`string`](#string),\n" " [`int`](#int), [`float`](#float), [`bit_array`](#bit_array), and [`bool`](#bool).\n" "\n" " ```gleam\n" " // Data:\n" " // \"Hello, Joe!\"\n" "\n" " let result = decode.run(data, decode.string)\n" " assert result == Ok(\"Hello, Joe!\")\n" " ```\n" "\n" " ## Lists\n" "\n" " The [`list`](#list) decoder decodes `List`s. To use it you must construct it by\n" " passing in another decoder into the `list` function, which is the decoder that\n" " is to be used for the elements of the list, type checking both the list and its\n" " elements.\n" "\n" " ```gleam\n" " // Data:\n" " // [1, 2, 3, 4]\n" "\n" " let result = decode.run(data, decode.list(decode.int))\n" " assert result == Ok([1, 2, 3, 4])\n" " ```\n" "\n" " On Erlang this decoder can decode from lists, and on JavaScript it can\n" " decode from lists as well as JavaScript arrays.\n" "\n" " ## Options\n" "\n" " The [`optional`](#optional) decoder is used to decode values that may or may not\n" " be present. In other environment these might be called \"nullable\" values.\n" "\n" " Like the `list` decoder, the `optional` decoder takes another decoder,\n" " which is used to decode the value if it is present.\n" "\n" " ```gleam\n" " // Data:\n" " // 12.45\n" "\n" " let result = decode.run(data, decode.optional(decode.float))\n" " assert result == Ok(option.Some(12.45))\n" " ```\n" " ```gleam\n" " // Data:\n" " // null\n" "\n" " let result = decode.run(data, decode.optional(decode.int))\n" " assert result == Ok(option.None)\n" " ```\n" "\n" " This decoder knows how to handle multiple different runtime representations of\n" " absent values, including `Nil`, `None`, `null`, and `undefined`.\n" "\n" " ## Dicts\n" "\n" " The [`dict`](#dict) decoder decodes `Dicts` and contains two other decoders, one\n" " for the keys, one for the values.\n" "\n" " ```gleam\n" " // Data:\n" " // { \"Lucy\" -> 10, \"Nubi\" -> 20 }\n" "\n" " let result = decode.run(data, decode.dict(decode.string, decode.int))\n" " assert result == Ok(dict.from_list([\n" " #(\"Lucy\", 10),\n" " #(\"Nubi\", 20),\n" " ]))\n" " ```\n" "\n" " ## Indexing objects\n" "\n" " The [`at`](#at) decoder can be used to decode a value that is nested within\n" " key-value containers such as Gleam dicts, Erlang maps, or JavaScript objects.\n" "\n" " ```gleam\n" " // Data:\n" " // { \"one\" -> { \"two\" -> 123 } }\n" "\n" " let result = decode.run(data, decode.at([\"one\", \"two\"], decode.int))\n" " assert result == Ok(123)\n" " ```\n" "\n" " ## Indexing arrays\n" "\n" " If you use ints as keys then the [`at`](#at) decoder can be used to index into\n" " array-like containers such as Gleam or Erlang tuples, or JavaScript arrays.\n" "\n" " ```gleam\n" " // Data:\n" " // [\"one\", \"two\", \"three\"]\n" "\n" " let result = decode.run(data, decode.at([1], decode.string))\n" " assert result == Ok(\"two\")\n" " ```\n" "\n" " ## Records\n" "\n" " Decoding records from dynamic data is more complex and requires combining a\n" " decoder for each field and a special constructor that builds your records with\n" " the decoded field values.\n" "\n" " ```gleam\n" " // Data:\n" " // {\n" " // \"score\" -> 180,\n" " // \"name\" -> \"Mel Smith\",\n" " // \"is-admin\" -> false,\n" " // \"enrolled\" -> true,\n" " // \"colour\" -> \"Red\",\n" " // }\n" "\n" " let decoder = {\n" " use name <- decode.field(\"name\", decode.string)\n" " use score <- decode.field(\"score\", decode.int)\n" " use colour <- decode.field(\"colour\", decode.string)\n" " use enrolled <- decode.field(\"enrolled\", decode.bool)\n" " decode.success(Player(name:, score:, colour:, enrolled:))\n" " }\n" "\n" " let result = decode.run(data, decoder)\n" " assert result == Ok(Player(\"Mel Smith\", 180, \"Red\", True))\n" " ```\n" "\n" " ## Enum variants\n" "\n" " Imagine you have a custom type where all the variants do not contain any values.\n" "\n" " ```gleam\n" " pub type PocketMonsterType {\n" " Fire\n" " Water\n" " Grass\n" " Electric\n" " }\n" " ```\n" "\n" " You might choose to encode these variants as strings, `\"fire\"` for `Fire`,\n" " `\"water\"` for `Water`, and so on. To decode them you'll need to decode the dynamic\n" " data as a string, but then you'll need to decode it further still as not all\n" " strings are valid values for the enum. This can be done with the `then`\n" " function, which enables running a second decoder after the first one\n" " succeeds.\n" "\n" " ```gleam\n" " let decoder = {\n" " use decoded_string <- decode.then(decode.string)\n" " case decoded_string {\n" " // Return succeeding decoders for valid strings\n" " \"fire\" -> decode.success(Fire)\n" " \"water\" -> decode.success(Water)\n" " \"grass\" -> decode.success(Grass)\n" " \"electric\" -> decode.success(Electric)\n" " // Return a failing decoder for any other strings\n" " _ -> decode.failure(Fire, \"PocketMonsterType\")\n" " }\n" " }\n" "\n" " let result = decode.run(dynamic.string(\"water\"), decoder)\n" " assert result == Ok(Water)\n" "\n" " let result = decode.run(dynamic.string(\"wobble\"), decoder)\n" " assert result == Error([DecodeError(\"PocketMonsterType\", \"String\", [])])\n" " ```\n" "\n" " ## Record variants\n" "\n" " Decoding type variants that contain other values is done by combining the\n" " techniques from the \"enum variants\" and \"records\" examples. Imagine you have\n" " this custom type that you want to decode:\n" "\n" " ```gleam\n" " pub type PocketMonsterPerson {\n" " Trainer(name: String, badge_count: Int)\n" " GymLeader(name: String, speciality: PocketMonsterType)\n" " }\n" " ```\n" " And you would like to be able to decode these from dynamic data like this:\n" " ```erlang\n" " {\n" " \"type\" -> \"trainer\",\n" " \"name\" -> \"Ash\",\n" " \"badge-count\" -> 1,\n" " }\n" " ```\n" " ```erlang\n" " {\n" " \"type\" -> \"gym-leader\",\n" " \"name\" -> \"Misty\",\n" " \"speciality\" -> \"water\",\n" " }\n" " ```\n" "\n" " Notice how both documents have a `\"type\"` field, which is used to indicate which\n" " variant the data is for.\n" "\n" " First, define decoders for each of the variants:\n" "\n" " ```gleam\n" " let trainer_decoder = {\n" " use name <- decode.field(\"name\", decode.string)\n" " use badge_count <- decode.field(\"badge-count\", decode.int)\n" " decode.success(Trainer(name, badge_count))\n" " }\n" "\n" " let gym_leader_decoder = {\n" " use name <- decode.field(\"name\", decode.string)\n" " use speciality <- decode.field(\"speciality\", pocket_monster_type_decoder)\n" " decode.success(GymLeader(name, speciality))\n" " }\n" " ```\n" "\n" " A third decoder can be used to extract and decode the `\"type\"` field, and the\n" " expression can evaluate to whichever decoder is suitable for the document.\n" "\n" " ```gleam\n" " // Data:\n" " // {\n" " // \"type\" -> \"gym-leader\",\n" " // \"name\" -> \"Misty\",\n" " // \"speciality\" -> \"water\",\n" " // }\n" "\n" " let decoder = {\n" " use tag <- decode.field(\"type\", decode.string)\n" " case tag {\n" " \"gym-leader\" -> gym_leader_decoder\n" " _ -> trainer_decoder\n" " }\n" " }\n" "\n" " let result = decode.run(data, decoder)\n" " assert result == Ok(GymLeader(\"Misty\", Water))\n" " ```\n" ). -type decode_error() :: {decode_error, binary(), binary(), list(binary())}. -opaque decoder(BUW) :: {decoder, fun((gleam@dynamic:dynamic_()) -> {BUW, list(decode_error())})}. -file("src/gleam/dynamic/decode.gleam", 356). ?DOC( " Run a decoder on a `Dynamic` value, decoding the value if it is of the\n" " desired type, or returning errors.\n" "\n" " # Examples\n" "\n" " ```gleam\n" " let decoder = {\n" " use name <- decode.field(\"email\", decode.string)\n" " use email <- decode.field(\"password\", decode.string)\n" " decode.success(SignUp(name: name, email: email))\n" " }\n" "\n" " decode.run(data, decoder)\n" " ```\n" ). -spec run(gleam@dynamic:dynamic_(), decoder(BVE)) -> {ok, BVE} | {error, list(decode_error())}. run(Data, Decoder) -> {Maybe_invalid_data, Errors} = (erlang:element(2, Decoder))(Data), case Errors of [] -> {ok, Maybe_invalid_data}; [_ | _] -> {error, Errors} end. -file("src/gleam/dynamic/decode.gleam", 479). ?DOC( " Finalise a decoder having successfully extracted a value.\n" "\n" " # Examples\n" "\n" " ```gleam\n" " let data = dynamic.properties([\n" " #(dynamic.string(\"email\"), dynamic.string(\"lucy@example.com\")),\n" " #(dynamic.string(\"name\"), dynamic.string(\"Lucy\")),\n" " ]))\n" "\n" " let decoder = {\n" " use name <- decode.field(\"name\", string)\n" " use email <- decode.field(\"email\", string)\n" " decode.success(SignUp(name: name, email: email))\n" " }\n" "\n" " let result = decode.run(data, decoder)\n" " assert result == Ok(SignUp(name: \"Lucy\", email: \"lucy@example.com\"))\n" " ```\n" ). -spec success(BWF) -> decoder(BWF). success(Data) -> {decoder, fun(_) -> {Data, []} end}. -file("src/gleam/dynamic/decode.gleam", 718). -spec decode_dynamic(gleam@dynamic:dynamic_()) -> {gleam@dynamic:dynamic_(), list(decode_error())}. decode_dynamic(Data) -> {Data, []}. -file("src/gleam/dynamic/decode.gleam", 875). ?DOC( " Apply a transformation function to any value decoded by the decoder.\n" "\n" " # Examples\n" "\n" " ```gleam\n" " let decoder = decode.int |> decode.map(int.to_string)\n" " let result = decode.run(dynamic.int(1000), decoder)\n" " assert result == Ok(\"1000\")\n" " ```\n" ). -spec map(decoder(BZC), fun((BZC) -> BZE)) -> decoder(BZE). map(Decoder, Transformer) -> {decoder, fun(D) -> {Data, Errors} = (erlang:element(2, Decoder))(D), {Transformer(Data), Errors} end}. -file("src/gleam/dynamic/decode.gleam", 884). ?DOC(" Apply a transformation function to any errors returned by the decoder.\n"). -spec map_errors( decoder(BZG), fun((list(decode_error())) -> list(decode_error())) ) -> decoder(BZG). map_errors(Decoder, Transformer) -> {decoder, fun(D) -> {Data, Errors} = (erlang:element(2, Decoder))(D), {Data, Transformer(Errors)} end}. -file("src/gleam/dynamic/decode.gleam", 922). ?DOC( " Create a new decoder based upon the value of a previous decoder.\n" "\n" " This may be useful to run one previous decoder to use in further decoding.\n" ). -spec then(decoder(BZO), fun((BZO) -> decoder(BZQ))) -> decoder(BZQ). then(Decoder, Next) -> {decoder, fun(Dynamic_data) -> {Data, Errors} = (erlang:element(2, Decoder))(Dynamic_data), Decoder@1 = Next(Data), {Data@1, _} = Layer = (erlang:element(2, Decoder@1))(Dynamic_data), case Errors of [] -> Layer; [_ | _] -> {Data@1, Errors} end end}. -file("src/gleam/dynamic/decode.gleam", 965). -spec run_decoders( gleam@dynamic:dynamic_(), {BZY, list(decode_error())}, list(decoder(BZY)) ) -> {BZY, list(decode_error())}. run_decoders(Data, Failure, Decoders) -> case Decoders of [] -> Failure; [Decoder | Decoders@1] -> {_, Errors} = Layer = (erlang:element(2, Decoder))(Data), case Errors of [] -> Layer; [_ | _] -> run_decoders(Data, Failure, Decoders@1) end end. -file("src/gleam/dynamic/decode.gleam", 952). ?DOC( " Create a new decoder from several other decoders. Each of the inner\n" " decoders is run in turn, and the value from the first to succeed is used.\n" "\n" " If no decoder succeeds then the errors from the first decoder is used.\n" " If you wish for different errors then you may wish to use the\n" " `collapse_errors` or `map_errors` functions.\n" "\n" " # Examples\n" "\n" " ```gleam\n" " let decoder = decode.one_of(decode.string, or: [\n" " decode.int |> decode.map(int.to_string),\n" " decode.float |> decode.map(float.to_string),\n" " ])\n" " decode.run(dynamic.int(1000), decoder)\n" " // -> Ok(\"1000\")\n" " ```\n" ). -spec one_of(decoder(BZT), list(decoder(BZT))) -> decoder(BZT). one_of(First, Alternatives) -> {decoder, fun(Dynamic_data) -> {_, Errors} = Layer = (erlang:element(2, First))(Dynamic_data), case Errors of [] -> Layer; [_ | _] -> run_decoders(Dynamic_data, Layer, Alternatives) end end}. -file("src/gleam/dynamic/decode.gleam", 1048). ?DOC( " Create a decoder that can refer to itself, useful for decoding deeply\n" " nested data.\n" "\n" " Attempting to create a recursive decoder without this function could result\n" " in an infinite loop. If you are using `field` or other `use`able functions\n" " then you may not need to use this function.\n" "\n" " ```gleam\n" " type Nested {\n" " Nested(List(Nested))\n" " Value(String)\n" " }\n" "\n" " fn nested_decoder() -> decode.Decoder(Nested) {\n" " use <- decode.recursive\n" " decode.one_of(decode.string |> decode.map(Value), [\n" " decode.list(nested_decoder()) |> decode.map(Nested),\n" " ])\n" " }\n" " ```\n" ). -spec recursive(fun(() -> decoder(CAJ))) -> decoder(CAJ). recursive(Inner) -> {decoder, fun(Data) -> Decoder = Inner(), (erlang:element(2, Decoder))(Data) end}. -file("src/gleam/dynamic/decode.gleam", 853). ?DOC( " A decoder that decodes nullable values of a type decoded by with a given\n" " decoder.\n" "\n" " This function can handle common representations of null on all runtimes, such as\n" " `nil`, `null`, and `undefined` on Erlang, and `undefined` and `null` on\n" " JavaScript.\n" "\n" " # Examples\n" "\n" " ```gleam\n" " let result = decode.run(dynamic.int(100), decode.optional(decode.int))\n" " assert result == Ok(option.Some(100))\n" " ```\n" "\n" " ```gleam\n" " let result = decode.run(dynamic.nil(), decode.optional(decode.int))\n" " assert result == Ok(option.None)\n" " ```\n" ). -spec optional(decoder(BYY)) -> decoder(gleam@option:option(BYY)). optional(Inner) -> {decoder, fun(Data) -> case gleam_stdlib:is_null(Data) of true -> {none, []}; false -> {Data@1, Errors} = (erlang:element(2, Inner))(Data), {{some, Data@1}, Errors} end end}. -file("src/gleam/dynamic/decode.gleam", 485). ?DOC(" Construct a decode error for some unexpected dynamic data.\n"). -spec decode_error(binary(), gleam@dynamic:dynamic_()) -> list(decode_error()). decode_error(Expected, Found) -> [{decode_error, Expected, gleam_stdlib:classify_dynamic(Found), []}]. -file("src/gleam/dynamic/decode.gleam", 609). -spec run_dynamic_function( gleam@dynamic:dynamic_(), binary(), fun((gleam@dynamic:dynamic_()) -> {ok, BWZ} | {error, BWZ}) ) -> {BWZ, list(decode_error())}. run_dynamic_function(Data, Name, F) -> case F(Data) of {ok, Data@1} -> {Data@1, []}; {error, Zero} -> {Zero, [{decode_error, Name, gleam_stdlib:classify_dynamic(Data), []}]} end. -file("src/gleam/dynamic/decode.gleam", 658). -spec decode_bool(gleam@dynamic:dynamic_()) -> {boolean(), list(decode_error())}. decode_bool(Data) -> case gleam_stdlib:identity(true) =:= Data of true -> {true, []}; false -> case gleam_stdlib:identity(false) =:= Data of true -> {false, []}; false -> {false, decode_error(<<"Bool"/utf8>>, Data)} end end. -file("src/gleam/dynamic/decode.gleam", 680). -spec decode_int(gleam@dynamic:dynamic_()) -> {integer(), list(decode_error())}. decode_int(Data) -> run_dynamic_function(Data, <<"Int"/utf8>>, fun gleam_stdlib:int/1). -file("src/gleam/dynamic/decode.gleam", 699). -spec decode_float(gleam@dynamic:dynamic_()) -> {float(), list(decode_error())}. decode_float(Data) -> run_dynamic_function(Data, <<"Float"/utf8>>, fun gleam_stdlib:float/1). -file("src/gleam/dynamic/decode.gleam", 733). -spec decode_bit_array(gleam@dynamic:dynamic_()) -> {bitstring(), list(decode_error())}. decode_bit_array(Data) -> run_dynamic_function( Data, <<"BitArray"/utf8>>, fun gleam_stdlib:bit_array/1 ). -file("src/gleam/dynamic/decode.gleam", 908). ?DOC( " Replace all errors produced by a decoder with one single error for a named\n" " expected type.\n" "\n" " This function may be useful if you wish to simplify errors before\n" " presenting them to a user, particularly when using the `one_of` function.\n" "\n" " # Examples\n" "\n" " ```gleam\n" " let decoder = decode.string |> decode.collapse_errors(\"MyThing\")\n" " let result = decode.run(dynamic.int(1000), decoder)\n" " assert result == Error([DecodeError(\"MyThing\", \"Int\", [])])\n" " ```\n" ). -spec collapse_errors(decoder(BZL), binary()) -> decoder(BZL). collapse_errors(Decoder, Name) -> {decoder, fun(Dynamic_data) -> {Data, Errors} = Layer = (erlang:element(2, Decoder))(Dynamic_data), case Errors of [] -> Layer; [_ | _] -> {Data, decode_error(Name, Dynamic_data)} end end}. -file("src/gleam/dynamic/decode.gleam", 986). ?DOC( " Define a decoder that always fails. The parameter for this function is the\n" " name of the type that has failed to decode.\n" ). -spec failure(CAD, binary()) -> decoder(CAD). failure(Zero, Expected) -> {decoder, fun(D) -> {Zero, decode_error(Expected, D)} end}. -file("src/gleam/dynamic/decode.gleam", 1015). ?DOC( " Create a decoder for a new data type from a decoding function.\n" "\n" " This function is used for new primitive types. For example, you might\n" " define a decoder for Erlang's pid type.\n" "\n" " A default \"zero\" value is also required to make a decoder. When this\n" " decoder is used as part of a larger decoder this zero value used as\n" " a placeholder so that the rest of the decoder can continue to run and\n" " collect all decoding errors.\n" "\n" " If you were to make a decoder for the `String` type (rather than using the\n" " build-in `string` decoder) you would define it like so:\n" "\n" " ```gleam\n" " pub fn string_decoder() -> decode.Decoder(String) {\n" " let default = \"\"\n" " decode.new_primitive_decoder(\"String\", fn(data) {\n" " case dynamic.string(data) {\n" " Ok(x) -> Ok(x)\n" " Error(_) -> Error(default)\n" " }\n" " })\n" " }\n" " ```\n" ). -spec new_primitive_decoder( binary(), fun((gleam@dynamic:dynamic_()) -> {ok, CAF} | {error, CAF}) ) -> decoder(CAF). new_primitive_decoder(Name, Decoding_function) -> {decoder, fun(D) -> case Decoding_function(D) of {ok, T} -> {T, []}; {error, Zero} -> {Zero, [{decode_error, Name, gleam_stdlib:classify_dynamic(D), []}]} end end}. -file("src/gleam/dynamic/decode.gleam", 636). -spec dynamic_string(gleam@dynamic:dynamic_()) -> {ok, binary()} | {error, binary()}. dynamic_string(Data) -> case gleam_stdlib:bit_array(Data) of {ok, Data@1} -> case gleam@bit_array:to_string(Data@1) of {ok, String} -> {ok, String}; {error, _} -> {error, <<""/utf8>>} end; {error, _} -> {error, <<""/utf8>>} end. -file("src/gleam/dynamic/decode.gleam", 631). -spec decode_string(gleam@dynamic:dynamic_()) -> {binary(), list(decode_error())}. decode_string(Data) -> run_dynamic_function(Data, <<"String"/utf8>>, fun dynamic_string/1). -file("src/gleam/dynamic/decode.gleam", 807). -spec fold_dict( {gleam@dict:dict(BYK, BYL), list(decode_error())}, gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_(), fun((gleam@dynamic:dynamic_()) -> {BYK, list(decode_error())}), fun((gleam@dynamic:dynamic_()) -> {BYL, list(decode_error())}) ) -> {gleam@dict:dict(BYK, BYL), list(decode_error())}. fold_dict(Acc, Key, Value, Key_decoder, Value_decoder) -> case Key_decoder(Key) of {Key@1, []} -> case Value_decoder(Value) of {Value@1, []} -> Dict = gleam@dict:insert( erlang:element(1, Acc), Key@1, Value@1 ), {Dict, erlang:element(2, Acc)}; {_, Errors} -> push_path({maps:new(), Errors}, [<<"values"/utf8>>]) end; {_, Errors@1} -> push_path({maps:new(), Errors@1}, [<<"keys"/utf8>>]) end. -file("src/gleam/dynamic/decode.gleam", 787). ?DOC( " A decoder that decodes dicts where all keys and vales are decoded with\n" " given decoders.\n" "\n" " # Examples\n" "\n" " ```gleam\n" " let values = dynamic.properties([\n" " #(dynamic.string(\"one\"), dynamic.int(1)),\n" " #(dynamic.string(\"two\"), dynamic.int(2)),\n" " ])\n" "\n" " let result =\n" " decode.run(values, decode.dict(decode.string, decode.int))\n" " assert result == Ok(values)\n" " ```\n" ). -spec dict(decoder(BYD), decoder(BYF)) -> decoder(gleam@dict:dict(BYD, BYF)). dict(Key, Value) -> {decoder, fun(Data) -> case gleam_stdlib:dict(Data) of {error, _} -> {maps:new(), decode_error(<<"Dict"/utf8>>, Data)}; {ok, Dict} -> gleam@dict:fold( Dict, {maps:new(), []}, fun(A, K, V) -> case erlang:element(2, A) of [] -> fold_dict( A, K, V, erlang:element(2, Key), erlang:element(2, Value) ); [_ | _] -> A end end ) end end}. -file("src/gleam/dynamic/decode.gleam", 755). ?DOC( " A decoder that decodes lists where all elements are decoded with a given\n" " decoder.\n" "\n" " # Examples\n" "\n" " ```gleam\n" " let result =\n" " [1, 2, 3]\n" " |> list.map(dynamic.int)\n" " |> dynamic.list\n" " |> decode.run(decode.list(of: decode.int))\n" " assert result == Ok([1, 2, 3])\n" " ```\n" ). -spec list(decoder(BXR)) -> decoder(list(BXR)). list(Inner) -> {decoder, fun(Data) -> gleam_stdlib:list( Data, erlang:element(2, Inner), fun(P, K) -> push_path(P, [K]) end, 0, [] ) end}. -file("src/gleam/dynamic/decode.gleam", 439). -spec push_path({BWA, list(decode_error())}, list(any())) -> {BWA, list(decode_error())}. push_path(Layer, Path) -> Decoder = one_of( {decoder, fun decode_string/1}, [begin _pipe = {decoder, fun decode_int/1}, map(_pipe, fun erlang:integer_to_binary/1) end] ), Path@1 = gleam@list:map( Path, fun(Key) -> Key@1 = gleam_stdlib:identity(Key), case run(Key@1, Decoder) of {ok, Key@2} -> Key@2; {error, _} -> <<<<"<"/utf8, (gleam_stdlib:classify_dynamic(Key@1))/binary>>/binary, ">"/utf8>> end end ), Errors = gleam@list:map( erlang:element(2, Layer), fun(Error) -> {decode_error, erlang:element(2, Error), erlang:element(3, Error), lists:append(Path@1, erlang:element(4, Error))} end ), {erlang:element(1, Layer), Errors}. -file("src/gleam/dynamic/decode.gleam", 403). -spec index( list(BVO), list(BVO), fun((gleam@dynamic:dynamic_()) -> {BVR, list(decode_error())}), gleam@dynamic:dynamic_(), fun((gleam@dynamic:dynamic_(), list(BVO)) -> {BVR, list(decode_error())}) ) -> {BVR, list(decode_error())}. index(Path, Position, Inner, Data, Handle_miss) -> case Path of [] -> _pipe = Data, _pipe@1 = Inner(_pipe), push_path(_pipe@1, lists:reverse(Position)); [Key | Path@1] -> case gleam_stdlib:index(Data, Key) of {ok, {some, Data@1}} -> index(Path@1, [Key | Position], Inner, Data@1, Handle_miss); {ok, none} -> Handle_miss(Data, [Key | Position]); {error, Kind} -> {Default, _} = Inner(Data), _pipe@2 = {Default, [{decode_error, Kind, gleam_stdlib:classify_dynamic(Data), []}]}, push_path(_pipe@2, lists:reverse(Position)) end end. -file("src/gleam/dynamic/decode.gleam", 324). ?DOC( " The same as [`field`](#field), except taking a path to the value rather\n" " than a field name.\n" "\n" " This function will index into dictionaries with any key type, and if the key is\n" " an int then it'll also index into Erlang tuples and JavaScript arrays, and\n" " the first eight elements of Gleam lists.\n" "\n" " # Examples\n" "\n" " ```gleam\n" " let data = dynamic.properties([\n" " #(dynamic.string(\"data\"), dynamic.properties([\n" " #(dynamic.string(\"email\"), dynamic.string(\"lucy@example.com\")),\n" " #(dynamic.string(\"name\"), dynamic.string(\"Lucy\")),\n" " ])\n" " ]))\n" "\n" " let decoder = {\n" " use name <- decode.subfield([\"data\", \"name\"], decode.string)\n" " use email <- decode.subfield([\"data\", \"email\"], decode.string)\n" " decode.success(SignUp(name: name, email: email))\n" " }\n" " let result = decode.run(data, decoder)\n" " assert result == Ok(SignUp(name: \"Lucy\", email: \"lucy@example.com\"))\n" " ```\n" ). -spec subfield(list(any()), decoder(BUZ), fun((BUZ) -> decoder(BVB))) -> decoder(BVB). subfield(Field_path, Field_decoder, Next) -> {decoder, fun(Data) -> {Out, Errors1} = index( Field_path, [], erlang:element(2, Field_decoder), Data, fun(Data@1, Position) -> {Default, _} = (erlang:element(2, Field_decoder))(Data@1), _pipe = {Default, [{decode_error, <<"Field"/utf8>>, <<"Nothing"/utf8>>, []}]}, push_path(_pipe, lists:reverse(Position)) end ), {Out@1, Errors2} = (erlang:element(2, Next(Out)))(Data), {Out@1, lists:append(Errors1, Errors2)} end}. -file("src/gleam/dynamic/decode.gleam", 393). ?DOC( " A decoder that decodes a value that is nested within other values. For\n" " example, decoding a value that is within some deeply nested JSON objects.\n" "\n" " This function will index into dictionaries with any key type, and if the key is\n" " an int then it'll also index into Erlang tuples and JavaScript arrays, and\n" " the first eight elements of Gleam lists.\n" "\n" " # Examples\n" "\n" " ```gleam\n" " let decoder = decode.at([\"one\", \"two\"], decode.int)\n" "\n" " let data = dynamic.properties([\n" " #(dynamic.string(\"one\"), dynamic.properties([\n" " #(dynamic.string(\"two\"), dynamic.int(1000)),\n" " ])),\n" " ]))\n" "\n" "\n" " decode.run(data, decoder)\n" " // -> Ok(1000)\n" " ```\n" "\n" " ```gleam\n" " dynamic.nil()\n" " |> decode.run(decode.optional(decode.int))\n" " // -> Ok(option.None)\n" " ```\n" ). -spec at(list(any()), decoder(BVL)) -> decoder(BVL). at(Path, Inner) -> {decoder, fun(Data) -> index( Path, [], erlang:element(2, Inner), Data, fun(Data@1, Position) -> {Default, _} = (erlang:element(2, Inner))(Data@1), _pipe = {Default, [{decode_error, <<"Field"/utf8>>, <<"Nothing"/utf8>>, []}]}, push_path(_pipe, lists:reverse(Position)) end ) end}. -file("src/gleam/dynamic/decode.gleam", 524). ?DOC( " Run a decoder on a field of a `Dynamic` value, decoding the value if it is\n" " of the desired type, or returning errors. An error is returned if there is\n" " no field for the specified key.\n" "\n" " This function will index into dictionaries with any key type, and if the key is\n" " an int then it'll also index into Erlang tuples and JavaScript arrays, and\n" " the first eight elements of Gleam lists.\n" "\n" " # Examples\n" "\n" " ```gleam\n" " let data = dynamic.properties([\n" " #(dynamic.string(\"email\"), dynamic.string(\"lucy@example.com\")),\n" " #(dynamic.string(\"name\"), dynamic.string(\"Lucy\")),\n" " ]))\n" "\n" " let decoder = {\n" " use name <- decode.field(\"name\", string)\n" " use email <- decode.field(\"email\", string)\n" " decode.success(SignUp(name: name, email: email))\n" " }\n" "\n" " let result = decode.run(data, decoder)\n" " assert result == Ok(SignUp(name: \"Lucy\", email: \"lucy@example.com\"))\n" " ```\n" "\n" " If you wish to decode a value that is more deeply nested within the dynamic\n" " data, see [`subfield`](#subfield) and [`at`](#at).\n" "\n" " If you wish to return a default in the event that a field is not present,\n" " see [`optional_field`](#optional_field) and / [`optionally_at`](#optionally_at).\n" ). -spec field(any(), decoder(BWJ), fun((BWJ) -> decoder(BWL))) -> decoder(BWL). field(Field_name, Field_decoder, Next) -> subfield([Field_name], Field_decoder, Next). -file("src/gleam/dynamic/decode.gleam", 557). ?DOC( " Run a decoder on a field of a `Dynamic` value, decoding the value if it is\n" " of the desired type, or returning errors. The given default value is\n" " returned if there is no field for the specified key.\n" "\n" " This function will index into dictionaries with any key type, and if the key is\n" " an int then it'll also index into Erlang tuples and JavaScript arrays, and\n" " the first eight elements of Gleam lists.\n" "\n" " # Examples\n" "\n" " ```gleam\n" " let data = dynamic.properties([\n" " #(dynamic.string(\"name\"), dynamic.string(\"Lucy\")),\n" " ]))\n" "\n" " let decoder = {\n" " use name <- decode.field(\"name\", string)\n" " use email <- decode.optional_field(\"email\", \"n/a\", string)\n" " decode.success(SignUp(name: name, email: email))\n" " }\n" "\n" " let result = decode.run(data, decoder)\n" " assert result == Ok(SignUp(name: \"Lucy\", email: \"n/a\"))\n" " ```\n" ). -spec optional_field(any(), BWP, decoder(BWP), fun((BWP) -> decoder(BWR))) -> decoder(BWR). optional_field(Key, Default, Field_decoder, Next) -> {decoder, fun(Data) -> {Out, Errors1} = begin _pipe = case gleam_stdlib:index(Data, Key) of {ok, {some, Data@1}} -> (erlang:element(2, Field_decoder))(Data@1); {ok, none} -> {Default, []}; {error, Kind} -> {Default, [{decode_error, Kind, gleam_stdlib:classify_dynamic(Data), []}]} end, push_path(_pipe, [Key]) end, {Out@1, Errors2} = (erlang:element(2, Next(Out)))(Data), {Out@1, lists:append(Errors1, Errors2)} end}. -file("src/gleam/dynamic/decode.gleam", 599). ?DOC( " A decoder that decodes a value that is nested within other values. For\n" " example, decoding a value that is within some deeply nested JSON objects.\n" "\n" " This function will index into dictionaries with any key type, and if the key is\n" " an int then it'll also index into Erlang tuples and JavaScript arrays, and\n" " the first eight elements of Gleam lists.\n" "\n" " # Examples\n" "\n" " ```gleam\n" " let decoder = decode.optionally_at([\"one\", \"two\"], 100, decode.int)\n" "\n" " let data = dynamic.properties([\n" " #(dynamic.string(\"one\"), dynamic.properties([])),\n" " ]))\n" "\n" "\n" " decode.run(data, decoder)\n" " // -> Ok(100)\n" " ```\n" ). -spec optionally_at(list(any()), BWW, decoder(BWW)) -> decoder(BWW). optionally_at(Path, Default, Inner) -> {decoder, fun(Data) -> index( Path, [], erlang:element(2, Inner), Data, fun(_, _) -> {Default, []} end ) end}.