Packages
gleam_stdlib
0.4.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
Current section
Files
Jump to
Current section
Files
gen/src/gleam@list.erl
-module(gleam@list).
-compile(no_auto_import).
-export([length/1, reverse/1, is_empty/1, contains/2, head/1, tail/1, filter/2, map/2, index_map/2, traverse/2, drop/2, take/2, new/0, append/2, flatten/1, fold/3, fold_right/3, find/2, all/2, any/2, zip/2, strict_zip/2, intersperse/2, at/2, unique/1, sort/2, range/2, repeat/2, split/2, split_while/2, key_find/2]).
length(A) ->
erlang:length(A).
reverse(A) ->
lists:reverse(A).
is_empty(List) ->
List =:= [].
contains(List, Elem) ->
case List of
[] ->
false;
[Head | Rest] ->
Head =:= Elem orelse contains(Rest, Elem)
end.
head(List) ->
case List of
[] ->
{error, nil};
[X | _] ->
{ok, X}
end.
tail(List) ->
case List of
[] ->
{error, nil};
[_ | Xs] ->
{ok, Xs}
end.
do_filter(List, Fun, Acc) ->
case List of
[] ->
reverse(Acc);
[X | Xs] ->
NewAcc = case Fun(X) of
true ->
[X | Acc];
false ->
Acc
end,
do_filter(Xs, Fun, NewAcc)
end.
filter(List, Fun) ->
do_filter(List, Fun, []).
do_map(List, Fun, Acc) ->
case List of
[] ->
reverse(Acc);
[X | Xs] ->
do_map(Xs, Fun, [Fun(X) | Acc])
end.
map(List, Fun) ->
do_map(List, Fun, []).
do_index_map(List, Fun, Index, Acc) ->
case List of
[] ->
reverse(Acc);
[X | Xs] ->
do_index_map(Xs, Fun, Index + 1, [Fun(Index, X) | Acc])
end.
index_map(List, Fun) ->
do_index_map(List, Fun, 0, []).
do_traverse(List, Fun, Acc) ->
case List of
[] ->
{ok, reverse(Acc)};
[X | Xs] ->
case Fun(X) of
{ok, Y} ->
do_traverse(Xs, Fun, [Y | Acc]);
{error, Error} ->
{error, Error}
end
end.
traverse(List, Fun) ->
do_traverse(List, Fun, []).
drop(List, N) ->
case N =< 0 of
true ->
List;
false ->
case List of
[] ->
[];
[_ | Xs] ->
drop(Xs, N - 1)
end
end.
do_take(List, N, Acc) ->
case N =< 0 of
true ->
reverse(Acc);
false ->
case List of
[] ->
reverse(Acc);
[X | Xs] ->
do_take(Xs, N - 1, [X | Acc])
end
end.
take(List, N) ->
do_take(List, N, []).
new() ->
[].
append(A, B) ->
lists:append(A, B).
do_flatten(Lists, Acc) ->
case Lists of
[] ->
Acc;
[L | Rest] ->
do_flatten(Rest, append(Acc, L))
end.
flatten(Lists) ->
do_flatten(Lists, []).
fold(List, Acc, Fun) ->
case List of
[] ->
Acc;
[X | Rest] ->
fold(Rest, Fun(X, Acc), Fun)
end.
fold_right(List, Acc, Fun) ->
case List of
[] ->
Acc;
[X | Rest] ->
Fun(X, fold_right(Rest, Acc, Fun))
end.
find(Haystack, F) ->
case Haystack of
[] ->
{error, nil};
[X | Rest] ->
case F(X) of
{ok, X1} ->
{ok, X1};
_ ->
find(Rest, F)
end
end.
all(List, F) ->
case List of
[] ->
true;
[X | Rest] ->
case F(X) of
true ->
all(Rest, F);
_ ->
false
end
end.
any(List, F) ->
case List of
[] ->
false;
[X | Rest] ->
case F(X) of
false ->
any(Rest, F);
_ ->
true
end
end.
zip(L1, L2) ->
case {L1, L2} of
{[], _} ->
[];
{_, []} ->
[];
{[X1 | Rest1], [X2 | Rest2]} ->
[{X1, X2} | zip(Rest1, Rest2)]
end.
strict_zip(L1, L2) ->
case length(L1) =:= length(L2) of
true ->
{ok, zip(L1, L2)};
false ->
{error, length_mismatch}
end.
intersperse(List, Elem) ->
case List of
[] ->
[];
[X] ->
[X];
[X1 | Rest] ->
[X1, Elem | intersperse(Rest, Elem)]
end.
at(List, I) ->
case I < 0 of
true ->
{error, nil};
false ->
case List of
[] ->
{error, nil};
[X | Rest] ->
case I =:= 0 of
true ->
{ok, X};
false ->
at(Rest, I - 1)
end
end
end.
unique(List) ->
case List of
[] ->
[];
[X | Rest] ->
[X | unique(filter(Rest, fun(Y) -> Y /= X end))]
end.
merge_sort(A, B, Compare) ->
case {A, B} of
{[], _} ->
B;
{_, []} ->
A;
{[Ax | Ar], [Bx | Br]} ->
case Compare(Ax, Bx) of
lt ->
[Ax | merge_sort(Ar, B, Compare)];
_ ->
[Bx | merge_sort(A, Br, Compare)]
end
end.
do_sort(List, Compare, ListLength) ->
case ListLength < 2 of
true ->
List;
false ->
SplitLength = ListLength div 2,
AList = take(List, SplitLength),
BList = drop(List, SplitLength),
merge_sort(
do_sort(AList, Compare, SplitLength),
do_sort(BList, Compare, ListLength - SplitLength),
Compare
)
end.
sort(List, Compare) ->
do_sort(List, Compare, length(List)).
range(Start, Stop) ->
case gleam@int:compare(Start, Stop) of
eq ->
[];
gt ->
[Start | range(Start - 1, Stop)];
lt ->
[Start | range(Start + 1, Stop)]
end.
do_repeat(A, Times, Acc) ->
case Times =< 0 of
true ->
Acc;
false ->
do_repeat(A, Times - 1, [A | Acc])
end.
repeat(A, Times) ->
do_repeat(A, Times, []).
do_split(List, N, Taken) ->
case N =< 0 of
true ->
{reverse(Taken), List};
false ->
case List of
[] ->
{reverse(Taken), []};
[X | Xs] ->
do_split(Xs, N - 1, [X | Taken])
end
end.
split(List, N) ->
do_split(List, N, []).
do_split_while(List, F, Acc) ->
case List of
[] ->
{reverse(Acc), []};
[X | Xs] ->
case F(X) of
false ->
{reverse(Acc), List};
_ ->
do_split_while(Xs, F, [X | Acc])
end
end.
split_while(List, F) ->
do_split_while(List, F, []).
key_find(Haystack, Needle) ->
find(Haystack, fun(P) -> case gleam@pair:first(P) =:= Needle of
true ->
{ok, gleam@pair:second(P)};
false ->
{error, nil}
end end).