module List:sig..end
列表操作。
有些函式被標記為非尾遞迴。尾遞迴函式使用固定的堆疊空間，而非尾遞迴函式使用的堆疊空間與其列表引數的長度成正比，這對於非常長的列表來說可能會是個問題。當函式接受多個列表引數時，會顯示一個近似公式來表示堆疊使用量（以某些未指定的常數單位）。
如果您的列表長度不超過 10000 個元素，通常可以忽略上述考量。
此模組的標籤版本可以使用 StdLabels 模組中的描述方式。
type'at ='a list=
| |
[] |
| |
(::) of |
列表類型的別名。
val length : 'a list -> int返回給定列表的長度（元素數量）。
val compare_lengths : 'a list -> 'b list -> int比較兩個列表的長度。compare_lengths l1 l2 等同於 compare (length l1) (length l2)，但計算會在到達最短列表的末尾後停止。
val compare_length_with : 'a list -> int -> int比較列表的長度與整數。compare_length_with l len 等同於 compare (length l) len，但計算會在列表上最多執行 len 次迭代後停止。
val is_empty : 'a list -> boolis_empty l 為真，當且僅當 l 沒有任何元素。它等同於 compare_length_with l 0 = 0。
val cons : 'a -> 'a list -> 'a listcons x xs 等同於 x :: xs
val hd : 'a list -> 'a返回給定列表的第一個元素。
Failure 異常。val tl : 'a list -> 'a list返回給定列表，但不包含第一個元素。
Failure 異常。val nth : 'a list -> int -> 'a返回給定列表的第 n 個元素。第一個元素（列表頭部）的位置為 0。
Failure 異常。n 為負數，則引發 Invalid_argument 異常。val nth_opt : 'a list -> int -> 'a option返回給定列表的第 n 個元素。第一個元素（列表頭部）的位置為 0。如果列表太短，則返回 None。
n 為負數，則引發 Invalid_argument 異常。val rev : 'a list -> 'a list列表反轉。
val init : int -> (int -> 'a) -> 'a listinit len f 是 [f 0; f 1; ...; f (len-1)]，由左至右進行評估。
len < 0，則引發 Invalid_argument 異常。val append : 'a list -> 'a list -> 'a listappend l0 l1 將 l1 附加到 l0。與中綴運算子 @ 的功能相同。
val rev_append : 'a list -> 'a list -> 'a listrev_append l1 l2 將 l1 反轉並與 l2 連接。這等同於 (List.rev l1) @ l2。
val concat : 'a list list -> 'a list連接列表的列表。引數中的所有元素都（以相同的順序）連接在一起以產生結果。非尾遞迴（引數的長度 + 最長子列表的長度）。
val flatten : 'a list list -> 'a list與 List.concat 相同。非尾遞迴（引數的長度 + 最長子列表的長度）。
val equal : ('a -> 'a -> bool) -> 'a list -> 'a list -> boolequal eq [a1; ...; an] [b1; ..; bm] 在兩個輸入列表具有相同的長度，且對於在相同位置的每一對元素 ai、bi，我們都有 eq ai bi 時成立。
注意：即使列表長度不同，也可能會呼叫 eq 函式。如果您知道您的相等函式很耗費效能，您可能會想先檢查 List.compare_lengths。
val compare : ('a -> 'a -> int) -> 'a list -> 'a list -> intcompare cmp [a1; ...; an] [b1; ...; bm] 使用與 compare 相同的 'a -> 'a -> int 介面，對兩個輸入列表執行字典比較。
a1 小於 a2，或者它們相等（結果為 0）且 l1 小於 l2，則 a1 :: l1 小於 a2 :: l2（結果為負數）。[] 嚴格小於非空列表。注意：即使列表長度不同，也將會呼叫 cmp 函式。
val iter : ('a -> unit) -> 'a list -> unititer f [a1; ...; an] 依次將函式 f 應用於 [a1; ...; an]。它等同於 f a1; f a2; ...; f an。
val iteri : (int -> 'a -> unit) -> 'a list -> unit與 List.iter 相同，但該函式會將元素的索引（從 0 開始計算）作為第一個引數，並將元素本身作為第二個引數。
val map : ('a -> 'b) -> 'a list -> 'b listmap f [a1; ...; an] 將函式 f 應用於 a1, ..., an，並使用 f 返回的結果建構列表 [f a1; ...; f an]。
val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list與 List.map 相同，但該函式會將元素的索引（從 0 開始計算）作為第一個引數，並將元素本身作為第二個引數。
val rev_map : ('a -> 'b) -> 'a list -> 'b list
val filter_map : ('a -> 'b option) -> 'a list -> 'b listfilter_map f l 將 f 應用於 l 的每個元素，篩選掉 None 元素，並返回 Some 元素的引數列表。
val concat_map : ('a -> 'b list) -> 'a list -> 'b listconcat_map f l 給出的結果與 List.concat (List.map f l) 相同。尾遞迴。
val fold_left_map : ('acc -> 'a -> 'acc * 'b) -> 'acc -> 'a list -> 'acc * 'b listfold_left_map 是 fold_left 和 map 的組合，它將累加器透過對 f 的呼叫進行傳遞。
val fold_left : ('acc -> 'a -> 'acc) -> 'acc -> 'a list -> 'accfold_left f init [b1; ...; bn] 是 f (... (f (f init b1) b2) ...) bn。
val fold_right : ('a -> 'acc -> 'acc) -> 'a list -> 'acc -> 'accfold_right f [a1; ...; an] init 是 f a1 (f a2 (... (f an init) ...))。非尾遞迴。
val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unititer2 f [a1; ...; an] [b1; ...; bn] 依次呼叫 f a1 b1; ...; f an bn。
Invalid_argument 異常。val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c listmap2 f [a1; ...; an] [b1; ...; bn] 是 [f a1 b1; ...; f an bn]。
Invalid_argument 異常。val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val fold_left2 : ('acc -> 'a -> 'b -> 'acc) -> 'acc -> 'a list -> 'b list -> 'accfold_left2 f init [a1; ...; an] [b1; ...; bn] 是 f (... (f (f init a1 b1) a2 b2) ...) an bn。
Invalid_argument 異常。val fold_right2 : ('a -> 'b -> 'acc -> 'acc) -> 'a list -> 'b list -> 'acc -> 'accfold_right2 f [a1; ...; an] [b1; ...; bn] init 是 f a1 b1 (f a2 b2 (... (f an bn init) ...))。
Invalid_argument 異常。非尾遞迴。val for_all : ('a -> bool) -> 'a list -> boolfor_all f [a1; ...; an] 檢查列表中的所有元素是否都滿足謂詞 f。也就是說，對於非空列表，它返回 (f a1) && (f a2) && ... && (f an)；如果列表為空，則返回 true。
val exists : ('a -> bool) -> 'a list -> boolexists f [a1; ...; an] 檢查列表中是否至少有一個元素滿足謂詞 f。也就是說，對於非空列表，它返回 (f a1) || (f a2) || ... || (f an)；如果列表為空，則返回 false。
val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool與 List.for_all 相同，但適用於雙引數謂詞。
Invalid_argument 異常。val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool與 List.exists 相同，但適用於雙引數謂詞。
Invalid_argument 異常。val mem : 'a -> 'a list -> boolmem a set 為真，當且僅當 a 等於 set 的一個元素。
val memq : 'a -> 'a list -> bool與 List.mem 相同，但使用實體相等性而非結構相等性來比較列表元素。
val find : ('a -> bool) -> 'a list -> 'afind f l 返回列表中第一個滿足謂詞 f 的元素 l。
l 中沒有任何值滿足 f，則引發 Not_found 異常。val find_opt : ('a -> bool) -> 'a list -> 'a optionfind f l 返回列表中第一個滿足謂詞 f 的元素 l。如果列表 l 中沒有任何值滿足 f，則返回 None。
val find_index : ('a -> bool) -> 'a list -> int optionfind_index f xs 返回 Some i，其中 i 是列表 xs 中第一個滿足 f x 的元素的索引（如果存在此類元素）。
如果沒有此類元素，則返回 None。
val find_map : ('a -> 'b option) -> 'a list -> 'b optionfind_map f l 依序將 f 應用於 l 的元素，並回傳第一個形式為 Some v 的結果，如果不存在則回傳 None。
val find_mapi : (int -> 'a -> 'b option) -> 'a list -> 'b option與 find_map 相同，但謂詞會將元素的索引 (從 0 開始計數) 作為第一個參數，元素本身作為第二個參數。
val filter : ('a -> bool) -> 'a list -> 'a listfilter f l 回傳列表 l 中所有滿足謂詞 f 的元素。輸入列表中元素的順序會被保留。
val find_all : ('a -> bool) -> 'a list -> 'a listfind_all 是 List.filter 的另一個名稱。
val filteri : (int -> 'a -> bool) -> 'a list -> 'a list與 List.filter 相同，但謂詞會將元素的索引 (從 0 開始計數) 作為第一個參數，元素本身作為第二個參數。
val partition : ('a -> bool) -> 'a list -> 'a list * 'a listpartition f l 回傳一對列表 (l1, l2)，其中 l1 是列表 l 中所有滿足謂詞 f 的元素所組成的列表，而 l2 是列表 l 中所有不滿足 f 的元素所組成的列表。輸入列表中元素的順序會被保留。
val partition_map : ('a -> ('b, 'c) Either.t) -> 'a list -> 'b list * 'c listpartition_map f l 回傳一對列表 (l1, l2)，對於輸入列表 l 的每個元素 x 而言：
f x 是 Left y1，則 y1 會在 l1 中，並且f x 是 Right y2，則 y2 會在 l2 中。輸出元素會以與 l 中對應輸入元素相同的相對順序包含在 l1 和 l2 中。
特別的是，partition_map (fun x -> if f x then Left x else Right x) l 等同於 partition f l。
val assoc : 'a -> ('a * 'b) list -> 'bassoc a l 回傳在配對列表 l 中與鍵值 a 相關聯的值。也就是說，如果 (a,b) 是列表 l 中 a 最左邊的繫結，則 assoc a [ ...; (a,b); ...] = b。
l 中沒有與 a 相關聯的值，則引發 Not_found 異常。val assoc_opt : 'a -> ('a * 'b) list -> 'b optionassoc_opt a l 回傳在配對列表 l 中與鍵值 a 相關聯的值。也就是說，如果 (a,b) 是列表 l 中 a 最左邊的繫結，則 assoc_opt a [ ...; (a,b); ...] = Some b。如果列表 l 中沒有與 a 相關聯的值，則回傳 None。
val assq : 'a -> ('a * 'b) list -> 'b與 List.assoc 相同，但使用實體相等性而不是結構相等性來比較鍵值。
val assq_opt : 'a -> ('a * 'b) list -> 'b option與 List.assoc_opt 相同，但使用實體相等性而不是結構相等性來比較鍵值。
val mem_assoc : 'a -> ('a * 'b) list -> bool與 List.assoc 相同，但如果存在繫結則直接回傳 true，如果給定的鍵值不存在繫結則回傳 false。
val mem_assq : 'a -> ('a * 'b) list -> bool與 List.mem_assoc 相同，但使用實體相等性而不是結構相等性來比較鍵值。
val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) listremove_assoc a l 回傳不包含第一個鍵值為 a 的配對 (如果有的話) 的配對列表 l。不是尾遞迴。
val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list與 List.remove_assoc 相同，但使用實體相等性而不是結構相等性來比較鍵值。不是尾遞迴。
val split : ('a * 'b) list -> 'a list * 'b list將配對列表轉換為配對列表：split [(a1,b1); ...; (an,bn)] 會是 ([a1; ...; an], [b1; ...; bn])。不是尾遞迴。
val combine : 'a list -> 'b list -> ('a * 'b) list將配對列表轉換為配對列表：combine [a1; ...; an] [b1; ...; bn] 會是 [(a1,b1); ...; (an,bn)]。
Invalid_argument 異常。不是尾遞迴。val sort : ('a -> 'a -> int) -> 'a list -> 'a listval stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list與 List.sort 相同，但排序演算法保證是穩定的 (也就是說，比較相等的元素會保持其原始順序)。
目前實作使用合併排序。它在常數堆積空間和對數堆疊空間中執行。
val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list與 List.sort 或 List.stable_sort 相同，取決於哪個在典型輸入上速度更快。
val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list與 List.sort 相同，但也移除重複項目。
val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list合併兩個列表：假設 l1 和 l2 已根據比較函數 cmp 排序，merge cmp l1 l2 將回傳一個排序過的列表，其中包含 l1 和 l2 的所有元素。如果多個元素比較相等，l1 的元素會排在 l2 的元素之前。不是尾遞迴 (引數長度的總和)。
val to_seq : 'a list -> 'a Seq.t在列表上迭代。
val of_seq : 'a Seq.t -> 'a list從序列建立列表。