search_algorithms_gleam

-module(internal@generalized_search).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/internal/generalized_search.gleam").
-export([search_until_found/3, generalized_search/6]).
-export_type([search_state/2]).

-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 search_state(GEW, GEX) :: {search_state,
        {integer(), GEX},
        internal@search_container:search_container(GEX),
        gleam@set:set(GEW),
        gleam@dict:dict(GEW, list({integer(), GEX}))}.

-file("src/internal/generalized_search.gleam", 33).
?DOC(false).
-spec search_until_found(
    fun((GEY) -> {ok, GEY} | {error, nil}),
    fun((GEY) -> boolean()),
    GEY
) -> {ok, GEY} | {error, nil}.
search_until_found(Get_next_states, Is_found, State) ->
    case Is_found(State) of
        true ->
            {ok, State};

        false ->
            _pipe = Get_next_states(State),
            gleam@result:'try'(
                _pipe,
                fun(_capture) ->
                    search_until_found(Get_next_states, Is_found, _capture)
                end
            )
    end.

-file("src/internal/generalized_search.gleam", 46).
?DOC(false).
-spec get_next_search_state(
    fun(({integer(), GFD}, {integer(), GFD}) -> boolean()),
    fun(({integer(), GFD}) -> GFH),
    fun(({integer(), GFD}) -> list({integer(), GFD})),
    search_state(GFH, GFD)
) -> {ok, search_state(GFH, GFD)} | {error, nil}.
get_next_search_state(Is_better, Make_key, Get_next_states, Search_state) ->
    Update_queue_paths = fun(Search_container_and_paths, Estimate_state_pair) ->
        {Search_container, Paths} = Search_container_and_paths,
        Key = Make_key(Estimate_state_pair),
        case gleam@set:contains(erlang:element(4, Search_state), Key) of
            true ->
                {Search_container, Paths};

            false ->
                Steps_so_far@1 = case gleam_stdlib:map_get(
                    erlang:element(5, Search_state),
                    Make_key(erlang:element(2, Search_state))
                ) of
                    {ok, Steps_so_far} -> Steps_so_far;
                    _assert_fail ->
                        erlang:error(#{gleam_error => let_assert,
                                    message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                    file => <<?FILEPATH/utf8>>,
                                    module => <<"internal/generalized_search"/utf8>>,
                                    function => <<"get_next_search_state"/utf8>>,
                                    line => 66,
                                    value => _assert_fail,
                                    start => 2462,
                                    'end' => 2562,
                                    pattern_start => 2473,
                                    pattern_end => 2489})
                end,
                Updated_queue = internal@search_container:push(
                    Search_container,
                    Estimate_state_pair
                ),
                Updated_paths = gleam@dict:insert(
                    Paths,
                    Key,
                    [Estimate_state_pair | Steps_so_far@1]
                ),
                case gleam_stdlib:map_get(Paths, Key) of
                    {error, nil} ->
                        {Updated_queue, Updated_paths};

                    {ok, Path} ->
                        Previous_estimate_state_pair@1 = case Path of
                            [Previous_estimate_state_pair | _] -> Previous_estimate_state_pair;
                            _assert_fail@1 ->
                                erlang:error(#{gleam_error => let_assert,
                                            message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                            file => <<?FILEPATH/utf8>>,
                                            module => <<"internal/generalized_search"/utf8>>,
                                            function => <<"get_next_search_state"/utf8>>,
                                            line => 77,
                                            value => _assert_fail@1,
                                            start => 2979,
                                            'end' => 3031,
                                            pattern_start => 2990,
                                            pattern_end => 3024})
                        end,
                        case Is_better(
                            Previous_estimate_state_pair@1,
                            Estimate_state_pair
                        ) of
                            true ->
                                {Updated_queue, Updated_paths};

                            false ->
                                {Search_container, Paths}
                        end
                end
        end
    end,
    {New_search_container, New_paths} = begin
        Next_states = Get_next_states(erlang:element(2, Search_state)),
        gleam@list:fold(
            Next_states,
            {erlang:element(3, Search_state), erlang:element(5, Search_state)},
            Update_queue_paths
        )
    end,
    _pipe = New_search_container,
    _pipe@1 = internal@search_container:pop(_pipe),
    _pipe@2 = gleam@result:map(
        _pipe@1,
        fun(Tuple) ->
            {Estimate_state_pair@1, Search_container@1} = Tuple,
            {search_state,
                Estimate_state_pair@1,
                Search_container@1,
                gleam@set:insert(
                    erlang:element(4, Search_state),
                    Make_key(Estimate_state_pair@1)
                ),
                New_paths}
        end
    ),
    gleam@result:'try'(
        _pipe@2,
        fun(Search_state@1) ->
            case gleam@set:contains(
                erlang:element(4, Search_state@1),
                Make_key(erlang:element(2, Search_state@1))
            ) of
                true ->
                    get_next_search_state(
                        Is_better,
                        Make_key,
                        Get_next_states,
                        Search_state@1
                    );

                false ->
                    {ok, Search_state@1}
            end
        end
    ).

-file("src/internal/generalized_search.gleam", 124).
?DOC(false).
-spec generalized_search(
    internal@search_container:search_container(GFR),
    fun(({integer(), GFR}) -> any()),
    fun(({integer(), GFR}, {integer(), GFR}) -> boolean()),
    fun(({integer(), GFR}) -> list({integer(), GFR})),
    fun(({integer(), GFR}) -> boolean()),
    {integer(), GFR}
) -> {ok, list({integer(), GFR})} | {error, nil}.
generalized_search(
    Search_container,
    Make_key,
    Is_better,
    Get_next_states,
    Is_found,
    Initial_estimate_state_pair
) ->
    Initial_key = Make_key(Initial_estimate_state_pair),
    Search_state = {search_state,
        Initial_estimate_state_pair,
        Search_container,
        gleam@set:from_list([Initial_key]),
        maps:from_list([{Initial_key, []}])},
    End_result = search_until_found(
        fun(_capture) ->
            get_next_search_state(
                Is_better,
                Make_key,
                Get_next_states,
                _capture
            )
        end,
        fun(Search_state@1) -> Is_found(erlang:element(2, Search_state@1)) end,
        Search_state
    ),
    Get_steps = fun(Search_state@2) ->
        Steps@1 = case gleam_stdlib:map_get(
            erlang:element(5, Search_state@2),
            Make_key(erlang:element(2, Search_state@2))
        ) of
            {ok, Steps} -> Steps;
            _assert_fail ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                            file => <<?FILEPATH/utf8>>,
                            module => <<"internal/generalized_search"/utf8>>,
                            function => <<"generalized_search"/utf8>>,
                            line => 155,
                            value => _assert_fail,
                            start => 5354,
                            'end' => 5443,
                            pattern_start => 5365,
                            pattern_end => 5374})
        end,
        Steps@1
    end,
    gleam@result:map(End_result, fun(St) -> _pipe = St,
            _pipe@1 = Get_steps(_pipe),
            lists:reverse(_pipe@1) end).