deriv

-module(deriv).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([consolidate_imports/1, consolidate_imports_for/2, build_same_file_writes/1, build_different_file_writes/1, build_writes/1, stop_warning/0, gen_derivs/2, main/0]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC("/ ///// ///// ///// ///// /////\n").

-file("src/deriv.gleam", 92).
-spec find_project_src_gleam_filepaths() -> list(binary()).
find_project_src_gleam_filepaths() ->
    _assert_subject = shellout:command(
        <<"find"/utf8>>,
        [<<"src"/utf8>>, <<"-name"/utf8>>, <<"*.gleam"/utf8>>],
        <<"."/utf8>>,
        []
    ),
    {ok, Output} = 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 => <<"deriv"/utf8>>,
                        function => <<"find_project_src_gleam_filepaths"/utf8>>,
                        line => 93})
    end,
    _pipe = Output,
    _pipe@1 = gleam@string:trim(_pipe),
    gleam@string:split(_pipe@1, <<"\n"/utf8>>).

-file("src/deriv.gleam", 109).
-spec project_name() -> binary().
project_name() ->
    _assert_subject = shellout:command(
        <<"cat"/utf8>>,
        [<<"gleam.toml"/utf8>>],
        <<"."/utf8>>,
        []
    ),
    {ok, Output} = 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 => <<"deriv"/utf8>>,
                        function => <<"project_name"/utf8>>,
                        line => 110})
    end,
    _assert_subject@1 = tom:parse(Output),
    {ok, Config} = case _assert_subject@1 of
        {ok, _} -> _assert_subject@1;
        _assert_fail@1 ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        value => _assert_fail@1,
                        module => <<"deriv"/utf8>>,
                        function => <<"project_name"/utf8>>,
                        line => 111})
    end,
    case tom:get_string(Config, [<<"name"/utf8>>]) of
        {error, _} ->
            erlang:error(#{gleam_error => panic,
                    message => <<"Cannot determine project name from `gleam.toml`"/utf8>>,
                    module => <<"deriv"/utf8>>,
                    function => <<"project_name"/utf8>>,
                    line => 114});

        {ok, Name} ->
            Name
    end.

-file("src/deriv.gleam", 171).
-spec file_path_to_gleam_module_str(binary()) -> binary().
file_path_to_gleam_module_str(Path) ->
    _assert_subject = gleam@regexp:from_string(<<"^src[/]"/utf8>>),
    {ok, Leading_src_slash} = 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 => <<"deriv"/utf8>>,
                        function => <<"file_path_to_gleam_module_str"/utf8>>,
                        line => 172})
    end,
    _assert_subject@1 = gleam@regexp:from_string(<<"[.]gleam$"/utf8>>),
    {ok, Trailing_dot_gleam} = case _assert_subject@1 of
        {ok, _} -> _assert_subject@1;
        _assert_fail@1 ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        value => _assert_fail@1,
                        module => <<"deriv"/utf8>>,
                        function => <<"file_path_to_gleam_module_str"/utf8>>,
                        line => 173})
    end,
    _pipe = Path,
    _pipe@1 = gleam_regexp_ffi:replace(Leading_src_slash, _pipe, <<""/utf8>>),
    gleam_regexp_ffi:replace(Trailing_dot_gleam, _pipe@1, <<""/utf8>>).

-file("src/deriv.gleam", 165).
-spec read_file(binary(), integer()) -> deriv@types:file().
read_file(Filepath, Idx) ->
    _assert_subject = simplifile:read(Filepath),
    {ok, Src} = 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 => <<"deriv"/utf8>>,
                        function => <<"read_file"/utf8>>,
                        line => 166})
    end,
    Module = file_path_to_gleam_module_str(Filepath),
    {file, Module, Src, {some, Idx + 1}}.

-file("src/deriv.gleam", 102).
-spec load_files(list(binary())) -> list(deriv@types:file()).
load_files(Filepaths) ->
    _pipe = Filepaths,
    gleam@list:index_map(_pipe, fun(Path, Idx) -> read_file(Path, Idx) end).

-file("src/deriv.gleam", 180).
-spec gleam_module_str_to_file_path(binary()) -> binary().
gleam_module_str_to_file_path(Module) ->
    <<<<"src/"/utf8, Module/binary>>/binary, ".gleam"/utf8>>.

-file("src/deriv.gleam", 184).
-spec parse_types_and_derivations(deriv@types:file()) -> list({glance:custom_type(),
    list(deriv@types:derivation()),
    gleam@dict:dict(deriv@types:deriv_field(), list(deriv@types:deriv_field_opt()))}).
parse_types_and_derivations(File) ->
    Parsed = case glance:module(erlang:element(3, File)) of
        {error, Err} ->
            gleam@io:debug(File),
            gleam@io:debug(Err),
            erlang:error(#{gleam_error => panic,
                    message => <<"`panic` expression evaluated."/utf8>>,
                    module => <<"deriv"/utf8>>,
                    function => <<"parse_types_and_derivations"/utf8>>,
                    line => 190});

        {ok, X} ->
            X
    end,
    _pipe = erlang:element(3, Parsed),
    _pipe@1 = gleam@list:map(_pipe, fun(Ct) -> erlang:element(3, Ct) end),
    _pipe@2 = gleam@list:map(
        _pipe@1,
        fun(_capture) ->
            deriv@parser:parse_type_with_derivations(
                _capture,
                erlang:element(3, File)
            )
        end
    ),
    gleam@result:values(_pipe@2).

-file("src/deriv.gleam", 202).
-spec gen_type_derivs(
    {glance:custom_type(),
        list(deriv@types:derivation()),
        gleam@dict:dict(deriv@types:deriv_field(), list(deriv@types:deriv_field_opt()))},
    deriv@types:file(),
    gleam@dict:dict(binary(), fun((glance:custom_type(), deriv@types:derivation(), gleam@dict:dict(deriv@types:deriv_field(), list(deriv@types:deriv_field_opt())), deriv@types:file(), fun((binary()) -> {ok,
            glance:module_()} |
        {error, deriv@types:module_reader_err()})) -> deriv@types:gen())),
    fun((binary()) -> {ok, glance:module_()} |
        {error, deriv@types:module_reader_err()})
) -> list(deriv@types:gen()).
gen_type_derivs(X, File, Gen_funcs, Module_reader) ->
    {Type_, Derivs, Field_opts} = X,
    _pipe = Derivs,
    _pipe@1 = gleam@list:map(
        _pipe,
        fun(D) -> case gleam_stdlib:map_get(Gen_funcs, erlang:element(2, D)) of
                {error, _} ->
                    {error, nil};

                {ok, F} ->
                    {ok, F(Type_, D, Field_opts, File, Module_reader)}
            end end
    ),
    gleam@result:values(_pipe@1).

-file("src/deriv.gleam", 315).
-spec perform_file_writes(list(deriv@types:write())) -> nil.
perform_file_writes(Xs) ->
    _pipe = Xs,
    gleam@list:each(
        _pipe,
        fun(Write) ->
            case erlang:element(4, Write) of
                {output, _, Deriv} ->
                    Dir = gleam@string:replace(
                        erlang:element(2, Write),
                        (<<Deriv/binary, ".gleam"/utf8>>),
                        <<""/utf8>>
                    ),
                    _assert_subject = simplifile:create_directory_all(Dir),
                    {ok, _} = 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 => <<"deriv"/utf8>>,
                                        function => <<"perform_file_writes"/utf8>>,
                                        line => 321})
                    end,
                    nil;

                _ ->
                    nil
            end,
            _assert_subject@1 = simplifile:write(
                erlang:element(2, Write),
                erlang:element(3, Write)
            ),
            {ok, _} = case _assert_subject@1 of
                {ok, _} -> _assert_subject@1;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                value => _assert_fail@1,
                                module => <<"deriv"/utf8>>,
                                function => <<"perform_file_writes"/utf8>>,
                                line => 329})
            end
        end
    ).

-file("src/deriv.gleam", 333).
-spec output_path(deriv@types:output()) -> binary().
output_path(Output) ->
    case Output of
        {output, Module, Deriv} ->
            _pipe = [<<"src"/utf8>>,
                <<"deriv"/utf8>>,
                Module,
                <<Deriv/binary, ".gleam"/utf8>>],
            gleam@string:join(_pipe, <<"/"/utf8>>);

        {output_inline, _, Filepath} ->
            Filepath
    end.

-file("src/deriv.gleam", 389).
-spec build_module_imports(list(deriv@types:gen()), deriv@types:output()) -> list(glance:import()).
build_module_imports(Gens, _) ->
    Files = begin
        _pipe = Gens,
        _pipe@1 = gleam@list:map(_pipe, fun(G) -> erlang:element(2, G) end),
        gleam@list:unique(_pipe@1)
    end,
    gleam@list:flat_map(Files, fun(File) -> case erlang:element(4, File) of
                {some, Idx} ->
                    _pipe@2 = {import,
                        erlang:element(2, File),
                        {some,
                            {named,
                                <<"m"/utf8,
                                    (erlang:integer_to_binary(Idx))/binary>>}},
                        [],
                        []},
                    (fun(X) -> [X] end)(_pipe@2);

                none ->
                    []
            end end).

-file("src/deriv.gleam", 454).
-spec consolidate_imports(list(glance:import())) -> list(glance:import()).
consolidate_imports(All_imports) ->
    _pipe = All_imports,
    _pipe@1 = gleam@list:group(_pipe, fun(I) -> erlang:element(2, I) end),
    _pipe@2 = maps:to_list(_pipe@1),
    _pipe@10 = gleam@list:map(
        _pipe@2,
        fun(X) ->
            {Module, Imports} = X,
            Alias@1 = begin
                _pipe@3 = Imports,
                _pipe@4 = gleam@list:map(
                    _pipe@3,
                    fun(I@1) -> erlang:element(3, I@1) end
                ),
                _pipe@5 = gleam@option:values(_pipe@4),
                (fun(Aliases) -> case gleam@list:unique(Aliases) of
                        [] ->
                            none;

                        [Alias] ->
                            {some, Alias};

                        _ ->
                            erlang:error(#{gleam_error => panic,
                                    message => begin
                                        gleam@io:debug(Aliases),
                                        <<<<"0 or 1 aliases allowed, but for module `"/utf8,
                                                Module/binary>>/binary,
                                            "` multiple aliases found (see above)"/utf8>>
                                    end,
                                    module => <<"deriv"/utf8>>,
                                    function => <<"consolidate_imports"/utf8>>,
                                    line => 469})
                    end end)(_pipe@5)
            end,
            Unqualified_types = begin
                _pipe@6 = Imports,
                _pipe@7 = gleam@list:flat_map(
                    _pipe@6,
                    fun(I@2) -> erlang:element(4, I@2) end
                ),
                gleam@list:unique(_pipe@7)
            end,
            Unqualified_values = begin
                _pipe@8 = Imports,
                _pipe@9 = gleam@list:flat_map(
                    _pipe@8,
                    fun(I@3) -> erlang:element(5, I@3) end
                ),
                gleam@list:unique(_pipe@9)
            end,
            {import, Module, Alias@1, Unqualified_types, Unqualified_values}
        end
    ),
    gleam@list:sort(
        _pipe@10,
        fun(A, B) ->
            gleam@string:compare(erlang:element(2, A), erlang:element(2, B))
        end
    ).

-file("src/deriv.gleam", 496).
-spec unqualified_import_str(glance:unqualified_import(), boolean()) -> binary().
unqualified_import_str(Uqi, Is_type) ->
    Type_ = case Is_type of
        true ->
            <<"type "/utf8>>;

        false ->
            <<""/utf8>>
    end,
    Alias@1 = case erlang:element(3, Uqi) of
        {some, Alias} ->
            <<" as "/utf8, Alias/binary>>;

        none ->
            <<""/utf8>>
    end,
    <<<<Type_/binary, (erlang:element(2, Uqi))/binary>>/binary, Alias@1/binary>>.

-file("src/deriv.gleam", 512).
-spec import_src(glance:import()) -> binary().
import_src(I) ->
    Alias = case erlang:element(3, I) of
        {some, {named, Name}} ->
            <<"as "/utf8, Name/binary>>;

        {some, {discarded, Name@1}} ->
            <<"as _"/utf8, Name@1/binary>>;

        none ->
            <<""/utf8>>
    end,
    Types = begin
        _pipe = erlang:element(4, I),
        _pipe@1 = gleam@list:sort(
            _pipe,
            fun(A, B) ->
                gleam@string:compare(erlang:element(2, A), erlang:element(2, B))
            end
        ),
        gleam@list:map(
            _pipe@1,
            fun(_capture) -> unqualified_import_str(_capture, true) end
        )
    end,
    Funcs = begin
        _pipe@2 = erlang:element(5, I),
        _pipe@3 = gleam@list:sort(
            _pipe@2,
            fun(A@1, B@1) ->
                gleam@string:compare(
                    erlang:element(2, A@1),
                    erlang:element(2, B@1)
                )
            end
        ),
        gleam@list:map(
            _pipe@3,
            fun(_capture@1) -> unqualified_import_str(_capture@1, false) end
        )
    end,
    Types_and_constructors = case lists:append(Types, Funcs) of
        [] ->
            <<""/utf8>>;

        Xs ->
            Str = gleam@string:join(Xs, <<", "/utf8>>),
            <<<<".{"/utf8, Str/binary>>/binary, "}"/utf8>>
    end,
    Module_with_types_and_constructors = <<(erlang:element(2, I))/binary,
        Types_and_constructors/binary>>,
    _pipe@4 = [<<"import"/utf8>>, Module_with_types_and_constructors, Alias],
    _pipe@5 = gleam@list:filter(_pipe@4, fun(Str@1) -> Str@1 /= <<""/utf8>> end),
    gleam@string:join(_pipe@5, <<" "/utf8>>).

-file("src/deriv.gleam", 415).
-spec consolidate_imports_for(binary(), list(glance:import())) -> binary().
consolidate_imports_for(Src, Add_imports) ->
    _assert_subject = case glance:module(Src) of
        {error, Err} ->
            gleam@io:debug(Err),
            gleam_stdlib:println(Src),
            erlang:error(#{gleam_error => panic,
                    message => <<"Failed to parse the above source with `glance.module`"/utf8>>,
                    module => <<"deriv"/utf8>>,
                    function => <<"consolidate_imports_for"/utf8>>,
                    line => 421});

        Ok ->
            Ok
    end,
    {ok, Module} = 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 => <<"deriv"/utf8>>,
                        function => <<"consolidate_imports_for"/utf8>>,
                        line => 416})
    end,
    Curr_imports = begin
        _pipe = erlang:element(2, Module),
        gleam@list:map(_pipe, fun(D) -> erlang:element(3, D) end)
    end,
    New_imports = begin
        _pipe@1 = [Curr_imports, Add_imports],
        _pipe@2 = gleam@list:flatten(_pipe@1),
        _pipe@3 = consolidate_imports(_pipe@2),
        _pipe@4 = gleam@list:map(_pipe@3, fun import_src/1),
        _pipe@5 = gleam@string:join(_pipe@4, <<"\n"/utf8>>),
        gleam@string:trim(_pipe@5)
    end,
    Src_without_imports = begin
        _pipe@6 = Src,
        _pipe@7 = gleam@string:split(_pipe@6, <<"\n"/utf8>>),
        _pipe@8 = lists:reverse(_pipe@7),
        _pipe@9 = gleam@list:take_while(
            _pipe@8,
            fun(Str) ->
                not gleam_stdlib:string_starts_with(Str, <<"import"/utf8>>)
            end
        ),
        _pipe@10 = lists:reverse(_pipe@9),
        _pipe@11 = gleam@string:join(_pipe@10, <<"\n"/utf8>>),
        gleam@string:trim(_pipe@11)
    end,
    _pipe@12 = [New_imports, Src_without_imports],
    gleam@string:join(_pipe@12, <<"\n\n"/utf8>>).

-file("src/deriv.gleam", 249).
-spec build_same_file_writes(list(deriv@types:gen())) -> list(deriv@types:write()).
build_same_file_writes(Xs) ->
    _pipe = Xs,
    _pipe@1 = gleam@list:group(
        _pipe,
        fun(Gen) -> erlang:element(2, erlang:element(2, Gen)) end
    ),
    _pipe@10 = gleam@dict:map_values(
        _pipe@1,
        fun(Module, Gens) ->
            Orig_src = begin
                _pipe@2 = Gens,
                _pipe@3 = gleam@list:first(_pipe@2),
                _pipe@4 = gleam@result:map(
                    _pipe@3,
                    fun(Gen@1) ->
                        erlang:element(3, erlang:element(2, Gen@1))
                    end
                ),
                (fun(R) -> case R of
                        {ok, Src} ->
                            Src;

                        {error, _} ->
                            erlang:error(#{gleam_error => panic,
                                    message => (<<<<"`File.src` could not be found for `"/utf8,
                                            Module/binary>>/binary,
                                        "`"/utf8>>),
                                    module => <<"deriv"/utf8>>,
                                    function => <<"build_same_file_writes"/utf8>>,
                                    line => 262})
                    end end)(_pipe@4)
            end,
            Output_path = gleam_module_str_to_file_path(Module),
            Output = {output_inline, Module, Output_path},
            Funcs = begin
                _pipe@5 = Gens,
                _pipe@6 = gleam@list:flat_map(
                    _pipe@5,
                    fun(Gen@2) -> erlang:element(5, Gen@2) end
                ),
                gleam@list:map(
                    _pipe@6,
                    fun(Func) ->
                        {deriv@util:func_name(Func), deriv@util:func_str(Func)}
                    end
                )
            end,
            Module_imports = build_module_imports(Gens, Output),
            Deriv_imports = gleam@list:flat_map(
                Gens,
                fun(Gen@3) -> erlang:element(4, Gen@3) end
            ),
            All_imports = begin
                _pipe@7 = [Module_imports, Deriv_imports],
                gleam@list:flatten(_pipe@7)
            end,
            Func_src_with_imports = deriv@util:update_funcs(Orig_src, Funcs),
            Output_src = begin
                _pipe@8 = Func_src_with_imports,
                _pipe@9 = consolidate_imports_for(_pipe@8, All_imports),
                gleam@string:trim(_pipe@9)
            end,
            {write, Output_path, Output_src, Output}
        end
    ),
    maps:values(_pipe@10).

-file("src/deriv.gleam", 349).
-spec build_output_src(list(deriv@types:gen()), deriv@types:output()) -> binary().
build_output_src(Gens, Output) ->
    case Output of
        {output, _, _} ->
            Module_imports = build_module_imports(Gens, Output),
            Deriv_imports = gleam@list:flat_map(
                Gens,
                fun(Gen) -> erlang:element(4, Gen) end
            ),
            Defs = gleam@list:map(
                Gens,
                fun(Gen@1) -> erlang:element(6, Gen@1) end
            ),
            Func_src = gleam@string:join(Defs, <<"\n\n"/utf8>>),
            All_imports = begin
                _pipe = [Module_imports, Deriv_imports],
                gleam@list:flatten(_pipe)
            end,
            consolidate_imports_for(Func_src, All_imports);

        {output_inline, _, _} ->
            erlang:error(#{gleam_error => panic,
                    message => <<"don't think this logic ever runs..."/utf8>>,
                    module => <<"deriv"/utf8>>,
                    function => <<"build_output_src"/utf8>>,
                    line => 371})
    end.

-file("src/deriv.gleam", 294).
-spec build_different_file_writes(list(deriv@types:gen())) -> list(deriv@types:write()).
build_different_file_writes(Xs) ->
    _pipe = Xs,
    _pipe@1 = gleam@list:group(
        _pipe,
        fun(Gen) ->
            {output,
                erlang:element(2, erlang:element(2, Gen)),
                erlang:element(2, erlang:element(3, Gen))}
        end
    ),
    _pipe@4 = gleam@dict:map_values(
        _pipe@1,
        fun(Output, Gens) ->
            Output_path = output_path(Output),
            Output_src = begin
                _pipe@2 = Gens,
                _pipe@3 = build_output_src(_pipe@2, Output),
                gleam@string:trim(_pipe@3)
            end,
            {write, Output_path, Output_src, Output}
        end
    ),
    maps:values(_pipe@4).

-file("src/deriv.gleam", 224).
-spec build_writes(list(deriv@types:gen())) -> list(deriv@types:write()).
build_writes(Xs) ->
    {Inline_derivs, Other_derivs} = begin
        _pipe = Xs,
        gleam@list:partition(
            _pipe,
            fun(Gen) -> _pipe@1 = erlang:element(7, Gen),
                _pipe@2 = gleam_stdlib:map_get(_pipe@1, <<"source"/utf8>>),
                _pipe@3 = gleam@result:map(
                    _pipe@2,
                    fun(Source) -> Source =:= <<"inline"/utf8>> end
                ),
                gleam@result:unwrap(_pipe@3, false) end
        )
    end,
    Same_file_writes = begin
        _pipe@4 = Inline_derivs,
        build_same_file_writes(_pipe@4)
    end,
    Diff_file_writes = begin
        _pipe@5 = Other_derivs,
        build_different_file_writes(_pipe@5)
    end,
    _pipe@6 = [Diff_file_writes, Same_file_writes],
    gleam@list:flatten(_pipe@6).

-file("src/deriv.gleam", 552).
-spec stop_warning() -> binary().
stop_warning() ->
    gleam@io:debug(<<""/utf8>>).

-file("src/deriv.gleam", 579).
-spec load_types_from_file(
    glance:import(),
    list(deriv@types:derivation()),
    list(deriv@types:file())
) -> {deriv@types:file(),
    list({glance:custom_type(),
        list(deriv@types:derivation()),
        gleam@dict:dict(deriv@types:deriv_field(), list(deriv@types:deriv_field_opt()))})}.
load_types_from_file(Import_, Derivs, All_files) ->
    _assert_subject = gleam@list:find(
        All_files,
        fun(F) -> erlang:element(2, F) =:= erlang:element(2, Import_) end
    ),
    {ok, File} = 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 => <<"deriv"/utf8>>,
                        function => <<"load_types_from_file"/utf8>>,
                        line => 580})
    end,
    _assert_subject@1 = glance:module(erlang:element(3, File)),
    {ok, Module} = case _assert_subject@1 of
        {ok, _} -> _assert_subject@1;
        _assert_fail@1 ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        value => _assert_fail@1,
                        module => <<"deriv"/utf8>>,
                        function => <<"load_types_from_file"/utf8>>,
                        line => 581})
    end,
    Type_names = begin
        _pipe = erlang:element(4, Import_),
        gleam@list:map(_pipe, fun(I) -> erlang:element(2, I) end)
    end,
    Types_and_derivs = begin
        _pipe@1 = erlang:element(3, Module),
        _pipe@2 = gleam@list:filter(
            _pipe@1,
            fun(T) ->
                gleam@list:contains(
                    Type_names,
                    erlang:element(2, erlang:element(3, T))
                )
            end
        ),
        gleam@list:map(
            _pipe@2,
            fun(T@1) -> {erlang:element(3, T@1), Derivs, maps:new()} end
        )
    end,
    {File, Types_and_derivs}.

-file("src/deriv.gleam", 611).
-spec suppress_warnings_types_to_write(glance:module_()) -> list(binary()).
suppress_warnings_types_to_write(Module) ->
    Import_types = begin
        _pipe = erlang:element(2, Module),
        gleam@list:flat_map(
            _pipe,
            fun(I) -> _pipe@1 = erlang:element(4, erlang:element(3, I)),
                gleam@list:map(_pipe@1, fun(T) -> erlang:element(2, T) end) end
        )
    end,
    Type_aliases = begin
        _pipe@2 = erlang:element(4, Module),
        gleam@list:map(
            _pipe@2,
            fun(Ta) -> erlang:element(2, erlang:element(3, Ta)) end
        )
    end,
    _pipe@3 = Import_types,
    gleam@list:filter(
        _pipe@3,
        fun(T@1) ->
            not gleam@list:contains(
                Type_aliases,
                <<"SuppressWarnings"/utf8, T@1/binary>>
            )
        end
    ).

-file("src/deriv.gleam", 597).
-spec write_suppress_warning_type_aliases_to_file(glance:module_()) -> nil.
write_suppress_warning_type_aliases_to_file(Module) ->
    Src = begin
        _pipe = Module,
        _pipe@1 = suppress_warnings_types_to_write(_pipe),
        _pipe@2 = gleam@list:map(
            _pipe@1,
            fun(T) ->
                <<<<<<"pub type SuppressWarnings"/utf8, T/binary>>/binary,
                        " = "/utf8>>/binary,
                    T/binary>>
            end
        ),
        gleam@string:join(_pipe@2, <<"\n"/utf8>>)
    end,
    Project_derivs_filepath = <<<<"src/"/utf8, (project_name())/binary>>/binary,
        "/derivs.gleam"/utf8>>,
    _assert_subject = simplifile:append(Project_derivs_filepath, Src),
    {ok, _} = 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 => <<"deriv"/utf8>>,
                        function => <<"write_suppress_warning_type_aliases_to_file"/utf8>>,
                        line => 606})
    end,
    nil.

-file("src/deriv.gleam", 557).
-spec derivs_file_import_gens(
    deriv@types:file(),
    list(deriv@types:file()),
    gleam@dict:dict(binary(), fun((glance:custom_type(), deriv@types:derivation(), gleam@dict:dict(deriv@types:deriv_field(), list(deriv@types:deriv_field_opt())), deriv@types:file(), fun((binary()) -> {ok,
            glance:module_()} |
        {error, deriv@types:module_reader_err()})) -> deriv@types:gen()))
) -> list(deriv@types:gen()).
derivs_file_import_gens(Derivs_file, All_files, Gen_funcs) ->
    _assert_subject = glance:module(erlang:element(3, Derivs_file)),
    {ok, Module} = 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 => <<"deriv"/utf8>>,
                        function => <<"derivs_file_import_gens"/utf8>>,
                        line => 562})
    end,
    write_suppress_warning_type_aliases_to_file(Module),
    _pipe = erlang:element(2, Module),
    _pipe@1 = gleam@list:map(_pipe, fun(I) -> erlang:element(3, I) end),
    _pipe@2 = gleam@list:map(
        _pipe@1,
        fun(_capture) ->
            deriv@parser:parse_import_with_derivations(
                _capture,
                erlang:element(3, Derivs_file)
            )
        end
    ),
    _pipe@3 = gleam@result:values(_pipe@2),
    gleam@list:flat_map(
        _pipe@3,
        fun(X) ->
            {Import_, Derivs} = X,
            {File, Types_and_derivs} = load_types_from_file(
                Import_,
                Derivs,
                All_files
            ),
            _pipe@4 = Types_and_derivs,
            gleam@list:flat_map(
                _pipe@4,
                fun(_capture@1) ->
                    gen_type_derivs(
                        _capture@1,
                        File,
                        Gen_funcs,
                        fun deriv@util:fetch_module/1
                    )
                end
            )
        end
    ).

-file("src/deriv.gleam", 119).
-spec gen_derivs(
    list(deriv@types:file()),
    fun((binary()) -> {ok, glance:module_()} |
        {error, deriv@types:module_reader_err()})
) -> list(deriv@types:gen()).
gen_derivs(Files, Module_reader) ->
    Gen_funcs = begin
        _pipe = [{<<"json"/utf8>>, fun deriv@json:gen/5},
            {<<"unify"/utf8>>, fun deriv@unify:gen/5}],
        maps:from_list(_pipe)
    end,
    Project_derivs_module_name = <<(project_name())/binary, "/derivs"/utf8>>,
    Type_inline_gens = begin
        _pipe@1 = Files,
        _pipe@2 = gleam@list:filter(
            _pipe@1,
            fun(File) ->
                erlang:element(2, File) /= Project_derivs_module_name
            end
        ),
        _pipe@5 = gleam@list:map(
            _pipe@2,
            fun(File@1) ->
                File@2 = begin
                    _record = File@1,
                    {file,
                        erlang:element(2, _record),
                        erlang:element(3, _record),
                        none}
                end,
                _pipe@3 = File@2,
                _pipe@4 = parse_types_and_derivations(_pipe@3),
                gleam@list:flat_map(
                    _pipe@4,
                    fun(_capture) ->
                        gen_type_derivs(
                            _capture,
                            File@2,
                            Gen_funcs,
                            Module_reader
                        )
                    end
                )
            end
        ),
        _pipe@6 = gleam@list:flatten(_pipe@5),
        gleam@list:map(_pipe@6, fun(Gen) -> _record@1 = Gen,
                {gen,
                    erlang:element(2, _record@1),
                    erlang:element(3, _record@1),
                    erlang:element(4, _record@1),
                    erlang:element(5, _record@1),
                    erlang:element(6, _record@1),
                    maps:from_list([{<<"source"/utf8>>, <<"inline"/utf8>>}])} end)
    end,
    Derivs_file = gleam@list:find(
        Files,
        fun(File@3) ->
            erlang:element(2, File@3) =:= Project_derivs_module_name
        end
    ),
    Derivs_file_import_gens = begin
        _pipe@7 = case Derivs_file of
            {ok, File@4} ->
                derivs_file_import_gens(File@4, Files, Gen_funcs);

            _ ->
                []
        end,
        gleam@list:map(_pipe@7, fun(Gen@1) -> _record@2 = Gen@1,
                {gen,
                    erlang:element(2, _record@2),
                    erlang:element(3, _record@2),
                    erlang:element(4, _record@2),
                    erlang:element(5, _record@2),
                    erlang:element(6, _record@2),
                    maps:from_list([{<<"source"/utf8>>, <<"import"/utf8>>}])} end)
    end,
    _pipe@8 = [Type_inline_gens, Derivs_file_import_gens],
    gleam@list:flatten(_pipe@8).

-file("src/deriv.gleam", 70).
-spec main() -> nil.
main() ->
    Filepaths = find_project_src_gleam_filepaths(),
    _pipe = Filepaths,
    _pipe@1 = load_files(_pipe),
    _pipe@2 = gen_derivs(_pipe@1, fun deriv@util:fetch_module/1),
    _pipe@3 = build_writes(_pipe@2),
    perform_file_writes(_pipe@3).