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]).
-export([object/1, success/1, dynamic/0, string/0, bool/0, float/0, int/0, null/0, list/1, result/2, field/4, optional/1, dict/2, enum/2, bit_array/0, map/4, encode/1, decode/1, type_def/1]).
-export_type([glitr_type/0, glitr_value/0, converter/1, partial_converter/1]).
-type glitr_type() :: string |
bool |
float |
int |
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()})} |
dynamic |
bit_array.
-type glitr_value() :: {string_value, binary()} |
{bool_value, boolean()} |
{float_value, float()} |
{int_value, integer()} |
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()} |
{dynamic_value, gleam@dynamic:dynamic_()} |
{bit_array_value, bitstring()}.
-opaque converter(FUK) :: {converter,
fun((FUK) -> glitr_value()),
fun((glitr_value()) -> {ok, FUK} |
{error, list(gleam@dynamic:decode_error())}),
glitr_type(),
FUK}.
-opaque partial_converter(FUL) :: {partial_converter,
fun((FUL) -> glitr_value()),
fun((glitr_value()) -> {ok, FUL} |
{error, list(gleam@dynamic:decode_error())}),
list({binary(), glitr_type()}),
{ok, FUL} | {error, list(gleam@dynamic:decode_error())}}.
-file("/home/runner/work/convert/convert/src/convert.gleam", 83).
-spec object(partial_converter(FUM)) -> converter(FUM).
object(Converter) ->
_assert_subject = erlang:element(5, Converter),
{ok, Default_value} = case _assert_subject of
{ok, _} -> _assert_subject;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail,
module => <<"convert"/utf8>>,
function => <<"object"/utf8>>,
line => 84})
end,
{converter,
erlang:element(2, Converter),
erlang:element(3, Converter),
{object, erlang:element(4, Converter)},
Default_value}.
-file("/home/runner/work/convert/convert/src/convert.gleam", 156).
-spec success(FUW) -> partial_converter(FUW).
success(C) ->
{partial_converter,
fun(_) -> {object_value, []} end,
fun(_) -> {ok, C} end,
[],
{ok, C}}.
-file("/home/runner/work/convert/convert/src/convert.gleam", 523).
-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>>;
{list_value, _} ->
<<"ListValue"/utf8>>;
null_value ->
<<"NullValue"/utf8>>;
{object_value, _} ->
<<"ObjectValue"/utf8>>;
{optional_value, _} ->
<<"OptionalValue"/utf8>>;
{result_value, _} ->
<<"ResultValue"/utf8>>;
{string_value, _} ->
<<"StringValue"/utf8>>;
{dynamic_value, _} ->
<<"DynamicValue"/utf8>>;
{bit_array_value, _} ->
<<"BitArrayValue"/utf8>>
end.
-file("/home/runner/work/convert/convert/src/convert.gleam", 447).
-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_stdlib:identity(nil)}.
-file("/home/runner/work/convert/convert/src/convert.gleam", 161).
-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("/home/runner/work/convert/convert/src/convert.gleam", 177).
-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("/home/runner/work/convert/convert/src/convert.gleam", 192).
-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("/home/runner/work/convert/convert/src/convert.gleam", 207).
-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("/home/runner/work/convert/convert/src/convert.gleam", 222).
-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("/home/runner/work/convert/convert/src/convert.gleam", 239).
-spec list(converter(FVD)) -> converter(list(FVD)).
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("/home/runner/work/convert/convert/src/convert.gleam", 285).
-spec result(converter(FVL), converter(FVN)) -> converter({ok, FVL} |
{error, FVN}).
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("/home/runner/work/convert/convert/src/convert.gleam", 100).
-spec field(
binary(),
fun((FUP) -> {ok, FUQ} | {error, nil}),
converter(FUQ),
fun((FUQ) -> partial_converter(FUP))
) -> partial_converter(FUP).
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("/home/runner/work/convert/convert/src/convert.gleam", 264).
-spec optional(converter(FVH)) -> converter(gleam@option:option(FVH)).
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("/home/runner/work/convert/convert/src/convert.gleam", 317).
-spec dict(converter(FVS), converter(FVU)) -> converter(gleam@dict:dict(FVS, FVU)).
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("/home/runner/work/convert/convert/src/convert.gleam", 405).
-spec enum(fun((FVZ) -> binary()), list({binary(), converter(FVZ)})) -> converter(FVZ).
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 | _] = case Converters of
[_ | _] -> Converters;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail,
module => <<"convert"/utf8>>,
function => <<"enum"/utf8>>,
line => 440})
end,
erlang:element(5, (erlang:element(2, First)))
end}.
-file("/home/runner/work/convert/convert/src/convert.gleam", 463).
-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("/home/runner/work/convert/convert/src/convert.gleam", 502).
-spec map(
converter(FWF),
fun((FWH) -> FWF),
fun((FWF) -> {ok, FWH} | {error, list(gleam@dynamic:decode_error())}),
FWH
) -> converter(FWH).
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("/home/runner/work/convert/convert/src/convert.gleam", 543).
-spec encode(converter(FWM)) -> fun((FWM) -> glitr_value()).
encode(Converter) ->
erlang:element(2, Converter).
-file("/home/runner/work/convert/convert/src/convert.gleam", 548).
-spec decode(converter(FWO)) -> fun((glitr_value()) -> {ok, FWO} |
{error, list(gleam@dynamic:decode_error())}).
decode(Converter) ->
erlang:element(3, Converter).
-file("/home/runner/work/convert/convert/src/convert.gleam", 555).
-spec type_def(converter(any())) -> glitr_type().
type_def(Converter) ->
erlang:element(4, Converter).