-module(gleam@result).
-compile([no_auto_import, nowarn_unused_vars]).

-export([is_ok/1, is_error/1, map/2, map_error/2, flatten/1, 'try'/2, then/2, unwrap/2, lazy_unwrap/2, unwrap_error/2, unwrap_both/1, nil_error/1, 'or'/2, lazy_or/2, all/1, replace/2, replace_error/2, values/1, try_recover/2, partition/1]).

-spec is_ok({ok, any()} | {error, any()}) -> boolean().
is_ok(Result) ->
    case Result of
        {error, _} ->
            false;

        {ok, _} ->
            true
    end.

-spec is_error({ok, any()} | {error, any()}) -> boolean().
is_error(Result) ->
    case Result of
        {ok, _} ->
            false;

        {error, _} ->
            true
    end.

-spec map({ok, BEB} | {error, BEC}, fun((BEB) -> BEF)) -> {ok, BEF} |
    {error, BEC}.
map(Result, Fun) ->
    case Result of
        {ok, X} ->
            {ok, Fun(X)};

        {error, E} ->
            {error, E}
    end.

-spec map_error({ok, BEI} | {error, BEJ}, fun((BEJ) -> BEM)) -> {ok, BEI} |
    {error, BEM}.
map_error(Result, Fun) ->
    case Result of
        {ok, X} ->
            {ok, X};

        {error, Error} ->
            {error, Fun(Error)}
    end.

-spec flatten({ok, {ok, BEP} | {error, BEQ}} | {error, BEQ}) -> {ok, BEP} |
    {error, BEQ}.
flatten(Result) ->
    case Result of
        {ok, X} ->
            X;

        {error, Error} ->
            {error, Error}
    end.

-spec 'try'({ok, BEX} | {error, BEY}, fun((BEX) -> {ok, BFB} | {error, BEY})) -> {ok,
        BFB} |
    {error, BEY}.
'try'(Result, Fun) ->
    case Result of
        {ok, X} ->
            Fun(X);

        {error, E} ->
            {error, E}
    end.

-spec then({ok, BFG} | {error, BFH}, fun((BFG) -> {ok, BFK} | {error, BFH})) -> {ok,
        BFK} |
    {error, BFH}.
then(Result, Fun) ->
    'try'(Result, Fun).

-spec unwrap({ok, BFP} | {error, any()}, BFP) -> BFP.
unwrap(Result, Default) ->
    case Result of
        {ok, V} ->
            V;

        {error, _} ->
            Default
    end.

-spec lazy_unwrap({ok, BFT} | {error, any()}, fun(() -> BFT)) -> BFT.
lazy_unwrap(Result, Default) ->
    case Result of
        {ok, V} ->
            V;

        {error, _} ->
            Default()
    end.

-spec unwrap_error({ok, any()} | {error, BFY}, BFY) -> BFY.
unwrap_error(Result, Default) ->
    case Result of
        {ok, _} ->
            Default;

        {error, E} ->
            E
    end.

-spec unwrap_both({ok, BGB} | {error, BGB}) -> BGB.
unwrap_both(Result) ->
    case Result of
        {ok, A} ->
            A;

        {error, A@1} ->
            A@1
    end.

-spec nil_error({ok, BGE} | {error, any()}) -> {ok, BGE} | {error, nil}.
nil_error(Result) ->
    map_error(Result, fun(_) -> nil end).

-spec 'or'({ok, BGK} | {error, BGL}, {ok, BGK} | {error, BGL}) -> {ok, BGK} |
    {error, BGL}.
'or'(First, Second) ->
    case First of
        {ok, _} ->
            First;

        {error, _} ->
            Second
    end.

-spec lazy_or({ok, BGS} | {error, BGT}, fun(() -> {ok, BGS} | {error, BGT})) -> {ok,
        BGS} |
    {error, BGT}.
lazy_or(First, Second) ->
    case First of
        {ok, _} ->
            First;

        {error, _} ->
            Second()
    end.

-spec all(list({ok, BHA} | {error, BHB})) -> {ok, list(BHA)} | {error, BHB}.
all(Results) ->
    gleam@list:try_map(Results, fun(X) -> X end).

-spec replace({ok, any()} | {error, BHY}, BIB) -> {ok, BIB} | {error, BHY}.
replace(Result, Value) ->
    case Result of
        {ok, _} ->
            {ok, Value};

        {error, Error} ->
            {error, Error}
    end.

-spec replace_error({ok, BIE} | {error, any()}, BII) -> {ok, BIE} | {error, BII}.
replace_error(Result, Error) ->
    case Result of
        {ok, X} ->
            {ok, X};

        {error, _} ->
            {error, Error}
    end.

-spec values(list({ok, BIL} | {error, any()})) -> list(BIL).
values(Results) ->
    gleam@list:filter_map(Results, fun(R) -> R end).

-spec try_recover(
    {ok, BIR} | {error, BIS},
    fun((BIS) -> {ok, BIR} | {error, BIV})
) -> {ok, BIR} | {error, BIV}.
try_recover(Result, Fun) ->
    case Result of
        {ok, Value} ->
            {ok, Value};

        {error, Error} ->
            Fun(Error)
    end.

-spec do_partition(list({ok, BHP} | {error, BHQ}), list(BHP), list(BHQ)) -> {list(BHP),
    list(BHQ)}.
do_partition(Results, Oks, Errors) ->
    case Results of
        [] ->
            {Oks, Errors};

        [{ok, A} | Rest] ->
            do_partition(Rest, [A | Oks], Errors);

        [{error, E} | Rest@1] ->
            do_partition(Rest@1, Oks, [E | Errors])
    end.

-spec partition(list({ok, BHI} | {error, BHJ})) -> {list(BHI), list(BHJ)}.
partition(Results) ->
    do_partition(Results, [], []).