module List: ListLabelstype'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 -> boolmem a ~set 成立的條件是，a 等於 set 的一個元素。
val memq : 'a -> set:'a list -> bool與 ListLabels.mem 相同，但使用物理相等性而非結構相等性來比較列表元素。
val find : f:('a -> bool) -> 'a list -> 'afind ~f l 回傳列表中第一個滿足謂詞 f 的元素 l。
l 中沒有值滿足 f，則拋出 Not_found。val find_opt : f:('a -> bool) -> 'a list -> 'a optionfind ~f l 回傳列表中第一個滿足謂詞 f 的元素 l。如果列表 l 中沒有值滿足 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 中。輸出元素會以與輸入列表 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 會回傳鍵值 a 在配對列表 l 中關聯的值。也就是說，如果 (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與 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從序列建立列表。