檢視原始碼 lists (stdlib v6.2)
列表處理函數。
這個模組包含列表處理的函數。
除非另有說明，所有函數都假設位置編號從 1 開始。也就是說，列表的第一個元素位於位置 1。
如果 T1 == T2 的求值結果為 true，則兩個項 T1 和 T2 比較相等。如果 T1 =:= T2 的求值結果為 true，則它們匹配。
每當期望一個排序函數 F 作為參數時，假設對於所有 x、y 和 z，F 具有以下屬性：
- 如果 x
Fy 且 yFx，則 x = y（F是反對稱的）。 - 如果 x
Fy 且 yFz，則 xFz（F是遞移的）。 - x
Fy 或 yFx（F是完全的）。
一個典型的排序函數範例是小於或等於：=</2。
摘要
函數
如果 List 中所有元素 Elem 的 Pred(Elem) 都返回 true，則返回 true，否則返回 false。Pred 函數必須返回布林值。
如果 List 中至少有一個元素 Elem 的 Pred(Elem) 返回 true，則返回 true。Pred 函數必須返回布林值。
返回一個列表，其中 ListOfLists 的所有子列表都已附加。
返回一個新的列表 List3，它由 List1 的元素後接 List2 的元素組成。
連接 Things 的元素的文字表示形式。Things 的元素可以是原子、整數、浮點數或字串。
返回 List1 的副本，其中刪除第一個與 Elem 匹配的元素（如果存在此類元素）。
刪除 List 的最後一個元素。列表不得為空，否則函數會因 function_clause 而崩潰。
當 Pred(Elem) 返回 true 時，從 List1 中刪除元素 Elem，並返回剩餘的列表。Pred 函數必須返回布林值。
返回一個包含 N 個項 Elem 副本的列表。
返回 List1，其中每個元素 H 都被一個形式為 {I, H} 的元組取代，其中 I 是 H 在 List1 中的位置。枚舉從 Index 開始，並且在每個步驟中增加 Step。
List2 是 List1 中所有 Pred(Elem) 返回 true 的元素 Elem 的列表。Pred 函數必須返回布林值。
依序在 List1 的連續元素 Elem 上呼叫 Fun(Elem)，以更新或從 List1 中移除元素。
等同於 length(flatten(DeepList))，但效率更高。
接收一個從 A 到 B 列表的函數，以及一個 A 的列表 (List1)，並透過將該函數應用於 List1 中的每個元素並附加結果列表來產生 B 的列表。
返回 DeepList 的扁平化版本。
返回 DeepList 的扁平化版本，並附加尾部 Tail。
在 List 的連續元素 A 上呼叫 Fun(Elem, AccIn)，從 AccIn == Acc0 開始。Fun/2 必須返回一個新的累加器，該累加器會傳遞到下一個呼叫。函數返回累加器的最終值。如果列表為空，則返回 Acc0。
與 foldl/3 類似，但列表從右向左遍歷。
針對 List 中的每個元素 Elem 呼叫 Fun(Elem)。此函數用於其副作用，並且評估順序定義為與列表中元素的順序相同。
在 List1 中的每個元素之間插入 Sep。對空列表和單例列表沒有影響。例如
返回 TupleList1 的副本，其中刪除第一個第 N 個元素與 Key 比較相等的元組（如果存在此類元組）。
在元組列表 TupleList 中搜尋第 N 個元素與 Key 比較相等的元組。如果找到此類元組，則返回 Tuple，否則返回 false。
返回一個元組列表，其中，對於 TupleList1 中的每個元組，元組的第 N 個元素 Term1 已被呼叫 Fun(Term1) 的結果取代。
如果 TupleList 中存在第 N 個元素與 Key 比較相等的元組，則返回 true，否則返回 false。
返回通過合併 TupleList1 和 TupleList2 形成的已排序列表。
返回 TupleList1 的副本，其中第一個第 N 個元素與 Key 比較相等的 T 元組被 NewTuple 取代（如果存在此類元組 T）。
在元組列表 TupleList 中搜尋第 N 個元素與 Key 比較相等的元組。如果找到此類元組，則返回 {value, Tuple}，否則返回 false。
返回一個包含列表 TupleList1 的已排序元素的列表。排序是在元組的第 N 個元素上執行的。排序是穩定的。
返回 TupleList1 的副本，其中第一個第 N 個元素與 Key 比較相等的元組 T 被 NewTuple 取代（如果存在此類元組 T）。如果不存在此類元組 T，則返回 TupleList1 的副本，其中 [NewTuple] 已附加到末尾。
在元組列表 TupleList1 中搜尋第 N 個元素與 Key 比較相等的元組。如果找到此類元組，則返回 {value, Tuple, TupleList2}，否則返回 false。TupleList2 是 TupleList1 的副本，其中已刪除 Tuple 的第一個出現位置。
返回 List 中的最後一個元素。
接收一個從 A 到 B 的函數，以及一個 A 的列表，並通過將該函數應用於列表中的每個元素來產生一個 B 的列表。此函數用於獲取回傳值。評估順序取決於實作。
返回 List 中大於或等於 List 中所有其他元素的第一個元素。
如果 Elem 與 List 的某些元素匹配，則返回 true，否則返回 false。
返回通過合併 List1、List2 和 List3 形成的已排序列表。在評估此函數之前，List1、List2 和 List3 都必須已排序。
返回通過合併 ListOfLists 的所有子列表形成的已排序列表。在評估此函數之前，所有子列表都必須已排序。
傳回合併 List1 和 List2 所形成的已排序列表。在評估此函數之前，List1 和 List2 都必須先排序。
傳回合併 List1 和 List2 所形成的已排序列表。在評估此函數之前，List1 和 List2 都必須根據排序函數 Fun 進行排序。
傳回 List 中，與 List 的所有其他元素相比，小於或等於所有其他元素的第一個元素。
傳回 List 的第 N 個元素。
傳回 List 的第 N 個尾部，也就是從 N+1 開始，直到列表結尾的 List 子列表。
將 List 分割成兩個列表，第一個列表包含 Pred(Elem) 返回 true 的所有元素，第二個列表包含 Pred(Elem) 返回 false 的所有元素。
如果 List1 是 List2 的前綴，則傳回 true，否則傳回 false。
傳回一個列表，其中包含 List1 中反向順序的元素。
傳回一個列表，其中包含 List1 中反向順序的元素，並附加尾部 Tail。
如果 List 中存在一個 Value，使得 Pred(Value) 傳回 true，則傳回第一個此類 Value 的 {value, Value}，否則傳回 false。Pred 函數必須傳回布林值。
傳回一個整數序列，該序列從 From 開始，並包含將 Incr 加到前一個元素的連續結果，直到達到或超過 To 為止（在後一種情況下，To 不是序列的元素）。 Incr 預設為 1。
傳回一個包含 List1 已排序元素的列表。
傳回一個包含根據排序函數 Fun 排序的 List1 元素的列表。如果 A 在排序中小於或等於 B，則 Fun(A, B) 應返回 true，否則應返回 false。
將 List1 分割成 List2 和 List3。List2 包含前 N 個元素，而 List3 包含剩餘的元素（第 N 個尾部）。
根據 Pred 將 List 分割成兩個列表。splitwith/2 的行為如同以下定義
傳回從位置 1 開始且最多包含 Len 個元素的 List1 子列表。 如果 Len 超出列表的長度，則不會發生錯誤，在這種情況下，會傳回整個列表。
傳回從 Start 開始且最多包含 Len 個元素的 List1 子列表。如果 Start+Len 超出列表的長度，則不會發生錯誤。
傳回一個新的列表 List3，它是 List1 的副本，並經過以下程序處理：對於 List2 中的每個元素，刪除它在 List1 中的第一次出現。
如果 List1 是 List2 的後綴，則傳回 true，否則傳回 false。
傳回 List 中元素的總和。
從 List1 中取出元素 Elem，只要 Pred(Elem) 傳回 true，也就是說，該函數傳回列表中所有元素都滿足謂詞的最長前綴。Pred 函數必須傳回布林值。
傳回合併 TupleList1 和 TupleList2 所形成的已排序列表。合併會在每個元組的第 N 個元素上執行。在評估此函數之前，TupleList1 和 TupleList2 都必須先按鍵排序，且不含重複項。
傳回一個包含列表 TupleList1 已排序元素的列表，其中除了比較相等的元組中的第一個元組外，其他元組都已被刪除。排序會在元組的第 N 個元素上執行。
傳回合併 List1、List2 和 List3 所形成的已排序列表。在評估此函數之前，List1、List2 和 List3 都必須先排序，且不含重複項。
傳回合併 ListOfLists 的所有子列表所形成的已排序列表。在評估此函數之前，所有子列表都必須先排序，且不含重複項。
傳回合併 List1 和 List2 所形成的已排序列表。在評估此函數之前，List1 和 List2 都必須先排序，且不含重複項。
傳回合併 List1 和 List2 所形成的已排序列表。在評估此函數之前，List1 和 List2 都必須根據排序函數 Fun 進行排序，且不含重複項。
傳回一個包含 List1 元素的列表，其中已刪除重複元素（保留元素的順序）。保留每個元素的第一次出現。
傳回一個列表，其中包含 List1 的元素，但不包含 Fun 返回重複值的元素（保留元素的順序）。保留每個元素的第一次出現。
將三元組列表「解壓縮」成三個列表，其中第一個列表包含每個元組的第一個元素，第二個列表包含每個元組的第二個元素，第三個列表包含每個元組的第三個元素。
將二元組列表「解壓縮」成兩個列表，其中第一個列表包含每個元組的第一個元素，第二個列表包含每個元組的第二個元素。
傳回一個包含 List1 已排序元素的列表，其中已刪除除了比較相等的元素中的第一個元素之外的所有元素。
傳回一個包含 List1 已排序元素的列表，其中已刪除根據排序函數 Fun 比較相等的元素中的第一個元素之外的所有元素。如果 A 在排序中小於或等於 B，則 Fun(A, B) 應返回 true，否則應返回 false。
將三個列表「壓縮」成一個三元組列表，其中每個元組的第一個元素取自第一個列表，第二個元素取自第二個列表中對應的元素，第三個元素取自第三個列表中對應的元素。
將兩個列表「壓縮」成一個二元組列表，其中每個元組的第一個元素取自第一個列表，第二個元素取自第二個列表中對應的元素。
將三個列表的元素組合成一個列表。對於來自三個列表的每個三元組 X、Y、Z 的列表元素，結果列表中的元素為 Combine(X, Y, Z)。
將兩個列表的元素組合成一個列表。對於來自兩個列表的每個配對 X、Y 的列表元素，結果列表中的元素為 Combine(X, Y)。
函數
-spec all(Pred, List) -> boolean() when Pred :: fun((Elem :: T) -> boolean()), List :: [T], T :: term().
如果 List 中所有元素 Elem 的 Pred(Elem) 都返回 true，則返回 true，否則返回 false。Pred 函數必須返回布林值。
-spec any(Pred, List) -> boolean() when Pred :: fun((Elem :: T) -> boolean()), List :: [T], T :: term().
如果 List 中至少有一個元素 Elem 的 Pred(Elem) 返回 true，則返回 true。Pred 函數必須返回布林值。
-spec append(ListOfLists) -> List1 when ListOfLists :: [List], List :: [T], List1 :: [T], T :: term().
返回一個列表，其中 ListOfLists 的所有子列表都已附加。
範例
> lists:append([[1, 2, 3], [a, b], [4, 5, 6]]).
[1,2,3,a,b,4,5,6]-spec append(List1, List2) -> List3 when List1 :: [T], List2 :: [T], List3 :: [T], T :: term().
返回一個新的列表 List3，它由 List1 的元素後接 List2 的元素組成。
範例
> lists:append("abc", "def").
"abcdef"lists:append(A, B) 等同於 A ++ B。
-spec concat(Things) -> string() when Things :: [Thing], Thing :: atom() | integer() | float() | string().
連接 Things 的元素的文字表示形式。Things 的元素可以是原子、整數、浮點數或字串。
範例
> lists:concat([doc, '/', file, '.', 3]).
"doc/file.3"-spec delete(Elem, List1) -> List2 when Elem :: T, List1 :: [T], List2 :: [T], T :: term().
返回 List1 的副本，其中刪除第一個與 Elem 匹配的元素（如果存在此類元素）。
-spec droplast(List) -> InitList when List :: [T, ...], InitList :: [T], T :: term().
刪除 List 的最後一個元素。列表不得為空，否則函數會因 function_clause 而崩潰。
-spec dropwhile(Pred, List1) -> List2 when Pred :: fun((Elem :: T) -> boolean()), List1 :: [T], List2 :: [T], T :: term().
當 Pred(Elem) 返回 true 時，從 List1 中刪除元素 Elem，並返回剩餘的列表。Pred 函數必須返回布林值。
-spec duplicate(N, Elem) -> List when N :: non_neg_integer(), Elem :: T, List :: [T], T :: term().
返回一個包含 N 個項 Elem 副本的列表。
範例
> lists:duplicate(5, xx).
[xx,xx,xx,xx,xx]-spec enumerate(Index, Step, List1) -> List2 when List1 :: [T], List2 :: [{Index, T}], Index :: integer(), Step :: integer(), T :: term().
返回 List1，其中每個元素 H 都被一個形式為 {I, H} 的元組取代，其中 I 是 H 在 List1 中的位置。枚舉從 Index 開始，並且在每個步驟中增加 Step。
也就是說，enumerate/3 的行為如同以下定義
enumerate(I, S, List) ->
{List1, _ } = lists:mapfoldl(fun(T, Acc) -> {{Acc, T}, Acc+S} end, I, List),
List1.Index 和 Step 的預設值皆為 1。
範例
> lists:enumerate([a,b,c]).
[{1,a},{2,b},{3,c}]> lists:enumerate(10, [a,b,c]).
[{10,a},{11,b},{12,c}]> lists:enumerate(0, -2, [a,b,c]).
[{0,a},{-2,b},{-4,c}]-spec filter(Pred, List1) -> List2 when Pred :: fun((Elem :: T) -> boolean()), List1 :: [T], List2 :: [T], T :: term().
List2 是 List1 中所有 Pred(Elem) 返回 true 的元素 Elem 的列表。Pred 函數必須返回布林值。
-spec filtermap(Fun, List1) -> List2 when Fun :: fun((Elem) -> boolean() | {true, Value}), List1 :: [Elem], List2 :: [Elem | Value], Elem :: term(), Value :: term().
依序在 List1 的連續元素 Elem 上呼叫 Fun(Elem)，以更新或從 List1 中移除元素。
Fun/1 必須回傳布林值或元組 {true, Value}。此函數會回傳 Fun 回傳新值的元素列表，其中 true 值等同於 {true, Elem}。
也就是說，filtermap 的行為如同以下定義
filtermap(Fun, List1) ->
lists:foldr(fun(Elem, Acc) ->
case Fun(Elem) of
false -> Acc;
true -> [Elem|Acc];
{true,Value} -> [Value|Acc]
end
end, [], List1).範例
> lists:filtermap(fun(X) -> case X rem 2 of 0 -> {true, X div 2}; _ -> false end end, [1,2,3,4,5]).
[1,2]-spec flatlength(DeepList) -> non_neg_integer() when DeepList :: [term() | DeepList].
等同於 length(flatten(DeepList))，但效率更高。
-spec flatmap(Fun, List1) -> List2 when Fun :: fun((A) -> [B]), List1 :: [A], List2 :: [B], A :: term(), B :: term().
接收一個從 A 到 B 列表的函數，以及一個 A 的列表 (List1)，並透過將該函數應用於 List1 中的每個元素並附加結果列表來產生 B 的列表。
也就是說，flatmap 的行為如同以下定義
flatmap(Fun, List1) ->
append(map(Fun, List1)).範例
> lists:flatmap(fun(X)->[X,X] end, [a,b,c]).
[a,a,b,b,c,c]返回 DeepList 的扁平化版本。
-spec flatten(DeepList, Tail) -> List when DeepList :: [term() | DeepList], Tail :: [term()], List :: [term()].
返回 DeepList 的扁平化版本，並附加尾部 Tail。
-spec foldl(Fun, Acc0, List) -> Acc1 when Fun :: fun((Elem :: T, AccIn) -> AccOut), Acc0 :: term(), Acc1 :: term(), AccIn :: term(), AccOut :: term(), List :: [T], T :: term().
在 List 的連續元素 A 上呼叫 Fun(Elem, AccIn)，從 AccIn == Acc0 開始。Fun/2 必須返回一個新的累加器，該累加器會傳遞到下一個呼叫。函數返回累加器的最終值。如果列表為空，則返回 Acc0。
範例
> lists:foldl(fun(X, Sum) -> X + Sum end, 0, [1,2,3,4,5]).
15
> lists:foldl(fun(X, Prod) -> X * Prod end, 1, [1,2,3,4,5]).
120-spec foldr(Fun, Acc0, List) -> Acc1 when Fun :: fun((Elem :: T, AccIn) -> AccOut), Acc0 :: term(), Acc1 :: term(), AccIn :: term(), AccOut :: term(), List :: [T], T :: term().
與 foldl/3 類似，但列表從右向左遍歷。
範例
> P = fun(A, AccIn) -> io:format("~p ", [A]), AccIn end.
#Fun<erl_eval.12.2225172>
> lists:foldl(P, void, [1,2,3]).
1 2 3 void
> lists:foldr(P, void, [1,2,3]).
3 2 1 void針對 List 中的每個元素 Elem 呼叫 Fun(Elem)。此函數用於其副作用，並且評估順序定義為與列表中元素的順序相同。
-spec join(Sep, List1) -> List2 when Sep :: T, List1 :: [T], List2 :: [T], T :: term().
在 List1 中的每個元素之間插入 Sep。對空列表和單例列表沒有影響。例如
> lists:join(x, [a,b,c]).
[a,x,b,x,c]
> lists:join(x, [a]).
[a]
> lists:join(x, []).
[]-spec keydelete(Key, N, TupleList1) -> TupleList2 when Key :: term(), N :: pos_integer(), TupleList1 :: [Tuple], TupleList2 :: [Tuple], Tuple :: tuple().
返回 TupleList1 的副本，其中刪除第一個第 N 個元素與 Key 比較相等的元組（如果存在此類元組）。
-spec keyfind(Key, N, TupleList) -> Tuple | false when Key :: term(), N :: pos_integer(), TupleList :: [Tuple], Tuple :: tuple().
在元組列表 TupleList 中搜尋第 N 個元素與 Key 比較相等的元組。如果找到此類元組，則返回 Tuple，否則返回 false。
-spec keymap(Fun, N, TupleList1) -> TupleList2 when Fun :: fun((Term1 :: term()) -> Term2 :: term()), N :: pos_integer(), TupleList1 :: [Tuple], TupleList2 :: [Tuple], Tuple :: tuple().
返回一個元組列表，其中，對於 TupleList1 中的每個元組，元組的第 N 個元素 Term1 已被呼叫 Fun(Term1) 的結果取代。
範例
> Fun = fun(Atom) -> atom_to_list(Atom) end.
#Fun<erl_eval.6.10732646>
2> lists:keymap(Fun, 2, [{name,jane,22},{name,lizzie,20},{name,lydia,15}]).
[{name,"jane",22},{name,"lizzie",20},{name,"lydia",15}]-spec keymember(Key, N, TupleList) -> boolean() when Key :: term(), N :: pos_integer(), TupleList :: [Tuple], Tuple :: tuple().
如果 TupleList 中存在第 N 個元素與 Key 比較相等的元組，則返回 true，否則返回 false。
-spec keymerge(N, TupleList1, TupleList2) -> TupleList3 when N :: pos_integer(), TupleList1 :: [T1], TupleList2 :: [T2], TupleList3 :: [T1 | T2], T1 :: Tuple, T2 :: Tuple, Tuple :: tuple().
返回通過合併 TupleList1 和 TupleList2 形成的已排序列表。
合併操作會在每個元組的第 N 個元素上執行。TupleList1 和 TupleList2 在評估此函數前都必須先依鍵排序。當兩個元組比較相等時，會優先選取 TupleList1 中的元組，再選取 TupleList2 中的元組。
-spec keyreplace(Key, N, TupleList1, NewTuple) -> TupleList2 when Key :: term(), N :: pos_integer(), TupleList1 :: [Tuple], TupleList2 :: [Tuple], NewTuple :: Tuple, Tuple :: tuple().
返回 TupleList1 的副本，其中第一個第 N 個元素與 Key 比較相等的 T 元組被 NewTuple 取代（如果存在此類元組 T）。
-spec keysearch(Key, N, TupleList) -> {value, Tuple} | false when Key :: term(), N :: pos_integer(), TupleList :: [Tuple], Tuple :: tuple().
在元組列表 TupleList 中搜尋第 N 個元素與 Key 比較相等的元組。如果找到此類元組，則返回 {value, Tuple}，否則返回 false。
注意
此函數保留以確保向後相容性。函數
keyfind/3通常更方便。
-spec keysort(N, TupleList1) -> TupleList2 when N :: pos_integer(), TupleList1 :: [Tuple], TupleList2 :: [Tuple], Tuple :: tuple().
返回一個包含列表 TupleList1 的已排序元素的列表。排序是在元組的第 N 個元素上執行的。排序是穩定的。
-spec keystore(Key, N, TupleList1, NewTuple) -> TupleList2 when Key :: term(), N :: pos_integer(), TupleList1 :: [Tuple], TupleList2 :: [Tuple, ...], NewTuple :: Tuple, Tuple :: tuple().
返回 TupleList1 的副本，其中第一個第 N 個元素與 Key 比較相等的元組 T 被 NewTuple 取代（如果存在此類元組 T）。如果不存在此類元組 T，則返回 TupleList1 的副本，其中 [NewTuple] 已附加到末尾。
-spec keytake(Key, N, TupleList1) -> {value, Tuple, TupleList2} | false when Key :: term(), N :: pos_integer(), TupleList1 :: [tuple()], TupleList2 :: [tuple()], Tuple :: tuple().
在元組列表 TupleList1 中搜尋第 N 個元素與 Key 比較相等的元組。如果找到此類元組，則返回 {value, Tuple, TupleList2}，否則返回 false。TupleList2 是 TupleList1 的副本，其中已刪除 Tuple 的第一個出現位置。
-spec last(List) -> Last when List :: [T, ...], Last :: T, T :: term().
返回 List 中的最後一個元素。
-spec map(Fun, List1) -> List2 when Fun :: fun((A) -> B), List1 :: [A], List2 :: [B], A :: term(), B :: term().
接收一個從 A 到 B 的函數，以及一個 A 的列表，並通過將該函數應用於列表中的每個元素來產生一個 B 的列表。此函數用於獲取回傳值。評估順序取決於實作。
-spec mapfoldl(Fun, Acc0, List1) -> {List2, Acc1} when Fun :: fun((A, AccIn) -> {B, AccOut}), Acc0 :: term(), Acc1 :: term(), AccIn :: term(), AccOut :: term(), List1 :: [A], List2 :: [B], A :: term(), B :: term().
範例
同時對列表中的元素求和並將其加倍
> lists:mapfoldl(fun(X, Sum) -> {2*X, X+Sum} end,
0, [1,2,3,4,5]).
{[2,4,6,8,10],15}-spec max(List) -> Max when List :: [T, ...], Max :: T, T :: term().
返回 List 中大於或等於 List 中所有其他元素的第一個元素。
如果 Elem 與 List 的某些元素匹配，則返回 true，否則返回 false。
-spec merge3(List1, List2, List3) -> List4 when List1 :: [X], List2 :: [Y], List3 :: [Z], List4 :: [X | Y | Z], X :: term(), Y :: term(), Z :: term().
返回通過合併 List1、List2 和 List3 形成的已排序列表。在評估此函數之前，List1、List2 和 List3 都必須已排序。
當兩個元素比較相等時，如果 List1 中有此元素，則會優先選取該元素，否則會優先選取 List2 中的元素，再選取 List3 中的元素。
-spec merge(ListOfLists) -> List1 when ListOfLists :: [List], List :: [T], List1 :: [T], T :: term().
返回通過合併 ListOfLists 的所有子列表形成的已排序列表。在評估此函數之前，所有子列表都必須已排序。
當兩個元素比較相等時，會優先選取 ListOfLists 中位置最低的子列表中的元素。
-spec merge(List1, List2) -> List3 when List1 :: [X], List2 :: [Y], List3 :: [X | Y], X :: term(), Y :: term().
傳回合併 List1 和 List2 所形成的已排序列表。在評估此函數之前，List1 和 List2 都必須先排序。
當兩個元素比較相等時，會優先選取 List1 中的元素，再選取 List2 中的元素。
-spec merge(Fun, List1, List2) -> List3 when Fun :: fun((A, B) -> boolean()), List1 :: [A], List2 :: [B], List3 :: [A | B], A :: term(), B :: term().
傳回合併 List1 和 List2 所形成的已排序列表。在評估此函數之前，List1 和 List2 都必須根據排序函數 Fun 進行排序。
如果 A 在排序中比較小於或等於 B，則 Fun(A, B) 應回傳 true，否則回傳 false。當兩個元素比較相等時，會優先選取 List1 中的元素，再選取 List2 中的元素。
-spec min(List) -> Min when List :: [T, ...], Min :: T, T :: term().
傳回 List 中，與 List 的所有其他元素相比，小於或等於所有其他元素的第一個元素。
-spec nth(N, List) -> Elem when N :: pos_integer(), List :: [T, ...], Elem :: T, T :: term().
傳回 List 的第 N 個元素。
範例
> lists:nth(3, [a, b, c, d, e]).
c-spec nthtail(N, List) -> Tail when N :: non_neg_integer(), List :: [T, ...], Tail :: [T], T :: term().
傳回 List 的第 N 個尾部，也就是從 N+1 開始，直到列表結尾的 List 子列表。
範例
> lists:nthtail(3, [a, b, c, d, e]).
[d,e]
> tl(tl(tl([a, b, c, d, e]))).
[d,e]
> lists:nthtail(0, [a, b, c, d, e]).
[a,b,c,d,e]
> lists:nthtail(5, [a, b, c, d, e]).
[]-spec partition(Pred, List) -> {Satisfying, NotSatisfying} when Pred :: fun((Elem :: T) -> boolean()), List :: [T], Satisfying :: [T], NotSatisfying :: [T], T :: term().
將 List 分割成兩個列表，第一個列表包含 Pred(Elem) 返回 true 的所有元素，第二個列表包含 Pred(Elem) 返回 false 的所有元素。
範例
> lists:partition(fun(A) -> A rem 2 == 1 end, [1,2,3,4,5,6,7]).
{[1,3,5,7],[2,4,6]}
> lists:partition(fun(A) -> is_atom(A) end, [a,b,1,c,d,2,3,4,e]).
{[a,b,c,d,e],[1,2,3,4]}如需以不同方式分割列表，請參閱 splitwith/2。
如果 List1 是 List2 的前綴，則傳回 true，否則傳回 false。
-spec reverse(List1) -> List2 when List1 :: [T], List2 :: [T], T :: term().
傳回一個列表，其中包含 List1 中反向順序的元素。
傳回一個列表，其中包含 List1 中反向順序的元素，並附加尾部 Tail。
範例
> lists:reverse([1, 2, 3, 4], [a, b, c]).
[4,3,2,1,a,b,c]-spec search(Pred, List) -> {value, Value} | false when Pred :: fun((T) -> boolean()), List :: [T], Value :: T.
如果 List 中存在一個 Value，使得 Pred(Value) 傳回 true，則傳回第一個此類 Value 的 {value, Value}，否則傳回 false。Pred 函數必須傳回布林值。
等同於 seq(From, To, 1)。
-spec seq(From, To, Incr) -> Seq when From :: integer(), To :: integer(), Incr :: integer(), Seq :: [integer()].
傳回一個整數序列，該序列從 From 開始，並包含將 Incr 加到前一個元素的連續結果，直到達到或超過 To 為止（在後一種情況下，To 不是序列的元素）。 Incr 預設為 1。
失敗情況
- 如果
To < From - Incr且Incr > 0。 - 如果
To > From - Incr且Incr < 0。 - 如果
Incr =:= 0且From =/= To。
以下等式適用於所有序列
length(lists:seq(From, To)) =:= To - From + 1
length(lists:seq(From, To, Incr)) =:= (To - From + Incr) div Incr範例
> lists:seq(1, 10).
[1,2,3,4,5,6,7,8,9,10]
> lists:seq(1, 20, 3).
[1,4,7,10,13,16,19]
> lists:seq(1, 0, 1).
[]
> lists:seq(10, 6, 4).
[]
> lists:seq(1, 1, 0).
[1]-spec sort(List1) -> List2 when List1 :: [T], List2 :: [T], T :: term().
傳回一個包含 List1 已排序元素的列表。
-spec sort(Fun, List1) -> List2 when Fun :: fun((A :: T, B :: T) -> boolean()), List1 :: [T], List2 :: [T], T :: term().
傳回一個包含根據排序函數 Fun 排序的 List1 元素的列表。如果 A 在排序中小於或等於 B，則 Fun(A, B) 應返回 true，否則應返回 false。
-spec split(N, List1) -> {List2, List3} when N :: non_neg_integer(), List1 :: [T], List2 :: [T], List3 :: [T], T :: term().
將 List1 分割成 List2 和 List3。List2 包含前 N 個元素，而 List3 包含剩餘的元素（第 N 個尾部）。
-spec splitwith(Pred, List) -> {List1, List2} when Pred :: fun((T) -> boolean()), List :: [T], List1 :: [T], List2 :: [T], T :: term().
根據 Pred 將 List 分割成兩個列表。splitwith/2 的行為如同以下定義
splitwith(Pred, List) ->
{takewhile(Pred, List), dropwhile(Pred, List)}.範例
> lists:splitwith(fun(A) -> A rem 2 == 1 end, [1,2,3,4,5,6,7]).
{[1],[2,3,4,5,6,7]}
> lists:splitwith(fun(A) -> is_atom(A) end, [a,b,1,c,d,2,3,4,e]).
{[a,b],[1,c,d,2,3,4,e]}Pred 函數必須回傳布林值。如需以不同方式分割列表，請參閱 partition/2。
-spec sublist(List1, Len) -> List2 when List1 :: [T], List2 :: [T], Len :: non_neg_integer(), T :: term().
傳回從位置 1 開始且最多包含 Len 個元素的 List1 子列表。 如果 Len 超出列表的長度，則不會發生錯誤，在這種情況下，會傳回整個列表。
-spec sublist(List1, Start, Len) -> List2 when List1 :: [T], List2 :: [T], Start :: pos_integer(), Len :: non_neg_integer(), T :: term().
傳回從 Start 開始且最多包含 Len 個元素的 List1 子列表。如果 Start+Len 超出列表的長度，則不會發生錯誤。
範例
> lists:sublist([1,2,3,4], 2, 2).
[2,3]
> lists:sublist([1,2,3,4], 2, 5).
[2,3,4]
> lists:sublist([1,2,3,4], 5, 2).
[]-spec subtract(List1, List2) -> List3 when List1 :: [T], List2 :: [T], List3 :: [T], T :: term().
傳回一個新的列表 List3，它是 List1 的副本，並經過以下程序處理：對於 List2 中的每個元素，刪除它在 List1 中的第一次出現。
範例
> lists:subtract("123212", "212").
"312".lists:subtract(A, B) 等同於 A -- B。
如果 List1 是 List2 的後綴，則傳回 true，否則傳回 false。
傳回 List 中元素的總和。
-spec takewhile(Pred, List1) -> List2 when Pred :: fun((Elem :: T) -> boolean()), List1 :: [T], List2 :: [T], T :: term().
從 List1 中取出元素 Elem，只要 Pred(Elem) 傳回 true，也就是說，該函數傳回列表中所有元素都滿足謂詞的最長前綴。Pred 函數必須傳回布林值。
-spec ukeymerge(N, TupleList1, TupleList2) -> TupleList3 when N :: pos_integer(), TupleList1 :: [T1], TupleList2 :: [T2], TupleList3 :: [T1 | T2], T1 :: Tuple, T2 :: Tuple, Tuple :: tuple().
傳回合併 TupleList1 和 TupleList2 所形成的已排序列表。合併會在每個元組的第 N 個元素上執行。在評估此函數之前，TupleList1 和 TupleList2 都必須先按鍵排序，且不含重複項。
當兩個元組比較相等時，會選取 TupleList1 中的元組，並刪除 TupleList2 中的元組。
-spec ukeysort(N, TupleList1) -> TupleList2 when N :: pos_integer(), TupleList1 :: [Tuple], TupleList2 :: [Tuple], Tuple :: tuple().
傳回一個包含列表 TupleList1 已排序元素的列表，其中除了比較相等的元組中的第一個元組外，其他元組都已被刪除。排序會在元組的第 N 個元素上執行。
-spec umerge3(List1, List2, List3) -> List4 when List1 :: [X], List2 :: [Y], List3 :: [Z], List4 :: [X | Y | Z], X :: term(), Y :: term(), Z :: term().
傳回合併 List1、List2 和 List3 所形成的已排序列表。在評估此函數之前，List1、List2 和 List3 都必須先排序，且不含重複項。
當兩個元素比較相等時，如果 List1 中有此元素，則會選取該元素，否則會選取 List2 中的元素，並刪除另一個元素。
-spec umerge(ListOfLists) -> List1 when ListOfLists :: [List], List :: [T], List1 :: [T], T :: term().
傳回合併 ListOfLists 的所有子列表所形成的已排序列表。在評估此函數之前，所有子列表都必須先排序，且不含重複項。
當兩個元素比較相等時，會選取 ListOfLists 中位置最低的子列表中的元素，並刪除另一個元素。
-spec umerge(List1, List2) -> List3 when List1 :: [X], List2 :: [Y], List3 :: [X | Y], X :: term(), Y :: term().
傳回合併 List1 和 List2 所形成的已排序列表。在評估此函數之前，List1 和 List2 都必須先排序，且不含重複項。
當兩個元素比較相等時，會選取 List1 中的元素，並刪除 List2 中的元素。
-spec umerge(Fun, List1, List2) -> List3 when Fun :: fun((A, B) -> boolean()), List1 :: [A], List2 :: [B], List3 :: [A | B], A :: term(), B :: term().
傳回合併 List1 和 List2 所形成的已排序列表。在評估此函數之前，List1 和 List2 都必須根據排序函數 Fun 進行排序，且不含重複項。
如果 A 在排序中比較小於或等於 B，則 Fun(A, B) 應回傳 true，否則回傳 false。當兩個元素比較相等時，會選取 List1 中的元素，並刪除 List2 中的元素。
-spec uniq(List1) -> List2 when List1 :: [T], List2 :: [T], T :: term().
傳回一個包含 List1 元素的列表，其中已刪除重複元素（保留元素的順序）。保留每個元素的第一次出現。
範例
> lists:uniq([3,3,1,2,1,2,3]).
[3,1,2]
> lists:uniq([a, a, 1, b, 2, a, 3]).
[a, 1, b, 2, 3]-spec uniq(Fun, List1) -> List2 when Fun :: fun((T) -> any()), List1 :: [T], List2 :: [T], T :: term().
傳回一個列表，其中包含 List1 的元素，但不包含 Fun 返回重複值的元素（保留元素的順序）。保留每個元素的第一次出現。
範例
> lists:uniq(fun({X, _}) -> X end, [{b, 2}, {a, 1}, {c, 3}, {a, 2}]).
[{b, 2}, {a, 1}, {c, 3}]-spec unzip3(List1) -> {List2, List3, List4} when List1 :: [{A, B, C}], List2 :: [A], List3 :: [B], List4 :: [C], A :: term(), B :: term(), C :: term().
將三元組列表「解壓縮」成三個列表，其中第一個列表包含每個元組的第一個元素，第二個列表包含每個元組的第二個元素，第三個列表包含每個元組的第三個元素。
-spec unzip(List1) -> {List2, List3} when List1 :: [{A, B}], List2 :: [A], List3 :: [B], A :: term(), B :: term().
將二元組列表「解壓縮」成兩個列表，其中第一個列表包含每個元組的第一個元素，第二個列表包含每個元組的第二個元素。
-spec usort(List1) -> List2 when List1 :: [T], List2 :: [T], T :: term().
傳回一個包含 List1 已排序元素的列表，其中已刪除除了比較相等的元素中的第一個元素之外的所有元素。
-spec usort(Fun, List1) -> List2 when Fun :: fun((T, T) -> boolean()), List1 :: [T], List2 :: [T], T :: term().
傳回一個包含 List1 已排序元素的列表，其中已刪除根據排序函數 Fun 比較相等的元素中的第一個元素之外的所有元素。如果 A 在排序中小於或等於 B，則 Fun(A, B) 應返回 true，否則應返回 false。
-spec zip3(List1, List2, List3, How) -> List4 when List1 :: [A], List2 :: [B], List3 :: [C], List4 :: [{A | DefaultA, B | DefaultB, C | DefaultC}], A :: term(), B :: term(), C :: term(), How :: fail | trim | {pad, {DefaultA, DefaultB, DefaultC}}, DefaultA :: term(), DefaultB :: term(), DefaultC :: term().
將三個列表「壓縮」成一個三元組列表，其中每個元組的第一個元素取自第一個列表，第二個元素取自第二個列表中對應的元素，第三個元素取自第三個列表中對應的元素。
如需 How 參數的說明，請參閱 zip/3。
-spec zip(List1, List2, How) -> List3 when List1 :: [A], List2 :: [B], List3 :: [{A | DefaultA, B | DefaultB}], A :: term(), B :: term(), How :: fail | trim | {pad, {DefaultA, DefaultB}}, DefaultA :: term(), DefaultB :: term().
將兩個列表「壓縮」成一個二元組列表，其中每個元組的第一個元素取自第一個列表，第二個元素取自第二個列表中對應的元素。
How 參數指定當給定的列表長度不同時的行為。
fail- 如果給定的列表長度不相等，則呼叫會失敗。這是預設值。trim- 會忽略較長列表中多餘的元素。範例
> lists:zip([a, b], [1, 2, 3], trim). [{a,1},{b,2}] > lists:zip([a, b, c], [1, 2], trim). [{a,1},{b,2}]{pad, Defaults}- 會使用給定Defaults元組中的對應元素，將較短的列表填充到較長列表的長度。範例
> lists:zip([a, b], [1, 2, 3], {pad, {x, 0}}). [{a,1},{b,2},{x,3}] > lists:zip([a, b, c], [1, 2], {pad, {x, 0}}). [{a,1},{b,2},{c,0}]
-spec zipwith3(Combine, List1, List2, List3, How) -> List4 when Combine :: fun((X | DefaultX, Y | DefaultY, Z | DefaultZ) -> T), List1 :: [X], List2 :: [Y], List3 :: [Z], List4 :: [T], X :: term(), Y :: term(), Z :: term(), How :: fail | trim | {pad, {DefaultX, DefaultY, DefaultZ}}, DefaultX :: term(), DefaultY :: term(), DefaultZ :: term(), T :: term().
將三個列表的元素組合成一個列表。對於來自三個列表的每個三元組 X、Y、Z 的列表元素，結果列表中的元素為 Combine(X, Y, Z)。
如需 How 參數的說明，請參閱 zip/3。
zipwith3(fun(X, Y, Z) -> {X,Y,Z} end, List1, List2, List3) 等同於 zip3(List1, List2, List3)。
範例
> lists:zipwith3(fun(X, Y, Z) -> X+Y+Z end, [1,2,3], [4,5,6], [7,8,9]).
[12,15,18]
> lists:zipwith3(fun(X, Y, Z) -> [X,Y,Z] end, [a,b,c], [x,y,z], [1,2,3]).
[[a,x,1],[b,y,2],[c,z,3]]-spec zipwith(Combine, List1, List2, How) -> List3 when Combine :: fun((X | DefaultX, Y | DefaultY) -> T), List1 :: [X], List2 :: [Y], List3 :: [T], X :: term(), Y :: term(), How :: fail | trim | {pad, {DefaultX, DefaultY}}, DefaultX :: term(), DefaultY :: term(), T :: term().
將兩個列表的元素組合成一個列表。對於來自兩個列表的每個配對 X、Y 的列表元素，結果列表中的元素為 Combine(X, Y)。
如需 How 參數的說明，請參閱 zip/3。
zipwith(fun(X, Y) -> {X,Y} end, List1, List2) 等同於 zip(List1, List2)。
範例
> lists:zipwith(fun(X, Y) -> X+Y end, [1,2,3], [4,5,6]).
[5,7,9]