module ListLabels: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 -> len: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 : len:int -> f:(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 連接。這等效於 (ListLabels.rev l1) @ l2。
val concat : 'a list list -> 'a list連接列表的列表。將參數中的所有元素連接在一起（以相同的順序）以產生結果。非尾遞迴（參數的長度 + 最長子列表的長度）。
val flatten : 'a list list -> 'a list與 ListLabels.concat 相同。非尾遞迴（參數的長度 + 最長子列表的長度）。
val equal : eq:('a -> 'a -> bool) -> 'a list -> 'a list -> boolequal eq [a1; ...; an] [b1; ..; bm] 在兩個輸入列表具有相同長度時成立，並且對於每個相同位置的元素對 ai、bi，我們有 eq ai bi。
注意：即使列表長度不同，也可以呼叫 eq 函式。如果您知道您的相等函式成本高昂，您可能需要先檢查 ListLabels.compare_lengths。
val compare : cmp:('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 : f:('a -> unit) -> 'a list -> unititer ~f [a1; ...; an] 依次將函式 f 應用於 [a1; ...; an]。它等效於 f a1; f a2; ...; f an。
val iteri : f:(int -> 'a -> unit) -> 'a list -> unit與 ListLabels.iter 相同，但該函式會將元素的索引作為第一個參數（從 0 開始計數），並將元素本身作為第二個參數。
val map : f:('a -> 'b) -> 'a list -> 'b listmap ~f [a1; ...; an] 將函式 f 應用於 a1, ..., an，並使用 f 返回的結果建立列表 [f a1; ...; f an]。
val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list與 ListLabels.map 相同，但該函式會將元素的索引作為第一個參數（從 0 開始計數），並將元素本身作為第二個參數。
val rev_map : f:('a -> 'b) -> 'a list -> 'b listrev_map ~f l 給出的結果與 ListLabels.rev (ListLabels.map f l) 相同，但效率更高。
val filter_map : f:('a -> 'b option) -> 'a list -> 'b listfilter_map ~f l 將 f 應用於 l 的每個元素，篩選掉 None 元素，並返回 Some 元素的參數列表。
val concat_map : f:('a -> 'b list) -> 'a list -> 'b listconcat_map ~f l 給出的結果與 ListLabels.concat (ListLabels.map f l) 相同。尾遞迴。
val fold_left_map : f:('acc -> 'a -> 'acc * 'b) -> init:'acc -> 'a list -> 'acc * 'b listfold_left_map 是 fold_left 和 map 的組合，它會透過呼叫 f 來傳遞累加器。
val fold_left : f:('acc -> 'a -> 'acc) -> init:'acc -> 'a list -> 'accfold_left ~f ~init [b1; ...; bn] 是 f (... (f (f init b1) b2) ...) bn。
val fold_right : f:('a -> 'acc -> 'acc) -> 'a list -> init:'acc -> 'accfold_right ~f [a1; ...; an] ~init 是 f a1 (f a2 (... (f an init) ...))。非尾遞迴。
val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unititer2 ~f [a1; ...; an] [b1; ...; bn] 依次呼叫 f a1 b1; ...; f an bn。
Invalid_argument。val map2 : f:('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 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c listrev_map2 ~f l1 l2 給出的結果與 ListLabels.rev (ListLabels.map2 f l1 l2) 相同，但效率更高。
val fold_left2 : f:('acc -> 'a -> 'b -> 'acc) -> init:'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 : f:('a -> 'b -> 'acc -> 'acc) -> 'a list -> 'b list -> init:'acc -> 'accfold_right2 ~f [a1; ...; an] [b1; ...; bn] ~init 是 f a1 b1 (f a2 b2 (... (f an bn init) ...))。
Invalid_argument。非尾遞迴。val for_all : f:('a -> bool) -> 'a list -> boolfor_all ~f [a1; ...; an] 檢查列表的所有元素是否滿足謂詞 f。也就是說，對於非空列表，它返回 (f a1) && (f a2) && ... && (f an)，如果列表為空，則返回 true。
val exists : f:('a -> bool) -> 'a list -> boolexists ~f [a1; ...; an] 檢查列表是否至少有一個元素滿足謂詞 f。也就是說，對於非空列表，它返回 (f a1) || (f a2) || ... || (f an)，如果列表為空，則返回 false。
val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool與 ListLabels.for_all 相同，但適用於雙參數謂詞。
Invalid_argument。val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool與 ListLabels.exists 相同，但適用於雙參數謂詞。
Invalid_argument。val mem : 'a -> set:'a list -> bool若且唯若 a 等於 set 的一個元素時，mem a ~set 才為真。
val memq : 'a -> set:'a list -> bool與 ListLabels.mem 相同，但使用物理相等性而非結構相等性來比較列表元素。
val find : f:('a -> bool) -> 'a list -> 'afind ~f l 返回列表中第一個滿足謂詞 f 的元素。
l 中沒有值滿足 f，則引發 Not_found。val find_opt : f:('a -> bool) -> 'a list -> 'a optionfind ~f l 返回列表中第一個滿足謂詞 f 的元素。如果列表中沒有值滿足 f，則返回 None。
val find_index : f:('a -> bool) -> 'a list -> int optionfind_index ~f xs 返回 Some i，其中 i 是列表 xs 中第一個滿足 f x 的元素的索引（如果存在此類元素）。
如果沒有此類元素，則返回 None。
val find_map : f:('a -> 'b option) -> 'a list -> 'b optionfind_map ~f l 依序將 f 應用於 l 的元素，並返回第一個 Some v 形式的結果，如果不存在，則返回 None。
val find_mapi : f:(int -> 'a -> 'b option) -> 'a list -> 'b option與 find_map 相同，但該謂詞會將元素的索引作為第一個參數（從 0 開始計數），並將元素本身作為第二個參數。
val filter : f:('a -> bool) -> 'a list -> 'a listfilter ~f l 返回列表 l 中所有滿足謂詞 f 的元素。會保留輸入列表中元素的順序。
val find_all : f:('a -> bool) -> 'a list -> 'a listfind_all 是 ListLabels.filter 的另一個名稱。
val filteri : f:(int -> 'a -> bool) -> 'a list -> 'a list與 ListLabels.filter 相同，但該謂詞會將元素的索引作為第一個參數（從 0 開始計數），並將元素本身作為第二個參數。
val partition : f:('a -> bool) -> 'a list -> 'a list * 'a listpartition ~f l 函式會回傳一對列表 (l1, l2)，其中 l1 是 l 中所有滿足謂詞 f 的元素所組成的列表，而 l2 則是 l 中所有不滿足 f 的元素所組成的列表。輸入列表中元素的順序會被保留。
val partition_map : f:('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 中。輸出元素在 l1 和 l2 中的相對順序，會與它們在輸入列表 l 中的相對順序相同。
特別地，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 函式會回傳鍵 a 在鍵值對列表 l 中所關聯的值。也就是說，如果 (a,b) 是列表 l 中最左邊綁定到 a 的鍵值對，則 assoc a [ ...; (a,b); ...] = b。
Not_found 例外，如果列表 l 中沒有與 a 相關聯的值。val assoc_opt : 'a -> ('a * 'b) list -> 'b optionassoc_opt a l 函式會回傳鍵 a 在鍵值對列表 l 中所關聯的值。也就是說，如果 (a,b) 是列表 l 中最左邊綁定到 a 的鍵值對，則 assoc_opt a [ ...; (a,b); ...] = Some b。如果列表 l 中沒有與 a 相關聯的值，則回傳 None。
val assq : 'a -> ('a * 'b) list -> 'b與 ListLabels.assoc 相同，但使用物理相等性而非結構相等性來比較鍵。
val assq_opt : 'a -> ('a * 'b) list -> 'b option與 ListLabels.assoc_opt 相同，但使用物理相等性而非結構相等性來比較鍵。
val mem_assoc : 'a -> map:('a * 'b) list -> bool與 ListLabels.assoc 相同，但如果存在綁定則簡單回傳 true，如果給定鍵不存在綁定則回傳 false。
val mem_assq : 'a -> map:('a * 'b) list -> bool與 ListLabels.mem_assoc 相同，但使用物理相等性而非結構相等性來比較鍵。
val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) listremove_assoc a l 函式會回傳列表 l，其中第一個具有鍵 a 的鍵值對（如果存在）會被移除。不是尾遞迴。
val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list與 ListLabels.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 : cmp:('a -> 'a -> int) -> 'a list -> 'a list根據比較函式，對列表進行遞增排序。比較函式必須在參數相等時回傳 0，第一個參數大於第二個參數時回傳正整數，以及第一個參數小於第二個參數時回傳負整數（有關完整規格，請參閱 Array.sort）。例如，compare 是一個合適的比較函式。產生的列表會依遞增順序排序。ListLabels.sort 保證以常數堆積空間（除了結果列表的大小）和對數堆疊空間執行。
目前的實作使用合併排序。它以常數堆積空間和對數堆疊空間執行。
val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list與 ListLabels.sort 相同，但排序演算法保證是穩定的（也就是說，比較相等的元素會保持其原始順序）。
目前的實作使用合併排序。它以常數堆積空間和對數堆疊空間執行。
val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list與 ListLabels.sort 或 ListLabels.stable_sort 相同，取決於在典型輸入上哪個速度較快。
val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list與 ListLabels.sort 相同，但也會移除重複項。
val merge : cmp:('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從序列建立列表。