radish

-module(radish@sorted_set).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([card/3, score/4, 'rem'/4, count/5, add_new/4, upsert/4, upsert_only_lower_scores/4, upsert_only_higher_scores/4, update/4, update_only_lower_scores/4, update_only_higher_scores/4, incr_by/5, rank/4, reverse_rank/4, head/3, random_members/4, pop_min/4, pop_max/4, range/5, reverse_range/5, range_by_score/5, scan/5, scan_pattern/6]).
-export_type([score/0]).

-type score() :: infinity | {double, float()} | negative_infinity.

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 158).
-spec card(lifeguard:pool(radish@client:message()), binary(), integer()) -> {ok,
        integer()} |
    {error, radish@error:error()}.
card(Client, Key, Timeout) ->
    _pipe = radish@command@sorted_set:card(Key),
    _pipe@1 = radish@utils:execute(Client, _pipe, Timeout),
    _pipe@2 = gleam@result:map(_pipe@1, fun(Value) -> case Value of
                [{integer, N}] ->
                    {ok, N};

                _ ->
                    {error, resp_error}
            end end),
    gleam@result:flatten(_pipe@2).

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 184).
-spec score(
    lifeguard:pool(radish@client:message()),
    binary(),
    binary(),
    integer()
) -> {ok, score()} | {error, radish@error:error()}.
score(Client, Key, Member, Timeout) ->
    _pipe = radish@command@sorted_set:score(Key, Member),
    _pipe@1 = radish@utils:execute(Client, _pipe, Timeout),
    _pipe@2 = gleam@result:map(_pipe@1, fun(Value) -> case Value of
                [infinity] ->
                    {ok, infinity};

                [{double, Score}] ->
                    {ok, {double, Score}};

                [negative_infinity] ->
                    {ok, negative_infinity};

                [null] ->
                    {error, not_found};

                _ ->
                    {error, resp_error}
            end end),
    gleam@result:flatten(_pipe@2).

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 273).
-spec 'rem'(
    lifeguard:pool(radish@client:message()),
    binary(),
    list(binary()),
    integer()
) -> {ok, integer()} | {error, radish@error:error()}.
'rem'(Client, Key, Members, Timeout) ->
    _pipe = radish@command@sorted_set:'rem'(Key, Members),
    _pipe@1 = radish@utils:execute(Client, _pipe, Timeout),
    _pipe@2 = gleam@result:map(_pipe@1, fun(Value) -> case Value of
                [{integer, N}] ->
                    {ok, N};

                _ ->
                    {error, resp_error}
            end end),
    gleam@result:flatten(_pipe@2).

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 421).
-spec encode_score(score()) -> binary().
encode_score(Score) ->
    case Score of
        infinity ->
            <<"+inf"/utf8>>;

        negative_infinity ->
            <<"-inf"/utf8>>;

        {double, Score@1} ->
            gleam_stdlib:float_to_string(Score@1)
    end.

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 171).
-spec count(
    lifeguard:pool(radish@client:message()),
    binary(),
    score(),
    score(),
    integer()
) -> {ok, integer()} | {error, radish@error:error()}.
count(Client, Key, Min, Max, Timeout) ->
    _pipe = radish@command@sorted_set:count(
        Key,
        encode_score(Min),
        encode_score(Max)
    ),
    _pipe@1 = radish@utils:execute(Client, _pipe, Timeout),
    _pipe@2 = gleam@result:map(_pipe@1, fun(Value) -> case Value of
                [{integer, N}] ->
                    {ok, N};

                _ ->
                    {error, resp_error}
            end end),
    gleam@result:flatten(_pipe@2).

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 417).
-spec encode_member({binary(), score()}) -> {binary(), binary()}.
encode_member(Member) ->
    {erlang:element(1, Member), encode_score(erlang:element(2, Member))}.

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 18).
-spec add_new(
    lifeguard:pool(radish@client:message()),
    binary(),
    list({binary(), score()}),
    integer()
) -> {ok, integer()} | {error, radish@error:error()}.
add_new(Client, Key, Members, Timeout) ->
    _pipe = radish@command@sorted_set:add_new(
        Key,
        gleam@list:map(Members, fun encode_member/1)
    ),
    _pipe@1 = radish@utils:execute(Client, _pipe, Timeout),
    _pipe@2 = gleam@result:map(_pipe@1, fun(Value) -> case Value of
                [{integer, N}] ->
                    {ok, N};

                _ ->
                    {error, resp_error}
            end end),
    gleam@result:flatten(_pipe@2).

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 36).
-spec upsert(
    lifeguard:pool(radish@client:message()),
    binary(),
    list({binary(), score()}),
    integer()
) -> {ok, integer()} | {error, radish@error:error()}.
upsert(Client, Key, Members, Timeout) ->
    _pipe = radish@command@sorted_set:upsert(
        Key,
        gleam@list:map(Members, fun encode_member/1)
    ),
    _pipe@1 = radish@utils:execute(Client, _pipe, Timeout),
    _pipe@2 = gleam@result:map(_pipe@1, fun(Value) -> case Value of
                [{integer, N}] ->
                    {ok, N};

                _ ->
                    {error, resp_error}
            end end),
    gleam@result:flatten(_pipe@2).

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 54).
-spec upsert_only_lower_scores(
    lifeguard:pool(radish@client:message()),
    binary(),
    list({binary(), score()}),
    integer()
) -> {ok, integer()} | {error, radish@error:error()}.
upsert_only_lower_scores(Client, Key, Members, Timeout) ->
    _pipe = radish@command@sorted_set:upsert_only_lower_scores(
        Key,
        gleam@list:map(Members, fun encode_member/1)
    ),
    _pipe@1 = radish@utils:execute(Client, _pipe, Timeout),
    _pipe@2 = gleam@result:map(_pipe@1, fun(Value) -> case Value of
                [{integer, N}] ->
                    {ok, N};

                _ ->
                    {error, resp_error}
            end end),
    gleam@result:flatten(_pipe@2).

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 72).
-spec upsert_only_higher_scores(
    lifeguard:pool(radish@client:message()),
    binary(),
    list({binary(), score()}),
    integer()
) -> {ok, integer()} | {error, radish@error:error()}.
upsert_only_higher_scores(Client, Key, Members, Timeout) ->
    _pipe = radish@command@sorted_set:upsert_only_higher_scores(
        Key,
        gleam@list:map(Members, fun encode_member/1)
    ),
    _pipe@1 = radish@utils:execute(Client, _pipe, Timeout),
    _pipe@2 = gleam@result:map(_pipe@1, fun(Value) -> case Value of
                [{integer, N}] ->
                    {ok, N};

                _ ->
                    {error, resp_error}
            end end),
    gleam@result:flatten(_pipe@2).

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 90).
-spec update(
    lifeguard:pool(radish@client:message()),
    binary(),
    list({binary(), score()}),
    integer()
) -> {ok, integer()} | {error, radish@error:error()}.
update(Client, Key, Members, Timeout) ->
    _pipe = radish@command@sorted_set:update(
        Key,
        gleam@list:map(Members, fun encode_member/1)
    ),
    _pipe@1 = radish@utils:execute(Client, _pipe, Timeout),
    _pipe@2 = gleam@result:map(_pipe@1, fun(Value) -> case Value of
                [{integer, N}] ->
                    {ok, N};

                _ ->
                    {error, resp_error}
            end end),
    gleam@result:flatten(_pipe@2).

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 108).
-spec update_only_lower_scores(
    lifeguard:pool(radish@client:message()),
    binary(),
    list({binary(), score()}),
    integer()
) -> {ok, integer()} | {error, radish@error:error()}.
update_only_lower_scores(Client, Key, Members, Timeout) ->
    _pipe = radish@command@sorted_set:update_only_lower_scores(
        Key,
        gleam@list:map(Members, fun encode_member/1)
    ),
    _pipe@1 = radish@utils:execute(Client, _pipe, Timeout),
    _pipe@2 = gleam@result:map(_pipe@1, fun(Value) -> case Value of
                [{integer, N}] ->
                    {ok, N};

                _ ->
                    {error, resp_error}
            end end),
    gleam@result:flatten(_pipe@2).

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 126).
-spec update_only_higher_scores(
    lifeguard:pool(radish@client:message()),
    binary(),
    list({binary(), score()}),
    integer()
) -> {ok, integer()} | {error, radish@error:error()}.
update_only_higher_scores(Client, Key, Members, Timeout) ->
    _pipe = radish@command@sorted_set:update_only_higher_scores(
        Key,
        gleam@list:map(Members, fun encode_member/1)
    ),
    _pipe@1 = radish@utils:execute(Client, _pipe, Timeout),
    _pipe@2 = gleam@result:map(_pipe@1, fun(Value) -> case Value of
                [{integer, N}] ->
                    {ok, N};

                _ ->
                    {error, resp_error}
            end end),
    gleam@result:flatten(_pipe@2).

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 429).
-spec map_score(list(radish@resp:value())) -> {ok, score()} |
    {error, radish@error:error()}.
map_score(Score) ->
    case Score of
        [infinity] ->
            {ok, infinity};

        [{double, Score@1}] ->
            {ok, {double, Score@1}};

        [negative_infinity] ->
            {ok, negative_infinity};

        _ ->
            {error, resp_error}
    end.

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 144).
-spec incr_by(
    lifeguard:pool(radish@client:message()),
    binary(),
    binary(),
    score(),
    integer()
) -> {ok, score()} | {error, radish@error:error()}.
incr_by(Client, Key, Member, Change_in_score, Timeout) ->
    _pipe = radish@command@sorted_set:incr_by(
        Key,
        Member,
        encode_score(Change_in_score)
    ),
    _pipe@1 = radish@utils:execute(Client, _pipe, Timeout),
    _pipe@2 = gleam@result:map(_pipe@1, fun map_score/1),
    gleam@result:flatten(_pipe@2).

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 294).
-spec rank(
    lifeguard:pool(radish@client:message()),
    binary(),
    binary(),
    integer()
) -> {ok, {integer(), score()}} | {error, radish@error:error()}.
rank(Client, Key, Member, Timeout) ->
    _pipe = radish@command@sorted_set:rank(Key, Member),
    _pipe@1 = radish@utils:execute(Client, _pipe, Timeout),
    _pipe@4 = gleam@result:map(_pipe@1, fun(Value) -> case Value of
                [{array, [{integer, Rank}, Score]}] ->
                    _pipe@2 = [Score],
                    _pipe@3 = map_score(_pipe@2),
                    gleam@result:map(
                        _pipe@3,
                        fun(Score@1) -> {Rank, Score@1} end
                    );

                [null] ->
                    {error, not_found};

                _ ->
                    {error, resp_error}
            end end),
    gleam@result:flatten(_pipe@4).

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 311).
-spec reverse_rank(
    lifeguard:pool(radish@client:message()),
    binary(),
    binary(),
    integer()
) -> {ok, {integer(), score()}} | {error, radish@error:error()}.
reverse_rank(Client, Key, Member, Timeout) ->
    _pipe = radish@command@sorted_set:reverse_rank(Key, Member),
    _pipe@1 = radish@utils:execute(Client, _pipe, Timeout),
    _pipe@4 = gleam@result:map(_pipe@1, fun(Value) -> case Value of
                [{array, [{integer, Rank}, Score]}] ->
                    _pipe@2 = [Score],
                    _pipe@3 = map_score(_pipe@2),
                    gleam@result:map(
                        _pipe@3,
                        fun(Score@1) -> {Rank, Score@1} end
                    );

                [null] ->
                    {error, not_found};

                _ ->
                    {error, resp_error}
            end end),
    gleam@result:flatten(_pipe@4).

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 352).
-spec head(lifeguard:pool(radish@client:message()), binary(), integer()) -> {ok,
        {binary(), score()}} |
    {error, radish@error:error()}.
head(Client, Key, Timeout) ->
    _pipe = radish@command@sorted_set:range(Key, 0, 0),
    _pipe@1 = radish@utils:execute(Client, _pipe, Timeout),
    _pipe@3 = gleam@result:map(_pipe@1, fun(Value) -> case Value of
                [{array, [Member | _]}] ->
                    gleam@result:then(
                        begin
                            _pipe@2 = Member,
                            (fun(Item) -> case Item of
                                    {array, [{bulk_string, Member@1}, Score]} ->
                                        case map_score([Score]) of
                                            {ok, Score@1} ->
                                                {ok, {Member@1, Score@1}};

                                            _ ->
                                                {error, resp_error}
                                        end;

                                    _ ->
                                        {error, resp_error}
                                end end)(_pipe@2)
                        end,
                        fun(Array) -> {ok, Array} end
                    );

                _ ->
                    {error, resp_error}
            end end),
    gleam@result:flatten(_pipe@3).

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 395).
-spec extract_member_score_pairs(list(radish@resp:value())) -> {ok,
        list({binary(), score()})} |
    {error, radish@error:error()}.
extract_member_score_pairs(Value) ->
    case Value of
        [{array, Members}] ->
            gleam@result:then(
                begin
                    _pipe = Members,
                    gleam@list:try_map(_pipe, fun(Item) -> case Item of
                                {array, [{bulk_string, Member}, Score]} ->
                                    case map_score([Score]) of
                                        {ok, Score@1} ->
                                            {ok, {Member, Score@1}};

                                        _ ->
                                            {error, resp_error}
                                    end;

                                _ ->
                                    {error, resp_error}
                            end end)
                end,
                fun(Array) -> {ok, Array} end
            );

        _ ->
            {error, resp_error}
    end.

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 286).
-spec random_members(
    lifeguard:pool(radish@client:message()),
    binary(),
    integer(),
    integer()
) -> {ok, list({binary(), score()})} | {error, radish@error:error()}.
random_members(Client, Key, Count, Timeout) ->
    _pipe = radish@command@sorted_set:random_members(Key, Count),
    _pipe@1 = radish@utils:execute(Client, _pipe, Timeout),
    _pipe@2 = gleam@result:map(_pipe@1, fun extract_member_score_pairs/1),
    gleam@result:flatten(_pipe@2).

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 328).
-spec pop_min(
    lifeguard:pool(radish@client:message()),
    binary(),
    integer(),
    integer()
) -> {ok, list({binary(), score()})} | {error, radish@error:error()}.
pop_min(Client, Key, Count, Timeout) ->
    _pipe = radish@command@sorted_set:pop_min(Key, Count),
    _pipe@1 = radish@utils:execute(Client, _pipe, Timeout),
    _pipe@2 = gleam@result:map(_pipe@1, fun extract_member_score_pairs/1),
    gleam@result:flatten(_pipe@2).

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 336).
-spec pop_max(
    lifeguard:pool(radish@client:message()),
    binary(),
    integer(),
    integer()
) -> {ok, list({binary(), score()})} | {error, radish@error:error()}.
pop_max(Client, Key, Count, Timeout) ->
    _pipe = radish@command@sorted_set:pop_max(Key, Count),
    _pipe@1 = radish@utils:execute(Client, _pipe, Timeout),
    _pipe@2 = gleam@result:map(_pipe@1, fun extract_member_score_pairs/1),
    gleam@result:flatten(_pipe@2).

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 344).
-spec range(
    lifeguard:pool(radish@client:message()),
    binary(),
    integer(),
    integer(),
    integer()
) -> {ok, list({binary(), score()})} | {error, radish@error:error()}.
range(Client, Key, Start, Stop, Timeout) ->
    _pipe = radish@command@sorted_set:range(Key, Start, Stop),
    _pipe@1 = radish@utils:execute(Client, _pipe, Timeout),
    _pipe@2 = gleam@result:map(_pipe@1, fun extract_member_score_pairs/1),
    gleam@result:flatten(_pipe@2).

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 380).
-spec reverse_range(
    lifeguard:pool(radish@client:message()),
    binary(),
    integer(),
    integer(),
    integer()
) -> {ok, list({binary(), score()})} | {error, radish@error:error()}.
reverse_range(Client, Key, Start, Stop, Timeout) ->
    _pipe = radish@command@sorted_set:reverse_range(Key, Start, Stop),
    _pipe@1 = radish@utils:execute(Client, _pipe, Timeout),
    _pipe@2 = gleam@result:map(_pipe@1, fun extract_member_score_pairs/1),
    gleam@result:flatten(_pipe@2).

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 388).
-spec range_by_score(
    lifeguard:pool(radish@client:message()),
    binary(),
    score(),
    score(),
    integer()
) -> {ok, list({binary(), score()})} | {error, radish@error:error()}.
range_by_score(Client, Key, Min, Max, Timeout) ->
    _pipe = radish@command@sorted_set:range_by_score(
        Key,
        encode_score(Min),
        encode_score(Max)
    ),
    _pipe@1 = radish@utils:execute(Client, _pipe, Timeout),
    _pipe@2 = gleam@result:map(_pipe@1, fun extract_member_score_pairs/1),
    gleam@result:flatten(_pipe@2).

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 438).
-spec decode_score(binary()) -> {ok, score()} | {error, nil}.
decode_score(Score) ->
    case Score of
        <<"+inf"/utf8>> ->
            {ok, infinity};

        <<"inf"/utf8>> ->
            {ok, infinity};

        <<"-inf"/utf8>> ->
            {ok, negative_infinity};

        _ ->
            case gleam_stdlib:parse_int(Score) of
                {ok, Score@1} ->
                    _pipe = Score@1,
                    _pipe@1 = erlang:float(_pipe),
                    _pipe@2 = {double, _pipe@1},
                    {ok, _pipe@2};

                {error, nil} ->
                    _pipe@3 = Score,
                    _pipe@4 = gleam_stdlib:parse_float(_pipe@3),
                    gleam@result:map(
                        _pipe@4,
                        fun(Field@0) -> {double, Field@0} end
                    )
            end
    end.

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 200).
-spec scan(
    lifeguard:pool(radish@client:message()),
    binary(),
    integer(),
    integer(),
    integer()
) -> {ok, {list({binary(), score()}), integer()}} |
    {error, radish@error:error()}.
scan(Client, Key, Cursor, Count, Timeout) ->
    _pipe = radish@command@sorted_set:scan(Key, Cursor, Count),
    _pipe@1 = radish@utils:execute(Client, _pipe, Timeout),
    _pipe@4 = gleam@result:map(_pipe@1, fun(Value) -> case Value of
                [{array, [{bulk_string, New_cursor_str}, {array, Members}]}] ->
                    case gleam_stdlib:parse_int(New_cursor_str) of
                        {ok, New_cursor} ->
                            gleam@result:then(
                                begin
                                    _pipe@2 = Members,
                                    _pipe@3 = gleam@list:sized_chunk(_pipe@2, 2),
                                    gleam@list:try_map(
                                        _pipe@3,
                                        fun(Item) -> case Item of
                                                [{bulk_string, Member},
                                                    {bulk_string, Score}] ->
                                                    case decode_score(Score) of
                                                        {ok, Score@1} ->
                                                            {ok,
                                                                {Member,
                                                                    Score@1}};

                                                        _ ->
                                                            {error, resp_error}
                                                    end;

                                                _ ->
                                                    {error, resp_error}
                                            end end
                                    )
                                end,
                                fun(Array) -> {ok, {Array, New_cursor}} end
                            );

                        {error, nil} ->
                            {error, resp_error}
                    end;

                _ ->
                    {error, resp_error}
            end end),
    gleam@result:flatten(_pipe@4).

-file("/home/massivefermion/Desktop/radish/src/radish/sorted_set.gleam", 233).
-spec scan_pattern(
    lifeguard:pool(radish@client:message()),
    binary(),
    integer(),
    binary(),
    integer(),
    integer()
) -> {ok, {list({binary(), score()}), integer()}} |
    {error, radish@error:error()}.
scan_pattern(Client, Key, Cursor, Pattern, Count, Timeout) ->
    _pipe = radish@command@sorted_set:scan_pattern(Key, Cursor, Pattern, Count),
    _pipe@1 = radish@utils:execute(Client, _pipe, Timeout),
    _pipe@4 = gleam@result:map(_pipe@1, fun(Value) -> case Value of
                [{array, [{bulk_string, New_cursor_str}, {array, Members}]}] ->
                    case gleam_stdlib:parse_int(New_cursor_str) of
                        {ok, New_cursor} ->
                            gleam@result:then(
                                begin
                                    _pipe@2 = Members,
                                    _pipe@3 = gleam@list:sized_chunk(_pipe@2, 2),
                                    gleam@list:try_map(
                                        _pipe@3,
                                        fun(Item) -> case Item of
                                                [{bulk_string, Member},
                                                    {bulk_string, Score}] ->
                                                    case decode_score(Score) of
                                                        {ok, Score@1} ->
                                                            {ok,
                                                                {Member,
                                                                    Score@1}};

                                                        _ ->
                                                            {error, resp_error}
                                                    end;

                                                _ ->
                                                    {error, resp_error}
                                            end end
                                    )
                                end,
                                fun(Array) -> {ok, {Array, New_cursor}} end
                            );

                        {error, nil} ->
                            {error, resp_error}
                    end;

                _ ->
                    {error, resp_error}
            end end),
    gleam@result:flatten(_pipe@4).