glib

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

-export([main/0]).

-spec do_repeat(GPR, integer(), list(GPR)) -> list(GPR).
do_repeat(A, Times, Acc) ->
    case Times =< 0 of
        true ->
            Acc;

        false ->
            do_repeat(A, Times - 1, [A | Acc])
    end.

-spec prepend(list(integer()), integer(), integer(), integer()) -> list(integer()).
prepend(L, Head, Entries, Times) ->
    [Head | do_repeat(Entries, Times, L)].

-spec bench_list_append() -> nil.
bench_list_append() ->
    Inputs = begin
        _pipe = gleam@iterator:iterate(11, fun(N) -> (N * 2) + 1 end),
        _pipe@1 = gleam@iterator:take(_pipe, 8),
        _pipe@2 = gleam@iterator:to_list(_pipe@1),
        gleam@list:map(
            _pipe@2,
            fun(Size) ->
                {input,
                    <<"Map size "/utf8, (gleam@int:to_string(Size))/binary>>,
                    {Size div 2, gleam@list:repeat(1, Size div 2)}}
            end
        )
    end,
    Tests = [{function,
            <<"append"/utf8>>,
            fun(Test_data) ->
                _ = lists:append(
                    [999 |
                        gleam@list:repeat(2, erlang:element(1, Test_data) - 1)],
                    erlang:element(2, Test_data)
                ),
                nil
            end},
        {function,
            <<"prepend"/utf8>>,
            fun(Test_data@1) ->
                _ = prepend(
                    erlang:element(2, Test_data@1),
                    999,
                    2,
                    erlang:element(1, Test_data@1) - 1
                ),
                nil
            end}],
    _pipe@3 = gleamy@bench:run(Inputs, Tests, [{warmup, 100}, {duration, 2000}]),
    _pipe@4 = gleamy@bench:table(_pipe@3, [ips, min, max, {p, 99}]),
    gleam@io:println(_pipe@4).

-spec map_bench(list(integer())) -> nil.
map_bench(Init_sizes) ->
    Inputs = gleam@list:map(
        Init_sizes,
        fun(Size) ->
            {input,
                <<"Map size "/utf8, (gleam@int:to_string(Size))/binary>>,
                (case Size of
                    0 ->
                        glib@map:new();

                    _ ->
                        _pipe = gleam@iterator:range(1, Size),
                        gleam@iterator:fold(
                            _pipe,
                            glib@map:new(),
                            fun(New_map, I) ->
                                glib@map:put(
                                    New_map,
                                    <<<<<<"key"/utf8,
                                                (gleam@int:to_string(I))/binary>>/binary,
                                            "_"/utf8>>/binary,
                                        (gleam@int:to_string(
                                            gleam@int:random(1000000)
                                        ))/binary>>,
                                    <<"value"/utf8,
                                        (gleam@int:to_string(I))/binary>>
                                )
                            end
                        )
                end)}
        end
    ),
    Tests = [{function,
            <<"Add Entry"/utf8>>,
            fun(Test_map) ->
                glib@map:put(Test_map, <<"First"/utf8>>, <<"Entry"/utf8>>)
            end}],
    _pipe@1 = gleamy@bench:run(Inputs, Tests, [{warmup, 100}, {duration, 5000}]),
    _pipe@2 = gleamy@bench:table(_pipe@1, [ips, min, max, {p, 99}]),
    gleam@io:println(_pipe@2).

-spec main() -> nil.
main() ->
    map_bench([8, 17, 35, 71, 143, 287, 1151]).

-spec dict_bench(list(integer())) -> nil.
dict_bench(Init_sizes) ->
    Inputs = gleam@list:map(
        Init_sizes,
        fun(Size) ->
            {input,
                <<"Map size "/utf8, (gleam@int:to_string(Size))/binary>>,
                (case Size of
                    0 ->
                        gleam@dict:new();

                    _ ->
                        _pipe = gleam@iterator:range(1, Size),
                        gleam@iterator:fold(
                            _pipe,
                            gleam@dict:new(),
                            fun(New_map, I) ->
                                gleam@dict:insert(
                                    New_map,
                                    <<<<<<"key"/utf8,
                                                (gleam@int:to_string(I))/binary>>/binary,
                                            "_"/utf8>>/binary,
                                        (gleam@int:to_string(
                                            gleam@int:random(1000000)
                                        ))/binary>>,
                                    <<"value"/utf8,
                                        (gleam@int:to_string(I))/binary>>
                                )
                            end
                        )
                end)}
        end
    ),
    Tests = [{function,
            <<"Add Entry"/utf8>>,
            fun(Test_map) ->
                gleam@dict:insert(Test_map, <<"First"/utf8>>, <<"Entry"/utf8>>)
            end}],
    _pipe@1 = gleamy@bench:run(Inputs, Tests, [{warmup, 100}, {duration, 2000}]),
    _pipe@2 = gleamy@bench:table(_pipe@1, [ips, min, max, {p, 99}]),
    gleam@io:println(_pipe@2).