Packages

gleam_stdlib

0.2.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

Retired package: Release invalid - Does not compile correctly
HexDocs

Current section

Files

Jump to
Readme
100 Versions
0 Dependencies
1565 Dependants
Files
Activity
gleam_stdlib gen test any_test.erl
Raw

gen/test/any_test.erl 

-module(any_test).

-compile(no_auto_import).



-export([string_test/0, int_test/0, float_test/0, thunk_test/0, bool_test/0, atom_test/0, list_test/0, tuple_test/0, field_test/0]).



string_test() ->

    expect:equal(any:string(any:from(<<"">>)), {ok, <<"">>}),

    expect:equal(any:string(any:from(<<"Hello">>)), {ok, <<"Hello">>}),

    expect:equal(any:string(any:from(1)),

                 {error, <<"Expected a String, got `1`">>}),

    expect:equal(any:string(any:from([])),

                 {error, <<"Expected a String, got `[]`">>}).



int_test() ->

    expect:equal(any:int(any:from(1)), {ok, 1}),

    expect:equal(any:int(any:from(2)), {ok, 2}),

    expect:equal(any:int(any:from(1.0)),

                 {error, <<"Expected an Int, got `1.0`">>}),

    expect:equal(any:int(any:from([])),

                 {error, <<"Expected an Int, got `[]`">>}).



float_test() ->

    expect:equal(any:float(any:from(1.0)), {ok, 1.0}),

    expect:equal(any:float(any:from(2.2)), {ok, 2.2}),

    expect:equal(any:float(any:from(1)),

                 {error, <<"Expected a Float, got `1`">>}),

    expect:equal(any:float(any:from([])),

                 {error, <<"Expected a Float, got `[]`">>}).



thunk_test() ->

    expect:is_ok(any:thunk(any:from(fun() -> 1 end))),

    expect:equal(result:map(any:thunk(any:from(fun() -> 1 end)),

                            fun(F) -> F() end),

                 {ok, any:from(1)}),

    expect:is_error(any:thunk(any:from(fun(X) -> X end))),

    expect:is_error(any:thunk(any:from(1))),

    expect:is_error(any:thunk(any:from([]))).



bool_test() ->

    expect:equal(any:bool(any:from(true)), {ok, true}),

    expect:equal(any:bool(any:from(false)), {ok, false}),

    expect:equal(any:bool(any:from(1)),

                 {error, <<"Expected a Bool, got `1`">>}),

    expect:equal(any:bool(any:from([])),

                 {error, <<"Expected a Bool, got `[]`">>}).



atom_test() ->

    expect:equal(any:atom(any:from(atom:create_from_string(<<"">>))),

                 {ok, atom:create_from_string(<<"">>)}),

    expect:equal(any:atom(any:from(atom:create_from_string(<<"ok">>))),

                 {ok, atom:create_from_string(<<"ok">>)}),

    expect:is_error(any:atom(any:from(1))),

    expect:is_error(any:atom(any:from([]))).



list_test() ->

    expect:equal(any:list(any:from([]), fun any:string/1), {ok, []}),

    expect:equal(any:list(any:from([]), fun any:int/1), {ok, []}),

    expect:equal(any:list(any:from([1, 2, 3]), fun any:int/1), {ok, [1, 2, 3]}),

    expect:equal(any:list(any:from([[1], [2], [3]]),

                          fun(Capture1) ->

                              any:list(Capture1, fun any:int/1)

                          end),

                 {ok, [[1], [2], [3]]}),

    expect:is_error(any:list(any:from(1), fun any:string/1)),

    expect:is_error(any:list(any:from(1.0), fun any:int/1)),

    expect:is_error(any:list(any:from([<<"">>]), fun any:int/1)),

    expect:is_error(any:list(any:from([any:from(1), any:from(<<"not an int">>)]),

                             fun any:int/1)).



tuple_test() ->

    expect:equal(any:tuple(any:from({1, []})),

                 {ok, {any:from(1), any:from([])}}),

    expect:equal(any:tuple(any:from({<<"ok">>, <<"ok">>})),

                 {ok, {any:from(<<"ok">>), any:from(<<"ok">>)}}),

    expect:is_error(any:tuple(any:from({1}))),

    expect:is_error(any:tuple(any:from({1, 2, 3}))),

    expect:equal(result:then(result:then(any:tuple(any:from({1, 2.0})),

                                         fun(X) ->

                                             result:map(any:int(tuple:first(X)),

                                                        fun(F) ->

                                                            {F, tuple:second(X)}

                                                        end)

                                         end),

                             fun(X) ->

                                 result:map(any:float(tuple:second(X)),

                                            fun(F) -> {tuple:first(X), F} end)

                             end),

                 {ok, {1, 2.0}}).



field_test() ->

    {ok, OkAtom} = atom:from_string(<<"ok">>),

    expect:equal(any:field(any:from(#{}#{ok => 1}), OkAtom), {ok, any:from(1)}),

    expect:equal(any:field(any:from(#{}#{ok => 3}#{earlier => 2}), OkAtom),

                 {ok, any:from(3)}),

    expect:is_error(any:field(any:from(#{}), OkAtom)),

    expect:is_error(any:field(any:from(1), OkAtom)),

    expect:is_error(any:field(any:from([]), [])).