-module(graded@internal@effects).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/graded/internal/effects.gleam").
-export([with_externals/2, compare_semver/2, semver_lte/2, pick_best_version/2, parse_semver/1, load_spec_returns_from_file/1, load_dep_spec/2, load_knowledge_base/2, empty_knowledge_base/0, lookup_type_field/4, with_type_fields/2, with_inferred_type_fields/2, lookup/2, lookup_effects/2, argument_value_effects/2, lookup_param_bounds/2, format_effect_set/1, parse_path_dependencies/1, load_spec_effects/1, load_spec_effects_from_file/1, with_inferred/2, with_inferred_params/2, with_inferred_returned_operators/2, with_factories/2, factories/1, lookup_returned_operator/2]).
-export_type([effect_lookup/0, knowledge_base/0, catalog_acc/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(false).

-type effect_lookup() :: {known, graded@internal@types:effect_term()} | unknown.

-type knowledge_base() :: {knowledge_base,
        gleam@dict:dict(graded@internal@types:qualified_name(), graded@internal@types:effect_term()),
        gleam@dict:dict(graded@internal@types:qualified_name(), list(graded@internal@types:param_bound())),
        gleam@dict:dict({binary(), binary(), binary()}, graded@internal@types:type_field_effect()),
        gleam@dict:dict(graded@internal@types:qualified_name(), graded@internal@types:effect_term()),
        gleam@dict:dict({binary(), binary()}, gleam@dict:dict(binary(), integer())),
        gleam@set:set(binary())}.

-type catalog_acc() :: {catalog_acc,
        gleam@dict:dict(graded@internal@types:qualified_name(), graded@internal@types:effect_term()),
        gleam@set:set(binary()),
        gleam@dict:dict(graded@internal@types:qualified_name(), graded@internal@types:effect_term()),
        gleam@dict:dict(graded@internal@types:qualified_name(), list(graded@internal@types:param_bound()))}.

-file("src/graded/internal/effects.gleam", 477).
?DOC(false).
-spec fold_qualified_annotation(
    {gleam@dict:dict(graded@internal@types:qualified_name(), graded@internal@types:effect_term()),
        gleam@dict:dict(graded@internal@types:qualified_name(), list(graded@internal@types:param_bound()))},
    graded@internal@types:effect_annotation()
) -> {gleam@dict:dict(graded@internal@types:qualified_name(), graded@internal@types:effect_term()),
    gleam@dict:dict(graded@internal@types:qualified_name(), list(graded@internal@types:param_bound()))}.
fold_qualified_annotation(Accumulator, Ann) ->
    {Effect_map, Param_map} = Accumulator,
    case graded@internal@annotation:split_qualified_name(erlang:element(3, Ann)) of
        {error, _} ->
            Accumulator;

        {ok, {Module, Function}} ->
            Qualified_name = {qualified_name, Module, Function},
            New_effect_map = case erlang:element(2, Ann) of
                effects ->
                    gleam@dict:insert(
                        Effect_map,
                        Qualified_name,
                        erlang:element(5, Ann)
                    );

                check ->
                    Effect_map
            end,
            New_param_map = case erlang:element(4, Ann) of
                [] ->
                    Param_map;

                Params ->
                    gleam@dict:insert(Param_map, Qualified_name, Params)
            end,
            {New_effect_map, New_param_map}
    end.

-file("src/graded/internal/effects.gleam", 149).
?DOC(false).
-spec with_externals(
    knowledge_base(),
    list(graded@internal@types:external_annotation())
) -> knowledge_base().
with_externals(Knowledge_base, Externals) ->
    {Effect_map@1, Pure_set@1} = gleam@list:fold(
        Externals,
        {erlang:element(2, Knowledge_base), erlang:element(7, Knowledge_base)},
        fun(Accumulator, External_annotation) ->
            {Effect_map, Pure_set} = Accumulator,
            case erlang:element(3, External_annotation) of
                module_external ->
                    {Effect_map,
                        gleam@set:insert(
                            Pure_set,
                            erlang:element(2, External_annotation)
                        )};

                {function_external, Function} ->
                    {gleam@dict:insert(
                            Effect_map,
                            {qualified_name,
                                erlang:element(2, External_annotation),
                                Function},
                            graded@internal@effect_term:from_effect_set(
                                erlang:element(4, External_annotation)
                            )
                        ),
                        Pure_set}
            end
        end
    ),
    {knowledge_base,
        Effect_map@1,
        erlang:element(3, Knowledge_base),
        erlang:element(4, Knowledge_base),
        erlang:element(5, Knowledge_base),
        erlang:element(6, Knowledge_base),
        Pure_set@1}.

-file("src/graded/internal/effects.gleam", 549).
?DOC(false).
-spec fold_catalog_file(catalog_acc(), binary()) -> catalog_acc().
fold_catalog_file(Acc, File_path) ->
    case simplifile:read(File_path) of
        {error, _} ->
            Acc;

        {ok, Content} ->
            case graded@internal@annotation:parse_file(Content) of
                {error, _} ->
                    Acc;

                {ok, Graded_file} ->
                    Kb = with_externals(
                        {knowledge_base,
                            erlang:element(2, Acc),
                            maps:new(),
                            maps:new(),
                            maps:new(),
                            maps:new(),
                            erlang:element(3, Acc)},
                        graded@internal@annotation:extract_externals(
                            Graded_file
                        )
                    ),
                    {Poly_effects, Poly_params} = gleam@list:fold(
                        graded@internal@annotation:extract_annotations(
                            Graded_file
                        ),
                        {erlang:element(4, Acc), erlang:element(5, Acc)},
                        fun fold_qualified_annotation/2
                    ),
                    {catalog_acc,
                        erlang:element(2, Kb),
                        erlang:element(7, Kb),
                        Poly_effects,
                        Poly_params}
            end
    end.

-file("src/graded/internal/effects.gleam", 672).
?DOC(false).
-spec compare_semver(
    {integer(), integer(), integer()},
    {integer(), integer(), integer()}
) -> gleam@order:order().
compare_semver(Left, Right) ->
    case gleam@int:compare(erlang:element(1, Left), erlang:element(1, Right)) of
        eq ->
            case gleam@int:compare(
                erlang:element(2, Left),
                erlang:element(2, Right)
            ) of
                eq ->
                    gleam@int:compare(
                        erlang:element(3, Left),
                        erlang:element(3, Right)
                    );

                Other ->
                    Other
            end;

        Other@1 ->
            Other@1
    end.

-file("src/graded/internal/effects.gleam", 668).
?DOC(false).
-spec semver_lte(
    {integer(), integer(), integer()},
    {integer(), integer(), integer()}
) -> boolean().
semver_lte(Left, Right) ->
    compare_semver(Left, Right) /= gt.

-file("src/graded/internal/effects.gleam", 628).
?DOC(false).
-spec pick_best_version(
    list({{integer(), integer(), integer()}, binary()}),
    {integer(), integer(), integer()}
) -> {ok, binary()} | {error, nil}.
pick_best_version(Versions, Installed) ->
    Eligible = begin
        _pipe = gleam@list:filter(
            Versions,
            fun(Version) ->
                semver_lte(erlang:element(1, Version), Installed)
            end
        ),
        gleam@list:sort(
            _pipe,
            fun(Left, Right) ->
                compare_semver(
                    erlang:element(1, Right),
                    erlang:element(1, Left)
                )
            end
        )
    end,
    case Eligible of
        [Best | _] ->
            {ok, erlang:element(2, Best)};

        [] ->
            case gleam@list:sort(
                Versions,
                fun(Left@1, Right@1) ->
                    compare_semver(
                        erlang:element(1, Right@1),
                        erlang:element(1, Left@1)
                    )
                end
            ) of
                [Best@1 | _] ->
                    {ok, erlang:element(2, Best@1)};

                [] ->
                    {error, nil}
            end
    end.

-file("src/graded/internal/effects.gleam", 652).
?DOC(false).
-spec parse_semver(binary()) -> {integer(), integer(), integer()}.
parse_semver(Version) ->
    case gleam@string:split(Version, <<"."/utf8>>) of
        [Major, Minor, Patch] ->
            {begin
                    _pipe = gleam_stdlib:parse_int(Major),
                    gleam@result:unwrap(_pipe, 0)
                end,
                begin
                    _pipe@1 = gleam_stdlib:parse_int(Minor),
                    gleam@result:unwrap(_pipe@1, 0)
                end,
                begin
                    _pipe@2 = gleam_stdlib:parse_int(Patch),
                    gleam@result:unwrap(_pipe@2, 0)
                end};

        [Major@1, Minor@1] ->
            {begin
                    _pipe@3 = gleam_stdlib:parse_int(Major@1),
                    gleam@result:unwrap(_pipe@3, 0)
                end,
                begin
                    _pipe@4 = gleam_stdlib:parse_int(Minor@1),
                    gleam@result:unwrap(_pipe@4, 0)
                end,
                0};

        _ ->
            {0, 0, 0}
    end.

-file("src/graded/internal/effects.gleam", 585).
?DOC(false).
-spec resolve_catalog_files(list(binary()), gleam@dict:dict(binary(), binary())) -> list(binary()).
resolve_catalog_files(Catalog_files, Installed_versions) ->
    Parsed = gleam@list:filter_map(
        Catalog_files,
        fun(Path) ->
            Filename = begin
                _pipe = Path,
                _pipe@1 = gleam@string:split(_pipe, <<"/"/utf8>>),
                _pipe@2 = gleam@list:last(_pipe@1),
                _pipe@3 = gleam@result:unwrap(_pipe@2, <<""/utf8>>),
                gleam@string:replace(_pipe@3, <<".graded"/utf8>>, <<""/utf8>>)
            end,
            case gleam@string:split(Filename, <<"@"/utf8>>) of
                [Package, Version] ->
                    {ok, {Package, parse_semver(Version), Path}};

                _ ->
                    {error, nil}
            end
        end
    ),
    Grouped = gleam@list:fold(
        Parsed,
        maps:new(),
        fun(Accumulator, Entry) ->
            {Package@1, Version@1, Path@1} = Entry,
            Existing = begin
                _pipe@4 = gleam_stdlib:map_get(Accumulator, Package@1),
                gleam@result:unwrap(_pipe@4, [])
            end,
            gleam@dict:insert(
                Accumulator,
                Package@1,
                [{Version@1, Path@1} | Existing]
            )
        end
    ),
    gleam@dict:fold(
        Grouped,
        [],
        fun(Selected, Package@2, Versions) ->
            case gleam_stdlib:map_get(Installed_versions, Package@2) of
                {error, nil} ->
                    Selected;

                {ok, Installed_str} ->
                    Installed = parse_semver(Installed_str),
                    Best = pick_best_version(Versions, Installed),
                    case Best of
                        {ok, Path@2} ->
                            [Path@2 | Selected];

                        {error, nil} ->
                            Selected
                    end
            end
        end
    ).

-file("src/graded/internal/effects.gleam", 686).
?DOC(false).
-spec parse_manifest_versions(binary()) -> gleam@dict:dict(binary(), binary()).
parse_manifest_versions(Manifest_path) ->
    Parsed = begin
        gleam@result:'try'(
            begin
                _pipe = simplifile:read(Manifest_path),
                gleam@result:map_error(_pipe, fun(_) -> nil end)
            end,
            fun(Content) ->
                gleam@result:'try'(
                    begin
                        _pipe@1 = tom:parse(Content),
                        gleam@result:map_error(_pipe@1, fun(_) -> nil end)
                    end,
                    fun(Toml) ->
                        gleam@result:'try'(
                            begin
                                _pipe@2 = tom:get_array(
                                    Toml,
                                    [<<"packages"/utf8>>]
                                ),
                                gleam@result:map_error(
                                    _pipe@2,
                                    fun(_) -> nil end
                                )
                            end,
                            fun(Packages) ->
                                {ok,
                                    gleam@list:fold(
                                        Packages,
                                        maps:new(),
                                        fun(Accumulator, Package) ->
                                            case Package of
                                                {inline_table, Table} ->
                                                    case {tom:get_string(
                                                            Table,
                                                            [<<"name"/utf8>>]
                                                        ),
                                                        tom:get_string(
                                                            Table,
                                                            [<<"version"/utf8>>]
                                                        )} of
                                                        {{ok, Name},
                                                            {ok, Version}} ->
                                                            gleam@dict:insert(
                                                                Accumulator,
                                                                Name,
                                                                Version
                                                            );

                                                        {_, _} ->
                                                            Accumulator
                                                    end;

                                                _ ->
                                                    Accumulator
                                            end
                                        end
                                    )}
                            end
                        )
                    end
                )
            end
        )
    end,
    gleam@result:unwrap(Parsed, maps:new()).

-file("src/graded/internal/effects.gleam", 522).
?DOC(false).
-spec load_catalog(binary(), binary()) -> {gleam@dict:dict(graded@internal@types:qualified_name(), graded@internal@types:effect_term()),
    gleam@set:set(binary()),
    gleam@dict:dict(graded@internal@types:qualified_name(), list(graded@internal@types:param_bound()))}.
load_catalog(Catalog_dir, Manifest_path) ->
    Installed_versions = parse_manifest_versions(Manifest_path),
    Catalog_files = case simplifile:get_files(Catalog_dir) of
        {ok, Files} ->
            gleam@list:filter(
                Files,
                fun(File) ->
                    gleam_stdlib:string_ends_with(File, <<".graded"/utf8>>)
                end
            );

        {error, _} ->
            []
    end,
    Selected = resolve_catalog_files(Catalog_files, Installed_versions),
    Initial = {catalog_acc, maps:new(), gleam@set:new(), maps:new(), maps:new()},
    Acc = gleam@list:fold(Selected, Initial, fun fold_catalog_file/2),
    All_effects = maps:merge(erlang:element(2, Acc), erlang:element(4, Acc)),
    {All_effects, erlang:element(3, Acc), erlang:element(5, Acc)}.

-file("src/graded/internal/effects.gleam", 505).
?DOC(false).
-spec find_catalog_directory() -> binary().
find_catalog_directory() ->
    Installed = <<"build/packages/graded/priv/catalog"/utf8>>,
    case simplifile_erl:is_directory(Installed) of
        {ok, true} ->
            Installed;

        _ ->
            <<"priv/catalog"/utf8>>
    end.

-file("src/graded/internal/effects.gleam", 369).
?DOC(false).
-spec fold_spec_returns(list(graded@internal@types:returns_annotation())) -> gleam@dict:dict(graded@internal@types:qualified_name(), graded@internal@types:effect_term()).
fold_spec_returns(Returns) ->
    gleam@list:fold(
        Returns,
        maps:new(),
        fun(Acc, Returns@1) ->
            case graded@internal@annotation:split_qualified_name(
                erlang:element(2, Returns@1)
            ) of
                {ok, {Module, Function}} ->
                    gleam@dict:insert(
                        Acc,
                        {qualified_name, Module, Function},
                        erlang:element(3, Returns@1)
                    );

                {error, _} ->
                    Acc
            end
        end
    ).

-file("src/graded/internal/effects.gleam", 363).
?DOC(false).
-spec load_spec_returns_from_file(graded@internal@types:graded_file()) -> gleam@dict:dict(graded@internal@types:qualified_name(), graded@internal@types:effect_term()).
load_spec_returns_from_file(File) ->
    fold_spec_returns(graded@internal@annotation:extract_returns(File)).

-file("src/graded/internal/effects.gleam", 354).
?DOC(false).
-spec read_spec_file(binary()) -> {ok, graded@internal@types:graded_file()} |
    {error, nil}.
read_spec_file(Spec_path) ->
    gleam@result:'try'(
        begin
            _pipe = simplifile:read(Spec_path),
            gleam@result:replace_error(_pipe, nil)
        end,
        fun(Content) ->
            _pipe@1 = graded@internal@annotation:parse_file(Content),
            gleam@result:replace_error(_pipe@1, nil)
        end
    ).

-file("src/graded/internal/effects.gleam", 309).
?DOC(false).
-spec load_dep_spec(binary(), binary()) -> {gleam@dict:dict(graded@internal@types:qualified_name(), graded@internal@types:effect_term()),
    gleam@dict:dict(graded@internal@types:qualified_name(), list(graded@internal@types:param_bound())),
    gleam@dict:dict(graded@internal@types:qualified_name(), graded@internal@types:effect_term())}.
load_dep_spec(Dep_root, Package_name) ->
    case read_spec_file(
        graded@internal@config:spec_file_for(Dep_root, Package_name)
    ) of
        {error, _} ->
            {maps:new(), maps:new(), maps:new()};

        {ok, File} ->
            {Effect_map, Param_map} = gleam@list:fold(
                graded@internal@annotation:extract_annotations(File),
                {maps:new(), maps:new()},
                fun fold_qualified_annotation/2
            ),
            {Effect_map, Param_map, load_spec_returns_from_file(File)}
    end.

-file("src/graded/internal/effects.gleam", 449).
?DOC(false).
-spec load_dependencies(binary()) -> {gleam@dict:dict(graded@internal@types:qualified_name(), graded@internal@types:effect_term()),
    gleam@dict:dict(graded@internal@types:qualified_name(), list(graded@internal@types:param_bound())),
    gleam@dict:dict(graded@internal@types:qualified_name(), graded@internal@types:effect_term())}.
load_dependencies(Packages_directory) ->
    Entries = case simplifile_erl:read_directory(Packages_directory) of
        {ok, Found} ->
            Found;

        {error, _} ->
            []
    end,
    gleam@list:fold(
        Entries,
        {maps:new(), maps:new(), maps:new()},
        fun(Acc, Package_name) ->
            {Effect_map, Param_map, Returns_map} = Acc,
            Dep_root = <<<<Packages_directory/binary, "/"/utf8>>/binary,
                Package_name/binary>>,
            {New_effects, New_params, New_returns} = load_dep_spec(
                Dep_root,
                Package_name
            ),
            {maps:merge(Effect_map, New_effects),
                maps:merge(Param_map, New_params),
                maps:merge(Returns_map, New_returns)}
        end
    ).

-file("src/graded/internal/effects.gleam", 55).
?DOC(false).
-spec load_knowledge_base(binary(), binary()) -> knowledge_base().
load_knowledge_base(Packages_directory, Manifest_path) ->
    {Dep_effects, Dep_params, Dep_returns} = load_dependencies(
        Packages_directory
    ),
    Catalog_dir = find_catalog_directory(),
    {Cat_effects, Cat_pure, Cat_params} = load_catalog(
        Catalog_dir,
        Manifest_path
    ),
    {knowledge_base,
        maps:merge(Cat_effects, Dep_effects),
        maps:merge(Cat_params, Dep_params),
        maps:new(),
        Dep_returns,
        maps:new(),
        Cat_pure}.

-file("src/graded/internal/effects.gleam", 76).
?DOC(false).
-spec empty_knowledge_base() -> knowledge_base().
empty_knowledge_base() ->
    Catalog_dir = find_catalog_directory(),
    {Cat_effects, Cat_pure, Cat_params} = load_catalog(
        Catalog_dir,
        <<"manifest.toml"/utf8>>
    ),
    {knowledge_base,
        Cat_effects,
        Cat_params,
        maps:new(),
        maps:new(),
        maps:new(),
        Cat_pure}.

-file("src/graded/internal/effects.gleam", 93).
?DOC(false).
-spec lookup_type_field(knowledge_base(), binary(), binary(), binary()) -> {ok,
        graded@internal@types:type_field_effect()} |
    {error, nil}.
lookup_type_field(Knowledge_base, Module, Type_name, Field) ->
    gleam_stdlib:map_get(
        erlang:element(4, Knowledge_base),
        {Module, Type_name, Field}
    ).

-file("src/graded/internal/effects.gleam", 106).
?DOC(false).
-spec with_type_fields(
    knowledge_base(),
    list(graded@internal@types:type_field_annotation())
) -> knowledge_base().
with_type_fields(Knowledge_base, Type_fields) ->
    Merged = gleam@list:fold(
        Type_fields,
        erlang:element(4, Knowledge_base),
        fun(Accumulator, Type_field) ->
            Module@1 = case erlang:element(2, Type_field) of
                {some, Module} ->
                    Module;

                none ->
                    <<""/utf8>>
            end,
            gleam@dict:insert(
                Accumulator,
                {Module@1,
                    erlang:element(3, Type_field),
                    erlang:element(4, Type_field)},
                {type_field_effect, erlang:element(5, Type_field), [], none}
            )
        end
    ),
    {knowledge_base,
        erlang:element(2, Knowledge_base),
        erlang:element(3, Knowledge_base),
        Merged,
        erlang:element(5, Knowledge_base),
        erlang:element(6, Knowledge_base),
        erlang:element(7, Knowledge_base)}.

-file("src/graded/internal/effects.gleam", 133).
?DOC(false).
-spec with_inferred_type_fields(
    knowledge_base(),
    list({{binary(), binary(), binary()},
        graded@internal@types:type_field_effect()})
) -> knowledge_base().
with_inferred_type_fields(Knowledge_base, Inferred) ->
    {knowledge_base,
        erlang:element(2, Knowledge_base),
        erlang:element(3, Knowledge_base),
        maps:merge(erlang:element(4, Knowledge_base), maps:from_list(Inferred)),
        erlang:element(5, Knowledge_base),
        erlang:element(6, Knowledge_base),
        erlang:element(7, Knowledge_base)}.

-file("src/graded/internal/effects.gleam", 183).
?DOC(false).
-spec lookup(knowledge_base(), graded@internal@types:qualified_name()) -> effect_lookup().
lookup(Knowledge_base, Name) ->
    case gleam_stdlib:map_get(erlang:element(2, Knowledge_base), Name) of
        {ok, Effect_set} ->
            {known, Effect_set};

        {error, nil} ->
            case gleam@set:contains(
                erlang:element(7, Knowledge_base),
                erlang:element(2, Name)
            ) of
                true ->
                    {known, graded@internal@effect_term:pure()};

                false ->
                    unknown
            end
    end.

-file("src/graded/internal/effects.gleam", 200).
?DOC(false).
-spec lookup_effects(knowledge_base(), graded@internal@types:qualified_name()) -> graded@internal@types:effect_term().
lookup_effects(Knowledge_base, Name) ->
    case lookup(Knowledge_base, Name) of
        {known, Effect_term} ->
            Effect_term;

        unknown ->
            graded@internal@effect_term:unknown()
    end.

-file("src/graded/internal/effects.gleam", 219).
?DOC(false).
-spec argument_value_effects(
    knowledge_base(),
    graded@internal@types:argument_value()
) -> graded@internal@types:effect_term().
argument_value_effects(Knowledge_base, Value) ->
    case Value of
        {function_ref, Name} ->
            lookup_effects(Knowledge_base, Name);

        constructor_ref ->
            graded@internal@effect_term:pure();

        _ ->
            graded@internal@effect_term:unknown()
    end.

-file("src/graded/internal/effects.gleam", 233).
?DOC(false).
-spec lookup_param_bounds(
    knowledge_base(),
    graded@internal@types:qualified_name()
) -> list(graded@internal@types:param_bound()).
lookup_param_bounds(Knowledge_base, Name) ->
    case gleam_stdlib:map_get(erlang:element(3, Knowledge_base), Name) of
        {ok, Bounds} ->
            Bounds;

        {error, nil} ->
            []
    end.

-file("src/graded/internal/effects.gleam", 246).
?DOC(false).
-spec format_effect_set(graded@internal@types:effect_set()) -> binary().
format_effect_set(Effect_set) ->
    graded@internal@annotation:format_effect_set(Effect_set).

-file("src/graded/internal/effects.gleam", 252).
?DOC(false).
-spec parse_path_dependencies(binary()) -> list({binary(), binary()}).
parse_path_dependencies(Gleam_toml_path) ->
    Parsed = begin
        gleam@result:'try'(
            begin
                _pipe = simplifile:read(Gleam_toml_path),
                gleam@result:map_error(_pipe, fun(_) -> nil end)
            end,
            fun(Content) ->
                gleam@result:'try'(
                    begin
                        _pipe@1 = tom:parse(Content),
                        gleam@result:map_error(_pipe@1, fun(_) -> nil end)
                    end,
                    fun(Toml) ->
                        gleam@result:'try'(
                            begin
                                _pipe@2 = tom:get_table(
                                    Toml,
                                    [<<"dependencies"/utf8>>]
                                ),
                                gleam@result:map_error(
                                    _pipe@2,
                                    fun(_) -> nil end
                                )
                            end,
                            fun(Deps) ->
                                {ok,
                                    gleam@dict:fold(
                                        Deps,
                                        [],
                                        fun(Acc, Name, Value) -> case Value of
                                                {inline_table, Table} ->
                                                    case tom:get_string(
                                                        Table,
                                                        [<<"path"/utf8>>]
                                                    ) of
                                                        {ok, Path} ->
                                                            [{Name, Path} | Acc];

                                                        {error, _} ->
                                                            Acc
                                                    end;

                                                _ ->
                                                    Acc
                                            end end
                                    )}
                            end
                        )
                    end
                )
            end
        )
    end,
    gleam@result:unwrap(Parsed, []).

-file("src/graded/internal/effects.gleam", 331).
?DOC(false).
-spec fold_spec_effects(list(graded@internal@types:effect_annotation())) -> gleam@dict:dict(graded@internal@types:qualified_name(), graded@internal@types:effect_term()).
fold_spec_effects(Annotations) ->
    gleam@list:fold(
        Annotations,
        maps:new(),
        fun(Acc, Ann) -> case erlang:element(2, Ann) of
                effects ->
                    case graded@internal@annotation:split_qualified_name(
                        erlang:element(3, Ann)
                    ) of
                        {ok, {Module, Function}} ->
                            gleam@dict:insert(
                                Acc,
                                {qualified_name, Module, Function},
                                erlang:element(5, Ann)
                            );

                        {error, _} ->
                            Acc
                    end;

                check ->
                    Acc
            end end
    ).

-file("src/graded/internal/effects.gleam", 347).
?DOC(false).
-spec read_spec_annotations(binary()) -> {ok,
        list(graded@internal@types:effect_annotation())} |
    {error, nil}.
read_spec_annotations(Spec_path) ->
    gleam@result:'try'(
        read_spec_file(Spec_path),
        fun(File) ->
            {ok, graded@internal@annotation:extract_annotations(File)}
        end
    ).

-file("src/graded/internal/effects.gleam", 286).
?DOC(false).
-spec load_spec_effects(binary()) -> gleam@dict:dict(graded@internal@types:qualified_name(), graded@internal@types:effect_term()).
load_spec_effects(Spec_path) ->
    case read_spec_annotations(Spec_path) of
        {error, _} ->
            maps:new();

        {ok, Annotations} ->
            fold_spec_effects(Annotations)
    end.

-file("src/graded/internal/effects.gleam", 296).
?DOC(false).
-spec load_spec_effects_from_file(graded@internal@types:graded_file()) -> gleam@dict:dict(graded@internal@types:qualified_name(), graded@internal@types:effect_term()).
load_spec_effects_from_file(File) ->
    fold_spec_effects(graded@internal@annotation:extract_annotations(File)).

-file("src/graded/internal/effects.gleam", 383).
?DOC(false).
-spec with_inferred(
    knowledge_base(),
    gleam@dict:dict(graded@internal@types:qualified_name(), graded@internal@types:effect_term())
) -> knowledge_base().
with_inferred(Knowledge_base, Inferred) ->
    Merged = maps:merge(Inferred, erlang:element(2, Knowledge_base)),
    {knowledge_base,
        Merged,
        erlang:element(3, Knowledge_base),
        erlang:element(4, Knowledge_base),
        erlang:element(5, Knowledge_base),
        erlang:element(6, Knowledge_base),
        erlang:element(7, Knowledge_base)}.

-file("src/graded/internal/effects.gleam", 395).
?DOC(false).
-spec with_inferred_params(
    knowledge_base(),
    gleam@dict:dict(graded@internal@types:qualified_name(), list(graded@internal@types:param_bound()))
) -> knowledge_base().
with_inferred_params(Knowledge_base, Inferred) ->
    Merged = maps:merge(Inferred, erlang:element(3, Knowledge_base)),
    {knowledge_base,
        erlang:element(2, Knowledge_base),
        Merged,
        erlang:element(4, Knowledge_base),
        erlang:element(5, Knowledge_base),
        erlang:element(6, Knowledge_base),
        erlang:element(7, Knowledge_base)}.

-file("src/graded/internal/effects.gleam", 406).
?DOC(false).
-spec with_inferred_returned_operators(
    knowledge_base(),
    gleam@dict:dict(graded@internal@types:qualified_name(), graded@internal@types:effect_term())
) -> knowledge_base().
with_inferred_returned_operators(Knowledge_base, Inferred) ->
    Merged = maps:merge(Inferred, erlang:element(5, Knowledge_base)),
    {knowledge_base,
        erlang:element(2, Knowledge_base),
        erlang:element(3, Knowledge_base),
        erlang:element(4, Knowledge_base),
        Merged,
        erlang:element(6, Knowledge_base),
        erlang:element(7, Knowledge_base)}.

-file("src/graded/internal/effects.gleam", 417).
?DOC(false).
-spec with_factories(
    knowledge_base(),
    gleam@dict:dict({binary(), binary()}, gleam@dict:dict(binary(), integer()))
) -> knowledge_base().
with_factories(Knowledge_base, Factories) ->
    {knowledge_base,
        erlang:element(2, Knowledge_base),
        erlang:element(3, Knowledge_base),
        erlang:element(4, Knowledge_base),
        erlang:element(5, Knowledge_base),
        Factories,
        erlang:element(7, Knowledge_base)}.

-file("src/graded/internal/effects.gleam", 426).
?DOC(false).
-spec factories(knowledge_base()) -> gleam@dict:dict({binary(), binary()}, gleam@dict:dict(binary(), integer())).
factories(Knowledge_base) ->
    erlang:element(6, Knowledge_base).

-file("src/graded/internal/effects.gleam", 434).
?DOC(false).
-spec lookup_returned_operator(
    knowledge_base(),
    graded@internal@types:qualified_name()
) -> {ok, graded@internal@types:effect_term()} | {error, nil}.
lookup_returned_operator(Knowledge_base, Name) ->
    gleam_stdlib:map_get(erlang:element(5, Knowledge_base), Name).