module Bytes: Bytesval length : bytes -> int回傳參數的長度（位元組數）。
val get : bytes -> int -> charget s n 回傳參數 s 中索引 n 的位元組。
Invalid_argument，如果 n 不是 s 中的有效索引。val set : bytes -> int -> char -> unitset s n c 就地修改 s，將索引 n 的位元組替換為 c。
Invalid_argument，如果 n 不是 s 中的有效索引。val create : int -> bytescreate n 回傳長度為 n 的新位元組序列。該序列未初始化，且包含任意位元組。
Invalid_argument，如果 n < 0 或 n > Sys.max_string_length。val make : int -> char -> bytesmake n c 回傳長度為 n 的新位元組序列，並以位元組 c 填充。
Invalid_argument，如果 n < 0 或 n > Sys.max_string_length。val init : int -> (int -> char) -> bytesinit n f 回傳長度為 n 的全新位元組序列，其中字元 i 初始化為 f i 的結果（按索引遞增順序）。
Invalid_argument，如果 n < 0 或 n > Sys.max_string_length。val empty : bytes大小為 0 的位元組序列。
val copy : bytes -> bytes回傳一個新的位元組序列，其中包含與參數相同的位元組。
val of_string : string -> bytes回傳一個新的位元組序列，其中包含與給定字串相同的位元組。
val to_string : bytes -> string回傳一個新的字串，其中包含與給定位元組序列相同的位元組。
val sub : bytes -> int -> int -> bytessub s pos len 回傳一個長度為 len 的新位元組序列，其中包含從位置 pos 開始且長度為 len 的 s 子序列。
Invalid_argument，如果 pos 和 len 未指定 s 的有效範圍。val sub_string : bytes -> int -> int -> string與 Bytes.sub 相同，但回傳字串而不是位元組序列。
val extend : bytes -> int -> int -> bytesextend s left right 回傳一個新的位元組序列，其中包含 s 的位元組，並在其前面加上 left 個未初始化的位元組，並在其後面加上 right 個未初始化的位元組。如果 left 或 right 為負數，則從 s 的對應側移除位元組（而不是附加）。
Invalid_argument，如果結果長度為負數或長於 Sys.max_string_length 個位元組。val fill : bytes -> int -> int -> char -> unitfill s pos len c 就地修改 s，從 pos 開始，將 len 個字元替換為 c。
Invalid_argument，如果 pos 和 len 未指定 s 的有效範圍。val blit : bytes -> int -> bytes -> int -> int -> unitblit src src_pos dst dst_pos len 從位元組序列 src 的索引 src_pos 開始，複製 len 個位元組到位元組序列 dst 的索引 dst_pos。即使 src 和 dst 是相同的位元組序列，且來源和目的地間隔重疊，它也能正確運作。
Invalid_argument，如果 src_pos 和 len 未指定 src 的有效範圍，或者如果 dst_pos 和 len 未指定 dst 的有效範圍。val blit_string : string -> int -> bytes -> int -> int -> unitblit_string src src_pos dst dst_pos len 從字串 src 的索引 src_pos 開始，複製 len 個位元組到位元組序列 dst 的索引 dst_pos。
Invalid_argument，如果 src_pos 和 len 未指定 src 的有效範圍，或者如果 dst_pos 和 len 未指定 dst 的有效範圍。val concat : bytes -> bytes list -> bytesconcat sep sl 連接位元組序列清單 sl，在每個序列之間插入分隔位元組序列 sep，並將結果回傳為新的位元組序列。
Invalid_argument，如果結果長於 Sys.max_string_length 個位元組。val cat : bytes -> bytes -> bytescat s1 s2 連接 s1 和 s2，並將結果回傳為新的位元組序列。
Invalid_argument，如果結果長於 Sys.max_string_length 個位元組。val iter : (char -> unit) -> bytes -> unititer f s 依序將函式 f 應用於 s 的所有位元組。它等同於 f (get s 0); f (get s 1); ...; f (get s。
(length s - 1)); ()
val iteri : (int -> char -> unit) -> bytes -> unit與 Bytes.iter 相同，但函式的第一個引數會應用於位元組的索引，第二個引數為位元組本身。
val map : (char -> char) -> bytes -> bytesmap f s 依序將函式 f 應用於 s 的所有位元組（按索引遞增順序），並將結果位元組儲存在新的序列中，該序列會作為結果回傳。
val mapi : (int -> char -> char) -> bytes -> bytesmapi f s 使用 s 的每個字元及其索引（按索引遞增順序）呼叫 f，並將結果位元組儲存在新的序列中，該序列會作為結果回傳。
val fold_left : ('acc -> char -> 'acc) -> '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 : (char -> 'acc -> 'acc) -> bytes -> '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 : (char -> bool) -> bytes -> boolfor_all p s 檢查 s 中的所有字元是否滿足謂詞 p。
val exists : (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) 之外的字元，以及反斜線和雙引號都會被跳脫。
Invalid_argument，如果結果長於 Sys.max_string_length 個位元組。val index : bytes -> char -> intindex s c 回傳 s 中第一個出現的位元組 c 的索引。
Not_found，如果 c 未在 s 中出現。val index_opt : bytes -> char -> int optionindex_opt s c 回傳 s 中第一個出現的位元組 c 的索引，如果 c 未在 s 中出現，則回傳 None。
val rindex : bytes -> char -> intrindex s c 回傳 s 中最後一個出現的位元組 c 的索引。
Not_found，如果 c 未在 s 中出現。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。
Invalid_argument，如果 i 不是 s 中的有效位置。Not_found，如果 c 未在位置 i 之後的 s 中出現。val index_from_opt : bytes -> int -> char -> int optionindex_from_opt s i c 回傳 s 中位置 i 之後第一個出現的位元組 c 的索引，如果 c 未在位置 i 之後的 s 中出現，則回傳 None。index_opt s c 等同於 index_from_opt s 0 c。
Invalid_argument，如果 i 不是 s 中的有效位置。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。
Invalid_argument，如果 i+1 不是 s 中的有效位置。Not_found，如果 c 未在位置 i+1 之前的 s 中出現。val rindex_from_opt : bytes -> int -> char -> int optionrindex_from_opt s i c 回傳 s 中位置 i+1 之前最後一個出現的位元組 c 的索引，如果 c 未在位置 i+1 之前的 s 中出現，則回傳 None。rindex_opt s c 等同於 rindex_from s (length s - 1) c。
Invalid_argument，如果 i+1 不是 s 中的有效位置。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
Invalid_argument，如果 start 不是 s 中的有效位置。val rcontains_from : bytes -> int -> char -> boolrcontains_from s stop c 測試位元組 c 是否在 s 中位置 stop+1 之前出現。
Invalid_argument，如果 stop < 0 或 stop+1 不是 s 中的有效位置。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 選項提供的字串不可變性。這些函式適用於專業程式庫作者，但對於大多數用途，您應該使用永遠正確的 Bytes.to_string 和 Bytes.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 : char -> bytes -> bytes listsplit_on_char sep s 會回傳由 sep 字元分隔的 s 所有（可能為空）子序列的列表。如果 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 的位置以 UTF-8 編碼 u，並回傳從 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 的位置以 UTF-16BE 編碼 u，並回傳從 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 的位置以 UTF-16LE 編碼 u，並回傳從 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。
小端序（或大端序）編碼表示最不重要的位元組（或最重要位元組）會先儲存。大端序也稱為網路位元組序。原生端序編碼是小端序或大端序，取決於 Sys.big_endian。
32 位元和 64 位元整數由 int32 和 int64 類型表示，可以將其解釋為帶符號或不帶符號的數字。
8 位元和 16 位元整數由 int 類型表示，該類型具有比二進位制編碼更多的位元。這些額外位元的處理方式如下
int 值表示的帶符號（或不帶符號）8 位元或 16 位元整數解碼的函式會對其結果進行符號擴展（或零擴展）。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' )
在這種情況下，觀察到將 'd' 寫入 b.0 的網域不保證也會觀察到寫入索引 1、2 或 3 的寫入。