Current section
Files
Jump to
Current section
Files
src/gleamgen@module.erl
-module(gleamgen@module).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/gleamgen/module.gleam").
-export([from_source_map/1, with_constant/3, with_import/2, with_dynamic_imports/2, replace_function/5, with_function/3, with_custom_type1/3, with_custom_type2/3, with_custom_type3/3, with_custom_type4/3, with_custom_type5/3, with_custom_type6/3, with_custom_type7/3, with_custom_type8/3, with_custom_type9/3, with_custom_type_dynamic/3, with_type_alias/3, eof/0, render_imported_module/1, render/2]).
-export_type([external_module/0, module_/0, predefined_definition/0, module_definition/0, definable/0, replacement_config/0]).
-opaque external_module() :: {external_module,
gleam@option:option(gleamgen@source:source_mapped(glance:module_())),
list(module_definition())}.
-type module_() :: {module,
list(module_definition()),
list(gleamgen@import_:imported_module()),
gleam@option:option(external_module())}.
-type predefined_definition() :: {predefined_import,
glance:definition(glance:import())} |
{predefined_custom_type, glance:definition(glance:custom_type())} |
{predefined_type_alias, glance:definition(glance:type_alias())} |
{predefined_constant, glance:definition(glance:constant())} |
{predefined_function, glance:definition(glance:function_())}.
-type module_definition() :: {definition,
gleamgen@module@definition:definition(),
definable()}.
-opaque definable() :: {function,
gleamgen@function:function_(gleamgen@types:dynamic_(), gleamgen@types:dynamic_())} |
{custom_type_builder,
gleamgen@types@custom:custom_type_builder(gleamgen@types:dynamic_(), nil, nil)} |
{constant, gleamgen@expression:expression(gleamgen@types:dynamic_())} |
{type_alias, gleamgen@types:generated_type(gleamgen@types:dynamic_())} |
{predefined,
predefined_definition(),
binary(),
binary(),
gleamgen@source:source()}.
-type replacement_config() :: replacement_inline |
{replacement_update_definition,
fun((gleamgen@module@definition:definition()) -> gleamgen@module@definition:definition())}.
-file("src/gleamgen/module.gleam", 92).
-spec handle_existing_definition(
predefined_definition(),
module_(),
binary(),
binary(),
gleamgen@source:source()
) -> module_().
handle_existing_definition(
Predefined_definition,
Module,
Before_text,
Definition_text,
Source
) ->
Add_definition = fun(Name, Publicity, Attributes) ->
External_module = begin
_pipe = erlang:element(4, Module),
gleam@option:unwrap(_pipe, {external_module, none, []})
end,
Is_public = case Publicity of
public ->
true;
private ->
false
end,
Attributes@1 = gleam@list:filter_map(
Attributes,
fun gleamgen@module@definition:attribute_from_glance/1
),
Details = begin
_pipe@1 = gleamgen@module@definition:new(Name),
_pipe@2 = gleamgen@module@definition:with_publicity(
_pipe@1,
Is_public
),
_pipe@3 = gleamgen@module@definition:with_attributes(
_pipe@2,
Attributes@1
),
_pipe@4 = gleamgen@module@definition:with_text_before(
_pipe@3,
Before_text
),
gleamgen@module@definition:set_predefined(_pipe@4, true)
end,
New_definition = {definition,
Details,
{predefined,
Predefined_definition,
Before_text,
Definition_text,
Source}},
{module,
erlang:element(2, Module),
erlang:element(3, Module),
{some,
{external_module,
erlang:element(2, External_module),
[New_definition | erlang:element(3, External_module)]}}}
end,
case Predefined_definition of
{predefined_import, Definition} ->
New_import = gleamgen@import_:convert_import(
Definition,
Before_text
),
{module,
erlang:element(2, Module),
[New_import | erlang:element(3, Module)],
erlang:element(4, Module)};
{predefined_constant, Definition@1} ->
Add_definition(
erlang:element(3, erlang:element(3, Definition@1)),
erlang:element(4, erlang:element(3, Definition@1)),
erlang:element(2, Definition@1)
);
{predefined_custom_type, Definition@2} ->
Add_definition(
erlang:element(3, erlang:element(3, Definition@2)),
erlang:element(4, erlang:element(3, Definition@2)),
erlang:element(2, Definition@2)
);
{predefined_type_alias, Definition@3} ->
Add_definition(
erlang:element(3, erlang:element(3, Definition@3)),
erlang:element(4, erlang:element(3, Definition@3)),
erlang:element(2, Definition@3)
);
{predefined_function, Definition@4} ->
Add_definition(
erlang:element(3, erlang:element(3, Definition@4)),
erlang:element(4, erlang:element(3, Definition@4)),
erlang:element(2, Definition@4)
)
end.
-file("src/gleamgen/module.gleam", 60).
-spec from_source_map(gleamgen@source:source_mapped(glance:module_())) -> module_().
from_source_map(Module) ->
Get_location = fun(Definition) -> case Definition of
{predefined_import, Def} ->
erlang:element(2, erlang:element(3, Def));
{predefined_constant, Def@1} ->
erlang:element(2, erlang:element(3, Def@1));
{predefined_custom_type, Def@2} ->
erlang:element(2, erlang:element(3, Def@2));
{predefined_type_alias, Def@3} ->
erlang:element(2, erlang:element(3, Def@3));
{predefined_function, Def@4} ->
erlang:element(2, erlang:element(3, Def@4))
end end,
{Module@1, _} = begin
_pipe = [gleam@list:map(
erlang:element(2, erlang:element(2, Module)),
fun(Field@0) -> {predefined_import, Field@0} end
),
gleam@list:map(
erlang:element(5, erlang:element(2, Module)),
fun(Field@0) -> {predefined_constant, Field@0} end
),
gleam@list:map(
erlang:element(3, erlang:element(2, Module)),
fun(Field@0) -> {predefined_custom_type, Field@0} end
),
gleam@list:map(
erlang:element(4, erlang:element(2, Module)),
fun(Field@0) -> {predefined_type_alias, Field@0} end
),
gleam@list:map(
erlang:element(6, erlang:element(2, Module)),
fun(Field@0) -> {predefined_function, Field@0} end
)],
_pipe@1 = lists:append(_pipe),
_pipe@2 = gleam@list:sort(
_pipe@1,
fun(First, Second) ->
gleam@int:compare(
erlang:element(2, Get_location(First)),
erlang:element(2, Get_location(Second))
)
end
),
gleamgen@source:fold(
_pipe@2,
erlang:element(3, Module),
{module, [], [], {some, {external_module, {some, Module}, []}}},
fun handle_existing_definition/5,
Get_location
)
end,
Module@1.
-file("src/gleamgen/module.gleam", 172).
-spec with_constant(
gleamgen@module@definition:definition(),
gleamgen@expression:expression(OMU),
fun((gleamgen@expression:expression(OMU)) -> module_())
) -> module_().
with_constant(Details, Value, Handler) ->
Rest = Handler(gleamgen@expression:raw(erlang:element(2, Details))),
{module,
[{definition,
Details,
{constant,
begin
_pipe = Value,
gleamgen_ffi:identity(_pipe)
end}} |
erlang:element(2, Rest)],
erlang:element(3, Rest),
erlang:element(4, Rest)}.
-file("src/gleamgen/module.gleam", 184).
-spec with_import(
gleamgen@import_:imported_module(),
fun((gleamgen@import_:imported_module()) -> module_())
) -> module_().
with_import(Module, Handler) ->
Rest = Handler(Module),
{module,
erlang:element(2, Rest),
[Module | erlang:element(3, Rest)],
erlang:element(4, Rest)}.
-file("src/gleamgen/module.gleam", 192).
-spec with_dynamic_imports(
list(gleamgen@import_:imported_module()),
fun((list(gleamgen@import_:imported_module())) -> module_())
) -> module_().
with_dynamic_imports(Modules, Handler) ->
Rest = Handler(Modules),
{module,
erlang:element(2, Rest),
lists:append(lists:reverse(Modules), erlang:element(3, Rest)),
erlang:element(4, Rest)}.
-file("src/gleamgen/module.gleam", 207).
-spec replace_function(
binary(),
module_(),
fun((gleam@option:option(gleamgen@source:source_mapped(glance:function_()))) -> gleamgen@function:function_(ONB, any())),
replacement_config(),
fun((module_(), gleamgen@expression:expression(ONB)) -> module_())
) -> module_().
replace_function(Function_name, Module, Func, Config, Handler) ->
Rest = Handler(Module, gleamgen@expression:raw(Function_name)),
case erlang:element(4, Module) of
{some, {external_module, _, Definitions} = External_module} ->
Definitions@1 = gleam@list:map(
Definitions,
fun(Definition) ->
gleam@bool:guard(
erlang:element(2, erlang:element(2, Definition)) /= Function_name,
Definition,
fun() ->
{Details@1, Value} = case erlang:element(
3,
Definition
) of
{predefined,
{predefined_function, F},
_,
_,
Source} ->
Details = case Config of
replacement_inline ->
erlang:element(2, Definition);
{replacement_update_definition,
Update_fn} ->
Update_fn(
erlang:element(2, Definition)
)
end,
{gleamgen@module@definition:set_predefined(
Details,
false
),
{function,
begin
_pipe = Func(
{some,
{source_mapped,
erlang:element(3, F),
Source}}
),
gleamgen_ffi:identity(_pipe)
end}};
V ->
{erlang:element(2, Definition), V}
end,
{definition, Details@1, Value}
end
)
end
),
{module,
erlang:element(2, Module),
erlang:element(3, Module),
{some,
{external_module,
erlang:element(2, External_module),
Definitions@1}}};
none ->
{module,
[{definition,
gleamgen@module@definition:new(Function_name),
{function,
begin
_pipe@1 = Func(none),
gleamgen_ffi:identity(_pipe@1)
end}} |
erlang:element(2, Rest)],
erlang:element(3, Rest),
erlang:element(4, Rest)}
end.
-file("src/gleamgen/module.gleam", 270).
-spec with_function(
gleamgen@module@definition:definition(),
gleamgen@function:function_(ONG, any()),
fun((gleamgen@expression:expression(ONG)) -> module_())
) -> module_().
with_function(Details, Func, Handler) ->
Rest = Handler(gleamgen@expression:raw(erlang:element(2, Details))),
{module,
[{definition,
Details,
{function,
begin
_pipe = Func,
gleamgen_ffi:identity(_pipe)
end}} |
erlang:element(2, Rest)],
erlang:element(3, Rest),
erlang:element(4, Rest)}.
-file("src/gleamgen/module.gleam", 282).
-spec with_custom_type1(
gleamgen@module@definition:definition(),
gleamgen@types@custom:custom_type_builder(ONL, {{}, ONM}, ONO),
fun((gleamgen@types@custom:custom_type(ONL, ONO), gleamgen@expression@constructor:constructor(ONL, ONM, ONO)) -> module_())
) -> module_().
with_custom_type1(Details, Type_, Handler) ->
Variant1@1 = case erlang:element(2, Type_) of
[Variant1] -> Variant1;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"gleamgen/module"/utf8>>,
function => <<"with_custom_type1"/utf8>>,
line => 291,
value => _assert_fail,
start => 8212,
'end' => 8250,
pattern_start => 8223,
pattern_end => 8233})
end,
Rest = Handler(
{custom_type, none, erlang:element(2, Details)},
gleamgen@expression@constructor:new(Variant1@1)
),
{module,
[{definition,
Details,
{custom_type_builder,
begin
_pipe = Type_,
gleamgen@types@custom:to_dynamic(_pipe)
end}} |
erlang:element(2, Rest)],
erlang:element(3, Rest),
erlang:element(4, Rest)}.
-file("src/gleamgen/module.gleam", 305).
-spec with_custom_type2(
gleamgen@module@definition:definition(),
gleamgen@types@custom:custom_type_builder(ONX, {{{}, ONY}, ONZ}, OOC),
fun((gleamgen@types@custom:custom_type(ONX, OOC), gleamgen@expression@constructor:constructor(ONX, ONY, OOC), gleamgen@expression@constructor:constructor(ONX, ONZ, OOC)) -> module_())
) -> module_().
with_custom_type2(Details, Type_, Handler) ->
{Variant2@1, Variant1@1} = case erlang:element(2, Type_) of
[Variant2, Variant1] -> {Variant2, Variant1};
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"gleamgen/module"/utf8>>,
function => <<"with_custom_type2"/utf8>>,
line => 315,
value => _assert_fail,
start => 8841,
'end' => 8889,
pattern_start => 8852,
pattern_end => 8872})
end,
Rest = Handler(
{custom_type, none, erlang:element(2, Details)},
gleamgen@expression@constructor:new(Variant1@1),
gleamgen@expression@constructor:new(Variant2@1)
),
{module,
[{definition,
Details,
{custom_type_builder,
begin
_pipe = Type_,
gleamgen@types@custom:to_dynamic(_pipe)
end}} |
erlang:element(2, Rest)],
erlang:element(3, Rest),
erlang:element(4, Rest)}.
-file("src/gleamgen/module.gleam", 328).
-spec with_custom_type3(
gleamgen@module@definition:definition(),
gleamgen@types@custom:custom_type_builder(OOO, {{{{}, OOP}, OOQ}, OOR}, OOV),
fun((gleamgen@types@custom:custom_type(OOO, OOV), gleamgen@expression@constructor:constructor(OOO, OOP, OOV), gleamgen@expression@constructor:constructor(OOO, OOQ, OOV), gleamgen@expression@constructor:constructor(OOO, OOR, OOV)) -> module_())
) -> module_().
with_custom_type3(Details, Type_, Handler) ->
{Variant3@1, Variant2@1, Variant1@1} = case erlang:element(2, Type_) of
[Variant3, Variant2, Variant1] -> {Variant3, Variant2, Variant1};
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"gleamgen/module"/utf8>>,
function => <<"with_custom_type3"/utf8>>,
line => 339,
value => _assert_fail,
start => 9556,
'end' => 9614,
pattern_start => 9567,
pattern_end => 9597})
end,
Rest = Handler(
{custom_type, none, erlang:element(2, Details)},
gleamgen@expression@constructor:new(Variant1@1),
gleamgen@expression@constructor:new(Variant2@1),
gleamgen@expression@constructor:new(Variant3@1)
),
{module,
[{definition,
Details,
{custom_type_builder,
begin
_pipe = Type_,
gleamgen@types@custom:to_dynamic(_pipe)
end}} |
erlang:element(2, Rest)],
erlang:element(3, Rest),
erlang:element(4, Rest)}.
-file("src/gleamgen/module.gleam", 353).
-spec with_custom_type4(
gleamgen@module@definition:definition(),
gleamgen@types@custom:custom_type_builder(OPK, {{{{{}, OPL}, OPM}, OPN},
OPO}, OPT),
fun((gleamgen@types@custom:custom_type(OPK, OPT), gleamgen@expression@constructor:constructor(OPK, OPL, OPT), gleamgen@expression@constructor:constructor(OPK, OPM, OPT), gleamgen@expression@constructor:constructor(OPK, OPN, OPT), gleamgen@expression@constructor:constructor(OPK, OPO, OPT)) -> module_())
) -> module_().
with_custom_type4(Details, Type_, Handler) ->
{Variant4@1, Variant3@1, Variant2@1, Variant1@1} = case erlang:element(
2,
Type_
) of
[Variant4, Variant3, Variant2, Variant1] -> {
Variant4,
Variant3,
Variant2,
Variant1};
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"gleamgen/module"/utf8>>,
function => <<"with_custom_type4"/utf8>>,
line => 365,
value => _assert_fail,
start => 10365,
'end' => 10433,
pattern_start => 10376,
pattern_end => 10416})
end,
Rest = Handler(
{custom_type, none, erlang:element(2, Details)},
gleamgen@expression@constructor:new(Variant1@1),
gleamgen@expression@constructor:new(Variant2@1),
gleamgen@expression@constructor:new(Variant3@1),
gleamgen@expression@constructor:new(Variant4@1)
),
{module,
[{definition,
Details,
{custom_type_builder,
begin
_pipe = Type_,
gleamgen@types@custom:to_dynamic(_pipe)
end}} |
erlang:element(2, Rest)],
erlang:element(3, Rest),
erlang:element(4, Rest)}.
-file("src/gleamgen/module.gleam", 380).
-spec with_custom_type5(
gleamgen@module@definition:definition(),
gleamgen@types@custom:custom_type_builder(OQL, {{{{{{}, OQM}, OQN}, OQO},
OQP},
OQQ}, OQW),
fun((gleamgen@types@custom:custom_type(OQL, OQW), gleamgen@expression@constructor:constructor(OQL, OQM, OQW), gleamgen@expression@constructor:constructor(OQL, OQN, OQW), gleamgen@expression@constructor:constructor(OQL, OQO, OQW), gleamgen@expression@constructor:constructor(OQL, OQP, OQW), gleamgen@expression@constructor:constructor(OQL, OQQ, OQW)) -> module_())
) -> module_().
with_custom_type5(Details, Type_, Handler) ->
{Variant5@1, Variant4@1, Variant3@1, Variant2@1, Variant1@1} = case erlang:element(
2,
Type_
) of
[Variant5, Variant4, Variant3, Variant2, Variant1] -> {
Variant5,
Variant4,
Variant3,
Variant2,
Variant1};
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"gleamgen/module"/utf8>>,
function => <<"with_custom_type5"/utf8>>,
line => 397,
value => _assert_fail,
start => 11285,
'end' => 11363,
pattern_start => 11296,
pattern_end => 11346})
end,
Rest = Handler(
{custom_type, none, erlang:element(2, Details)},
gleamgen@expression@constructor:new(Variant1@1),
gleamgen@expression@constructor:new(Variant2@1),
gleamgen@expression@constructor:new(Variant3@1),
gleamgen@expression@constructor:new(Variant4@1),
gleamgen@expression@constructor:new(Variant5@1)
),
{module,
[{definition,
Details,
{custom_type_builder,
begin
_pipe = Type_,
gleamgen@types@custom:to_dynamic(_pipe)
end}} |
erlang:element(2, Rest)],
erlang:element(3, Rest),
erlang:element(4, Rest)}.
-file("src/gleamgen/module.gleam", 413).
-spec with_custom_type6(
gleamgen@module@definition:definition(),
gleamgen@types@custom:custom_type_builder(ORR, {{{{{{{}, ORS}, ORT}, ORU},
ORV},
ORW},
ORX}, OSE),
fun((gleamgen@types@custom:custom_type(ORR, OSE), gleamgen@expression@constructor:constructor(ORR, ORS, OSE), gleamgen@expression@constructor:constructor(ORR, ORT, OSE), gleamgen@expression@constructor:constructor(ORR, ORU, OSE), gleamgen@expression@constructor:constructor(ORR, ORV, OSE), gleamgen@expression@constructor:constructor(ORR, ORW, OSE), gleamgen@expression@constructor:constructor(ORR, ORX, OSE)) -> module_())
) -> module_().
with_custom_type6(Details, Type_, Handler) ->
{Variant6@1, Variant5@1, Variant4@1, Variant3@1, Variant2@1, Variant1@1} = case erlang:element(
2,
Type_
) of
[Variant6, Variant5, Variant4, Variant3, Variant2, Variant1] -> {
Variant6,
Variant5,
Variant4,
Variant3,
Variant2,
Variant1};
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"gleamgen/module"/utf8>>,
function => <<"with_custom_type6"/utf8>>,
line => 431,
value => _assert_fail,
start => 12299,
'end' => 12391,
pattern_start => 12310,
pattern_end => 12370})
end,
Rest = Handler(
{custom_type, none, erlang:element(2, Details)},
gleamgen@expression@constructor:new(Variant1@1),
gleamgen@expression@constructor:new(Variant2@1),
gleamgen@expression@constructor:new(Variant3@1),
gleamgen@expression@constructor:new(Variant4@1),
gleamgen@expression@constructor:new(Variant5@1),
gleamgen@expression@constructor:new(Variant6@1)
),
{module,
[{definition,
Details,
{custom_type_builder,
begin
_pipe = Type_,
gleamgen@types@custom:to_dynamic(_pipe)
end}} |
erlang:element(2, Rest)],
erlang:element(3, Rest),
erlang:element(4, Rest)}.
-file("src/gleamgen/module.gleam", 449).
-spec with_custom_type7(
gleamgen@module@definition:definition(),
gleamgen@types@custom:custom_type_builder(OTC, {{{{{{{{}, OTD}, OTE}, OTF},
OTG},
OTH},
OTI},
OTJ}, OTR),
fun((gleamgen@types@custom:custom_type(OTC, OTR), gleamgen@expression@constructor:constructor(OTC, OTD, OTR), gleamgen@expression@constructor:constructor(OTC, OTE, OTR), gleamgen@expression@constructor:constructor(OTC, OTF, OTR), gleamgen@expression@constructor:constructor(OTC, OTG, OTR), gleamgen@expression@constructor:constructor(OTC, OTH, OTR), gleamgen@expression@constructor:constructor(OTC, OTI, OTR), gleamgen@expression@constructor:constructor(OTC, OTJ, OTR)) -> module_())
) -> module_().
with_custom_type7(Details, Type_, Handler) ->
{
Variant7@1,
Variant6@1,
Variant5@1,
Variant4@1,
Variant3@1,
Variant2@1,
Variant1@1} = case erlang:element(2, Type_) of
[Variant7, Variant6, Variant5, Variant4, Variant3, Variant2, Variant1] -> {
Variant7,
Variant6,
Variant5,
Variant4,
Variant3,
Variant2,
Variant1};
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"gleamgen/module"/utf8>>,
function => <<"with_custom_type7"/utf8>>,
line => 468,
value => _assert_fail,
start => 13411,
'end' => 13542,
pattern_start => 13422,
pattern_end => 13525})
end,
Rest = Handler(
{custom_type, none, erlang:element(2, Details)},
gleamgen@expression@constructor:new(Variant1@1),
gleamgen@expression@constructor:new(Variant2@1),
gleamgen@expression@constructor:new(Variant3@1),
gleamgen@expression@constructor:new(Variant4@1),
gleamgen@expression@constructor:new(Variant5@1),
gleamgen@expression@constructor:new(Variant6@1),
gleamgen@expression@constructor:new(Variant7@1)
),
{module,
[{definition,
Details,
{custom_type_builder,
begin
_pipe = Type_,
gleamgen@types@custom:to_dynamic(_pipe)
end}} |
erlang:element(2, Rest)],
erlang:element(3, Rest),
erlang:element(4, Rest)}.
-file("src/gleamgen/module.gleam", 494).
-spec with_custom_type8(
gleamgen@module@definition:definition(),
gleamgen@types@custom:custom_type_builder(OUS, {{{{{{{{{}, OUT}, OUU}, OUV},
OUW},
OUX},
OUY},
OUZ},
OVA}, OVJ),
fun((gleamgen@types@custom:custom_type(OUS, OVJ), gleamgen@expression@constructor:constructor(OUS, OUT, OVJ), gleamgen@expression@constructor:constructor(OUS, OUU, OVJ), gleamgen@expression@constructor:constructor(OUS, OUV, OVJ), gleamgen@expression@constructor:constructor(OUS, OUW, OVJ), gleamgen@expression@constructor:constructor(OUS, OUX, OVJ), gleamgen@expression@constructor:constructor(OUS, OUY, OVJ), gleamgen@expression@constructor:constructor(OUS, OUZ, OVJ), gleamgen@expression@constructor:constructor(OUS, OVA, OVJ)) -> module_())
) -> module_().
with_custom_type8(Details, Type_, Handler) ->
{
Variant8@1,
Variant7@1,
Variant6@1,
Variant5@1,
Variant4@1,
Variant3@1,
Variant2@1,
Variant1@1} = case erlang:element(2, Type_) of
[Variant8,
Variant7,
Variant6,
Variant5,
Variant4,
Variant3,
Variant2,
Variant1] -> {
Variant8,
Variant7,
Variant6,
Variant5,
Variant4,
Variant3,
Variant2,
Variant1};
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"gleamgen/module"/utf8>>,
function => <<"with_custom_type8"/utf8>>,
line => 514,
value => _assert_fail,
start => 14646,
'end' => 14791,
pattern_start => 14657,
pattern_end => 14774})
end,
Rest = Handler(
{custom_type, none, erlang:element(2, Details)},
gleamgen@expression@constructor:new(Variant1@1),
gleamgen@expression@constructor:new(Variant2@1),
gleamgen@expression@constructor:new(Variant3@1),
gleamgen@expression@constructor:new(Variant4@1),
gleamgen@expression@constructor:new(Variant5@1),
gleamgen@expression@constructor:new(Variant6@1),
gleamgen@expression@constructor:new(Variant7@1),
gleamgen@expression@constructor:new(Variant8@1)
),
{module,
[{definition,
Details,
{custom_type_builder,
begin
_pipe = Type_,
gleamgen@types@custom:to_dynamic(_pipe)
end}} |
erlang:element(2, Rest)],
erlang:element(3, Rest),
erlang:element(4, Rest)}.
-file("src/gleamgen/module.gleam", 542).
-spec with_custom_type9(
gleamgen@module@definition:definition(),
gleamgen@types@custom:custom_type_builder(OWN, {{{{{{{{{{}, OWO}, OWP}, OWQ},
OWR},
OWS},
OWT},
OWU},
OWV},
OWW}, OXG),
fun((gleamgen@types@custom:custom_type(OWN, OXG), gleamgen@expression@constructor:constructor(OWN, OWO, OXG), gleamgen@expression@constructor:constructor(OWN, OWP, OXG), gleamgen@expression@constructor:constructor(OWN, OWQ, OXG), gleamgen@expression@constructor:constructor(OWN, OWR, OXG), gleamgen@expression@constructor:constructor(OWN, OWS, OXG), gleamgen@expression@constructor:constructor(OWN, OWT, OXG), gleamgen@expression@constructor:constructor(OWN, OWU, OXG), gleamgen@expression@constructor:constructor(OWN, OWV, OXG), gleamgen@expression@constructor:constructor(OWN, OWW, OXG)) -> module_())
) -> module_().
with_custom_type9(Details, Type_, Handler) ->
{
Variant9@1,
Variant8@1,
Variant7@1,
Variant6@1,
Variant5@1,
Variant4@1,
Variant3@1,
Variant2@1,
Variant1@1} = case erlang:element(2, Type_) of
[Variant9,
Variant8,
Variant7,
Variant6,
Variant5,
Variant4,
Variant3,
Variant2,
Variant1] -> {
Variant9,
Variant8,
Variant7,
Variant6,
Variant5,
Variant4,
Variant3,
Variant2,
Variant1};
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"gleamgen/module"/utf8>>,
function => <<"with_custom_type9"/utf8>>,
line => 563,
value => _assert_fail,
start => 15979,
'end' => 16138,
pattern_start => 15990,
pattern_end => 16121})
end,
Rest = Handler(
{custom_type, none, erlang:element(2, Details)},
gleamgen@expression@constructor:new(Variant1@1),
gleamgen@expression@constructor:new(Variant2@1),
gleamgen@expression@constructor:new(Variant3@1),
gleamgen@expression@constructor:new(Variant4@1),
gleamgen@expression@constructor:new(Variant5@1),
gleamgen@expression@constructor:new(Variant6@1),
gleamgen@expression@constructor:new(Variant7@1),
gleamgen@expression@constructor:new(Variant8@1),
gleamgen@expression@constructor:new(Variant9@1)
),
{module,
[{definition,
Details,
{custom_type_builder,
begin
_pipe = Type_,
gleamgen@types@custom:to_dynamic(_pipe)
end}} |
erlang:element(2, Rest)],
erlang:element(3, Rest),
erlang:element(4, Rest)}.
-file("src/gleamgen/module.gleam", 595).
-spec with_custom_type_dynamic(
gleamgen@module@definition:definition(),
gleamgen@types@custom:custom_type_builder(OYN, gleamgen@types:dynamic_(), OYO),
fun((gleamgen@types@custom:custom_type(OYN, OYO), list(gleamgen@expression@constructor:constructor(OYN, gleamgen@types:dynamic_(), OYO))) -> module_())
) -> module_().
with_custom_type_dynamic(Details, Type_, Handler) ->
Rest = Handler(
{custom_type, none, erlang:element(2, Details)},
begin
_pipe = erlang:element(2, Type_),
_pipe@1 = lists:reverse(_pipe),
gleam@list:map(_pipe@1, fun gleamgen@expression@constructor:new/1)
end
),
{module,
[{definition,
Details,
{custom_type_builder,
begin
_pipe@2 = Type_,
gleamgen@types@custom:to_dynamic(_pipe@2)
end}} |
erlang:element(2, Rest)],
erlang:element(3, Rest),
erlang:element(4, Rest)}.
-file("src/gleamgen/module.gleam", 615).
-spec with_type_alias(
gleamgen@module@definition:definition(),
gleamgen@types:generated_type(OYY),
fun((gleamgen@types:generated_type(OYY)) -> module_())
) -> module_().
with_type_alias(Details, Type_, Handler) ->
Rest = Handler(gleamgen@types:raw(erlang:element(2, Details))),
{module,
[{definition,
Details,
{type_alias,
begin
_pipe = Type_,
gleamgen_ffi:identity(_pipe)
end}} |
erlang:element(2, Rest)],
erlang:element(3, Rest),
erlang:element(4, Rest)}.
-file("src/gleamgen/module.gleam", 627).
-spec eof() -> module_().
eof() ->
{module, [], [], none}.
-file("src/gleamgen/module.gleam", 762).
-spec separate_definitions(
list(module_definition()),
list(module_definition()),
list(module_definition()),
gleam@dict:dict(binary(), list(module_definition()))
) -> {list(module_definition()),
list(module_definition()),
gleam@dict:dict(binary(), list(module_definition()))}.
separate_definitions(Definitions, At_top, At_bottom, After_definition) ->
case Definitions of
[Definition | Rest] ->
case erlang:element(5, erlang:element(2, Definition)) of
top ->
separate_definitions(
Rest,
[Definition | At_top],
At_bottom,
After_definition
);
bottom ->
separate_definitions(
Rest,
At_top,
[Definition | At_bottom],
After_definition
);
{after_definition, Def_name} ->
After_definition@1 = gleam@dict:upsert(
After_definition,
Def_name,
fun(Currently_after_definition) ->
case Currently_after_definition of
{some, List} ->
[Definition | List];
none ->
[Definition]
end
end
),
separate_definitions(
Rest,
At_top,
At_bottom,
After_definition@1
)
end;
[] ->
{At_top, At_bottom, After_definition}
end.
-file("src/gleamgen/module.gleam", 682).
-spec render_imported_module(gleamgen@import_:imported_module()) -> gleamgen@internal@render:rendered().
render_imported_module(Module) ->
_pipe = glam@doc:concat(
[glam@doc:from_string(erlang:element(5, Module)),
glam@doc:from_string(<<"import "/utf8>>),
glam@doc:from_string(
gleam@string:join(erlang:element(2, Module), <<"/"/utf8>>)
),
case erlang:element(4, Module) of
[] ->
{concat, []};
Exposing ->
glam@doc:concat(
[glam@doc:from_string(<<".{"/utf8>>),
glam@doc:from_string(
gleamgen@import_:exposing_to_string(Exposing)
),
glam@doc:from_string(<<"}"/utf8>>)]
)
end,
case erlang:element(3, Module) of
{some, Alias} ->
glam@doc:concat(
[{break, <<" "/utf8>>, <<""/utf8>>},
glam@doc:from_string(<<"as"/utf8>>),
{break, <<" "/utf8>>, <<""/utf8>>},
glam@doc:from_string(Alias)]
);
none ->
{concat, []}
end]
),
{render, _pipe, {rendered_details, [], {report, [], []}}}.
-file("src/gleamgen/module.gleam", 631).
-spec render(module_(), gleamgen@internal@render:context()) -> gleamgen@internal@render:rendered().
render(Module, Context) ->
{Definitions_at_top, Definitions_at_bottom, Definitions_after} = separate_definitions(
erlang:element(2, Module),
[],
[],
maps:new()
),
External_definitions = case erlang:element(4, Module) of
{some, External} ->
erlang:element(3, External);
none ->
[]
end,
All_definitions = begin
_pipe = [Definitions_at_bottom,
External_definitions,
Definitions_at_top],
_pipe@1 = lists:append(_pipe),
lists:reverse(_pipe@1)
end,
{Details, Rendered_defs} = render_all_definitions(
All_definitions,
Definitions_after,
none,
Context,
{rendered_details, [], {report, [], []}},
[]
),
Rendered_imports = begin
_pipe@2 = erlang:element(3, Module),
_pipe@4 = gleam@list:filter(
_pipe@2,
fun(M) ->
(erlang:element(6, M) orelse not gleam@list:is_empty(
erlang:element(4, M)
))
orelse begin
_pipe@3 = erlang:element(2, Details),
gleam@list:contains(
_pipe@3,
gleamgen@import_:get_reference(M, none)
)
end
end
),
_pipe@5 = gleam@list:sort(_pipe@4, fun gleamgen@import_:compare/2),
_pipe@6 = gleamgen@import_:merge_imports(_pipe@5),
_pipe@9 = gleam@list:map(_pipe@6, fun(X) -> _pipe@7 = X,
_pipe@8 = render_imported_module(_pipe@7),
gleamgen@internal@render:to_string(_pipe@8) end),
_pipe@10 = gleam@list:map(_pipe@9, fun glam@doc:from_string/1),
_pipe@11 = glam@doc:join(_pipe@10, {line, 1}),
glam@doc:append(
_pipe@11,
case gleam@list:is_empty(erlang:element(3, Module)) of
true ->
{concat, []};
false ->
glam@doc:concat([{line, 1}, {line, 1}])
end
)
end,
_pipe@12 = Rendered_imports,
_pipe@13 = glam@doc:append(
_pipe@12,
glam@doc:concat_join(Rendered_defs, [{line, 1}, {line, 1}])
),
{render, _pipe@13, Details}.
-file("src/gleamgen/module.gleam", 810).
-spec render_definition(module_definition(), gleamgen@internal@render:context()) -> {glam@doc:document(),
gleamgen@internal@render:rendered_details()}.
render_definition(Definition, Context) ->
{Rendered@1, Details} = case erlang:element(3, Definition) of
{constant, Value} ->
Rendered_expr = gleamgen@expression:render(Value, Context),
{glam@doc:concat(
[glam@doc:from_string(<<"const "/utf8>>),
glam@doc:from_string(
erlang:element(2, erlang:element(2, Definition))
),
{break, <<" "/utf8>>, <<""/utf8>>},
glam@doc:from_string(<<"="/utf8>>),
{break, <<" "/utf8>>, <<""/utf8>>},
erlang:element(2, Rendered_expr)]
),
erlang:element(3, Rendered_expr)};
{custom_type_builder, Type_} ->
Rendered_type = gleamgen@types@custom:render(Type_),
{glam@doc:concat(
[glam@doc:from_string(<<"type "/utf8>>),
glam@doc:from_string(
erlang:element(2, erlang:element(2, Definition))
),
erlang:element(2, Rendered_type)]
),
erlang:element(3, Rendered_type)};
{type_alias, Type_@1} ->
Rendered_type@1 = gleamgen@types:render_type(Type_@1),
{glam@doc:concat(
[glam@doc:from_string(<<"type "/utf8>>),
glam@doc:from_string(
erlang:element(2, erlang:element(2, Definition))
),
{break, <<" "/utf8>>, <<""/utf8>>},
glam@doc:from_string(<<"="/utf8>>),
{break, <<" "/utf8>>, <<""/utf8>>},
begin
_pipe = Rendered_type@1,
_pipe@1 = gleam@result:map(
_pipe,
fun(V) -> erlang:element(2, V) end
),
gleam@result:unwrap(
_pipe@1,
glam@doc:from_string(<<"??"/utf8>>)
)
end]
),
begin
_pipe@2 = Rendered_type@1,
_pipe@3 = gleam@result:map(
_pipe@2,
fun(V@1) -> erlang:element(3, V@1) end
),
gleam@result:unwrap(
_pipe@3,
{rendered_details, [], {report, [], []}}
)
end};
{function, Func} ->
Rendered = gleamgen@function:render(
Func,
Context,
{some, erlang:element(2, erlang:element(2, Definition))}
),
{erlang:element(2, Rendered), erlang:element(3, Rendered)};
{predefined, _, _, Content, _} ->
{glam@doc:from_string(Content),
{rendered_details, [], {report, [], []}}}
end,
Full_doc = begin
_pipe@4 = glam@doc:concat(
[glam@doc:from_string(
erlang:element(6, erlang:element(2, Definition))
),
glam@doc:join(
gleam@list:map(
erlang:element(4, erlang:element(2, Definition)),
fun gleamgen@module@definition:render_attribute/1
),
{line, 1}
)]
),
_pipe@5 = glam@doc:append(
_pipe@4,
case gleam@list:is_empty(
erlang:element(4, erlang:element(2, Definition))
) of
true ->
{concat, []};
false ->
{line, 1}
end
),
_pipe@6 = glam@doc:append(
_pipe@5,
case erlang:element(3, erlang:element(2, Definition)) andalso not erlang:element(
7,
erlang:element(2, Definition)
) of
true ->
glam@doc:concat(
[glam@doc:from_string(<<"pub"/utf8>>),
{break, <<" "/utf8>>, <<""/utf8>>}]
);
false ->
{concat, []}
end
),
glam@doc:append(_pipe@6, Rendered@1)
end,
{Full_doc, Details}.
-file("src/gleamgen/module.gleam", 711).
-spec render_all_definitions(
list(module_definition()),
gleam@dict:dict(binary(), list(module_definition())),
gleam@option:option(binary()),
gleamgen@internal@render:context(),
gleamgen@internal@render:rendered_details(),
list(glam@doc:document())
) -> {gleamgen@internal@render:rendered_details(), list(glam@doc:document())}.
render_all_definitions(
Definitions,
After_definition,
Last_definition_name,
Context,
Previous_details,
Rendered_definitions
) ->
Definitions_to_prepend = begin
_pipe = Last_definition_name,
gleam@option:then(
_pipe,
fun(Name) -> case gleam_stdlib:map_get(After_definition, Name) of
{ok, Defs} ->
{some,
{Defs, gleam@dict:delete(After_definition, Name)}};
{error, _} ->
none
end end
)
end,
case Definitions_to_prepend of
{some, {Defs@1, New_after_definition}} ->
render_all_definitions(
lists:append(Defs@1, Definitions),
New_after_definition,
none,
Context,
Previous_details,
Rendered_definitions
);
none ->
case Definitions of
[Definition | Rest] ->
{Rendered_def, New_details} = render_definition(
Definition,
Context
),
render_all_definitions(
Rest,
After_definition,
{some, erlang:element(2, erlang:element(2, Definition))},
Context,
gleamgen@internal@render:merge_details(
Previous_details,
New_details
),
[Rendered_def | Rendered_definitions]
);
[] ->
{Previous_details, lists:reverse(Rendered_definitions)}
end
end.