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
Current section
Files
Jump to
Current section
Files
gen/src/list.erl
-module(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/1, range/2, repeat/2, split/2, split_while/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, empty};
[X | _] ->
{ok, X}
end.
tail(List) ->
case List of
[] ->
{error, empty};
[_ | 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, not_found};
[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, not_found};
false ->
case List of
[] ->
{error, not_found};
[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) ->
case {A, B} of
{[], _} ->
B;
{_, []} ->
A;
{[Ax | Ar], [Bx | Br]} ->
case Ax < Bx of
true ->
[Ax | merge_sort(Ar, B)];
false ->
[Bx | merge_sort(A, Br)]
end
end.
sort(List) ->
ListLength = length(List),
case ListLength < 2 of
true ->
List;
false ->
SplitLength = ListLength div 2,
AList = take(List, SplitLength),
BList = drop(List, SplitLength),
merge_sort(sort(AList), sort(BList))
end.
range(Start, Stop) ->
case 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, []).