Current section
Files
Jump to
Current section
Files
src/json@blueprint.erl
-module(json@blueprint).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/json/blueprint.gleam").
-export([generate_json_schema/1, list/1, reuse_decoder/1, self_decoder/1, get_dynamic_decoder/1, decode/2, string/0, int/0, float/0, bool/0, field/2, optional/1, optional_field/2, encode_optional_field/4, union_type_encoder/2, union_type_decoder/1, enum_type_encoder/2, enum_type_decoder/1, map/2, tuple2/2, tuple3/3, tuple4/4, tuple5/5, tuple6/6, decode0/1, decode1/2, decode2/3, decode3/4, decode4/5, decode5/6, decode6/7, decode7/8, decode8/9, decode9/10, encode_tuple2/3, encode_tuple3/4, encode_tuple4/5, encode_tuple5/6, encode_tuple6/7, encode_tuple7/8, encode_tuple8/9, encode_tuple9/10]).
-export_type([decoder/1, field_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.
-type decoder(FDU) :: {decoder,
fun((gleam@dynamic:dynamic_()) -> {ok, FDU} |
{error, list(json@blueprint@dynamic:decode_error())}),
json@blueprint@schema:schema_definition(),
list({binary(), json@blueprint@schema:schema_definition()})}.
-type field_decoder(FDV) :: {field_decoder,
fun((gleam@dynamic:dynamic_()) -> {ok, FDV} |
{error, list(json@blueprint@dynamic:decode_error())}),
{binary(), json@blueprint@schema:schema_definition()},
list({binary(), json@blueprint@schema:schema_definition()})}.
-file("src/json/blueprint.gleam", 33).
-spec generate_json_schema(decoder(any())) -> gleam@json:json().
generate_json_schema(Decoder) ->
Refs = case erlang:element(4, Decoder) of
[] ->
none;
Xs ->
{some, Xs}
end,
json@blueprint@schema:to_json(
json@blueprint@schema:new_schema(erlang:element(3, Decoder), Refs)
).
-file("src/json/blueprint.gleam", 180).
-spec list(decoder(FEV)) -> decoder(list(FEV)).
list(Decoder_type) ->
{decoder,
json@blueprint@dynamic:list(erlang:element(2, Decoder_type)),
{array, {some, erlang:element(3, Decoder_type)}},
erlang:element(4, Decoder_type)}.
-file("src/json/blueprint.gleam", 76).
?DOC(
" Creates a reusable version of a decoder that can be used multiple times in a schema\n"
" without duplicating the schema definition.\n"
"\n"
" The function:\n"
" 1. Creates a unique reference name based on the schema's hash\n"
" 2. Moves the original schema into the `$defs` section\n"
" 3. Returns a new decoder that references the schema via `$ref`\n"
"\n"
" ## Example\n"
" ```gleam\n"
" type Person {\n"
" Person(name: String, friends: List(Pet))\n"
" }\n"
"\n"
" type Pet {\n"
" Pet(name: String)\n"
" }\n"
"\n"
"\n"
" let pet_decoder = reuse_decoder(\n"
" decode2(\n"
" Pet,\n"
" field(\"name\", string()),\n"
" )\n"
" )\n"
"\n"
" let person_decoder = reuse_decoder(\n"
" decode2(\n"
" Person,\n"
" field(\"name\", string()),\n"
" field(\"friends\", list(pet_decoder))\n"
" )\n"
" )\n"
" ```\n"
).
-spec reuse_decoder(decoder(FEE)) -> decoder(FEE).
reuse_decoder(Decoder) ->
Def_name = <<"ref_"/utf8,
(json@blueprint@schema:hash_schema_definition(
erlang:element(3, Decoder)
))/binary>>,
Ref_name = <<"#/$defs/"/utf8, Def_name/binary>>,
Schema_with_rebased_self_refs = json@blueprint@schema:map_ref(
erlang:element(3, Decoder),
fun(Original_ref_name) -> case Original_ref_name of
<<"#"/utf8>> ->
Ref_name;
X ->
X
end end
),
{decoder,
erlang:element(2, Decoder),
{ref, Ref_name},
begin
_pipe = erlang:element(4, Decoder),
gleam@list:prepend(_pipe, {Def_name, Schema_with_rebased_self_refs})
end}.
-file("src/json/blueprint.gleam", 133).
?DOC(
" Creates a decoder for recursive data types by allowing self-referential definitions.\n"
" This is useful when you have types that contain themselves, like trees or linked lists.\n"
"\n"
" The function takes a lazy decoder (a function that returns a decoder) to break the\n"
" recursive dependency cycle. The returned decoder uses a JSON Schema reference \"#\"\n"
" to point to the root schema definition.\n"
"\n"
" > ❗ _**IMPORTANT**_\n"
" > Add the reuse_decoder when there are nested recursive types so\n"
" > the schema references (`#`) get rewritten correctly and self-references from the\n"
" > different types don't get mixed up. As a recommendation, always add it when\n"
" > decoding recursive types.\n"
"\n"
" ## Example\n"
" ```gleam\n"
" // A binary tree type that can contain itself\n"
" pub type Tree {\n"
" Node(value: Int, left: Option(Tree), right: Option(Tree))\n"
" Leaf(value: Int)\n"
" }\n"
"\n"
" // Create a recursive decoder for the Tree type\n"
" pub fn tree_decoder() -> Decoder(Tree) {\n"
" // Use union_type_decoder for handling different variants\n"
" union_type_decoder([\n"
" #(\"leaf\", decode1(Leaf, field(\"value\", int()))),\n"
" #(\"node\", decode3(\n"
" Node,\n"
" field(\"value\", int()),\n"
" // Use self_decoder to handle recursive fields\n"
" field(\"left\", optional(self_decoder(tree_decoder))),\n"
" field(\"right\", optional(self_decoder(tree_decoder))),\n"
" )),\n"
" ])\n"
" |> reuse_decoder\n"
" }\n"
" ```\n"
).
-spec self_decoder(fun(() -> decoder(FEH))) -> decoder(FEH).
self_decoder(Lazy) ->
{decoder,
fun(Input) -> (erlang:element(2, Lazy()))(Input) end,
{ref, <<"#"/utf8>>},
[]}.
-file("src/json/blueprint.gleam", 137).
-spec get_dynamic_decoder(decoder(FEK)) -> fun((gleam@dynamic:dynamic_()) -> {ok,
FEK} |
{error, list(json@blueprint@dynamic:decode_error())}).
get_dynamic_decoder(Decoder) ->
erlang:element(2, Decoder).
-file("src/json/blueprint.gleam", 141).
-spec decode(decoder(FEN), binary()) -> {ok, FEN} |
{error, gleam@json:decode_error()}.
decode(Decoder, Json_string) ->
gleam@result:'try'(
gleam@json:parse(
Json_string,
{decoder, fun gleam@dynamic@decode:decode_dynamic/1}
),
fun(Dyn) -> _pipe = (erlang:element(2, Decoder))(Dyn),
gleam@result:map_error(
_pipe,
fun(Errors) ->
{unable_to_decode,
gleam@list:map(
Errors,
fun(Error) ->
{decode_error,
erlang:element(2, Error),
erlang:element(3, Error),
erlang:element(4, Error)}
end
)}
end
) end
).
-file("src/json/blueprint.gleam", 164).
-spec string() -> decoder(binary()).
string() ->
{decoder, fun json@blueprint@dynamic:string/1, {type, string_type}, []}.
-file("src/json/blueprint.gleam", 168).
-spec int() -> decoder(integer()).
int() ->
{decoder, fun json@blueprint@dynamic:int/1, {type, integer_type}, []}.
-file("src/json/blueprint.gleam", 172).
-spec float() -> decoder(float()).
float() ->
{decoder, fun json@blueprint@dynamic:float/1, {type, number_type}, []}.
-file("src/json/blueprint.gleam", 176).
-spec bool() -> decoder(boolean()).
bool() ->
{decoder, fun json@blueprint@dynamic:bool/1, {type, boolean_type}, []}.
-file("src/json/blueprint.gleam", 188).
-spec field(binary(), decoder(FEZ)) -> field_decoder(FEZ).
field(Name, Inner_type) ->
{field_decoder,
json@blueprint@dynamic:field(Name, erlang:element(2, Inner_type)),
{Name, erlang:element(3, Inner_type)},
erlang:element(4, Inner_type)}.
-file("src/json/blueprint.gleam", 218).
?DOC(
" Creates a decoder that can handle `null` values by wrapping the result in an `Option` type.\n"
" When the value is `null`, it returns `None`. Otherwise, it uses the provided decoder\n"
" to decode the value and wraps the result in `Some`. If you need the decoder to handle a possible missing field\n"
" (i.e., the field is absent from the JSON), use the `optional_field` function instead.\n"
"\n"
" ## Example\n"
" ```gleam\n"
" type User {\n"
" User(name: String, age: Option(Int))\n"
" }\n"
"\n"
" let decoder = decode2(\n"
" User,\n"
" field(\"name\", string()),\n"
" field(\"age\", optional(int())) // Will handle \"age\": null\n"
" )\n"
"\n"
" // These JSON strings will decode successfully:\n"
" // {\"name\": \"Alice\", \"age\": 25} -> User(\"Alice\", Some(25))\n"
" // {\"name\": \"Bob\", \"age\": null} -> User(\"Bob\", None)\n"
" ```\n"
).
-spec optional(decoder(FFC)) -> decoder(gleam@option:option(FFC)).
optional(Decode) ->
{decoder,
json@blueprint@dynamic:optional(erlang:element(2, Decode)),
{nullable, erlang:element(3, Decode)},
erlang:element(4, Decode)}.
-file("src/json/blueprint.gleam", 254).
?DOC(
" Decode a field that can be missing or have a `null` value into an `Option` type.\n"
" This function is useful when you want to handle both cases where a field is absent from the JSON\n"
" or when it's explicitly set to `null`.\n"
"\n"
" If you only need to handle fields that are present but might be `null`, use the `optional` function instead.\n"
"\n"
" ## Example\n"
" ```gleam\n"
" type User {\n"
" User(name: String, age: Option(Int))\n"
" }\n"
"\n"
" let decoder = decode2(\n"
" User,\n"
" field(\"name\", string()),\n"
" optional_field(\"age\", int()) // Will handle both missing \"age\" field and \"age\": null\n"
" )\n"
"\n"
" // All these JSON strings will decode successfully:\n"
" // {\"name\": \"Alice\", \"age\": 25} -> User(\"Alice\", Some(25))\n"
" // {\"name\": \"Bob\", \"age\": null} -> User(\"Bob\", None)\n"
" // {\"name\": \"Charlie\"} -> User(\"Charlie\", None)\n"
" ```\n"
).
-spec optional_field(binary(), decoder(FFG)) -> field_decoder(gleam@option:option(FFG)).
optional_field(Name, Inner_type) ->
{field_decoder,
fun(Value) ->
_pipe = (json@blueprint@dynamic:optional_field(
Name,
fun(Dyn) -> case Dyn =:= json_blueprint_ffi:null() of
false ->
gleam@result:map(
(erlang:element(2, Inner_type))(Dyn),
fun(Field@0) -> {some, Field@0} end
);
true ->
{ok, none}
end end
))(Value),
gleam@result:map(_pipe, fun gleam@option:flatten/1)
end,
{Name, {optional, erlang:element(3, Inner_type)}},
erlang:element(4, Inner_type)}.
-file("src/json/blueprint.gleam", 316).
?DOC(
" Adds an optional field to a list of key-value pairs that will be used to create a JSON object.\n"
" This is particularly useful when defining JSON encoder to pair up to the `optional_field` decoder.\n"
"\n"
" ## Example\n"
" ```gleam\n"
" fn tree_decoder() {\n"
" blueprint.union_type_decoder([\n"
" #(\n"
" \"node\",\n"
" blueprint.decode3(\n"
" Node,\n"
" blueprint.field(\"value\", blueprint.int()),\n"
" // This is an optional field for an optional value\n"
" blueprint.optional_field(\"left\", blueprint.self_decoder(tree_decoder)),\n"
" // And this is a required field with an optional value\n"
" blueprint.field(\n"
" \"right\",\n"
" blueprint.optional(blueprint.self_decoder(tree_decoder)),\n"
" ),\n"
" ),\n"
" ),\n"
" ])\n"
" |> blueprint.reuse_decoder\n"
" }\n"
"\n"
" fn encode_tree(tree: Tree) -> json.Json {\n"
" blueprint.union_type_encoder(tree, fn(node) {\n"
" case node {\n"
" Node(value, left, right) -> #(\n"
" \"node\",\n"
" [\n"
" #(\"value\", json.int(value)),\n"
" // This is a required field with an optional value\n"
" #(\"right\", json.nullable(right, encode_tree)),\n"
" ]\n"
" // And this is an optional field for an optional value\n"
" |> blueprint.encode_optional_field(\"left\", left, encode_tree)\n"
" |> json.object(),\n"
" )\n"
" }\n"
" })\n"
" }\n"
" ```\n"
).
-spec encode_optional_field(
list({binary(), gleam@json:json()}),
binary(),
gleam@option:option(FFL),
fun((FFL) -> gleam@json:json())
) -> list({binary(), gleam@json:json()}).
encode_optional_field(Fields, Name, Value, Encode_fn) ->
case Value of
{some, Left} ->
gleam@list:prepend(Fields, {Name, Encode_fn(Left)});
none ->
Fields
end.
-file("src/json/blueprint.gleam", 356).
?DOC(
" Function to encode a union type into a JSON object.\n"
" The function takes a value and an encoder function that returns a tuple of the type name and the JSON value.\n"
"\n"
"> [!IMPORTANT]\n"
"> Make sure to update the decoder function accordingly.\n"
"\n"
" ## Example\n"
" ```gleam\n"
" type Shape {\n"
" Circle(Float)\n"
" Rectangle(Float, Float)\n"
" }\n"
"\n"
" let shape_encoder = union_type_encoder(fn(shape) {\n"
" case shape {\n"
" Circle(radius) -> #(\"circle\", json.object([#(\"radius\", json.float(radius))]))\n"
" Rectangle(width, height) -> #(\n"
" \"rectangle\",\n"
" json.object([\n"
" #(\"width\", json.float(width)),\n"
" #(\"height\", json.float(height))\n"
" ])\n"
" )\n"
" }\n"
" })\n"
" ```\n"
).
-spec union_type_encoder(FFO, fun((FFO) -> {binary(), gleam@json:json()})) -> gleam@json:json().
union_type_encoder(Of, Encoder_fn) ->
{Field_name, Json_value} = Encoder_fn(Of),
gleam@json:object(
[{<<"type"/utf8>>, gleam@json:string(Field_name)},
{<<"data"/utf8>>, Json_value}]
).
-file("src/json/blueprint.gleam", 386).
?DOC(
" Function to defined a decoder for a union types.\n"
" The function takes a list of decoders for each possible type of the union.\n"
"\n"
"> [!IMPORTANT]\n"
"> Make sure to add tests for every possible type of the union because it is not possible to check for exhaustiveness in the case.\n"
"\n"
" ## Example\n"
" ```gleam\n"
" type Shape {\n"
" Circle(Float)\n"
" Rectangle(Float, Float)\n"
" }\n"
"\n"
" let shape_decoder = union_type_decoder([\n"
" #(\"circle\", decode1(Circle, field(\"radius\", float()))),\n"
" #(\"rectangle\", decode2(Rectangle,\n"
" field(\"width\", float()),\n"
" field(\"height\", float())\n"
" ))\n"
" ])\n"
" ```\n"
).
-spec union_type_decoder(list({binary(), decoder(FFP)})) -> decoder(FFP).
union_type_decoder(Decoders) ->
Constructor = fun(Type_str, Data) -> _pipe = Decoders,
_pipe@1 = gleam@list:find_map(
_pipe,
fun(Dec) -> case erlang:element(1, Dec) =:= Type_str of
true ->
{ok,
(erlang:element(2, (erlang:element(2, Dec))))(Data)};
_ ->
{error, []}
end end
),
_pipe@4 = gleam@result:map_error(
_pipe@1,
fun(_) ->
Valid_types = begin
_pipe@2 = Decoders,
_pipe@3 = gleam@list:map(
_pipe@2,
fun(Dec@1) -> erlang:element(1, Dec@1) end
),
gleam@string:join(_pipe@3, <<", "/utf8>>)
end,
[{decode_error,
<<"valid constructor type, one of: "/utf8,
Valid_types/binary>>,
Type_str,
[]}]
end
),
gleam@result:flatten(_pipe@4) end,
Enum_decoder = fun(Data@1) ->
_pipe@5 = (json@blueprint@dynamic:decode2(
Constructor,
json@blueprint@dynamic:field(
<<"type"/utf8>>,
fun json@blueprint@dynamic:string/1
),
json@blueprint@dynamic:field(
<<"data"/utf8>>,
fun json@blueprint@dynamic:dynamic/1
)
))(Data@1),
gleam@result:flatten(_pipe@5)
end,
Schema = case Decoders of
[] ->
{object, [], {some, false}, none};
[{Name, Dec@2}] ->
{object,
[{<<"type"/utf8>>,
{enum, [gleam@json:string(Name)], {some, string_type}}},
{<<"data"/utf8>>, erlang:element(3, Dec@2)}],
{some, false},
{some, [<<"type"/utf8>>, <<"data"/utf8>>]}};
Xs ->
_pipe@6 = gleam@list:map(
Xs,
fun(Field_dec) ->
{Name@1, Dec@3} = Field_dec,
{object,
[{<<"type"/utf8>>,
{enum,
[gleam@json:string(Name@1)],
{some, string_type}}},
{<<"data"/utf8>>, erlang:element(3, Dec@3)}],
{some, false},
{some, [<<"type"/utf8>>, <<"data"/utf8>>]}}
end
),
{any_of, _pipe@6}
end,
Defs = gleam@list:flat_map(
Decoders,
fun(Dec@4) -> erlang:element(4, (erlang:element(2, Dec@4))) end
),
{decoder, Enum_decoder, Schema, Defs}.
-file("src/json/blueprint.gleam", 482).
?DOC(
" Function to encode an enum type (unions where constructors have no arguments) into a JSON object.\n"
" The function takes a value and an encoder function that returns the string representation of the enum value.\n"
"\n"
"> [!IMPORTANT]\n"
"> Make sure to update the decoder function accordingly.\n"
"\n"
" ## Example\n"
" ```gleam\n"
" type Color {\n"
" Red\n"
" Green\n"
" Blue\n"
" }\n"
"\n"
" let color_encoder = enum_type_encoder(fn(color) {\n"
" case color {\n"
" Red -> \"red\"\n"
" Green -> \"green\"\n"
" Blue -> \"blue\"\n"
" }\n"
" })\n"
" ```\n"
).
-spec enum_type_encoder(FFT, fun((FFT) -> binary())) -> gleam@json:json().
enum_type_encoder(Of, Encoder_fn) ->
Field_name = Encoder_fn(Of),
gleam@json:object([{<<"enum"/utf8>>, gleam@json:string(Field_name)}]).
-file("src/json/blueprint.gleam", 511).
?DOC(
" Function to define a decoder for enum types (unions where constructors have no arguments).\n"
" The function takes a list of tuples containing the string representation and the corresponding enum value.\n"
"\n"
"> [!IMPORTANT]\n"
"> Make sure to add tests for every possible enum value because it is not possible to check for exhaustiveness.\n"
"\n"
" ## Example\n"
" ```gleam\n"
" type Color {\n"
" Red\n"
" Green\n"
" Blue\n"
" }\n"
"\n"
" let color_decoder = enum_type_decoder([\n"
" #(\"red\", Red),\n"
" #(\"green\", Green),\n"
" #(\"blue\", Blue),\n"
" ])\n"
" ```\n"
).
-spec enum_type_decoder(list({binary(), FFU})) -> decoder(FFU).
enum_type_decoder(Decoders) ->
Constructor = fun(Type_str) -> _pipe = Decoders,
_pipe@1 = gleam@list:find_map(
_pipe,
fun(Dec) -> case erlang:element(1, Dec) =:= Type_str of
true ->
{ok, erlang:element(2, Dec)};
_ ->
{error, []}
end end
),
gleam@result:map_error(
_pipe@1,
fun(_) ->
Valid_types = begin
_pipe@2 = Decoders,
_pipe@3 = gleam@list:map(
_pipe@2,
fun(Dec@1) -> erlang:element(1, Dec@1) end
),
gleam@string:join(_pipe@3, <<", "/utf8>>)
end,
[{decode_error,
<<"valid constructor type, one of: "/utf8,
Valid_types/binary>>,
Type_str,
[]}]
end
) end,
Enum_decoder = fun(Data) ->
_pipe@4 = (json@blueprint@dynamic:decode1(
Constructor,
json@blueprint@dynamic:field(
<<"enum"/utf8>>,
fun json@blueprint@dynamic:string/1
)
))(Data),
gleam@result:flatten(_pipe@4)
end,
{decoder,
Enum_decoder,
begin
_pipe@5 = gleam@list:map(
Decoders,
fun(Field_dec) ->
gleam@json:string(erlang:element(1, Field_dec))
end
),
_pipe@6 = (fun(Enum_values) ->
[{<<"enum"/utf8>>, {enum, Enum_values, {some, string_type}}}]
end)(_pipe@5),
{object, _pipe@6, {some, false}, {some, [<<"enum"/utf8>>]}}
end,
[]}.
-file("src/json/blueprint.gleam", 554).
-spec map(decoder(FFX), fun((FFX) -> FFZ)) -> decoder(FFZ).
map(Decoder, Foo) ->
{decoder,
fun(Input) ->
gleam@result:map((erlang:element(2, Decoder))(Input), Foo)
end,
erlang:element(3, Decoder),
erlang:element(4, Decoder)}.
-file("src/json/blueprint.gleam", 562).
-spec tuple2(decoder(FGB), decoder(FGD)) -> decoder({FGB, FGD}).
tuple2(Decode1, Decode2) ->
{decoder,
json@blueprint@dynamic:tuple2(
erlang:element(2, Decode1),
erlang:element(2, Decode2)
),
{detailed_array,
none,
{some, [erlang:element(3, Decode1), erlang:element(3, Decode2)]},
{some, 2},
{some, 2},
none,
none,
none,
none},
lists:append(erlang:element(4, Decode1), erlang:element(4, Decode2))}.
-file("src/json/blueprint.gleam", 582).
-spec tuple3(decoder(FGG), decoder(FGI), decoder(FGK)) -> decoder({FGG,
FGI,
FGK}).
tuple3(Decode1, Decode2, Decode3) ->
{decoder,
json@blueprint@dynamic:tuple3(
erlang:element(2, Decode1),
erlang:element(2, Decode2),
erlang:element(2, Decode3)
),
{detailed_array,
none,
{some,
[erlang:element(3, Decode1),
erlang:element(3, Decode2),
erlang:element(3, Decode3)]},
{some, 3},
{some, 3},
none,
none,
none,
none},
lists:append(
[erlang:element(4, Decode1),
erlang:element(4, Decode2),
erlang:element(4, Decode3)]
)}.
-file("src/json/blueprint.gleam", 607).
-spec tuple4(decoder(FGN), decoder(FGP), decoder(FGR), decoder(FGT)) -> decoder({FGN,
FGP,
FGR,
FGT}).
tuple4(Decode1, Decode2, Decode3, Decode4) ->
{decoder,
json@blueprint@dynamic:tuple4(
erlang:element(2, Decode1),
erlang:element(2, Decode2),
erlang:element(2, Decode3),
erlang:element(2, Decode4)
),
{detailed_array,
none,
{some,
[erlang:element(3, Decode1),
erlang:element(3, Decode2),
erlang:element(3, Decode3),
erlang:element(3, Decode4)]},
{some, 4},
{some, 4},
none,
none,
none,
none},
lists:append(
[erlang:element(4, Decode1),
erlang:element(4, Decode2),
erlang:element(4, Decode3),
erlang:element(4, Decode4)]
)}.
-file("src/json/blueprint.gleam", 634).
-spec tuple5(
decoder(FGW),
decoder(FGY),
decoder(FHA),
decoder(FHC),
decoder(FHE)
) -> decoder({FGW, FGY, FHA, FHC, FHE}).
tuple5(Decode1, Decode2, Decode3, Decode4, Decode5) ->
{decoder,
json@blueprint@dynamic:tuple5(
erlang:element(2, Decode1),
erlang:element(2, Decode2),
erlang:element(2, Decode3),
erlang:element(2, Decode4),
erlang:element(2, Decode5)
),
{detailed_array,
none,
{some,
[erlang:element(3, Decode1),
erlang:element(3, Decode2),
erlang:element(3, Decode3),
erlang:element(3, Decode4),
erlang:element(3, Decode5)]},
{some, 5},
{some, 5},
none,
none,
none,
none},
lists:append(
[erlang:element(4, Decode1),
erlang:element(4, Decode2),
erlang:element(4, Decode3),
erlang:element(4, Decode4),
erlang:element(4, Decode5)]
)}.
-file("src/json/blueprint.gleam", 675).
-spec tuple6(
decoder(FHH),
decoder(FHJ),
decoder(FHL),
decoder(FHN),
decoder(FHP),
decoder(FHR)
) -> decoder({FHH, FHJ, FHL, FHN, FHP, FHR}).
tuple6(Decode1, Decode2, Decode3, Decode4, Decode5, Decode6) ->
{decoder,
json@blueprint@dynamic:tuple6(
erlang:element(2, Decode1),
erlang:element(2, Decode2),
erlang:element(2, Decode3),
erlang:element(2, Decode4),
erlang:element(2, Decode5),
erlang:element(2, Decode6)
),
{detailed_array,
none,
{some,
[erlang:element(3, Decode1),
erlang:element(3, Decode2),
erlang:element(3, Decode3),
erlang:element(3, Decode4),
erlang:element(3, Decode5),
erlang:element(3, Decode6)]},
{some, 6},
{some, 6},
none,
none,
none,
none},
lists:append(
[erlang:element(4, Decode1),
erlang:element(4, Decode2),
erlang:element(4, Decode3),
erlang:element(4, Decode4),
erlang:element(4, Decode5),
erlang:element(4, Decode6)]
)}.
-file("src/json/blueprint.gleam", 720).
-spec create_object_schema(
list({binary(), json@blueprint@schema:schema_definition()})
) -> json@blueprint@schema:schema_definition().
create_object_schema(Fields) ->
{object,
Fields,
{some, false},
{some, gleam@list:filter_map(Fields, fun(Field_dec) -> case Field_dec of
{_, {optional, _}} ->
{error, nil};
{Name, _} ->
{ok, Name}
end end)}}.
-file("src/json/blueprint.gleam", 737).
-spec decode0(FHV) -> decoder(FHV).
decode0(Constructor) ->
{decoder,
fun(_) -> {ok, Constructor} end,
{object, [], {some, false}, none},
[]}.
-file("src/json/blueprint.gleam", 764).
-spec decode1(fun((FHX) -> FHY), field_decoder(FHX)) -> decoder(FHY).
decode1(Constructor, T1) ->
{decoder,
json@blueprint@dynamic:decode1(Constructor, erlang:element(2, T1)),
create_object_schema([erlang:element(3, T1)]),
erlang:element(4, T1)}.
-file("src/json/blueprint.gleam", 772).
-spec decode2(fun((FIB, FIC) -> FID), field_decoder(FIB), field_decoder(FIC)) -> decoder(FID).
decode2(Constructor, T1, T2) ->
{decoder,
json@blueprint@dynamic:decode2(
Constructor,
erlang:element(2, T1),
erlang:element(2, T2)
),
create_object_schema([erlang:element(3, T1), erlang:element(3, T2)]),
lists:append([erlang:element(4, T1), erlang:element(4, T2)])}.
-file("src/json/blueprint.gleam", 784).
-spec decode3(
fun((FIH, FII, FIJ) -> FIK),
field_decoder(FIH),
field_decoder(FII),
field_decoder(FIJ)
) -> decoder(FIK).
decode3(Constructor, T1, T2, T3) ->
{decoder,
json@blueprint@dynamic:decode3(
Constructor,
erlang:element(2, T1),
erlang:element(2, T2),
erlang:element(2, T3)
),
create_object_schema(
[erlang:element(3, T1),
erlang:element(3, T2),
erlang:element(3, T3)]
),
lists:append(
[erlang:element(4, T1),
erlang:element(4, T2),
erlang:element(4, T3)]
)}.
-file("src/json/blueprint.gleam", 797).
-spec decode4(
fun((FIP, FIQ, FIR, FIS) -> FIT),
field_decoder(FIP),
field_decoder(FIQ),
field_decoder(FIR),
field_decoder(FIS)
) -> decoder(FIT).
decode4(Constructor, T1, T2, T3, T4) ->
{decoder,
json@blueprint@dynamic:decode4(
Constructor,
erlang:element(2, T1),
erlang:element(2, T2),
erlang:element(2, T3),
erlang:element(2, T4)
),
create_object_schema(
[erlang:element(3, T1),
erlang:element(3, T2),
erlang:element(3, T3),
erlang:element(3, T4)]
),
lists:append(
[erlang:element(4, T1),
erlang:element(4, T2),
erlang:element(4, T3),
erlang:element(4, T4)]
)}.
-file("src/json/blueprint.gleam", 822).
-spec decode5(
fun((FIZ, FJA, FJB, FJC, FJD) -> FJE),
field_decoder(FIZ),
field_decoder(FJA),
field_decoder(FJB),
field_decoder(FJC),
field_decoder(FJD)
) -> decoder(FJE).
decode5(Constructor, T1, T2, T3, T4, T5) ->
{decoder,
json@blueprint@dynamic:decode5(
Constructor,
erlang:element(2, T1),
erlang:element(2, T2),
erlang:element(2, T3),
erlang:element(2, T4),
erlang:element(2, T5)
),
create_object_schema(
[erlang:element(3, T1),
erlang:element(3, T2),
erlang:element(3, T3),
erlang:element(3, T4),
erlang:element(3, T5)]
),
lists:append(
[erlang:element(4, T1),
erlang:element(4, T2),
erlang:element(4, T3),
erlang:element(4, T4),
erlang:element(4, T5)]
)}.
-file("src/json/blueprint.gleam", 850).
-spec decode6(
fun((FJL, FJM, FJN, FJO, FJP, FJQ) -> FJR),
field_decoder(FJL),
field_decoder(FJM),
field_decoder(FJN),
field_decoder(FJO),
field_decoder(FJP),
field_decoder(FJQ)
) -> decoder(FJR).
decode6(Constructor, T1, T2, T3, T4, T5, T6) ->
{decoder,
json@blueprint@dynamic:decode6(
Constructor,
erlang:element(2, T1),
erlang:element(2, T2),
erlang:element(2, T3),
erlang:element(2, T4),
erlang:element(2, T5),
erlang:element(2, T6)
),
create_object_schema(
[erlang:element(3, T1),
erlang:element(3, T2),
erlang:element(3, T3),
erlang:element(3, T4),
erlang:element(3, T5),
erlang:element(3, T6)]
),
lists:append(
[erlang:element(4, T1),
erlang:element(4, T2),
erlang:element(4, T3),
erlang:element(4, T4),
erlang:element(4, T5),
erlang:element(4, T6)]
)}.
-file("src/json/blueprint.gleam", 881).
-spec decode7(
fun((FJZ, FKA, FKB, FKC, FKD, FKE, FKF) -> FKG),
field_decoder(FJZ),
field_decoder(FKA),
field_decoder(FKB),
field_decoder(FKC),
field_decoder(FKD),
field_decoder(FKE),
field_decoder(FKF)
) -> decoder(FKG).
decode7(Constructor, T1, T2, T3, T4, T5, T6, T7) ->
{decoder,
json@blueprint@dynamic:decode7(
Constructor,
erlang:element(2, T1),
erlang:element(2, T2),
erlang:element(2, T3),
erlang:element(2, T4),
erlang:element(2, T5),
erlang:element(2, T6),
erlang:element(2, T7)
),
create_object_schema(
[erlang:element(3, T1),
erlang:element(3, T2),
erlang:element(3, T3),
erlang:element(3, T4),
erlang:element(3, T5),
erlang:element(3, T6),
erlang:element(3, T7)]
),
lists:append(
[erlang:element(4, T1),
erlang:element(4, T2),
erlang:element(4, T3),
erlang:element(4, T4),
erlang:element(4, T5),
erlang:element(4, T6),
erlang:element(4, T7)]
)}.
-file("src/json/blueprint.gleam", 915).
-spec decode8(
fun((FKP, FKQ, FKR, FKS, FKT, FKU, FKV, FKW) -> FKX),
field_decoder(FKP),
field_decoder(FKQ),
field_decoder(FKR),
field_decoder(FKS),
field_decoder(FKT),
field_decoder(FKU),
field_decoder(FKV),
field_decoder(FKW)
) -> decoder(FKX).
decode8(Constructor, T1, T2, T3, T4, T5, T6, T7, T8) ->
{decoder,
json@blueprint@dynamic:decode8(
Constructor,
erlang:element(2, T1),
erlang:element(2, T2),
erlang:element(2, T3),
erlang:element(2, T4),
erlang:element(2, T5),
erlang:element(2, T6),
erlang:element(2, T7),
erlang:element(2, T8)
),
create_object_schema(
[erlang:element(3, T1),
erlang:element(3, T2),
erlang:element(3, T3),
erlang:element(3, T4),
erlang:element(3, T5),
erlang:element(3, T6),
erlang:element(3, T7),
erlang:element(3, T8)]
),
lists:append(
[erlang:element(4, T1),
erlang:element(4, T2),
erlang:element(4, T3),
erlang:element(4, T4),
erlang:element(4, T5),
erlang:element(4, T6),
erlang:element(4, T7),
erlang:element(4, T8)]
)}.
-file("src/json/blueprint.gleam", 961).
-spec decode9(
fun((FLH, FLI, FLJ, FLK, FLL, FLM, FLN, FLO, FLP) -> FLQ),
field_decoder(FLH),
field_decoder(FLI),
field_decoder(FLJ),
field_decoder(FLK),
field_decoder(FLL),
field_decoder(FLM),
field_decoder(FLN),
field_decoder(FLO),
field_decoder(FLP)
) -> decoder(FLQ).
decode9(Constructor, T1, T2, T3, T4, T5, T6, T7, T8, T9) ->
{decoder,
json@blueprint@dynamic:decode9(
Constructor,
erlang:element(2, T1),
erlang:element(2, T2),
erlang:element(2, T3),
erlang:element(2, T4),
erlang:element(2, T5),
erlang:element(2, T6),
erlang:element(2, T7),
erlang:element(2, T8),
erlang:element(2, T9)
),
create_object_schema(
[erlang:element(3, T1),
erlang:element(3, T2),
erlang:element(3, T3),
erlang:element(3, T4),
erlang:element(3, T5),
erlang:element(3, T6),
erlang:element(3, T7),
erlang:element(3, T8),
erlang:element(3, T9)]
),
lists:append(
[erlang:element(4, T1),
erlang:element(4, T2),
erlang:element(4, T3),
erlang:element(4, T4),
erlang:element(4, T5),
erlang:element(4, T6),
erlang:element(4, T7),
erlang:element(4, T8),
erlang:element(4, T9)]
)}.
-file("src/json/blueprint.gleam", 1011).
-spec encode_tuple2(
{FMB, FMC},
fun((FMB) -> gleam@json:json()),
fun((FMC) -> gleam@json:json())
) -> gleam@json:json().
encode_tuple2(Tuple, Encode1, Encode2) ->
{T1, T2} = Tuple,
gleam@json:preprocessed_array([Encode1(T1), Encode2(T2)]).
-file("src/json/blueprint.gleam", 1020).
-spec encode_tuple3(
{FMD, FME, FMF},
fun((FMD) -> gleam@json:json()),
fun((FME) -> gleam@json:json()),
fun((FMF) -> gleam@json:json())
) -> gleam@json:json().
encode_tuple3(Tuple, Encode1, Encode2, Encode3) ->
{T1, T2, T3} = Tuple,
gleam@json:preprocessed_array([Encode1(T1), Encode2(T2), Encode3(T3)]).
-file("src/json/blueprint.gleam", 1030).
-spec encode_tuple4(
{FMG, FMH, FMI, FMJ},
fun((FMG) -> gleam@json:json()),
fun((FMH) -> gleam@json:json()),
fun((FMI) -> gleam@json:json()),
fun((FMJ) -> gleam@json:json())
) -> gleam@json:json().
encode_tuple4(Tuple, Encode1, Encode2, Encode3, Encode4) ->
{T1, T2, T3, T4} = Tuple,
gleam@json:preprocessed_array(
[Encode1(T1), Encode2(T2), Encode3(T3), Encode4(T4)]
).
-file("src/json/blueprint.gleam", 1041).
-spec encode_tuple5(
{FMK, FML, FMM, FMN, FMO},
fun((FMK) -> gleam@json:json()),
fun((FML) -> gleam@json:json()),
fun((FMM) -> gleam@json:json()),
fun((FMN) -> gleam@json:json()),
fun((FMO) -> gleam@json:json())
) -> gleam@json:json().
encode_tuple5(Tuple, Encode1, Encode2, Encode3, Encode4, Encode5) ->
{T1, T2, T3, T4, T5} = Tuple,
gleam@json:preprocessed_array(
[Encode1(T1), Encode2(T2), Encode3(T3), Encode4(T4), Encode5(T5)]
).
-file("src/json/blueprint.gleam", 1059).
-spec encode_tuple6(
{FMP, FMQ, FMR, FMS, FMT, FMU},
fun((FMP) -> gleam@json:json()),
fun((FMQ) -> gleam@json:json()),
fun((FMR) -> gleam@json:json()),
fun((FMS) -> gleam@json:json()),
fun((FMT) -> gleam@json:json()),
fun((FMU) -> gleam@json:json())
) -> gleam@json:json().
encode_tuple6(Tuple, Encode1, Encode2, Encode3, Encode4, Encode5, Encode6) ->
{T1, T2, T3, T4, T5, T6} = Tuple,
gleam@json:preprocessed_array(
[Encode1(T1),
Encode2(T2),
Encode3(T3),
Encode4(T4),
Encode5(T5),
Encode6(T6)]
).
-file("src/json/blueprint.gleam", 1079).
-spec encode_tuple7(
{FMV, FMW, FMX, FMY, FMZ, FNA, FNB},
fun((FMV) -> gleam@json:json()),
fun((FMW) -> gleam@json:json()),
fun((FMX) -> gleam@json:json()),
fun((FMY) -> gleam@json:json()),
fun((FMZ) -> gleam@json:json()),
fun((FNA) -> gleam@json:json()),
fun((FNB) -> gleam@json:json())
) -> gleam@json:json().
encode_tuple7(
Tuple,
Encode1,
Encode2,
Encode3,
Encode4,
Encode5,
Encode6,
Encode7
) ->
{T1, T2, T3, T4, T5, T6, T7} = Tuple,
gleam@json:preprocessed_array(
[Encode1(T1),
Encode2(T2),
Encode3(T3),
Encode4(T4),
Encode5(T5),
Encode6(T6),
Encode7(T7)]
).
-file("src/json/blueprint.gleam", 1101).
-spec encode_tuple8(
{FNC, FND, FNE, FNF, FNG, FNH, FNI, FNJ},
fun((FNC) -> gleam@json:json()),
fun((FND) -> gleam@json:json()),
fun((FNE) -> gleam@json:json()),
fun((FNF) -> gleam@json:json()),
fun((FNG) -> gleam@json:json()),
fun((FNH) -> gleam@json:json()),
fun((FNI) -> gleam@json:json()),
fun((FNJ) -> gleam@json:json())
) -> gleam@json:json().
encode_tuple8(
Tuple,
Encode1,
Encode2,
Encode3,
Encode4,
Encode5,
Encode6,
Encode7,
Encode8
) ->
{T1, T2, T3, T4, T5, T6, T7, T8} = Tuple,
gleam@json:preprocessed_array(
[Encode1(T1),
Encode2(T2),
Encode3(T3),
Encode4(T4),
Encode5(T5),
Encode6(T6),
Encode7(T7),
Encode8(T8)]
).
-file("src/json/blueprint.gleam", 1125).
-spec encode_tuple9(
{FNK, FNL, FNM, FNN, FNO, FNP, FNQ, FNR, FNS},
fun((FNK) -> gleam@json:json()),
fun((FNL) -> gleam@json:json()),
fun((FNM) -> gleam@json:json()),
fun((FNN) -> gleam@json:json()),
fun((FNO) -> gleam@json:json()),
fun((FNP) -> gleam@json:json()),
fun((FNQ) -> gleam@json:json()),
fun((FNR) -> gleam@json:json()),
fun((FNS) -> gleam@json:json())
) -> gleam@json:json().
encode_tuple9(
Tuple,
Encode1,
Encode2,
Encode3,
Encode4,
Encode5,
Encode6,
Encode7,
Encode8,
Encode9
) ->
{T1, T2, T3, T4, T5, T6, T7, T8, T9} = Tuple,
gleam@json:preprocessed_array(
[Encode1(T1),
Encode2(T2),
Encode3(T3),
Encode4(T4),
Encode5(T5),
Encode6(T6),
Encode7(T7),
Encode8(T8),
Encode9(T9)]
).