Packages
gleam_stdlib
0.15.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, filter_map/2, map/2, index_map/2, try_map/2, drop/2, take/2, new/0, append/2, flatten/1, fold/3, fold_right/3, index_fold/3, try_fold/3, fold_until/3, find/2, find_map/2, all/2, any/2, zip/2, strict_zip/2, unzip/1, intersperse/2, at/2, unique/1, sort/2, range/2, repeat/2, split/2, split_while/2, key_find/2, pop/2, pop_map/2, key_pop/2, key_set/3, each/2, partition/2, permutations/1, window/2, window_by_2/1, drop_while/2, take_while/2]).
-export_type([length_mismatch/0, continue_or_stop/1]).
-type length_mismatch() :: length_mismatch.
-type continue_or_stop(ABC) :: {continue, ABC} | {stop, ABC}.
-spec length(list(any())) -> integer().
length(A) ->
erlang:length(A).
-spec reverse(list(ABF)) -> list(ABF).
reverse(A) ->
lists:reverse(A).
-spec is_empty(list(any())) -> boolean().
is_empty(List) ->
List =:= [].
-spec contains(list(ABK), ABK) -> boolean().
contains(List, Elem) ->
case List of
[] ->
false;
[Head | Rest] ->
(Head =:= Elem) orelse contains(Rest, Elem)
end.
-spec head(list(ABM)) -> {ok, ABM} | {error, nil}.
head(List) ->
case List of
[] ->
{error, nil};
[X | _] ->
{ok, X}
end.
-spec tail(list(ABQ)) -> {ok, list(ABQ)} | {error, nil}.
tail(List) ->
case List of
[] ->
{error, nil};
[_ | Xs] ->
{ok, Xs}
end.
-spec do_filter(list(ABV), fun((ABV) -> boolean()), list(ABV)) -> list(ABV).
do_filter(List, Fun, Acc) ->
case List of
[] ->
lists:reverse(Acc);
[X | Xs] ->
New_acc = case Fun(X) of
true ->
[X | Acc];
false ->
Acc
end,
do_filter(Xs, Fun, New_acc)
end.
-spec filter(list(ABZ), fun((ABZ) -> boolean())) -> list(ABZ).
filter(List, Predicate) ->
do_filter(List, Predicate, []).
-spec do_filter_map(
list(ACC),
fun((ACC) -> {ok, ACE} | {error, any()}),
list(ACE)
) -> list(ACE).
do_filter_map(List, Fun, Acc) ->
case List of
[] ->
lists:reverse(Acc);
[X | Xs] ->
New_acc = case Fun(X) of
{ok, X@1} ->
[X@1 | Acc];
{error, _} ->
Acc
end,
do_filter_map(Xs, Fun, New_acc)
end.
-spec filter_map(list(ACK), fun((ACK) -> {ok, ACM} | {error, any()})) -> list(ACM).
filter_map(List, Fun) ->
do_filter_map(List, Fun, []).
-spec do_map(list(ACR), fun((ACR) -> ACT), list(ACT)) -> list(ACT).
do_map(List, Fun, Acc) ->
case List of
[] ->
lists:reverse(Acc);
[X | Xs] ->
do_map(Xs, Fun, [Fun(X) | Acc])
end.
-spec map(list(ACW), fun((ACW) -> ACY)) -> list(ACY).
map(List, Fun) ->
do_map(List, Fun, []).
-spec do_index_map(
list(ADA),
fun((integer(), ADA) -> ADC),
integer(),
list(ADC)
) -> list(ADC).
do_index_map(List, Fun, Index, Acc) ->
case List of
[] ->
lists:reverse(Acc);
[X | Xs] ->
do_index_map(Xs, Fun, Index + 1, [Fun(Index, X) | Acc])
end.
-spec index_map(list(ADF), fun((integer(), ADF) -> ADH)) -> list(ADH).
index_map(List, Fun) ->
do_index_map(List, Fun, 0, []).
-spec do_try_map(list(ADJ), fun((ADJ) -> {ok, ADL} | {error, ADM}), list(ADL)) -> {ok,
list(ADL)} |
{error, ADM}.
do_try_map(List, Fun, Acc) ->
case List of
[] ->
{ok, lists:reverse(Acc)};
[X | Xs] ->
case Fun(X) of
{ok, Y} ->
do_try_map(Xs, Fun, [Y | Acc]);
{error, Error} ->
{error, Error}
end
end.
-spec try_map(list(ADT), fun((ADT) -> {ok, ADV} | {error, ADW})) -> {ok,
list(ADV)} |
{error, ADW}.
try_map(List, Fun) ->
do_try_map(List, Fun, []).
-spec drop(list(AEC), integer()) -> list(AEC).
drop(List, N) ->
case N =< 0 of
true ->
List;
false ->
case List of
[] ->
[];
[_ | Xs] ->
drop(Xs, N - 1)
end
end.
-spec do_take(list(AEF), integer(), list(AEF)) -> list(AEF).
do_take(List, N, Acc) ->
case N =< 0 of
true ->
lists:reverse(Acc);
false ->
case List of
[] ->
lists:reverse(Acc);
[X | Xs] ->
do_take(Xs, N - 1, [X | Acc])
end
end.
-spec take(list(AEJ), integer()) -> list(AEJ).
take(List, N) ->
do_take(List, N, []).
-spec new() -> list(any()).
new() ->
[].
-spec append(list(AEO), list(AEO)) -> list(AEO).
append(A, B) ->
lists:append(A, B).
-spec do_flatten(list(list(AES)), list(AES)) -> list(AES).
do_flatten(Lists, Acc) ->
case Lists of
[] ->
Acc;
[L | Rest] ->
do_flatten(Rest, lists:append(Acc, L))
end.
-spec flatten(list(list(AEX))) -> list(AEX).
flatten(Lists) ->
do_flatten(Lists, []).
-spec fold(list(AFB), AFD, fun((AFB, AFD) -> AFD)) -> AFD.
fold(List, Initial, Fun) ->
case List of
[] ->
Initial;
[X | Rest] ->
fold(Rest, Fun(X, Initial), Fun)
end.
-spec fold_right(list(AFE), AFG, fun((AFE, AFG) -> AFG)) -> AFG.
fold_right(List, Initial, Fun) ->
case List of
[] ->
Initial;
[X | Rest] ->
Fun(X, fold_right(Rest, Initial, Fun))
end.
-spec do_index_fold(
list(AFH),
AFJ,
fun((integer(), AFH, AFJ) -> AFJ),
integer()
) -> AFJ.
do_index_fold(Over, Acc, With, Index) ->
case Over of
[] ->
Acc;
[First | Rest] ->
do_index_fold(Rest, With(Index, First, Acc), With, Index + 1)
end.
-spec index_fold(list(AFK), AFM, fun((integer(), AFK, AFM) -> AFM)) -> AFM.
index_fold(Over, Initial, Fun) ->
do_index_fold(Over, Initial, Fun, 0).
-spec try_fold(list(AFN), AFP, fun((AFN, AFP) -> {ok, AFP} | {error, AFQ})) -> {ok,
AFP} |
{error, AFQ}.
try_fold(Collection, Accumulator, Fun) ->
case Collection of
[] ->
{ok, Accumulator};
[First | Rest] ->
case Fun(First, Accumulator) of
{ok, Next_accumulator} ->
try_fold(Rest, Next_accumulator, Fun);
{error, Err} ->
{error, Err}
end
end.
-spec fold_until(list(AFV), AFX, fun((AFV, AFX) -> continue_or_stop(AFX))) -> AFX.
fold_until(Collection, Accumulator, Fun) ->
case Collection of
[] ->
Accumulator;
[First | Rest] ->
case Fun(First, Accumulator) of
{continue, Next_accumulator} ->
fold_until(Rest, Next_accumulator, Fun);
{stop, B} ->
B
end
end.
-spec find(list(AFZ), fun((AFZ) -> boolean())) -> {ok, AFZ} | {error, nil}.
find(Haystack, Is_desired) ->
case Haystack of
[] ->
{error, nil};
[X | Rest] ->
case Is_desired(X) of
true ->
{ok, X};
_ ->
find(Rest, Is_desired)
end
end.
-spec find_map(list(AGD), fun((AGD) -> {ok, AGF} | {error, any()})) -> {ok, AGF} |
{error, nil}.
find_map(Haystack, Fun) ->
case Haystack of
[] ->
{error, nil};
[X | Rest] ->
case Fun(X) of
{ok, X@1} ->
{ok, X@1};
_ ->
find_map(Rest, Fun)
end
end.
-spec all(list(AGL), fun((AGL) -> boolean())) -> boolean().
all(List, Predicate) ->
case List of
[] ->
true;
[X | Rest] ->
case Predicate(X) of
true ->
all(Rest, Predicate);
_ ->
false
end
end.
-spec any(list(AGN), fun((AGN) -> boolean())) -> boolean().
any(List, Predicate) ->
case List of
[] ->
false;
[X | Rest] ->
case Predicate(X) of
false ->
any(Rest, Predicate);
_ ->
true
end
end.
-spec zip(list(AGP), list(AGR)) -> list({AGP, AGR}).
zip(Xs, Ys) ->
case {Xs, Ys} of
{[], _} ->
[];
{_, []} ->
[];
{[X | Xs@1], [Y | Ys@1]} ->
[{X, Y} | zip(Xs@1, Ys@1)]
end.
-spec strict_zip(list(AGU), list(AGW)) -> {ok, list({AGU, AGW})} |
{error, length_mismatch()}.
strict_zip(L1, L2) ->
case erlang:length(L1) =:= erlang:length(L2) of
true ->
{ok, zip(L1, L2)};
false ->
{error, length_mismatch}
end.
-spec do_unzip(list({AHF, AHG}), list(AHF), list(AHG)) -> {list(AHF), list(AHG)}.
do_unzip(Input, Xs, Ys) ->
case Input of
[] ->
{lists:reverse(Xs), lists:reverse(Ys)};
[{X, Y} | Rest] ->
do_unzip(Rest, [X | Xs], [Y | Ys])
end.
-spec unzip(list({AHF, AHG})) -> {list(AHF), list(AHG)}.
unzip(Input) ->
do_unzip(Input, [], []).
-spec intersperse(list(AHK), AHK) -> list(AHK).
intersperse(List, Elem) ->
case List of
[] ->
List;
[_] ->
List;
[X | Rest] ->
[X, Elem | intersperse(Rest, Elem)]
end.
-spec at(list(AHN), integer()) -> {ok, AHN} | {error, nil}.
at(List, Index) ->
case Index < 0 of
true ->
{error, nil};
false ->
case List of
[] ->
{error, nil};
[X | Rest] ->
case Index =:= 0 of
true ->
{ok, X};
false ->
at(Rest, Index - 1)
end
end
end.
-spec unique(list(AHR)) -> list(AHR).
unique(List) ->
case List of
[] ->
[];
[X | Rest] ->
[X | unique(filter(Rest, fun(Y) -> Y /= X end))]
end.
-spec merge_sort(list(AHU), list(AHU), fun((AHU, AHU) -> gleam@order:order())) -> list(AHU).
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.
-spec do_sort(list(AHY), fun((AHY, AHY) -> gleam@order:order()), integer()) -> list(AHY).
do_sort(List, Compare, List_length) ->
case List_length < 2 of
true ->
List;
false ->
Split_length = List_length div 2,
A_list = take(List, Split_length),
B_list = drop(List, Split_length),
merge_sort(
do_sort(A_list, Compare, Split_length),
do_sort(B_list, Compare, List_length - Split_length),
Compare
)
end.
-spec sort(list(AIB), fun((AIB, AIB) -> gleam@order:order())) -> list(AIB).
sort(List, Compare) ->
do_sort(List, Compare, erlang:length(List)).
-spec range(integer(), integer()) -> list(integer()).
range(Start, Stop) ->
case gleam@int:compare(Start, Stop) of
eq ->
[];
gt ->
[Start | range(Start - 1, Stop)];
lt ->
[Start | range(Start + 1, Stop)]
end.
-spec do_repeat(AIF, integer(), list(AIF)) -> list(AIF).
do_repeat(A, Times, Acc) ->
case Times =< 0 of
true ->
Acc;
false ->
do_repeat(A, Times - 1, [A | Acc])
end.
-spec repeat(AII, integer()) -> list(AII).
repeat(A, Times) ->
do_repeat(A, Times, []).
-spec do_split(list(AIK), integer(), list(AIK)) -> {list(AIK), list(AIK)}.
do_split(List, N, Taken) ->
case N =< 0 of
true ->
{lists:reverse(Taken), List};
false ->
case List of
[] ->
{lists:reverse(Taken), []};
[X | Xs] ->
do_split(Xs, N - 1, [X | Taken])
end
end.
-spec split(list(AIP), integer()) -> {list(AIP), list(AIP)}.
split(List, Index) ->
do_split(List, Index, []).
-spec do_split_while(list(AIT), fun((AIT) -> boolean()), list(AIT)) -> {list(AIT),
list(AIT)}.
do_split_while(List, F, Acc) ->
case List of
[] ->
{lists:reverse(Acc), []};
[X | Xs] ->
case F(X) of
false ->
{lists:reverse(Acc), List};
_ ->
do_split_while(Xs, F, [X | Acc])
end
end.
-spec split_while(list(AIY), fun((AIY) -> boolean())) -> {list(AIY), list(AIY)}.
split_while(List, Predicate) ->
do_split_while(List, Predicate, []).
-spec key_find(list({AJC, AJD}), AJC) -> {ok, AJD} | {error, nil}.
key_find(Keyword_list, Desired_key) ->
find_map(Keyword_list, fun(Keyword) -> {Key, Value} = Keyword,
case Key =:= Desired_key of
true ->
{ok, Value};
false ->
{error, nil}
end end).
-spec do_pop(list(AJL), fun((AJL) -> boolean()), list(AJL)) -> {ok,
{AJL, list(AJL)}} |
{error, nil}.
do_pop(Haystack, Predicate, Checked) ->
case Haystack of
[] ->
{error, nil};
[X | Rest] ->
case Predicate(X) of
true ->
{ok, {X, lists:append(lists:reverse(Checked), Rest)}};
false ->
do_pop(Rest, Predicate, [X | Checked])
end
end.
-spec pop(list(AJL), fun((AJL) -> boolean())) -> {ok, {AJL, list(AJL)}} |
{error, nil}.
pop(Haystack, Is_desired) ->
do_pop(Haystack, Is_desired, []).
-spec do_pop_map(list(AJU), fun((AJU) -> {ok, AJW} | {error, any()}), list(AJU)) -> {ok,
{AJW,
list(AJU)}} |
{error, nil}.
do_pop_map(Haystack, Mapper, Checked) ->
case Haystack of
[] ->
{error, nil};
[X | Rest] ->
case Mapper(X) of
{ok, Y} ->
{ok, {Y, lists:append(lists:reverse(Checked), Rest)}};
{error, _} ->
do_pop_map(Rest, Mapper, [X | Checked])
end
end.
-spec pop_map(list(AJU), fun((AJU) -> {ok, AJW} | {error, any()})) -> {ok,
{AJW,
list(AJU)}} |
{error, nil}.
pop_map(Haystack, Is_desired) ->
do_pop_map(Haystack, Is_desired, []).
-spec key_pop(list({AKD, AKE}), AKD) -> {ok, {AKE, list({AKD, AKE})}} |
{error, nil}.
key_pop(Haystack, Key) ->
pop_map(Haystack, fun(Entry) -> {K, V} = Entry,
case K of
K@1 when K@1 =:= Key ->
{ok, V};
_ ->
{error, nil}
end end).
-spec key_set(list({AKJ, AKK}), AKJ, AKK) -> list({AKJ, AKK}).
key_set(List, Key, Value) ->
case List of
[] ->
[{Key, Value}];
[{K, _} | Rest] when K =:= Key ->
[{Key, Value} | Rest];
[First | Rest@1] ->
[First | key_set(Rest@1, Key, Value)]
end.
-spec each(list(AKN), fun((AKN) -> any())) -> nil.
each(List, F) ->
case List of
[] ->
nil;
[X | Xs] ->
F(X),
each(Xs, F)
end.
-spec do_partition(list(AKV), fun((AKV) -> boolean()), list(AKV), list(AKV)) -> {list(AKV),
list(AKV)}.
do_partition(List, Categorise, Trues, Falses) ->
case List of
[] ->
{lists:reverse(Trues), lists:reverse(Falses)};
[X | Xs] ->
case Categorise(X) of
true ->
do_partition(Xs, Categorise, [X | Trues], Falses);
false ->
do_partition(Xs, Categorise, Trues, [X | Falses])
end
end.
-spec partition(list(AKV), fun((AKV) -> boolean())) -> {list(AKV), list(AKV)}.
partition(List, Categorise) ->
do_partition(List, Categorise, [], []).
-spec permutations(list(AKZ)) -> list(list(AKZ)).
permutations(L) ->
case L of
[] ->
[[]];
_ ->
flatten(
map(
L,
fun(X) ->
map(
permutations(filter(L, fun(Y) -> Y /= X end)),
fun(Gleam@capture_variable) ->
lists:append([X], Gleam@capture_variable)
end
)
end
)
)
end.
-spec do_window(list(list(ALD)), list(ALD), integer()) -> list(list(ALD)).
do_window(Acc, L, N) ->
Window = take(L, N),
case erlang:length(Window) =:= N of
true ->
do_window([Window | Acc], drop(L, 1), N);
false ->
Acc
end.
-spec window(list(ALJ), integer()) -> list(list(ALJ)).
window(L, N) ->
lists:reverse(do_window([], L, N)).
-spec window_by_2(list(ALN)) -> list({ALN, ALN}).
window_by_2(L) ->
zip(L, drop(L, 1)).
-spec drop_while(list(ALQ), fun((ALQ) -> boolean())) -> list(ALQ).
drop_while(List, Predicate) ->
case List of
[] ->
[];
[X | Xs] ->
case Predicate(X) of
true ->
drop_while(Xs, Predicate);
false ->
[X | Xs]
end
end.
-spec do_take_while(list(ALT), fun((ALT) -> boolean()), list(ALT)) -> list(ALT).
do_take_while(List, Predicate, Acc) ->
case List of
[] ->
lists:reverse(Acc);
[Head | Tail] ->
case Predicate(Head) of
true ->
do_take_while(Tail, Predicate, [Head | Acc]);
false ->
lists:reverse(Acc)
end
end.
-spec take_while(list(ALX), fun((ALX) -> boolean())) -> list(ALX).
take_while(List, Predicate) ->
do_take_while(List, Predicate, []).