module Array: ArrayLabelstype'at ='a array
陣列類型的別名。
val length : 'a array -> int返回給定陣列的長度（元素數量）。
val get : 'a array -> int -> 'aget a n 返回陣列 a 中第 n 個元素。第一個元素的編號為 0。最後一個元素的編號為 length a - 1。您也可以使用 a.(n) 來代替 get a n。
n 超出 0 到 (length a - 1) 的範圍，則會引發 Invalid_argument 錯誤。val set : 'a array -> int -> 'a -> unitset a n x 會就地修改陣列 a，將第 n 個元素替換為 x。您也可以使用 a.(n) <- x 來代替 set a n x。
n 超出 0 到 length a - 1 的範圍，則會引發 Invalid_argument 錯誤。val make : int -> 'a -> 'a arraymake n x 返回一個長度為 n 的新陣列，並以 x 初始化。這個新陣列的所有元素最初在物理上都等於 x（在 == 謂詞的意義上）。因此，如果 x 是可變的，它會在陣列的所有元素之間共享，並且透過陣列中的一個條目修改 x 將會同時修改所有其他條目。
n < 0 或 n > Sys.max_array_length，則會引發 Invalid_argument 錯誤。如果 x 的值是浮點數，則最大大小僅為 Sys.max_array_length / 2。val create_float : int -> float arraycreate_float n 返回一個長度為 n 的新浮點數陣列，其中包含未初始化的資料。
val init : int -> f:(int -> 'a) -> 'a arrayinit n ~f 返回一個長度為 n 的新陣列，其中第 i 個元素初始化為 f i 的結果。換句話說，init n ~f 會將 f 依序套用到整數 0 到 n-1 並將結果製表。
n < 0 或 n > Sys.max_array_length，則會引發 Invalid_argument 錯誤。如果 f 的返回類型是 float，則最大大小僅為 Sys.max_array_length / 2。val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array arraymake_matrix ~dimx ~dimy e 返回一個二維陣列（陣列的陣列），其第一維度為 dimx，第二維度為 dimy。這個新矩陣的所有元素最初在物理上都等於 e。矩陣 m 的元素 (x,y) 可以使用符號 m.(x).(y) 來存取。
dimx 或 dimy 為負數或大於 Sys.max_array_length，則會引發 Invalid_argument 錯誤。如果 e 的值是浮點數，則最大大小僅為 Sys.max_array_length / 2。val init_matrix : dimx:int -> dimy:int -> f:(int -> int -> 'a) -> 'a array arrayinit_matrix ~dimx ~dimy ~f 返回一個二維陣列（陣列的陣列），其第一維度為 dimx，第二維度為 dimy，其中索引為 (x,y) 的元素會初始化為 f x y。矩陣 m 的元素 (x,y) 可以使用符號 m.(x).(y) 來存取。
dimx 或 dimy 為負數或大於 Sys.max_array_length，則會引發 Invalid_argument 錯誤。如果 f 的返回類型是 float，則最大大小僅為 Sys.max_array_length / 2。val append : 'a array -> 'a array -> 'a arrayappend v1 v2 返回一個包含陣列 v1 和 v2 連接的新陣列。
length v1 + length v2 > Sys.max_array_length，則會引發 Invalid_argument 錯誤。val concat : 'a array list -> 'a array與 ArrayLabels.append 相同，但會連接陣列列表。
val sub : 'a array -> pos:int -> len:int -> 'a arraysub a ~pos ~len 返回一個長度為 len 的新陣列，其中包含陣列 a 中編號為 pos 到 pos + len - 1 的元素。
pos 和 len 沒有指定 a 的有效子陣列；也就是說，如果 pos < 0，或 len < 0，或 pos + len > length a，則會引發 Invalid_argument 錯誤。val copy : 'a array -> 'a arraycopy a 返回 a 的副本，也就是說，一個包含與 a 相同元素的新陣列。
val fill : 'a array -> pos:int -> len:int -> 'a -> unitfill a ~pos ~len x 會就地修改陣列 a，將 x 儲存到編號為 pos 到 pos + len - 1 的元素中。
pos 和 len 沒有指定 a 的有效子陣列，則會引發 Invalid_argument 錯誤。val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unitblit ~src ~src_pos ~dst ~dst_pos ~len 會將陣列 src 中從編號 src_pos 的元素開始的 len 個元素複製到陣列 dst 中，從編號 dst_pos 的元素開始。即使 src 和 dst 是同一個陣列，且來源和目標區塊重疊，此方法也能正常運作。
src_pos 和 len 沒有指定 src 的有效子陣列，或者如果 dst_pos 和 len 沒有指定 dst 的有效子陣列，則會引發 Invalid_argument 錯誤。val to_list : 'a array -> 'a listto_list a 返回 a 中所有元素的列表。
val of_list : 'a list -> 'a arrayof_list l 返回一個包含 l 的元素的新陣列。
l 的長度大於 Sys.max_array_length，則會引發 Invalid_argument 錯誤。val iter : f:('a -> unit) -> 'a array -> unititer ~f a 會依序將函式 f 套用到 a 的所有元素。它等同於 f a.(0); f a.(1); ...; f a.(length a - 1); ()。
val iteri : f:(int -> 'a -> unit) -> 'a array -> unit與 ArrayLabels.iter 相同，但函式會將元素的索引作為第一個引數，並將元素本身作為第二個引數套用。
val map : f:('a -> 'b) -> 'a array -> 'b arraymap ~f a 會將函式 f 套用到 a 的所有元素，並使用 f 返回的結果建構一個陣列：[| f a.(0); f a.(1); ...; f a.(length a - 1) |]。
val map_inplace : f:('a -> 'a) -> 'a array -> unitmap_inplace ~f a 會將函式 f 套用到 a 的所有元素，並就地更新它們的值。
val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array與 ArrayLabels.map 相同，但函式會將元素的索引作為第一個引數，並將元素本身作為第二個引數套用。
val mapi_inplace : f:(int -> 'a -> 'a) -> 'a array -> unit與 ArrayLabels.map_inplace 相同，但函式會將元素的索引作為第一個引數，並將元素本身作為第二個引數套用。
val fold_left : f:('acc -> 'a -> 'acc) -> init:'acc -> 'a array -> 'accfold_left ~f ~init a 會計算 f (... (f (f init a.(0)) a.(1)) ...) a.(n-1)，其中 n 是陣列 a 的長度。
val fold_left_map : f:('acc -> 'a -> 'acc * 'b) -> init:'acc -> 'a array -> 'acc * 'b arrayfold_left_map 是 ArrayLabels.fold_left 和 ArrayLabels.map 的組合，它會透過對 f 的呼叫來傳遞累加器。
val fold_right : f:('a -> 'acc -> 'acc) -> 'a array -> init:'acc -> 'accfold_right ~f a ~init 會計算 f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...))，其中 n 是陣列 a 的長度。
val iter2 : f:('a -> 'b -> unit) -> 'a array -> 'b array -> unititer2 ~f a b 會將函式 f 套用到 a 和 b 的所有元素。
Invalid_argument 錯誤。val map2 : f:('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c arraymap2 ~f a b 會將函式 f 套用到 a 和 b 的所有元素，並使用 f 返回的結果建構一個陣列：[| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)|]。
Invalid_argument 錯誤。val for_all : f:('a -> bool) -> 'a array -> boolfor_all ~f [|a1; ...; an|] 會檢查陣列的所有元素是否都滿足謂詞 f。也就是說，它會返回 (f a1) && (f a2) && ... && (f an)。
val exists : f:('a -> bool) -> 'a array -> boolexists ~f [|a1; ...; an|] 會檢查陣列中是否至少有一個元素滿足謂詞 f。也就是說，它會返回 (f a1) || (f a2) || ... || (f an)。
val for_all2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool與 ArrayLabels.for_all 相同，但適用於雙引數謂詞。
Invalid_argument 錯誤。val exists2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool與 ArrayLabels.exists 相同，但適用於雙引數謂詞。
Invalid_argument 錯誤。val mem : 'a -> set:'a array -> boolmem a ~set 為 true，若且唯若 a 在結構上等於 set 的一個元素（也就是說，在 set 中存在一個 x，使得 compare a x = 0）。
val memq : 'a -> set:'a array -> bool與 ArrayLabels.mem 相同，但會使用物理相等性而不是結構相等性來比較陣列元素。
val find_opt : f:('a -> bool) -> 'a array -> 'a optionfind_opt ~f a 返回陣列 a 中第一個符合謂詞 f 的元素，如果陣列 a 中沒有任何值符合 f，則返回 None。
val find_index : f:('a -> bool) -> 'a array -> int optionfind_index ~f a 返回 Some i，其中 i 是陣列 a 中第一個符合 f x 的元素的索引，如果存在這樣的元素。
如果沒有這樣的元素，則返回 None。
val find_map : f:('a -> 'b option) -> 'a array -> 'b optionfind_map ~f a 依序將 f 應用於 a 的元素，並返回第一個形式為 Some v 的結果，如果不存在則返回 None。
val find_mapi : f:(int -> 'a -> 'b option) -> 'a array -> 'b option與 find_map 相同，但謂詞的第一個參數是元素的索引（從 0 開始計數），第二個參數是元素本身。
val split : ('a * 'b) array -> 'a array * 'b arraysplit [|(a1,b1); ...; (an,bn)|] 等於 ([|a1; ...; an|], [|b1; ...; bn|])。
val combine : 'a array -> 'b array -> ('a * 'b) arraycombine [|a1; ...; an|] [|b1; ...; bn|] 等於 [|(a1,b1); ...; (an,bn)|]。如果兩個陣列的長度不同，則拋出 Invalid_argument 異常。
val sort : cmp:('a -> 'a -> int) -> 'a array -> unit根據比較函數以遞增順序對陣列進行排序。如果其參數比較相等，則比較函數必須返回 0；如果第一個大於第二個，則返回正整數；如果第一個小於第二個，則返回負整數（完整的規格請參閱下文）。例如，compare 是一個合適的比較函數。在調用 sort 後，陣列會原地以遞增順序排序。sort 保證以恆定的堆空間和（最多）對數堆疊空間運行。
目前的實作使用堆積排序。它以恆定的堆疊空間運行。
比較函數的規格：假設 a 為陣列，cmp 為比較函數。對於 a 中的所有 x、y、z，以下條件必須成立：
cmp x y > 0 若且唯若 cmp y x < 0cmp x y >= 0 且 cmp y z >= 0，則 cmp x z >= 0當 sort 返回時，a 包含與之前相同的元素，並以以下方式重新排序：對於 a 的所有有效索引 i 和 j
cmp a.(i) a.(j) >= 0 若且唯若 i >= jval stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit與 ArrayLabels.sort 相同，但排序演算法是穩定的（即，比較相等的元素會保持其原始順序），並且不保證以恆定的堆空間運行。
目前的實作使用合併排序。它使用長度為 n/2 的臨時陣列，其中 n 是陣列的長度。它通常比 ArrayLabels.sort 的目前實作更快。
val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit與 ArrayLabels.sort 或 ArrayLabels.stable_sort 相同，取決於在典型輸入上哪一個更快。
val shuffle : rand:(int -> int) -> 'a array -> unitshuffle ~rand a 使用 rand 隨機排列 a 的元素，以產生隨機性。排列的分佈是均勻的。
rand 必須使呼叫 rand n 會返回範圍 [0;n-1] 內均勻分佈的隨機數。Random.int 可用於此（不要忘記初始化產生器）。
val to_seq : 'a array -> 'a Seq.t以遞增順序迭代陣列。迭代期間對陣列的修改將反映在序列中。
val to_seqi : 'a array -> (int * 'a) Seq.t以遞增順序迭代陣列，同時產生元素及其索引。迭代期間對陣列的修改將反映在序列中。
val of_seq : 'a Seq.t -> 'a array從產生器建立陣列
從多個網域並行存取陣列時必須小心：存取陣列永遠不會導致程式崩潰，但未同步的存取可能會產生令人驚訝的（非循序一致的）結果。
每個存取多個陣列元素的陣列操作都不是原子性的。這包括迭代、掃描、排序、分割和合併陣列。
例如，考慮以下程式
let size = 100_000_000
let a = ArrayLabels.make size 1
let d1 = Domain.spawn (fun () ->
ArrayLabels.iteri ~f:(fun i x -> a.(i) <- x + 1) a
)
let d2 = Domain.spawn (fun () ->
ArrayLabels.iteri ~f:(fun i x -> a.(i) <- 2 * x + 1) a
)
let () = Domain.join d1; Domain.join d2
執行此程式碼後，陣列 a 的每個欄位不是 2、3、4 就是 5。如果需要原子性，則使用者必須實作自己的同步機制（例如，使用 Mutex.t）。
如果兩個網域僅存取陣列的不相交部分，則觀察到的行為等同於兩個網域操作的某種循序交錯。
當兩個網域在沒有同步的情況下存取同一個陣列元素，且至少有一個存取是寫入時，就會發生資料競爭。在沒有資料競爭的情況下，觀察到的行為等同於不同網域操作的某種循序交錯。
在可能的情況下，應該使用同步來調解對陣列元素的存取，以避免資料競爭。
實際上，在存在資料競爭的情況下，程式不會崩潰，但觀察到的行為可能不等同於不同網域操作的任何循序交錯。儘管如此，即使存在資料競爭，讀取操作也會返回先前寫入該位置的值（浮點數陣列有一些例外）。
在存在資料競爭的情況下，浮點數陣列有兩個補充注意事項。
首先，blit 操作可能會逐位元組複製陣列。此 blit 操作與另一個操作之間的資料競爭可能會因撕裂而產生令人驚訝的值：與其他操作交錯的部分寫入可能會產生在循序執行中不存在的浮點數值。
例如，在以下程式碼的結尾
let zeros = Array.make size 0.
let max_floats = Array.make size Float.max_float
let res = Array.copy zeros
let d1 = Domain.spawn (fun () -> Array.blit zeros 0 res 0 size)
let d2 = Domain.spawn (fun () -> Array.blit max_floats 0 res 0 size)
let () = Domain.join d1; Domain.join d2
res 陣列可能包含既不是 0. 也不是 max_float 的值。
其次，在 32 位元架構上，取得或設定欄位涉及兩個單獨的記憶體存取。在存在資料競爭的情況下，使用者可能會在任何操作中觀察到撕裂。