查看源码 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 而崩溃。
从 List1 中删除 Elem 元素，只要 Pred(Elem) 返回 true，并返回剩余的列表。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 的副本，其中删除了第一个 Nth 元素与 Key 比较相等的元组（如果存在这样的元组）。
在元组列表 TupleList 中搜索 Nth 元素与 Key 比较相等的元组。如果找到这样的元组，则返回 Tuple，否则返回 false。
返回一个元组列表，其中，对于 TupleList1 中的每个元组，元组的第 N 个元素 Term1 已被调用 Fun(Term1) 的结果替换。
如果 TupleList 中存在一个元组，其第 N 个元素与 Key 比较相等，则返回 true，否则返回 false。
返回通过合并 TupleList1 和 TupleList2 形成的已排序列表。
返回 TupleList1 的副本，其中，如果存在这样的元组 T，则第一个 Nth 元素与 Key 比较相等的 T 元组将被 NewTuple 替换。
在元组列表 TupleList 中搜索第 N 个元素与 Key 比较相等的元组。如果找到这样的元组，则返回 {value, Tuple}，否则返回 false。
返回一个包含列表 TupleList1 的已排序元素的列表。排序是在元组的第 N 个元素上执行的。排序是稳定的。
返回 TupleList1 的副本，其中第一个 Nth 元素与 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 的行为就像它被定义为如下
返回 List1 的子列表，该子列表从位置 1 开始，最多包含 Len 个元素。如果 Len 超过列表的长度，则不会报错，在这种情况下，将返回整个列表。
返回 List1 的子列表，该子列表从 Start 开始，最多包含 Len 个元素。如果 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 的排序元素，并且已删除比较相等的元素中除第一个元素外的所有元素。
返回一个列表，其中包含根据排序函数 Fun 排序的 List1 的元素，并且已删除比较相等的元素中除第一个元素外的所有元素。如果 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().
从 List1 中删除 Elem 元素，只要 Pred(Elem) 返回 true，并返回剩余的列表。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 的副本，其中删除了第一个 Nth 元素与 Key 比较相等的元组（如果存在这样的元组）。
-spec keyfind(Key, N, TupleList) -> Tuple | false when Key :: term(), N :: pos_integer(), TupleList :: [Tuple], Tuple :: tuple().
在元组列表 TupleList 中搜索 Nth 元素与 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 的副本，其中，如果存在这样的元组 T，则第一个 Nth 元素与 Key 比较相等的 T 元组将被 NewTuple 替换。
-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 的副本，其中第一个 Nth 元素与 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().
将 map/2 和 foldl/3 的操作组合到一个过程中。
示例
求一个列表中元素的总和，同时将它们翻倍
> 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 进行排序。
Fun(A, B) 在排序中，如果 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().
返回 List1 的子列表，该子列表从位置 1 开始，最多包含 Len 个元素。如果 Len 超过列表的长度，则不会报错，在这种情况下，将返回整个列表。
-spec sublist(List1, Start, Len) -> List2 when List1 :: [T], List2 :: [T], Start :: pos_integer(), Len :: non_neg_integer(), T :: term().
返回 List1 的子列表，该子列表从 Start 开始，最多包含 Len 个元素。如果 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 进行排序，且不包含重复项。
Fun(A, B) 在排序中，如果 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().
返回一个列表，其中包含根据排序函数 Fun 排序的 List1 的元素，并且已删除比较相等的元素中除第一个元素外的所有元素。如果 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]