Packages

gleam_stdlib

0.38.0
1.0.3 1.0.2 1.0.1 1.0.0 0.71.0 0.70.0 0.69.0 0.68.1 0.68.0 0.67.1 0.67.0 0.65.0 0.64.0 0.63.2 0.63.1 0.63.0 0.62.1 0.62.0 0.61.0 0.60.0 0.59.0 0.58.0 0.57.0 0.56.0 0.55.0 0.54.0 0.53.0 0.52.0 0.51.0 0.50.0 0.49.0 0.48.0 0.47.0 0.46.0 0.45.0 0.44.0 0.43.0 0.42.0 0.41.0 0.40.0 0.39.0 0.38.0 0.37.0 0.36.0 0.35.1 0.35.0 0.34.0 0.33.1 0.33.0 0.32.1 0.32.0 0.31.0 0.30.2 0.30.1 0.30.0 0.29.2 0.29.1 0.29.0 0.28.2 0.28.1 0.28.0 0.27.0 0.26.1 0.26.0 0.25.0 0.24.0 0.23.0 0.22.3 0.22.2 0.22.1 0.22.0 0.21.0 0.20.0 0.19.3 0.19.2 0.19.1 0.19.0 0.18.1 0.18.0 0.18.0-rc1 0.17.1 0.17.0 0.16.0 0.15.0 0.14.0 0.13.0 0.12.0 0.11.0 0.10.1 0.10.0 0.9.0 0.8.0 0.7.0 0.6.0 0.5.0 0.4.0 0.4.0-rc1 0.3.1 0.3.0 0.2.0 retired

A standard library for the Gleam programming language

HexDocs

Current section

Files

Jump to
Readme
100 Versions
0 Dependencies
Dependants
Files
Activity
gleam_stdlib src gleam@result.erl
Raw

src/gleam@result.erl 

-module(gleam@result).

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



-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, partition/1, replace/2, replace_error/2, values/1, try_recover/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, BMR} | {error, BMS}, fun((BMR) -> BMV)) -> {ok, BMV} |

    {error, BMS}.

map(Result, Fun) ->

    case Result of

        {ok, X} ->

            {ok, Fun(X)};



        {error, E} ->

            {error, E}

    end.



-spec map_error({ok, BMY} | {error, BMZ}, fun((BMZ) -> BNC)) -> {ok, BMY} |

    {error, BNC}.

map_error(Result, Fun) ->

    case Result of

        {ok, X} ->

            {ok, X};



        {error, Error} ->

            {error, Fun(Error)}

    end.



-spec flatten({ok, {ok, BNF} | {error, BNG}} | {error, BNG}) -> {ok, BNF} |

    {error, BNG}.

flatten(Result) ->

    case Result of

        {ok, X} ->

            X;



        {error, Error} ->

            {error, Error}

    end.



-spec 'try'({ok, BNN} | {error, BNO}, fun((BNN) -> {ok, BNR} | {error, BNO})) -> {ok,

        BNR} |

    {error, BNO}.

'try'(Result, Fun) ->

    case Result of

        {ok, X} ->

            Fun(X);



        {error, E} ->

            {error, E}

    end.



-spec then({ok, BNW} | {error, BNX}, fun((BNW) -> {ok, BOA} | {error, BNX})) -> {ok,

        BOA} |

    {error, BNX}.

then(Result, Fun) ->

    'try'(Result, Fun).



-spec unwrap({ok, BOF} | {error, any()}, BOF) -> BOF.

unwrap(Result, Default) ->

    case Result of

        {ok, V} ->

            V;



        {error, _} ->

            Default

    end.



-spec lazy_unwrap({ok, BOJ} | {error, any()}, fun(() -> BOJ)) -> BOJ.

lazy_unwrap(Result, Default) ->

    case Result of

        {ok, V} ->

            V;



        {error, _} ->

            Default()

    end.



-spec unwrap_error({ok, any()} | {error, BOO}, BOO) -> BOO.

unwrap_error(Result, Default) ->

    case Result of

        {ok, _} ->

            Default;



        {error, E} ->

            E

    end.



-spec unwrap_both({ok, BOR} | {error, BOR}) -> BOR.

unwrap_both(Result) ->

    case Result of

        {ok, A} ->

            A;



        {error, A@1} ->

            A@1

    end.



-spec nil_error({ok, BOU} | {error, any()}) -> {ok, BOU} | {error, nil}.

nil_error(Result) ->

    map_error(Result, fun(_) -> nil end).



-spec 'or'({ok, BPA} | {error, BPB}, {ok, BPA} | {error, BPB}) -> {ok, BPA} |

    {error, BPB}.

'or'(First, Second) ->

    case First of

        {ok, _} ->

            First;



        {error, _} ->

            Second

    end.



-spec lazy_or({ok, BPI} | {error, BPJ}, fun(() -> {ok, BPI} | {error, BPJ})) -> {ok,

        BPI} |

    {error, BPJ}.

lazy_or(First, Second) ->

    case First of

        {ok, _} ->

            First;



        {error, _} ->

            Second()

    end.



-spec all(list({ok, BPQ} | {error, BPR})) -> {ok, list(BPQ)} | {error, BPR}.

all(Results) ->

    gleam@list:try_map(Results, fun(X) -> X end).



-spec do_partition(list({ok, BQF} | {error, BQG}), list(BQF), list(BQG)) -> {list(BQF),

    list(BQG)}.

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, BPY} | {error, BPZ})) -> {list(BPY), list(BPZ)}.

partition(Results) ->

    do_partition(Results, [], []).



-spec replace({ok, any()} | {error, BQO}, BQR) -> {ok, BQR} | {error, BQO}.

replace(Result, Value) ->

    case Result of

        {ok, _} ->

            {ok, Value};



        {error, Error} ->

            {error, Error}

    end.



-spec replace_error({ok, BQU} | {error, any()}, BQY) -> {ok, BQU} | {error, BQY}.

replace_error(Result, Error) ->

    case Result of

        {ok, X} ->

            {ok, X};



        {error, _} ->

            {error, Error}

    end.



-spec values(list({ok, BRB} | {error, any()})) -> list(BRB).

values(Results) ->

    gleam@list:filter_map(Results, fun(R) -> R end).



-spec try_recover(

    {ok, BRH} | {error, BRI},

    fun((BRI) -> {ok, BRH} | {error, BRL})

) -> {ok, BRH} | {error, BRL}.

try_recover(Result, Fun) ->

    case Result of

        {ok, Value} ->

            {ok, Value};



        {error, Error} ->

            Fun(Error)

    end.