module List: Listtype'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 沒有元素時為 true。它等同於 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 的一個元素時為 true。
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 返回列表中所有滿足述詞 f 的元素 l。保留輸入列表中元素的順序。
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 中。輸出元素包含在 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 返回與配對列表 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 傳回與鍵值 a 在配對列表 l 中相關聯的值。也就是說，如果 (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 傳回配對列表 l，其中不包含第一個鍵值為 a 的配對（如果有的話）。不是尾遞迴。
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從序列建立列表。