-module(gleam@result).
-compile(no_auto_import).

-export([is_ok/1, is_error/1, map/2, map_error/2, flatten/1, then/2, unwrap/2, lazy_unwrap/2, nil_error/1, 'or'/2, lazy_or/2, all/1, replace_error/2]).

-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, BUC} | {error, BUD}, fun((BUC) -> BUG)) -> {ok, BUG} |
    {error, BUD}.
map(Result, Fun) ->
    case Result of
        {ok, X} ->
            {ok, Fun(X)};

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

-spec map_error({ok, BUJ} | {error, BUK}, fun((BUK) -> BUN)) -> {ok, BUJ} |
    {error, BUN}.
map_error(Result, Fun) ->
    case Result of
        {ok, X} ->
            {ok, X};

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

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

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

-spec then({ok, BUY} | {error, BUZ}, fun((BUY) -> {ok, BVC} | {error, BUZ})) -> {ok,
                                                                                 BVC} |
    {error, BUZ}.
then(Result, Fun) ->
    case Result of
        {ok, X} ->
            Fun(X);

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

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

        {error, _} ->
            Default
    end.

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

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

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

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

        {error, _} ->
            Second
    end.

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

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

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

-spec replace_error({ok, BWT} | {error, any()}, BWX) -> {ok, BWT} | {error, BWX}.
replace_error(Result, Error) ->
    map_error(Result, fun(_) -> Error end).