Current section
Files
Jump to
Current section
Files
src/convert.erl
-module(convert).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/convert.gleam").
-export([object/1, success/1, encode/1, decode/1, string/0, bool/0, float/0, int/0, dynamic/0, bit_array/0, null/0, list/1, result/2, field/4, optional/1, dict/2, enum/2, map/4, type_def/1, default_value/1]).
-export_type([glitr_type/0, glitr_value/0, converter/1, partial_converter/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 glitr_type() :: string |
bool |
float |
int |
dynamic |
bit_array |
null |
{list, glitr_type()} |
{dict, glitr_type(), glitr_type()} |
{object, list({binary(), glitr_type()})} |
{optional, glitr_type()} |
{result, glitr_type(), glitr_type()} |
{enum, list({binary(), glitr_type()})}.
-type glitr_value() :: {string_value, binary()} |
{bool_value, boolean()} |
{float_value, float()} |
{int_value, integer()} |
{dynamic_value, gleam@dynamic:dynamic_()} |
{bit_array_value, bitstring()} |
null_value |
{list_value, list(glitr_value())} |
{dict_value, gleam@dict:dict(glitr_value(), glitr_value())} |
{object_value, list({binary(), glitr_value()})} |
{optional_value, gleam@option:option(glitr_value())} |
{result_value, {ok, glitr_value()} | {error, glitr_value()}} |
{enum_value, binary(), glitr_value()}.
-opaque converter(DTS) :: {converter,
fun((DTS) -> glitr_value()),
fun((glitr_value()) -> {ok, DTS} |
{error, list(gleam@dynamic@decode:decode_error())}),
glitr_type(),
DTS}.
-opaque partial_converter(DTT) :: {partial_converter,
fun((DTT) -> glitr_value()),
fun((glitr_value()) -> {ok, DTT} |
{error, list(gleam@dynamic@decode:decode_error())}),
list({binary(), glitr_type()}),
{ok, DTT} | {error, list(gleam@dynamic@decode:decode_error())}}.
-file("src/convert.gleam", 84).
?DOC(
" Create a Converter from a PartialConverter\n"
" \n"
" Example:\n"
" ```\n"
" type Person {\n"
" Person(name: String, age: Int)\n"
" }\n"
" \n"
" let convert = object({\n"
" use name <- field(\"name\", fn(v: Person) { Ok(v.name) }, string())\n"
" use age <- field(\"age\", fn(v: Person) { Ok(v.age) }, int())\n"
" success(Person(name:, age:))\n"
" })\n"
" ```\n"
).
-spec object(partial_converter(DTU)) -> converter(DTU).
object(Converter) ->
Default_value@1 = case erlang:element(5, Converter) of
{ok, Default_value} -> Default_value;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"convert"/utf8>>,
function => <<"object"/utf8>>,
line => 85,
value => _assert_fail,
start => 2558,
'end' => 2612,
pattern_start => 2569,
pattern_end => 2586})
end,
{converter,
erlang:element(2, Converter),
erlang:element(3, Converter),
{object, erlang:element(4, Converter)},
Default_value@1}.
-file("src/convert.gleam", 157).
?DOC(
" Used to initialize a PartialConverter \n"
" See `object` for its usage details\n"
).
-spec success(DUE) -> partial_converter(DUE).
success(C) ->
{partial_converter,
fun(_) -> {object_value, []} end,
fun(_) -> {ok, C} end,
[],
{ok, C}}.
-file("src/convert.gleam", 522).
-spec get_type(glitr_value()) -> binary().
get_type(Val) ->
case Val of
{bool_value, _} ->
<<"BoolValue"/utf8>>;
{dict_value, _} ->
<<"DictValue"/utf8>>;
{enum_value, _, _} ->
<<"EnumValue"/utf8>>;
{float_value, _} ->
<<"FloatValue"/utf8>>;
{int_value, _} ->
<<"IntValue"/utf8>>;
{dynamic_value, _} ->
<<"DynamicValue"/utf8>>;
{bit_array_value, _} ->
<<"BitArrayValue"/utf8>>;
{list_value, _} ->
<<"ListValue"/utf8>>;
null_value ->
<<"NullValue"/utf8>>;
{object_value, _} ->
<<"ObjectValue"/utf8>>;
{optional_value, _} ->
<<"OptionalValue"/utf8>>;
{result_value, _} ->
<<"ResultValue"/utf8>>;
{string_value, _} ->
<<"StringValue"/utf8>>
end.
-file("src/convert.gleam", 542).
?DOC(
" Encode a value into the corresponding GlitrValue using the converter. \n"
" If the converter isn't valid, a NullValue is returned.\n"
).
-spec encode(converter(DVU)) -> fun((DVU) -> glitr_value()).
encode(Converter) ->
erlang:element(2, Converter).
-file("src/convert.gleam", 547).
?DOC(" Decode a GlitrValue using the provided converter.\n").
-spec decode(converter(DVW)) -> fun((glitr_value()) -> {ok, DVW} |
{error, list(gleam@dynamic@decode:decode_error())}).
decode(Converter) ->
erlang:element(3, Converter).
-file("src/convert.gleam", 162).
?DOC(" Basic converter for a String value\n").
-spec string() -> converter(binary()).
string() ->
{converter, fun(V) -> {string_value, V} end, fun(V@1) -> case V@1 of
{string_value, Val} ->
{ok, Val};
Other ->
{error,
[{decode_error,
<<"StringValue"/utf8>>,
get_type(Other),
[]}]}
end end, string, <<""/utf8>>}.
-file("src/convert.gleam", 177).
?DOC(" Basic converter for a Bool value\n").
-spec bool() -> converter(boolean()).
bool() ->
{converter, fun(V) -> {bool_value, V} end, fun(V@1) -> case V@1 of
{bool_value, Val} ->
{ok, Val};
Other ->
{error,
[{decode_error,
<<"BoolValue"/utf8>>,
get_type(Other),
[]}]}
end end, bool, false}.
-file("src/convert.gleam", 192).
?DOC(" Basic converter for a Float value\n").
-spec float() -> converter(float()).
float() ->
{converter, fun(V) -> {float_value, V} end, fun(V@1) -> case V@1 of
{float_value, Val} ->
{ok, Val};
Other ->
{error,
[{decode_error,
<<"FloatValue"/utf8>>,
get_type(Other),
[]}]}
end end, float, +0.0}.
-file("src/convert.gleam", 207).
?DOC(" Basic converter for a Int value\n").
-spec int() -> converter(integer()).
int() ->
{converter, fun(V) -> {int_value, V} end, fun(V@1) -> case V@1 of
{int_value, Val} ->
{ok, Val};
Other ->
{error,
[{decode_error,
<<"IntValue"/utf8>>,
get_type(Other),
[]}]}
end end, int, 0}.
-file("src/convert.gleam", 222).
?DOC(" Basic converter for Dynamic values\n").
-spec dynamic() -> converter(gleam@dynamic:dynamic_()).
dynamic() ->
{converter, fun(V) -> {dynamic_value, V} end, fun(V@1) -> case V@1 of
{dynamic_value, Val} ->
{ok, Val};
Other ->
{error,
[{decode_error,
<<"DynamicValue"/utf8>>,
get_type(Other),
[]}]}
end end, dynamic, gleam@dynamic:nil()}.
-file("src/convert.gleam", 238).
?DOC(" Basic converter for BitArray values\n").
-spec bit_array() -> converter(bitstring()).
bit_array() ->
{converter, fun(V) -> {bit_array_value, V} end, fun(V@1) -> case V@1 of
{bit_array_value, Val} ->
{ok, Val};
Other ->
{error,
[{decode_error,
<<"BitArrayValue"/utf8>>,
get_type(Other),
[]}]}
end end, bit_array, <<>>}.
-file("src/convert.gleam", 254).
?DOC(" Basic converter for a Nil value\n").
-spec null() -> converter(nil).
null() ->
{converter, fun(_) -> null_value end, fun(V) -> case V of
null_value ->
{ok, nil};
Other ->
{error,
[{decode_error,
<<"NullValue"/utf8>>,
get_type(Other),
[]}]}
end end, null, nil}.
-file("src/convert.gleam", 271).
?DOC(
" Basic converter for a List value. \n"
" \n"
" `of` is a converter for the type of the elements.\n"
).
-spec list(converter(DUN)) -> converter(list(DUN)).
list(Of) ->
{converter,
fun(V) ->
{list_value,
begin
_pipe = V,
gleam@list:map(_pipe, erlang:element(2, Of))
end}
end,
fun(V@1) -> case V@1 of
{list_value, Vals} ->
_pipe@1 = Vals,
gleam@list:fold(
_pipe@1,
{ok, []},
fun(Result, Val) ->
case {Result, (erlang:element(3, Of))(Val)} of
{{ok, Res}, {ok, New_res}} ->
{ok, lists:append(Res, [New_res])};
{{error, Errs}, {error, New_errs}} ->
{error, lists:append(Errs, New_errs)};
{_, {error, Errs@1}} ->
{error, Errs@1};
{{error, Errs@1}, _} ->
{error, Errs@1}
end
end
);
Other ->
{error,
[{decode_error,
<<"ListValue"/utf8>>,
get_type(Other),
[]}]}
end end,
{list, erlang:element(4, Of)},
[]}.
-file("src/convert.gleam", 317).
?DOC(
" Basic converter for a Result value.\n"
" \n"
" `res` is a converter for the Ok value.\n"
" `error` is a converter for the Error value.\n"
).
-spec result(converter(DUV), converter(DUX)) -> converter({ok, DUV} |
{error, DUX}).
result(Res, Error) ->
{converter,
fun(V) ->
{result_value,
begin
_pipe = V,
_pipe@1 = gleam@result:map(_pipe, erlang:element(2, Res)),
gleam@result:map_error(_pipe@1, erlang:element(2, Error))
end}
end,
fun(V@1) -> case V@1 of
{result_value, {ok, Val}} ->
_pipe@2 = Val,
_pipe@3 = (erlang:element(3, Res))(_pipe@2),
gleam@result:map(_pipe@3, fun(Field@0) -> {ok, Field@0} end);
{result_value, {error, Val@1}} ->
_pipe@4 = Val@1,
_pipe@5 = (erlang:element(3, Error))(_pipe@4),
gleam@result:map(
_pipe@5,
fun(Field@0) -> {error, Field@0} end
);
Other ->
{error,
[{decode_error,
<<"ResultValue"/utf8>>,
get_type(Other),
[]}]}
end end,
{result, erlang:element(4, Res), erlang:element(4, Error)},
{ok, erlang:element(5, Res)}}.
-file("src/convert.gleam", 101).
?DOC(
" Add a field to a PartialConverter \n"
" See `object` for its usage details\n"
" \n"
" 'field_name' is the field name that will be used in the converted value. It may not be equal to the actual field name. \n"
" 'field_getter' is a function that returns the value of the field from the complete object. \n"
" 'field_type' is a Converter associated to the type of the field.\n"
).
-spec field(
binary(),
fun((DTX) -> {ok, DTY} | {error, nil}),
converter(DTY),
fun((DTY) -> partial_converter(DTX))
) -> partial_converter(DTX).
field(Field_name, Field_getter, Field_type, Next) ->
{partial_converter,
fun(Base) ->
Value = Field_getter(Base),
case Value of
{error, nil} ->
null_value;
{ok, Field_value} ->
Converter = Next(Field_value),
case (erlang:element(2, Converter))(Base) of
{object_value, Fields} ->
{object_value,
[{Field_name,
(erlang:element(2, Field_type))(
Field_value
)} |
Fields]};
_ ->
null_value
end
end
end,
fun(V) -> case V of
{object_value, Values} ->
Field_value@1 = begin
_pipe = Values,
_pipe@1 = gleam@list:key_find(_pipe, Field_name),
_pipe@2 = gleam@result:replace_error(
_pipe@1,
[{decode_error,
<<"Value"/utf8>>,
<<"None"/utf8>>,
[Field_name]}]
),
gleam@result:then(
_pipe@2,
erlang:element(3, Field_type)
)
end,
gleam@result:'try'(
Field_value@1,
fun(A) -> (erlang:element(3, Next(A)))(V) end
);
_ ->
{error, []}
end end,
([{Field_name, erlang:element(4, Field_type)} |
erlang:element(4, Next(erlang:element(5, Field_type)))]),
(erlang:element(5, Next(erlang:element(5, Field_type))))}.
-file("src/convert.gleam", 296).
?DOC(
" Basic converter for a Option value.\n"
" \n"
" `of` is a converter for the optional value.\n"
).
-spec optional(converter(DUR)) -> converter(gleam@option:option(DUR)).
optional(Of) ->
{converter,
fun(V) ->
{optional_value,
begin
_pipe = V,
gleam@option:map(_pipe, erlang:element(2, Of))
end}
end,
fun(V@1) -> case V@1 of
{optional_value, none} ->
{ok, none};
{optional_value, {some, Val}} ->
_pipe@1 = Val,
_pipe@2 = (erlang:element(3, Of))(_pipe@1),
gleam@result:map(
_pipe@2,
fun(Field@0) -> {some, Field@0} end
);
Other ->
{error,
[{decode_error,
<<"OptionalValue"/utf8>>,
get_type(Other),
[]}]}
end end,
{optional, erlang:element(4, Of)},
none}.
-file("src/convert.gleam", 348).
?DOC(
" Basic converter for a Dict value.\n"
" \n"
" `key` is a converter for the keys.\n"
" `value` is a converter for the values.\n"
" \n"
" Example:\n"
" ```\n"
" let converter: Converter(Dict(String, Int)) = dict(string(), int())\n"
" ```\n"
).
-spec dict(converter(DVC), converter(DVE)) -> converter(gleam@dict:dict(DVC, DVE)).
dict(Key, Value) ->
{converter,
fun(V) ->
{dict_value,
begin
_pipe = V,
_pipe@1 = maps:to_list(_pipe),
_pipe@4 = gleam@list:map(
_pipe@1,
fun(Kv) ->
{begin
_pipe@2 = erlang:element(1, Kv),
(erlang:element(2, Key))(_pipe@2)
end,
begin
_pipe@3 = erlang:element(2, Kv),
(erlang:element(2, Value))(_pipe@3)
end}
end
),
maps:from_list(_pipe@4)
end}
end,
fun(V@1) -> case V@1 of
{dict_value, D} ->
_pipe@5 = D,
_pipe@6 = maps:to_list(_pipe@5),
_pipe@7 = gleam@list:fold(
_pipe@6,
{ok, []},
fun(Result, Kv@1) ->
case {Result,
(erlang:element(3, Key))(
erlang:element(1, Kv@1)
),
(erlang:element(3, Value))(
erlang:element(2, Kv@1)
)} of
{{ok, Values}, {ok, New_k}, {ok, New_v}} ->
{ok, lists:append(Values, [{New_k, New_v}])};
{{error, Errs}, {ok, _}, {ok, _}} ->
{error, Errs};
{{ok, _}, {ok, _}, {error, Errs}} ->
{error, Errs};
{{ok, _}, {error, Errs}, {ok, _}} ->
{error, Errs};
{{ok, _}, {error, Errs_1}, {error, Errs_2}} ->
{error, lists:append(Errs_1, Errs_2)};
{{error, Errs_1}, {error, Errs_2}, {ok, _}} ->
{error, lists:append(Errs_1, Errs_2)};
{{error, Errs_1}, {ok, _}, {error, Errs_2}} ->
{error, lists:append(Errs_1, Errs_2)};
{{error, Errs@1},
{error, Errs_k},
{error, Errs_v}} ->
{error,
gleam@list:flatten(
[Errs@1, Errs_k, Errs_v]
)}
end
end
),
gleam@result:map(_pipe@7, fun maps:from_list/1);
Other ->
{error,
[{decode_error,
<<"DictValue"/utf8>>,
get_type(Other),
[]}]}
end end,
{dict, erlang:element(4, Key), erlang:element(4, Value)},
maps:new()}.
-file("src/convert.gleam", 436).
?DOC(
" Create a converter for an enum type\n"
" \n"
" `tags` is a function that associate a tag to each variant of the enum\n"
" `converters` is a list of converters, each associated with a tag\n"
" \n"
" Example:\n"
" ```\n"
" type Action {\n"
" Open(id: String)\n"
" Close(id: String)\n"
" }\n"
" \n"
" let open_converter = object({\n"
" use id <- field(\"id\", fn(v: Action) {\n"
" case v {\n"
" Open(id) -> Ok(id)\n"
" _ -> Error(Nil)\n"
" }\n"
" }, string())\n"
" success(Open(id:))\n"
" })\n"
" \n"
" let close_converter = object({\n"
" use id <- field(\"id\", fn(v: Action) {\n"
" case v {\n"
" Close(id) -> Ok(id)\n"
" _ -> Error(Nil)\n"
" }\n"
" }, string())\n"
" success(Close(id:))\n"
" })\n"
" \n"
" let action_converter = enum(\n"
" fn(v) {\n"
" case v {\n"
" Open(_) -> \"Open\"\n"
" Close(_) -> \"Close\"\n"
" }\n"
" },\n"
" [\n"
" #(\"Open\", open_converter),\n"
" #(\"Close\", close_converter),\n"
" ]\n"
" )\n"
" ```\n"
).
-spec enum(fun((DVJ) -> binary()), list({binary(), converter(DVJ)})) -> converter(DVJ).
enum(Tags, Converters) ->
{converter,
fun(V) ->
Tag = Tags(V),
case begin
_pipe = Converters,
gleam@list:key_find(_pipe, Tag)
end of
{ok, Variant} ->
{enum_value, Tag, (erlang:element(2, Variant))(V)};
{error, _} ->
null_value
end
end,
fun(V@1) -> case V@1 of
{enum_value, Variant_name, Value} ->
gleam@result:'try'(
begin
_pipe@1 = Converters,
_pipe@2 = gleam@list:key_find(_pipe@1, Variant_name),
gleam@result:replace_error(
_pipe@2,
[{decode_error,
<<"One of: "/utf8,
(begin
_pipe@3 = Converters,
_pipe@4 = gleam@list:map(
_pipe@3,
fun(V@2) ->
erlang:element(1, V@2)
end
),
gleam@string:join(
_pipe@4,
<<"/"/utf8>>
)
end)/binary>>,
Variant_name,
[<<"0"/utf8>>]}]
)
end,
fun(Variant@1) ->
(erlang:element(3, Variant@1))(Value)
end
);
Other ->
{error,
[{decode_error,
<<"EnumValue"/utf8>>,
get_type(Other),
[]}]}
end end,
{enum,
begin
_pipe@5 = Converters,
gleam@list:map(
_pipe@5,
fun(Var) ->
{erlang:element(1, Var),
erlang:element(4, (erlang:element(2, Var)))}
end
)
end},
begin
First@1 = case Converters of
[First | _] -> First;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"convert"/utf8>>,
function => <<"enum"/utf8>>,
line => 471,
value => _assert_fail,
start => 12558,
'end' => 12593,
pattern_start => 12569,
pattern_end => 12580})
end,
erlang:element(5, (erlang:element(2, First@1)))
end}.
-file("src/convert.gleam", 501).
?DOC(
" Create a converter by mapping the encode and decode functions from an existing one\n"
" \n"
" Example:\n"
" ```\n"
" pub type Date {\n"
" Date(year: Int, month: Int, day: Int)\n"
" }\n"
" \n"
" // We are storing the date as a string for optimized memory storage\n"
" pub fn date_converter() -> Converter(Date) {\n"
" string()\n"
" |> map(\n"
" fn(v: Date) { [v.year, v.month, v.day] |> list.map(int.to_string) |> string.join(\"/\") },\n"
" fn(v: String) { \n"
" let elems = string.split(v, \"/\")\n"
" case elems {\n"
" [y, m, d, ..] -> Ok(Date(y, m, d))\n"
" _ -> Error([])\n"
" },\n"
" Date(0, 0, 0) // This is required for now...\n"
" }\n"
" )\n"
" }\n"
" ```\n"
).
-spec map(
converter(DVN),
fun((DVP) -> DVN),
fun((DVN) -> {ok, DVP} | {error, list(gleam@dynamic@decode:decode_error())}),
DVP
) -> converter(DVP).
map(Converter, Encode_map, Decode_map, Default_value) ->
{converter,
fun(V) ->
A_value = Encode_map(V),
(erlang:element(2, Converter))(A_value)
end,
fun(V@1) -> _pipe = (erlang:element(3, Converter))(V@1),
gleam@result:then(_pipe, Decode_map) end,
erlang:element(4, Converter),
Default_value}.
-file("src/convert.gleam", 554).
?DOC(" Return the GlitrType associated with the converter\n").
-spec type_def(converter(any())) -> glitr_type().
type_def(Converter) ->
erlang:element(4, Converter).
-file("src/convert.gleam", 570).
?DOC(
" Retrieve the default value associated with a converter.\n"
" \n"
" This value is used as a fallback when decoding fails,\n"
" especially when building decoders that must return a value\n"
" even in the presence of errors.\n"
"\n"
" ## Example\n"
" ```\n"
" let string_conv = string()\n"
" let default = default_value(string_conv)\n"
" // default == \"\"\n"
" ```\n"
).
-spec default_value(converter(DWD)) -> DWD.
default_value(Conv) ->
erlang:element(5, Conv).