module Bytes: BytesLabelsval length : bytes -> int回傳參數的長度（位元組數）。
val get : bytes -> int -> charget s n 回傳參數 s 中索引為 n 的位元組。
n 不是 s 中的有效索引，則引發 Invalid_argument 異常。val set : bytes -> int -> char -> unitset s n c 就地修改 s，將索引為 n 的位元組替換為 c。
n 不是 s 中的有效索引，則引發 Invalid_argument 異常。val create : int -> bytescreate n 回傳一個長度為 n 的新位元組序列。此序列未初始化，包含任意位元組。
n < 0 或 n > Sys.max_string_length，則引發 Invalid_argument 異常。val make : int -> char -> bytesmake n c 回傳一個長度為 n 的新位元組序列，並以位元組 c 填滿。
n < 0 或 n > Sys.max_string_length，則引發 Invalid_argument 異常。val init : int -> f:(int -> char) -> bytesinit n f 回傳一個長度為 n 的新位元組序列，其中索引為 i 的字元初始化為 f i 的結果（依照索引遞增順序）。
n < 0 或 n > Sys.max_string_length，則引發 Invalid_argument 異常。val empty : bytes一個大小為 0 的位元組序列。
val copy : bytes -> bytes回傳一個新的位元組序列，其中包含與參數相同的位元組。
val of_string : string -> bytes回傳一個新的位元組序列，其中包含與指定字串相同的位元組。
val to_string : bytes -> string回傳一個新的字串，其中包含與指定位元組序列相同的位元組。
val sub : bytes -> pos:int -> len:int -> bytessub s ~pos ~len 回傳一個長度為 len 的新位元組序列，其中包含 s 中從位置 pos 開始，長度為 len 的子序列。
pos 和 len 沒有指定 s 的有效範圍，則引發 Invalid_argument 異常。val sub_string : bytes -> pos:int -> len:int -> string與 BytesLabels.sub 相同，但回傳字串而非位元組序列。
val extend : bytes -> left:int -> right:int -> bytesextend s ~left ~right 回傳一個新的位元組序列，其中包含 s 的位元組，並在前面加上 left 個未初始化的位元組，並在後面加上 right 個未初始化的位元組。如果 left 或 right 為負數，則會從 s 的對應邊移除位元組（而不是附加）。
Sys.max_string_length 個位元組，則引發 Invalid_argument 異常。val fill : bytes -> pos:int -> len:int -> char -> unitfill s ~pos ~len c 就地修改 s，將從 pos 開始的 len 個字元替換為 c。
pos 和 len 沒有指定 s 的有效範圍，則引發 Invalid_argument 異常。val blit : src:bytes -> src_pos:int -> dst:bytes -> 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 blit_string : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unitblit_string ~src ~src_pos ~dst ~dst_pos ~len 從字串 src 中索引為 src_pos 開始複製 len 個位元組到位元組序列 dst 中索引為 dst_pos 的位置。
src_pos 和 len 沒有指定 src 的有效範圍，或 dst_pos 和 len 沒有指定 dst 的有效範圍，則引發 Invalid_argument 異常。val concat : sep:bytes -> bytes list -> bytesconcat ~sep sl 連接位元組序列列表 sl，在每個之間插入分隔符號位元組序列 sep，並將結果回傳為新的位元組序列。
Sys.max_string_length 個位元組，則引發 Invalid_argument 異常。val cat : bytes -> bytes -> bytescat s1 s2 連接 s1 和 s2，並將結果回傳為新的位元組序列。
Sys.max_string_length 個位元組，則引發 Invalid_argument 異常。val iter : f:(char -> unit) -> bytes -> unititer ~f s 依序將函式 f 應用於 s 的所有位元組。它等同於 f (get s 0); f (get s 1); ...; f (get s。
(length s - 1)); ()
val iteri : f:(int -> char -> unit) -> bytes -> unit與 BytesLabels.iter 相同，但該函式的第一個參數會應用於位元組的索引，第二個參數則應用於位元組本身。
val map : f:(char -> char) -> bytes -> bytesmap ~f s 依序將函式 f 應用於 s 的所有位元組（依照索引遞增順序），並將結果位元組儲存在新的序列中，並將其做為結果回傳。
val mapi : f:(int -> char -> char) -> bytes -> bytesmapi ~f s 使用 s 的每個字元及其索引（依照索引遞增順序）來呼叫 f，並將結果位元組儲存在新的序列中，並將其做為結果回傳。
val fold_left : f:('acc -> char -> 'acc) -> init:'acc -> bytes -> 'accfold_left f x s 計算 f (... (f (f x (get s 0)) (get s 1)) ...) (get s (n-1))，其中 n 是 s 的長度。
val fold_right : f:(char -> 'acc -> 'acc) -> bytes -> init:'acc -> 'accfold_right f s x 計算 f (get s 0) (f (get s 1) ( ... (f (get s (n-1)) x) ...))，其中 n 是 s 的長度。
val for_all : f:(char -> bool) -> bytes -> boolfor_all p s 檢查 s 中的所有字元是否都滿足謂詞 p。
val exists : f:(char -> bool) -> bytes -> boolexists p s 檢查 s 中是否至少有一個字元滿足謂詞 p。
val trim : bytes -> bytes回傳參數的副本，不含開頭和結尾的空白。被視為空白的位元組是 ASCII 字元 ' '、'\012'、'\n'、'\r' 和 '\t'。
val escaped : bytes -> bytes回傳參數的副本，特殊字元以跳脫序列表示，遵循 OCaml 的詞法慣例。所有超出 ASCII 可列印範圍 (32..126) 的字元都會被跳脫，反斜線和雙引號也會被跳脫。
Sys.max_string_length 個位元組，則引發 Invalid_argument 異常。val index : bytes -> char -> intindex s c 回傳 s 中位元組 c 第一次出現的索引。
c 沒有在 s 中出現，則引發 Not_found 異常。val index_opt : bytes -> char -> int optionindex_opt s c 回傳 s 中位元組 c 第一次出現的索引，如果 c 沒有在 s 中出現，則回傳 None。
val rindex : bytes -> char -> intrindex s c 回傳 s 中位元組 c 最後一次出現的索引。
c 沒有在 s 中出現，則引發 Not_found 異常。val rindex_opt : bytes -> char -> int optionrindex_opt s c 回傳 s 中位元組 c 最後一次出現的索引，如果 c 沒有在 s 中出現，則回傳 None。
val index_from : bytes -> int -> char -> intindex_from s i c 回傳 s 中位置 i 之後位元組 c 第一次出現的索引。index s c 等同於 index_from s 0 c。
i 不是 s 的有效位置，則引發 Invalid_argument 異常。c 沒有在 s 中位置 i 之後出現，則引發 Not_found 異常。val index_from_opt : bytes -> int -> char -> int optionindex_from_opt s i c 回傳 s 中位置 i 之後位元組 c 第一次出現的索引，如果 c 沒有在 s 中位置 i 之後出現，則回傳 None。index_opt s c 等同於 index_from_opt s 0 c。
i 不是 s 的有效位置，則引發 Invalid_argument 異常。val rindex_from : bytes -> int -> char -> intrindex_from s i c 回傳 s 中位置 i+1 之前位元組 c 最後一次出現的索引。rindex s c 等同於 rindex_from s (length s - 1) c。
i+1 不是 s 的有效位置，則引發 Invalid_argument 異常。c 沒有在 s 中位置 i+1 之前出現，則引發 Not_found 異常。val rindex_from_opt : bytes -> int -> char -> int optionrindex_from_opt s i c 回傳 s 中位置 i+1 之前位元組 c 最後一次出現的索引，如果 c 沒有在 s 中位置 i+1 之前出現，則回傳 None。rindex_opt s c 等同於 rindex_from s (length s - 1) c。
i+1 不是 s 的有效位置，則引發 Invalid_argument 異常。val contains : bytes -> char -> boolcontains s c 測試位元組 c 是否出現在 s 中。
val contains_from : bytes -> int -> char -> boolcontains_from s start c 測試位元組 c 是否出現在 s 中位置 start 之後。contains s c 等同於 contains_from。
s 0 c
start 不是 s 的有效位置，則引發 Invalid_argument 異常。val rcontains_from : bytes -> int -> char -> boolrcontains_from s stop c 測試位元組 c 是否在 s 中，且在位置 stop+1 之前出現。
stop < 0 或 stop+1 不是 s 中的有效位置，則引發 Invalid_argument 異常。val uppercase_ascii : bytes -> bytes回傳一個參數的副本，其中所有小寫字母都使用 US-ASCII 字元集轉換為大寫。
val lowercase_ascii : bytes -> bytes回傳一個參數的副本，其中所有大寫字母都使用 US-ASCII 字元集轉換為小寫。
val capitalize_ascii : bytes -> bytes回傳一個參數的副本，其中第一個字元使用 US-ASCII 字元集轉換為大寫。
val uncapitalize_ascii : bytes -> bytes回傳一個參數的副本，其中第一個字元使用 US-ASCII 字元集轉換為小寫。
typet =bytes
位元組序列類型的別名。
val compare : t -> t -> int
val equal : t -> t -> bool位元組序列的相等函數。
val starts_with : prefix:bytes -> bytes -> boolstarts_with ~prefix s 當且僅當 s 以 prefix 開頭時為 true。
val ends_with : suffix:bytes -> bytes -> boolends_with ~suffix s 當且僅當 s 以 suffix 結尾時為 true。
本節介紹 bytes 和 string 之間的不安全、低階轉換函數。它們不複製內部資料；使用不當可能會破壞 -safe-string 選項提供的字串不可變性。它們適用於專業的程式庫作者，但對於大多數用途，您應該改用始終正確的 BytesLabels.to_string 和 BytesLabels.of_string。
val unsafe_to_string : bytes -> string不安全地將位元組序列轉換為字串。
為了推斷 unsafe_to_string 的使用方式，可以考慮一種「所有權」規則。一段操作某些資料的程式碼「擁有」它；有幾種不相交的所有權模式，包括：
獨佔所有權是線性的：將資料傳遞給另一段程式碼意味著放棄所有權（我們無法再次寫入資料）。獨佔擁有者可以決定將資料設為共享（放棄對其進行修改的權利），但共享資料可能無法再次變為獨佔所有。
只有當呼叫者擁有位元組序列 s 時（無論是獨佔還是作為共享不可變資料），才能使用 unsafe_to_string s。呼叫者放棄 s 的所有權，並獲得回傳字串的所有權。
有兩個符合此所有權規則的有效使用案例：
1. 通過初始化和修改位元組序列來建立字串，該位元組序列在執行初始化後永遠不會被更改。
let string_init len f : string =
let s = Bytes.create len in
for i = 0 to len - 1 do Bytes.set s i (f i) done;
Bytes.unsafe_to_string s
此函數是安全的，因為在呼叫 unsafe_to_string 之後，永遠不會存取或修改位元組序列 s。string_init 程式碼放棄 s 的所有權，並將產生的字串的所有權回傳給呼叫者。
請注意，如果將 s 作為額外參數傳遞給函數 f，則會不安全，因為它可能會以這種方式逸出並在未來被修改 -- string_init 會放棄 s 的所有權，以將其傳遞給 f，並且無法安全地呼叫 unsafe_to_string。
我們提供了 String.init、String.map 和 String.mapi 函數來涵蓋建立新字串的大多數情況。在適用的情況下，您應該優先使用這些函數，而不是 to_string 或 unsafe_to_string。
2. 暫時將位元組序列的所有權授予一個期望獨佔字串並回傳所有權的函數，以便我們可以在呼叫結束後再次修改該序列。
let bytes_length (s : bytes) =
String.length (Bytes.unsafe_to_string s)
在這種情況下，我們不保證在呼叫 bytes_length s 之後永遠不會修改 s。String.length 函數會暫時借用位元組序列的獨佔所有權（並將其視為 string），但會將所有權回傳給呼叫者，呼叫者可以假設在呼叫之後 s 仍然是有效的位元組序列。請注意，這僅在我們知道 String.length 不會捕獲其參數時才正確 -- 它可能會通過諸如記憶體化組合器之類的側通道逸出。
當字串被借用時，呼叫者不得修改 s（它已暫時放棄了所有權）。這會影響並行程式，也會影響高階函數：如果 String.length 回傳稍後要呼叫的閉包，則在完全應用此閉包並回傳所有權之前，不應修改 s。
val unsafe_of_string : string -> bytes不安全地將共享字串轉換為不應修改的位元組序列。
使 unsafe_to_string 正確的相同所有權規則也適用於 unsafe_of_string：如果您是 string 值的所有者，則可以使用它，並且您將以相同的模式擁有回傳的 bytes。
實際上，很難正確推斷字串值的獨佔所有權。您應該始終假設字串是共享的，而不是獨佔所有。
例如，字串文字由編譯器隱式共享，因此您永遠不會獨佔擁有它們。
let incorrect = Bytes.unsafe_of_string "hello"
let s = Bytes.of_string "hello"
第一個宣告是不正確的，因為字串文字 "hello" 可能會被編譯器與程式的其他部分共享，而修改 incorrect 是一個錯誤。您必須始終使用第二個版本，該版本執行複製，因此是正確的。
假設不是字串文字，而是（部分）由字串文字建立的字串具有獨佔所有權也是不正確的。例如，修改 unsafe_of_string ("foo" ^ s) 可能會修改共享字串 "foo" -- 假設字串採用類似繩索的表示形式。更一般地說，操作字串的函數將假設共享所有權，它們不會保留獨佔所有權。因此，假設 unsafe_of_string 的結果具有獨佔所有權是不正確的。
我們合理確信安全的唯一情況是，產生的 bytes 是共享的 -- 用作不可變的位元組序列。這對於逐步遷移操作不可變位元組序列的低階程式（例如 Marshal.from_bytes）且先前為此目的使用 string 類型可能很有用。
val split_on_char : sep:char -> bytes -> bytes listsplit_on_char sep s 回傳 s 的所有（可能為空的）子序列的列表，這些子序列由 sep 字元分隔。如果 s 為空，則結果是單例列表 [empty]。
函數的輸出由以下不變式指定：
sep 作為分隔符串連其元素，回傳的位元組序列等於輸入（Bytes.concat (Bytes.make 1 sep)
(Bytes.split_on_char sep s) = s）。sep 字元。val to_seq : t -> char Seq.t以遞增的索引順序迭代字串。迭代期間對字串的修改將反映在序列中。
val to_seqi : t -> (int * char) Seq.t依遞增順序迭代字串，沿著字元產生索引
val of_seq : char Seq.t -> t從產生器建立字串
val get_utf_8_uchar : t -> int -> Uchar.utf_decodeget_utf_8_uchar b i 解碼 b 中索引 i 處的 UTF-8 字元。
val set_utf_8_uchar : t -> int -> Uchar.t -> intset_utf_8_uchar b i u 在 b 中索引 i 處對 u 進行 UTF-8 編碼，並回傳從 i 開始寫入的位元組數 n。如果 n 為 0，則沒有足夠的空間在 i 處編碼 u，並且 b 保持不變。否則，可以在 i + n 處編碼一個新字元。
val is_valid_utf_8 : t -> bool當且僅當 b 包含有效的 UTF-8 資料時，is_valid_utf_8 b 為 true。
val get_utf_16be_uchar : t -> int -> Uchar.utf_decodeget_utf_16be_uchar b i 解碼 b 中索引 i 處的 UTF-16BE 字元。
val set_utf_16be_uchar : t -> int -> Uchar.t -> intset_utf_16be_uchar b i u 在 b 中索引 i 處對 u 進行 UTF-16BE 編碼，並回傳從 i 開始寫入的位元組數 n。如果 n 為 0，則沒有足夠的空間在 i 處編碼 u，並且 b 保持不變。否則，可以在 i + n 處編碼一個新字元。
val is_valid_utf_16be : t -> bool當且僅當 b 包含有效的 UTF-16BE 資料時，is_valid_utf_16be b 為 true。
val get_utf_16le_uchar : t -> int -> Uchar.utf_decodeget_utf_16le_uchar b i 解碼 b 中索引 i 處的 UTF-16LE 字元。
val set_utf_16le_uchar : t -> int -> Uchar.t -> intset_utf_16le_uchar b i u 在 b 中索引 i 處對 u 進行 UTF-16LE 編碼，並回傳從 i 開始寫入的位元組數 n。如果 n 為 0，則沒有足夠的空間在 i 處編碼 u，並且 b 保持不變。否則，可以在 i + n 處編碼一個新字元。
val is_valid_utf_16le : t -> bool當且僅當 b 包含有效的 UTF-16LE 資料時，is_valid_utf_16le b 為 true。
本節中的函式負責將整數進行二進位編碼和解碼，使其與位元組序列相互轉換。
如果需要在索引 i 處解碼或編碼整數時，空間不足，則以下所有函式都會引發 Invalid_argument 例外。
小端（little-endian，resp.）編碼表示最低有效位元組會先儲存；大端（big-endian）編碼則表示最高有效位元組會先儲存。大端編碼也稱為網路位元組順序。原生端（native-endian）編碼則根據 Sys.big_endian 的值，決定採用小端或大端編碼。
32 位元和 64 位元整數分別以 int32 和 int64 型別表示，這兩種型別可以被解讀為有號數或無號數。
8 位元和 16 位元整數則以 int 型別表示，此型別的位元數比二進位編碼的位元數多。這些多出的位元會以以下方式處理：
int 值表示的有號（resp. 無號）8 位元或 16 位元整數的函式，會對其結果進行符號擴展（resp. 零擴展）。int 值表示的 8 位元或 16 位元整數的函式，會將其輸入截斷為最低有效位元組。val get_uint8 : bytes -> int -> intget_uint8 b i 會取得 b 中，從位元組索引 i 開始的無號 8 位元整數。
val get_int8 : bytes -> int -> intget_int8 b i 會取得 b 中，從位元組索引 i 開始的有號 8 位元整數。
val get_uint16_ne : bytes -> int -> intget_uint16_ne b i 會取得 b 中，從位元組索引 i 開始的原生端無號 16 位元整數。
val get_uint16_be : bytes -> int -> intget_uint16_be b i 會取得 b 中，從位元組索引 i 開始的大端無號 16 位元整數。
val get_uint16_le : bytes -> int -> intget_uint16_le b i 會取得 b 中，從位元組索引 i 開始的小端無號 16 位元整數。
val get_int16_ne : bytes -> int -> intget_int16_ne b i 會取得 b 中，從位元組索引 i 開始的原生端有號 16 位元整數。
val get_int16_be : bytes -> int -> intget_int16_be b i 會取得 b 中，從位元組索引 i 開始的大端有號 16 位元整數。
val get_int16_le : bytes -> int -> intget_int16_le b i 會取得 b 中，從位元組索引 i 開始的小端有號 16 位元整數。
val get_int32_ne : bytes -> int -> int32get_int32_ne b i 會取得 b 中，從位元組索引 i 開始的原生端 32 位元整數。
val get_int32_be : bytes -> int -> int32get_int32_be b i 會取得 b 中，從位元組索引 i 開始的大端 32 位元整數。
val get_int32_le : bytes -> int -> int32get_int32_le b i 會取得 b 中，從位元組索引 i 開始的小端 32 位元整數。
val get_int64_ne : bytes -> int -> int64get_int64_ne b i 會取得 b 中，從位元組索引 i 開始的原生端 64 位元整數。
val get_int64_be : bytes -> int -> int64get_int64_be b i 會取得 b 中，從位元組索引 i 開始的大端 64 位元整數。
val get_int64_le : bytes -> int -> int64get_int64_le b i 會取得 b 中，從位元組索引 i 開始的小端 64 位元整數。
val set_uint8 : bytes -> int -> int -> unitset_uint8 b i v 會將 b 中，從位元組索引 i 開始的無號 8 位元整數設定為 v。
val set_int8 : bytes -> int -> int -> unitset_int8 b i v 會將 b 中，從位元組索引 i 開始的有號 8 位元整數設定為 v。
val set_uint16_ne : bytes -> int -> int -> unitset_uint16_ne b i v 會將 b 中，從位元組索引 i 開始的原生端無號 16 位元整數設定為 v。
val set_uint16_be : bytes -> int -> int -> unitset_uint16_be b i v 會將 b 中，從位元組索引 i 開始的大端無號 16 位元整數設定為 v。
val set_uint16_le : bytes -> int -> int -> unitset_uint16_le b i v 會將 b 中，從位元組索引 i 開始的小端無號 16 位元整數設定為 v。
val set_int16_ne : bytes -> int -> int -> unitset_int16_ne b i v 會將 b 中，從位元組索引 i 開始的原生端有號 16 位元整數設定為 v。
val set_int16_be : bytes -> int -> int -> unitset_int16_be b i v 會將 b 中，從位元組索引 i 開始的大端有號 16 位元整數設定為 v。
val set_int16_le : bytes -> int -> int -> unitset_int16_le b i v 會將 b 中，從位元組索引 i 開始的小端有號 16 位元整數設定為 v。
val set_int32_ne : bytes -> int -> int32 -> unitset_int32_ne b i v 會將 b 中，從位元組索引 i 開始的原生端 32 位元整數設定為 v。
val set_int32_be : bytes -> int -> int32 -> unitset_int32_be b i v 會將 b 中，從位元組索引 i 開始的大端 32 位元整數設定為 v。
val set_int32_le : bytes -> int -> int32 -> unitset_int32_le b i v 會將 b 中，從位元組索引 i 開始的小端 32 位元整數設定為 v。
val set_int64_ne : bytes -> int -> int64 -> unitset_int64_ne b i v 會將 b 中，從位元組索引 i 開始的原生端 64 位元整數設定為 v。
val set_int64_be : bytes -> int -> int64 -> unitset_int64_be b i v 會將 b 中，從位元組索引 i 開始的大端 64 位元整數設定為 v。
val set_int64_le : bytes -> int -> int64 -> unitset_int64_le b i v 會將 b 中，從位元組索引 i 開始的小端 64 位元整數設定為 v。
從多個網域並行存取位元組序列時必須謹慎：存取位元組序列永遠不會導致程式崩潰，但未同步的存取可能會產生令人意外的（非循序一致性）結果。
每個存取多個位元組的位元組序列操作都不是不可分割的，包括迭代和掃描。
例如，考慮以下程式：
let size = 100_000_000
let b = Bytes.make size ' '
let update b f () =
Bytes.iteri (fun i x -> Bytes.set b i (Char.chr (f (Char.code x)))) b
let d1 = Domain.spawn (update b (fun x -> x + 1))
let d2 = Domain.spawn (update b (fun x -> 2 * x + 1))
let () = Domain.join d1; Domain.join d2
位元組序列 b 可能包含 '!'、'A'、'B' 和 'C' 值的非確定性混合。
執行此程式碼後，序列 b 的每個位元組不是 '!'，就是 'A'、'B' 或 'C'。如果需要不可分割性，則使用者必須實作自己的同步機制（例如，使用 Mutex.t）。
如果兩個網域只存取位元組序列的不相交部分，則觀察到的行為等同於來自兩個網域的操作的某種循序交錯。
當兩個網域在沒有同步的情況下存取同一個位元組，且至少其中一個存取是寫入時，就會發生資料競爭。在沒有資料競爭的情況下，觀察到的行為等同於來自不同網域的操作的某種循序交錯。
應盡可能避免資料競爭，方法是使用同步機制來協調對序列元素的存取。
實際上，在出現資料競爭的情況下，程式不會崩潰，但觀察到的行為可能不等同於來自不同網域的任何操作的循序交錯。然而，即使在出現資料競爭的情況下，讀取操作也會傳回先前對該位置的寫入值。
另一個微妙的點是，如果資料競爭涉及對同一個位置進行混合大小的寫入和讀取，則網域觀察到這些寫入和讀取的順序並未指定。例如，以下程式碼會循序將一個 32 位元整數和一個 char 寫入同一個索引：
let b = Bytes.make 10 '\000'
let d1 = Domain.spawn (fun () -> Bytes.set_int32_ne b 0 100; b.[0] <- 'd' )
在這種情況下，觀察到對 b.0 寫入 'd' 的網域，不保證也會觀察到對索引 1、2 或 3 的寫入。