module Array:sig..end
陣列操作。
這個模組的標籤版本可以使用在 StdLabels 模組中所描述的方式。
type'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。
Invalid_argument，如果 n 超出 0 到 (length a - 1) 的範圍。val set : 'a array -> int -> 'a -> unitset a n x 就地修改陣列 a，將編號為 n 的元素替換為 x。你也可以寫 a.(n) <- x 來代替 set a n x。
Invalid_argument，如果 n 超出 0 到 length a - 1 的範圍。val make : int -> 'a -> 'a arraymake n x 回傳一個長度為 n 的新陣列，並使用 x 初始化。這個新陣列的所有元素一開始都與 x 在實體上相等（在 == 謂詞的意義上）。因此，如果 x 是可變的，它會在陣列的所有元素之間共享，並且透過其中一個陣列條目修改 x 會同時修改所有其他條目。
Invalid_argument，如果 n < 0 或 n > Sys.max_array_length。如果 x 的值是浮點數，則最大大小僅為 Sys.max_array_length / 2。val create_float : int -> float arraycreate_float n 回傳一個長度為 n 的新浮點數陣列，其中包含未初始化的資料。
val init : int -> (int -> 'a) -> 'a arrayinit n f 回傳一個長度為 n 的新陣列，其中編號為 i 的元素初始化為 f i 的結果。換句話說，init n f 將 f 依序套用至整數 0 到 n-1 的結果製成表格。
Invalid_argument，如果 n < 0 或 n > Sys.max_array_length。如果 f 的回傳型別為 float，則最大大小僅為 Sys.max_array_length / 2。val make_matrix : int -> int -> 'a -> 'a array arraymake_matrix dimx dimy e 回傳一個二維陣列（陣列的陣列），其中第一維度為 dimx，第二維度為 dimy。這個新矩陣的所有元素一開始都與 e 在實體上相等。矩陣 m 的元素 (x,y) 可使用 m.(x).(y) 的符號來存取。
Invalid_argument，如果 dimx 或 dimy 為負數或大於 Sys.max_array_length。如果 e 的值是浮點數，則最大大小僅為 Sys.max_array_length / 2。val init_matrix : int -> int -> (int -> int -> 'a) -> 'a array arrayinit_matrix dimx dimy f 回傳一個二維陣列（陣列的陣列），其中第一維度為 dimx，第二維度為 dimy，其中索引 (x,y) 的元素使用 f x y 初始化。矩陣 m 的元素 (x,y) 可使用 m.(x).(y) 的符號來存取。
Invalid_argument，如果 dimx 或 dimy 為負數或大於 Sys.max_array_length。如果 f 的回傳型別為 float，則最大大小僅為 Sys.max_array_length / 2。val append : 'a array -> 'a array -> 'a arrayappend v1 v2 回傳一個包含陣列 v1 和 v2 串接的新陣列。
Invalid_argument，如果 length v1 + length v2 > Sys.max_array_length。val concat : 'a array list -> 'a array與 Array.append 相同，但會串接陣列列表。
val sub : 'a array -> int -> int -> 'a arraysub a pos len 回傳一個長度為 len 的新陣列，其中包含陣列 a 中編號為 pos 到 pos + len - 1 的元素。
Invalid_argument，如果 pos 和 len 未指定 a 的有效子陣列；也就是說，如果 pos < 0，或 len < 0，或 pos + len > length a。val copy : 'a array -> 'a arraycopy a 回傳 a 的副本，也就是說，一個包含與 a 相同元素的新陣列。
val fill : 'a array -> int -> int -> 'a -> unitfill a pos len x 就地修改陣列 a，將 x 儲存到編號為 pos 到 pos + len - 1 的元素中。
Invalid_argument，如果 pos 和 len 未指定 a 的有效子陣列。val blit : 'a array -> int -> 'a array -> int -> int -> unitblit src src_pos dst dst_pos len 將 len 個元素從陣列 src (從編號為 src_pos 的元素開始) 複製到陣列 dst (從編號為 dst_pos 的元素開始)。即使 src 和 dst 是同一個陣列，並且來源和目標區塊重疊，它也能正確運作。
Invalid_argument，如果 src_pos 和 len 未指定 src 的有效子陣列，或者如果 dst_pos 和 len 未指定 dst 的有效子陣列。val to_list : 'a array -> 'a listto_list a 回傳 a 所有元素的列表。
val of_list : 'a list -> 'a arrayof_list l 回傳一個包含 l 元素的新陣列。
Invalid_argument，如果 l 的長度大於 Sys.max_array_length。val iter : ('a -> unit) -> 'a array -> unititer f a 依序將函式 f 套用至 a 的所有元素。它等同於 f a.(0); f a.(1); ...; f a.(length a - 1); ()。
val iteri : (int -> 'a -> unit) -> 'a array -> unit與 Array.iter 相同，但函式的第一個引數為元素的索引，第二個引數為元素本身。
val map : ('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 : ('a -> 'a) -> 'a array -> unitmap_inplace f a 將函式 f 套用至 a 的所有元素，並就地更新它們的值。
val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array與 Array.map 相同，但函式的第一個引數為元素的索引，第二個引數為元素本身。
val mapi_inplace : (int -> 'a -> 'a) -> 'a array -> unit與 Array.map_inplace 相同，但函式的第一個引數為元素的索引，第二個引數為元素本身。
val fold_left : ('acc -> 'a -> 'acc) -> '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 : ('acc -> 'a -> 'acc * 'b) -> 'acc -> 'a array -> 'acc * 'b arrayfold_left_map 是 Array.fold_left 和 Array.map 的組合，它會透過對 f 的呼叫來傳遞累加器。
val fold_right : ('a -> 'acc -> 'acc) -> 'a array -> 'acc -> 'accfold_right f a init 計算 f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...))，其中 n 是陣列 a 的長度。
val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unititer2 f a b 將函式 f 套用至 a 和 b 的所有元素。
Invalid_argument，如果陣列大小不相同。val map2 : ('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 : ('a -> bool) -> 'a array -> boolfor_all f [|a1; ...; an|] 檢查陣列的所有元素是否滿足謂詞 f。也就是說，它回傳 (f a1) && (f a2) && ... && (f an)。
val exists : ('a -> bool) -> 'a array -> boolexists f [|a1; ...; an|] 檢查陣列中是否至少有一個元素滿足謂詞 f。也就是說，它回傳 (f a1) || (f a2) || ... || (f an)。
val for_all2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool與 Array.for_all 相同，但用於接受兩個引數的謂詞。
Invalid_argument，如果兩個陣列的長度不同。val exists2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool與 Array.exists 相同，但用於接受兩個引數的謂詞。
Invalid_argument，如果兩個陣列的長度不同。val mem : 'a -> 'a array -> boolmem a set 成立若且唯若 a 與 set 的元素在結構上相等（也就是說，在 set 中存在一個 x 使得 compare a x = 0）。
val memq : 'a -> 'a array -> bool與 Array.mem 相同，但使用實體相等而非結構相等來比較陣列元素。
val find_opt : ('a -> bool) -> 'a array -> 'a optionfind_opt f a 回傳陣列 a 中第一個滿足謂詞 f 的元素，如果陣列 a 中沒有任何值滿足 f，則回傳 None。
val find_index : ('a -> bool) -> 'a array -> int optionfind_index f a 回傳 Some i，其中 i 是陣列 a 中第一個滿足 f x 的元素的索引，如果存在這樣一個元素。
如果沒有這樣的元素，則回傳 None。
val find_map : ('a -> 'b option) -> 'a array -> 'b optionfind_map f a 會依序將 f 應用於 a 的元素，並返回第一個形式為 Some v 的結果，如果不存在則返回 None。
val find_mapi : (int -> 'a -> 'b option) -> 'a array -> 'b option與 find_map 相同，但謂詞 (predicate) 會將元素的索引（從 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 : ('a -> 'a -> int) -> 'a array -> unit根據比較函數以遞增順序對陣列進行排序。如果參數相等，比較函數必須返回 0；如果第一個參數較大，則返回正整數；如果第一個參數較小，則返回負整數（完整規範請見下方）。例如，compare 是一個合適的比較函數。呼叫 sort 後，陣列會原地排序為遞增順序。sort 保證在常數堆積空間和（最多）對數堆疊空間中執行。
目前的實作使用堆積排序 (Heap 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 : ('a -> 'a -> int) -> 'a array -> unit與 Array.sort 相同，但排序演算法是穩定的（即，比較相等的元素會保持其原始順序），並且不保證在常數堆積空間中執行。
目前的實作使用合併排序 (Merge Sort)。它使用一個長度為 n/2 的臨時陣列，其中 n 是陣列的長度。它通常比目前 Array.sort 的實作更快。
val fast_sort : ('a -> 'a -> int) -> 'a array -> unit與 Array.sort 或 Array.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從產生器建立陣列
從多個域 (domain) 並行存取陣列時必須小心：存取陣列永遠不會導致程式崩潰，但未同步的存取可能會產生令人驚訝（非循序一致）的結果。
每個存取多個陣列元素的陣列操作都不是原子操作。這包括迭代、掃描、排序、分割和合併陣列。
例如，考慮以下程式：
let size = 100_000_000
let a = Array.make size 1
let d1 = Domain.spawn (fun () ->
Array.iteri (fun i x -> a.(i) <- x + 1) a
)
let d2 = Domain.spawn (fun () ->
Array.iteri (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 操作與另一個操作之間的資料競爭可能會因撕裂 (tearing) 而產生令人驚訝的值：與其他操作交錯的部分寫入可能會創建在循序執行中不存在的浮點數值。
例如，在
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 位元架構上，取得或設定欄位涉及兩個單獨的記憶體存取。在存在資料競爭的情況下，使用者可能會在任何操作中觀察到撕裂現象。