module ListLabels: 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 沒有元素時才為 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 如果列表太短。Invalid_argument 如果 n 為負數。val nth_opt : 'a list -> int -> 'a option回傳給定列表的第 n 個元素。第一個元素（列表頭）的位置為 0。如果列表太短，則回傳 None。
Invalid_argument 如果 n 為負數。val rev : 'a list -> 'a list列表反轉。
val init : len:int -> f:(int -> 'a) -> 'a listinit ~len ~f 為 [f 0; f 1; ...; f (len-1)]，從左至右求值。
Invalid_argument 如果 len < 0。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 的元素時才為 true。
val memq : 'a -> set:'a list -> bool與 ListLabels.mem 相同，但使用實體相等性而非結構相等性來比較列表元素。
val find : f:('a -> bool) -> 'a list -> 'afind ~f l 會回傳列表中滿足謂詞 f 的第一個元素 l。
Not_found 如果列表 l 中沒有值滿足 f。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 返回與配對列表 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與 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從序列建立列表。