slabs

-module(slabs).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/slabs.gleam").
-export([new/0, insert/2, insert_many/2, remove/2, get/2]).
-export_type([entry/1, slab/1, slab_error/0]).

-type entry(DTX) :: {vacant, gleam@option:option(integer())} | {occupied, DTX}.

-opaque slab(DTY) :: {slab,
        list(entry(DTY)),
        gleam@option:option(integer()),
        integer()}.

-type slab_error() :: {bad_index, integer()}.

-file("src/slabs.gleam", 17).
-spec new() -> slab(any()).
new() ->
    {slab, [], none, 0}.

-file("src/slabs.gleam", 21).
-spec insert(slab(DUB), DUB) -> {slab(DUB), integer()}.
insert(Slab, Value) ->
    case erlang:element(3, Slab) of
        {some, Slot_index} ->
            Index = (erlang:element(4, Slab) - 1) - Slot_index,
            {Left, Right} = begin
                _pipe = erlang:element(2, Slab),
                gleam@list:split(_pipe, Index)
            end,
            Next_id@1 = case begin
                _pipe@1 = Right,
                gleam@list:first(_pipe@1)
            end of
                {ok, {vacant, Next_id}} -> Next_id;
                _assert_fail ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"slabs"/utf8>>,
                                function => <<"insert"/utf8>>,
                                line => 30,
                                value => _assert_fail,
                                start => 574,
                                'end' => 642,
                                pattern_start => 585,
                                pattern_end => 604})
            end,
            Right@1 = case Right of
                [_ | Rest] ->
                    Rest;

                [] ->
                    []
            end,
            Inner = lists:append(Left, [{occupied, Value} | Right@1]),
            {{slab, Inner, Next_id@1, erlang:element(4, Slab)}, Slot_index};

        none ->
            Index@1 = erlang:length(erlang:element(2, Slab)),
            {{slab,
                    [{occupied, Value} | erlang:element(2, Slab)],
                    erlang:element(3, Slab),
                    erlang:element(4, Slab) + 1},
                Index@1}
    end.

-file("src/slabs.gleam", 58).
-spec insert_accum(slab(DUE), list(DUE), list(integer())) -> {slab(DUE),
    list(integer())}.
insert_accum(Slab, Values, Acc) ->
    case Values of
        [V | Rest] ->
            {Slab@1, Index} = insert(Slab, V),
            insert_accum(Slab@1, Rest, [Index | Acc]);

        [] ->
            {Slab, Acc}
    end.

-file("src/slabs.gleam", 72).
-spec insert_many(slab(DUK), list(DUK)) -> {slab(DUK), list(integer())}.
insert_many(Slab, Values) ->
    insert_accum(Slab, Values, []).

-file("src/slabs.gleam", 76).
-spec remove(slab(DUP), integer()) -> {ok, {slab(DUP), DUP}} |
    {error, slab_error()}.
remove(Slab, Index) ->
    case (Index >= 0) andalso (Index < erlang:element(4, Slab)) of
        true ->
            {Left, Right} = begin
                _pipe = erlang:element(2, Slab),
                gleam@list:split(_pipe, (erlang:element(4, Slab) - 1) - Index)
            end,
            Entry@1 = case begin
                _pipe@1 = Right,
                gleam@list:first(_pipe@1)
            end of
                {ok, Entry} -> Entry;
                _assert_fail ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"slabs"/utf8>>,
                                function => <<"remove"/utf8>>,
                                line => 83,
                                value => _assert_fail,
                                start => 1702,
                                'end' => 1760,
                                pattern_start => 1713,
                                pattern_end => 1722})
            end,
            Right@1 = case Right of
                [_ | Rest] ->
                    Rest;

                [] ->
                    []
            end,
            Inner = lists:append(
                Left,
                [{vacant, erlang:element(3, Slab)} | Right@1]
            ),
            Value@1 = case Entry@1 of
                {occupied, Value} -> Value;
                _assert_fail@1 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"slabs"/utf8>>,
                                function => <<"remove"/utf8>>,
                                line => 94,
                                value => _assert_fail@1,
                                start => 1923,
                                'end' => 1957,
                                pattern_start => 1934,
                                pattern_end => 1949})
            end,
            {ok,
                {{slab, Inner, {some, Index}, erlang:element(4, Slab)}, Value@1}};

        false ->
            {error, {bad_index, Index}}
    end.

-file("src/slabs.gleam", 102).
-spec get_items(list(entry(DUU)), integer(), integer()) -> gleam@option:option(DUU).
get_items(Items, Acc, Index) ->
    case Items of
        [V, _] when Acc =:= Index ->
            case V of
                {vacant, _} ->
                    none;

                {occupied, V@1} ->
                    {some, V@1}
            end;

        [V] when Acc =:= Index ->
            case V of
                {vacant, _} ->
                    none;

                {occupied, V@1} ->
                    {some, V@1}
            end;

        [_ | Rest] ->
            get_items(Rest, Acc - 1, Index);

        [] ->
            none
    end.

-file("src/slabs.gleam", 117).
-spec get(slab(DUY), integer()) -> gleam@option:option(DUY).
get(Slab, Index) ->
    get_items(erlang:element(2, Slab), erlang:element(4, Slab) - 1, Index).