search_algorithms_gleam

-module(internal@search_container).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/internal/search_container.gleam").
-export([new_stack/0, new_queue/0, new_lifo_heap/0, pop/1, push/2]).
-export_type([search_container/1]).

-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).

-opaque search_container(GBS) :: {stack, list(GBS)} |
    {queue, gleam@deque:deque(GBS)} |
    {l_i_f_o_heap, balanced_tree:balanced_tree(integer(), list(GBS))}.

-file("src/internal/search_container.gleam", 24).
?DOC(false).
-spec new_stack() -> search_container(any()).
new_stack() ->
    {stack, []}.

-file("src/internal/search_container.gleam", 28).
?DOC(false).
-spec new_queue() -> search_container(any()).
new_queue() ->
    {queue, gleam@deque:new()}.

-file("src/internal/search_container.gleam", 32).
?DOC(false).
-spec new_lifo_heap() -> search_container(any()).
new_lifo_heap() ->
    {l_i_f_o_heap, gb_trees:empty()}.

-file("src/internal/search_container.gleam", 38).
?DOC(false).
-spec pop(search_container(GBX)) -> {ok,
        {{integer(), GBX}, search_container(GBX)}} |
    {error, nil}.
pop(Search_container) ->
    case Search_container of
        {stack, List} ->
            case List of
                [Head | Tail] ->
                    {ok, {{0, Head}, {stack, Tail}}};

                [] ->
                    {error, nil}
            end;

        {queue, Deque} ->
            _pipe = Deque,
            _pipe@1 = gleam@deque:pop_front(_pipe),
            gleam@result:map(
                _pipe@1,
                fun(Tuple) ->
                    {{0, erlang:element(1, Tuple)},
                        {queue, erlang:element(2, Tuple)}}
                end
            );

        {l_i_f_o_heap, Tree} ->
            _pipe@2 = Tree,
            _pipe@3 = balanced_tree:get_min(_pipe@2),
            gleam@result:'try'(_pipe@3, fun(State) -> case State of
                        {Cost, [Head@1]} ->
                            Next_heap = begin
                                _pipe@4 = Tree,
                                _pipe@5 = balanced_tree:delete(_pipe@4, Cost),
                                {l_i_f_o_heap, _pipe@5}
                            end,
                            {ok, {{Cost, Head@1}, Next_heap}};

                        {Cost@1, [Head@2 | Tail@1]} ->
                            Next_heap@1 = begin
                                _pipe@6 = Tree,
                                _pipe@7 = balanced_tree:insert(
                                    _pipe@6,
                                    Cost@1,
                                    Tail@1
                                ),
                                {l_i_f_o_heap, _pipe@7}
                            end,
                            {ok, {{Cost@1, Head@2}, Next_heap@1}};

                        {Cost@2, []} ->
                            Next_heap@2 = begin
                                _pipe@8 = Tree,
                                _pipe@9 = balanced_tree:delete(_pipe@8, Cost@2),
                                {l_i_f_o_heap, _pipe@9}
                            end,
                            pop(Next_heap@2)
                    end end)
    end.

-file("src/internal/search_container.gleam", 82).
?DOC(false).
-spec push(search_container(GCD), {integer(), GCD}) -> search_container(GCD).
push(Search_container, Estimate_state_pair) ->
    case Search_container of
        {stack, List} ->
            _pipe = gleam@list:prepend(
                List,
                erlang:element(2, Estimate_state_pair)
            ),
            {stack, _pipe};

        {queue, Queue} ->
            _pipe@1 = gleam@deque:push_back(
                Queue,
                erlang:element(2, Estimate_state_pair)
            ),
            {queue, _pipe@1};

        {l_i_f_o_heap, Tree} ->
            {Cost, State} = Estimate_state_pair,
            Handler = fun(Opt) -> case Opt of
                    {some, List@1} ->
                        [State | List@1];

                    none ->
                        [State]
                end end,
            _pipe@2 = balanced_tree:upsert(Tree, Cost, Handler),
            {l_i_f_o_heap, _pipe@2}
    end.