geny

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

-export([get_error/1, to_normal/1, 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]).
-export_type([geny/1]).

-type geny(FLP) :: {geny, FLP, list(binary())}.

-spec get_error(geny(FLV)) -> FLV.
get_error(Geny) ->
    {geny, Error, _} = Geny,
    Error.

-spec to_normal({ok, FLX} | {error, geny(FLY)}) -> {ok, FLX} | {error, FLY}.
to_normal(Result) ->
    case Result of
        {ok, X} ->
            {ok, X};

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

-spec is_ok({ok, any()} | {error, geny(any())}) -> boolean().
is_ok(Result) ->
    gleam@result:is_ok(Result).

-spec is_error({ok, any()} | {error, geny(any())}) -> boolean().
is_error(Result) ->
    gleam@result:is_error(Result).

-spec map({ok, FML} | {error, geny(FMM)}, fun((FML) -> FMP)) -> {ok, FMP} |
    {error, geny(FMM)}.
map(Result, Fun) ->
    gleam@result:map(Result, Fun).

-spec map_error({ok, FMS} | {error, geny(FMT)}, fun((FMT) -> FMW)) -> {ok, FMS} |
    {error, geny(FMW)}.
map_error(Result, Fun) ->
    case Result of
        {ok, X} ->
            {ok, X};

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

-spec flatten({ok, {ok, FMZ} | {error, geny(FNA)}} | {error, geny(FNA)}) -> {ok,
        FMZ} |
    {error, geny(FNA)}.
flatten(Result) ->
    gleam@result:flatten(Result).

-spec 'try'(
    {ok, FNH} | {error, geny(FNI)},
    fun((FNH) -> {ok, FNL} | {error, geny(FNI)})
) -> {ok, FNL} | {error, geny(FNI)}.
'try'(Result, Fun) ->
    gleam@result:'try'(Result, Fun).

-spec then(
    {ok, FNQ} | {error, geny(FNR)},
    fun((FNQ) -> {ok, FNU} | {error, geny(FNR)})
) -> {ok, FNU} | {error, geny(FNR)}.
then(Result, Fun) ->
    'try'(Result, Fun).

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

        {error, _} ->
            Default
    end.

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

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

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

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

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

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

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

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

        {error, _} ->
            Second
    end.

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

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

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