數值索引


( * ) [Stdlib]	整數乘法。
( ** ) [Stdlib]	指數運算。
( *. ) [Stdlib]	浮點數乘法。
(!) [Stdlib]	`!r` 傳回參照 `r` 的目前內容。
(!=) [Stdlib]	`(==)` 的否定。
(&&) [Stdlib]	布林「且」。
(&&) [Bool]	`e0 && e1` 是表達式 `e0` 和 `e1` 的惰性布林連詞。
(+) [Stdlib]	整數加法。
(+.) [Stdlib]	浮點數加法。
(-) [Stdlib]	整數減法。
(-.) [Stdlib]	浮點數減法。
(/) [Stdlib]	整數除法。
(/.) [Stdlib]	浮點數除法。
(:=) [Stdlib]	`r := a` 將 `a` 的值儲存在參照 `r` 中。
(<) [Stdlib]	請參閱 `(>=)`。
(<=) [Stdlib]	請參閱 `(>=)`。
(<>) [Stdlib]	`(=)` 的否定。
(=) [Stdlib]	`e1 = e2` 測試 `e1` 和 `e2` 的結構相等性。
(==) [Stdlib]	`e1 == e2` 測試 `e1` 和 `e2` 的物理相等性。
(>) [Stdlib]	請參閱 `(>=)`。
(>=) [Stdlib]	結構排序函式。
(@) [Stdlib]	`l0 @ l1` 將 `l1` 附加到 `l0`。
(@@) [Stdlib]	應用運算子：`g @@ f @@ x` 完全等同於 `g (f (x))`。
(^) [Stdlib]	字串串連。
(^^) [Stdlib]	`f1 ^^ f2` 將格式字串 `f1` 和 `f2` 串連起來。
(asr) [Stdlib]	`n asr m` 將 `n` 向右位移 `m` 個位元。
(land) [Stdlib]	位元邏輯「且」。
(lor) [Stdlib]	位元邏輯「或」。
(lsl) [Stdlib]	`n lsl m` 將 `n` 向左位移 `m` 個位元。
(lsr) [Stdlib]	`n lsr m` 將 `n` 向右位移 `m` 個位元。
(lxor) [Stdlib]	位元邏輯互斥「或」。
(mod) [Stdlib]	整數餘數。
(\|>) [Stdlib]	反向應用運算子：`x \|> f \|> g` 完全等同於 `g (f (x))`。
(\|\|) [Stdlib]	布林「或」。
(\|\|) [Bool]	`e0 \|\| e1` 是表達式 `e0` 和 `e1` 的惰性布林析取。
(~+) [Stdlib]	一元加法。
(~+.) [Stdlib]	一元加法。
(~-) [Stdlib]	一元否定。
(~-.) [Stdlib]	一元否定。
__FILE__ [Stdlib]	`__FILE__` 傳回編譯器目前正在剖析的檔案名稱。
__FUNCTION__ [Stdlib]	`__FUNCTION__` 傳回目前函式或方法的名稱，包括任何封閉模組或類別。
__LINE_OF__ [Stdlib]	`__LINE_OF__ expr` 傳回一個配對 `(line, expr)`，其中 `line` 是表達式 `expr` 出現在編譯器目前正在剖析的檔案中的行號。
__LINE__ [Stdlib]	`__LINE__` 傳回此表達式出現在編譯器目前正在剖析的檔案中的行號。
__LOC_OF__ [Stdlib]	`__LOC_OF__ expr` 傳回一個配對 `(loc, expr)`，其中 `loc` 是 `expr` 在編譯器目前正在剖析的檔案中的位置，採用 OCaml 的標準錯誤格式：「File %S, line %d, characters %d-%d」。
__LOC__ [Stdlib]	`__LOC__` 傳回此表達式出現在編譯器目前正在剖析的檔案中的位置，採用 OCaml 的標準錯誤格式：「File %S, line %d, characters %d-%d」。
__MODULE__ [Stdlib]	`__MODULE__` 傳回編譯器正在剖析的檔案的模組名稱。
__POS_OF__ [Stdlib]	`__POS_OF__ expr` 傳回一個配對 `(loc,expr)`，其中 `loc` 是一個元組 `(file,lnum,cnum,enum)`，對應於表達式 `expr` 出現在編譯器目前正在剖析的檔案中的位置。
__POS__ [Stdlib]	`__POS__` 傳回一個元組 `(file,lnum,cnum,enum)`，對應於此表達式出現在編譯器目前正在剖析的檔案中的位置。
_exit [UnixLabels]	立即終止呼叫進程，並將指定的狀態碼傳回作業系統：通常 0 表示沒有錯誤，而小的正整數表示失敗。
_exit [Unix]	立即終止呼叫進程，並將指定的狀態碼傳回作業系統：通常 0 表示沒有錯誤，而小的正整數表示失敗。
A
abs [Stdlib]	`abs x` 是 `x` 的絕對值。
abs [Nativeint]	`abs x` 是 `x` 的絕對值。
abs [Int64]	`abs x` 是 `x` 的絕對值。
abs [Int32]	`abs x` 是 `x` 的絕對值。
abs [Int]	`abs x` 是 `x` 的絕對值。
abs [Float]	`abs f` 傳回 `f` 的絕對值。
abs_float [Stdlib]	`abs_float f` 傳回 `f` 的絕對值。
abstract_tag [Obj]
accept [UnixLabels]	接受給定 socket 上的連線。
accept [Unix]	接受給定 socket 上的連線。
access [UnixLabels]	檢查進程是否對指定名稱的檔案擁有給定的權限。
access [Unix]	檢查進程是否對指定名稱的檔案擁有給定的權限。
acos [Stdlib]	反餘弦。
acos [Float]	反餘弦。
acosh [Stdlib]	雙曲反餘弦。
acosh [Float]	雙曲反餘弦。
acquire [Semaphore.Binary]	`acquire s` 會封鎖呼叫執行緒，直到號誌 `s` 的值為 1 (可用) 為止，然後自動將其設定為 0 並傳回。
acquire [Semaphore.Counting]	`acquire s` 會封鎖呼叫執行緒，直到號誌 `s` 的值不為零為止，然後自動遞減 `s` 的值並傳回。
adapt_filename [Dynlink]	在位元組碼中，是恆等函式。
add [Weak.S]	`add t x` 將 `x` 新增到 `t`。
add [Set.S]	`add x s` 傳回一個包含 `s` 的所有元素，再加上 `x` 的集合。
add [Queue]	`add x q` 將元素 `x` 新增到佇列 `q` 的末尾。
add [Nativeint]	加法。
add [MoreLabels.Set.S]	`add x s` 傳回一個包含 `s` 的所有元素，再加上 `x` 的集合。
add [MoreLabels.Map.S]	`add ~key ~data m` 傳回一個包含與 `m` 相同的繫結的對應，再加上 `key` 到 `data` 的繫結。
add [MoreLabels.Hashtbl.SeededS]
add [MoreLabels.Hashtbl.S]
add [MoreLabels.Hashtbl]	`Hashtbl.add tbl ~key ~data` 將 `key` 與 `data` 的綁定加入到表 `tbl` 中。
add [Map.S]	`add key data m` 返回一個包含與 `m` 相同綁定，再加上 `key` 到 `data` 的綁定的映射。
add [Int64]	加法。
add [Int32]	加法。
add [Int]	`add x y` 是加法 `x + y`。
add [Hashtbl.SeededS]
add [Hashtbl.S]
add [Hashtbl]	`Hashtbl.add tbl key data` 將 `key` 與 `data` 的綁定加入到表 `tbl` 中。
add [Float]	浮點數加法。
add [Ephemeron.Kn.Bucket]	將一個暫存器加入到桶中。
add [Ephemeron.K2.Bucket]	將一個暫存器加入到桶中。
add [Ephemeron.K1.Bucket]	將一個暫存器加入到桶中。
add [Ephemeron.SeededS]
add [Ephemeron.S]
add [Complex]	加法
add_buffer [Buffer]	`add_buffer b1 b2` 將緩衝區 `b2` 的當前內容附加到緩衝區 `b1` 的末尾。
add_bytes [Buffer]	`add_bytes b s` 將位元組序列 `s` 附加到緩衝區 `b` 的末尾。
add_channel [Buffer]	`add_channel b ic n` 從輸入通道 `ic` 讀取最多 `n` 個字元，並將它們儲存在緩衝區 `b` 的末尾。
add_char [Buffer]	`add_char b c` 將字元 `c` 附加到緩衝區 `b` 的末尾。
add_in_char_set [CamlinternalFormat]
add_initializer [CamlinternalOO]
add_int16_be [Buffer]	`add_int16_be b i` 將一個二進位大端有號 16 位元整數 `i` 附加到 `b`。
add_int16_le [Buffer]	`add_int16_le b i` 將一個二進位小端有號 16 位元整數 `i` 附加到 `b`。
add_int16_ne [Buffer]	`add_int16_ne b i` 將一個二進位原生端有號 16 位元整數 `i` 附加到 `b`。
add_int32_be [Buffer]	`add_int32_be b i` 將一個二進位大端 32 位元整數 `i` 附加到 `b`。
add_int32_le [Buffer]	`add_int32_le b i` 將一個二進位小端 32 位元整數 `i` 附加到 `b`。
add_int32_ne [Buffer]	`add_int32_ne b i` 將一個二進位原生端 32 位元整數 `i` 附加到 `b`。
add_int64_be [Buffer]	`add_int64_be b i` 將一個二進位大端 64 位元整數 `i` 附加到 `b`。
add_int64_le [Buffer]	`add_int64_ne b i` 將一個二進位小端 64 位元整數 `i` 附加到 `b`。
add_int64_ne [Buffer]	`add_int64_ne b i` 將一個二進位原生端 64 位元整數 `i` 附加到 `b`。
add_int8 [Buffer]	`add_int8 b i` 將一個二進位有號 8 位元整數 `i` 附加到 `b`。
add_last [Dynarray]	`add_last a x` 將元素 `x` 加入到陣列 `a` 的末尾。
add_offset [Obj]
add_seq [Stack]	將序列中的元素加到堆疊頂部。
add_seq [Set.S]	依序將給定的元素加到集合中。
add_seq [Queue]	將序列中的元素加到佇列的末尾。
add_seq [MoreLabels.Set.S]	依序將給定的元素加到集合中。
add_seq [MoreLabels.Map.S]	依序將給定的綁定加到映射中。
add_seq [MoreLabels.Hashtbl.SeededS]
add_seq [MoreLabels.Hashtbl.S]
add_seq [MoreLabels.Hashtbl]	使用 `MoreLabels.Hashtbl.add` 將給定的綁定加入到表中
add_seq [Map.S]	依序將給定的綁定加到映射中。
add_seq [Hashtbl.SeededS]
add_seq [Hashtbl.S]
add_seq [Hashtbl]	使用 `Hashtbl.add` 將給定的綁定加入到表中
add_seq [Ephemeron.SeededS]
add_seq [Ephemeron.S]
add_seq [Buffer]	將字元加入到緩衝區
add_string [Buffer]	`add_string b s` 將字串 `s` 附加到緩衝區 `b` 的末尾。
add_subbytes [Buffer]	`add_subbytes b s ofs len` 從位元組序列 `s` 中偏移量 `ofs` 開始取 `len` 個字元，並將它們附加到緩衝區 `b` 的末尾。
add_substitute [Buffer]	`add_substitute b f s` 將帶有替換的字串模式 `s` 附加到緩衝區 `b` 的末尾。
add_substring [Buffer]	`add_substring b s ofs len` 從字串 `s` 中偏移量 `ofs` 開始取 `len` 個字元，並將它們附加到緩衝區 `b` 的末尾。
add_symbolic_output_item [Format]	`add_symbolic_output_item sob itm` 將項目 `itm` 加入到緩衝區 `sob`。
add_to_list [MoreLabels.Map.S]	`add_to_list ~key ~data m` 是 `m`，其中 `key` 映射到 `l`，使得如果 `key` 在 `m` 中綁定，則 `l` 是 `data :: Map.find key m`，否則為 `[v]`。
add_to_list [Map.S]	`add_to_list key data m` 是 `m`，其中 `key` 映射到 `l`，使得如果 `key` 在 `m` 中綁定，則 `l` 是 `data :: Map.find key m`，否則為 `[v]`。
add_uint16_be [Buffer]	`add_uint16_be b i` 將一個二進位大端無號 16 位元整數 `i` 附加到 `b`。
add_uint16_le [Buffer]	`add_uint16_le b i` 將一個二進位小端無號 16 位元整數 `i` 附加到 `b`。
add_uint16_ne [Buffer]	`add_uint16_ne b i` 將一個二進位原生端無號 16 位元整數 `i` 附加到 `b`。
add_uint8 [Buffer]	`add_uint8 b i` 將一個二進位無號 8 位元整數 `i` 附加到 `b`。
add_user_event [Runtime_events.Callbacks]	`add_user_event ty callback t` 擴展 `t` 以額外訂閱類型為 `ty` 的使用者事件。
add_utf_16be_uchar [Buffer]	`add_utf_16be_uchar b u` 將 `u` 的 UTF-16BE 編碼附加到緩衝區 `b` 的末尾。
add_utf_16le_uchar [Buffer]	`add_utf_16le_uchar b u` 將 `u` 的 UTF-16LE 編碼附加到緩衝區 `b` 的末尾。
add_utf_8_uchar [Buffer]	`add_utf_8_uchar b u` 將 `u` 的 UTF-8 編碼附加到緩衝區 `b` 的末尾。
alarm [UnixLabels]	在給定的秒數後排程一個 `SIGALRM` 訊號。
alarm [Unix]	在給定的秒數後排程一個 `SIGALRM` 訊號。
align [Arg]	根據關鍵字的長度，通過在第一個對齊分隔符（Tab，如果找不到 Tab，則為空格）處插入空格來對齊文件字串。
all_units [Dynlink]	返回構成主程式的編譯單元列表，以及通過 `loadfile` 動態載入的（而不是通過 `loadfile_private` 載入的）編譯單元。
allocated_bytes [Gc]	返回此網域和可能先前網域分配的位元組數。
allow_only [Dynlink]	`allow_only units` 將允許的單元列表設定為現有允許的單元與給定單元列表的交集。
allow_unsafe_modules [Dynlink]	控制是否允許動態連結不安全的物件檔案。
always [Event]	`always v` 傳回一個永遠準備好進行同步的事件。
append [Seq]	`append xs ys` 是序列 `xs` 和 `ys` 的串接。
append [ListLabels]	`append l0 l1` 將 `l1` 附加到 `l0`。
append [List]	`append l0 l1` 將 `l1` 附加到 `l0`。
append [Float.ArrayLabels]	`append v1 v2` 傳回一個新的浮點數陣列，其中包含浮點數陣列 `v1` 和 `v2` 的串接。
append [Float.Array]	`append v1 v2` 傳回一個新的浮點數陣列，其中包含浮點數陣列 `v1` 和 `v2` 的串接。
append [Dynarray]	`append a b` 類似於 `append_array a b`，但 `b` 本身是一個動態陣列，而不是固定大小的陣列。
append [ArrayLabels]	`append v1 v2` 傳回一個新的陣列，其中包含陣列 `v1` 和 `v2` 的串接。
append [Array]	`append v1 v2` 傳回一個新的陣列，其中包含陣列 `v1` 和 `v2` 的串接。
append_array [Dynarray]	`append_array a b` 將 `b` 的所有元素按照它們在 `b` 中出現的順序添加到 `a` 的末尾。
append_iter [Dynarray]	`append_iter a iter x` 將 `x` 的每個元素添加到 `a` 的末尾。
append_list [Dynarray]	與 `Dynarray.append_array` 類似，但使用列表。
append_seq [Dynarray]	與 `Dynarray.append_array` 類似，但使用序列。
arg [Complex]	參數。
argv [Sys]	傳遞給進程的命令列引數。
array0_of_genarray [Bigarray]	傳回對應於給定泛型 Bigarray 的零維 Bigarray。
array1_of_genarray [Bigarray]	傳回對應於給定泛型 Bigarray 的一維 Bigarray。
array2_of_genarray [Bigarray]	傳回對應於給定泛型 Bigarray 的二維 Bigarray。
array3_of_genarray [Bigarray]	傳回對應於給定泛型 Bigarray 的三維 Bigarray。
asin [Stdlib]	反正弦。
asin [Float]	反正弦。
asinh [Stdlib]	雙曲反正弦。
asinh [Float]	雙曲反正弦。
asprintf [Format]	與上面的 `printf` 相同，但不是列印在格式器上，而是傳回一個包含引數格式化結果的字串。
assoc [ListLabels]	`assoc a l` 傳回與配對列表 `l` 中鍵 `a` 相關聯的值。
assoc [List]	`assoc a l` 傳回與配對列表 `l` 中鍵 `a` 相關聯的值。
assoc_opt [ListLabels]	`assoc_opt a l` 傳回與配對列表 `l` 中鍵 `a` 相關聯的值。
assoc_opt [List]	`assoc_opt a l` 傳回與配對列表 `l` 中鍵 `a` 相關聯的值。
assq [ListLabels]	與 `ListLabels.assoc` 相同，但使用物理相等性而不是結構相等性來比較鍵。
assq [List]	與 `List.assoc` 相同，但使用物理相等性而不是結構相等性來比較鍵。
assq_opt [ListLabels]	與 `ListLabels.assoc_opt` 相同，但使用物理相等性而不是結構相等性來比較鍵。
assq_opt [List]	與 `List.assoc_opt` 相同，但使用物理相等性而不是結構相等性來比較鍵。
at_exit [Stdlib]	註冊給定函數在程式終止時呼叫。
at_exit [Domain]	`at_exit f` 註冊 `f`，以便在目前網域退出時呼叫。
atan [Stdlib]	反正切。
atan [Float]	反正切。
atan2 [Stdlib]	`atan2 y x` 傳回 `y /. x` 的反正切。
atan2 [Float]	`atan2 y x` 傳回 `y /. x` 的反正切。
atanh [Stdlib]	雙曲反正切。
atanh [Float]	雙曲反正切。
B
backend_type [Sys]	目前執行 OCaml 程式的後端類型。
backtrace_slots [Printexc]	傳回原始回溯的插槽，如果它們都不包含有用的資訊，則傳回 `None`。
backtrace_slots_of_raw_entry [Printexc]	傳回單個原始回溯條目的插槽，如果此條目缺少除錯資訊，則傳回 `None`。
backtrace_status [Printexc]	`Printexc.backtrace_status()` 如果目前記錄異常回溯，則傳回 `true`，如果沒有，則傳回 `false`。
basename [Filename]	將檔案名稱分割成目錄名稱/基本檔案名稱。
before_first_spawn [Domain]	`before_first_spawn f` 註冊 `f`，以便在程式產生第一個網域之前呼叫。
beginning_of_input [Scanf.Scanning]	`Scanning.beginning_of_input ic` 測試給定的 `Scanf.Scanning.in_channel` 格式化輸入通道的輸入條件開頭。
big_endian [Sys]	目前執行 Caml 程式的機器是否為大端。
bind [UnixLabels]	將 socket 繫結到位址。
bind [Unix]	將 socket 繫結到位址。
bind [Result]	如果 `r` 為 `Ok v`，則 `bind r f` 為 `f v`，如果 `r` 為 `Error _`，則為 `r`。
bind [Option]	如果 `o` 為 `Some v`，則 `bind o f` 為 `f v`，如果 `o` 為 `None`，則為 `None`。
bindings [MoreLabels.Map.S]	傳回給定 map 的所有繫結列表。
bindings [Map.S]	傳回給定 map 的所有繫結列表。
bits [Random.State]
bits [Random]	以非負整數形式傳回 30 個隨機位元。
bits32 [Random.State]
bits32 [Random]	`Random.bits32 ()` 傳回 32 個隨機位元，作為介於 `Int32.min_int` 和 `Int32.max_int` 之間的整數。
bits64 [Random.State]
bits64 [Random]	`Random.bits64 ()` 傳回 64 個隨機位元，作為介於 `Int64.min_int` 和 `Int64.max_int` 之間的整數。
bits_of_float [Int64]	根據 IEEE 754 浮點「雙精度格式」位元配置，傳回給定浮點數的內部表示法。
bits_of_float [Int32]	根據 IEEE 754 浮點「單精度格式」位元配置，傳回給定浮點數的內部表示法。
blit [Weak]	`Weak.blit ar1 off1 ar2 off2 len` 從 `ar1`（從 `off1` 開始）複製 `len` 個弱指標到 `ar2`（從 `off2` 開始）。
blit [String]	與應該優先使用的 `Bytes.blit_string` 相同。
blit [StringLabels]	與應該優先使用的 `Bytes.blit_string` 相同。
blit [Float.ArrayLabels]	`blit ~src ~src_pos ~dst ~dst_pos ~len` 從浮點數陣列 `src` 複製 `len` 個元素（從元素編號 `src_pos` 開始）到浮點數陣列 `dst`（從元素編號 `dst_pos` 開始）。
blit [Float.Array]	`blit src src_pos dst dst_pos len` 從浮點數陣列 `src` 複製 `len` 個元素（從元素編號 `src_pos` 開始）到浮點數陣列 `dst`（從元素編號 `dst_pos` 開始）。
blit [BytesLabels]	`blit ~src ~src_pos ~dst ~dst_pos ~len` 從位元組序列 `src` 複製 `len` 個位元組（從索引 `src_pos` 開始）到位元組序列 `dst`（從索引 `dst_pos` 開始）。
blit [Bytes]	`blit src src_pos dst dst_pos len` 從位元組序列 `src` 複製 `len` 個位元組（從索引 `src_pos` 開始）到位元組序列 `dst`（從索引 `dst_pos` 開始）。
blit [Buffer]	`Buffer.blit src srcoff dst dstoff len` 從緩衝區 `src` 的目前內容（從偏移量 `srcoff` 開始）複製 `len` 個字元到 `dst`（從字元 `dstoff` 開始）。
blit [Bigarray.Array3]	將第一個 Bigarray 複製到第二個 Bigarray。
blit [Bigarray.Array2]	將第一個 Bigarray 複製到第二個 Bigarray。
blit [Bigarray.Array1]	將第一個 Bigarray 複製到第二個 Bigarray。
blit [Bigarray.Array0]	將第一個 Bigarray 複製到第二個 Bigarray。
blit [Bigarray.Genarray]	將一個 Bigarray 的所有元素複製到另一個 Bigarray 中。
blit [ArrayLabels]	`blit ~src ~src_pos ~dst ~dst_pos ~len` 從陣列 `src` 的 `src_pos` 索引位置開始，複製 `len` 個元素到陣列 `dst` 的 `dst_pos` 索引位置開始。
blit [Array]	`blit src src_pos dst dst_pos len` 從陣列 `src` 的 `src_pos` 索引位置開始，複製 `len` 個元素到陣列 `dst` 的 `dst_pos` 索引位置開始。
blit_data [Obj.Ephemeron]
blit_key [Obj.Ephemeron]
blit_string [BytesLabels]	`blit_string ~src ~src_pos ~dst ~dst_pos ~len` 從字串 `src` 的 `src_pos` 索引位置開始，複製 `len` 個位元組到位元組序列 `dst` 的 `dst_pos` 索引位置開始。
blit_string [Bytes]	`blit_string src src_pos dst dst_pos len` 從字串 `src` 的 `src_pos` 索引位置開始，複製 `len` 個位元組到位元組序列 `dst` 的 `dst_pos` 索引位置開始。
bom [Uchar]	`bom` 是 U+FEFF，即位元組順序標記 (BOM) 字元。
bool [Random.State]
bool [Random]	`Random.bool ()` 返回 `true` 或 `false`，各自的機率為 0.5。
bool_of_string [Stdlib]	與 `bool_of_string_opt` 相同，但會拋出 `Invalid_argument "bool_of_string"` 異常，而不是返回 `None`。
bool_of_string_opt [Stdlib]	將給定的字串轉換為布林值。
bounded_full_split [Str]	與 `Str.bounded_split_delim` 相同，但也會返回分隔符號以及分隔符號之間包含的子字串。
bounded_split [Str]	與 `Str.split` 相同，但最多會分割成 `n` 個子字串，其中 `n` 是額外的整數參數。
bounded_split_delim [Str]	與 `Str.bounded_split` 相同，但會識別字串開頭和結尾處的分隔符號，並在結果中將其作為空字串返回。
bprintf [Printf]	與 `Printf.fprintf` 相同，但不是在輸出通道上列印，而是將格式化的引數附加到給定的可擴充緩衝區 (請參閱模組 `Buffer`)。
broadcast [Condition]	`broadcast c` 會喚醒所有等待條件變數 `c` 的執行緒。
bscanf [Scanf]
bscanf_format [Scanf]	`bscanf_format ic fmt f` 根據給定的格式字串 `fmt`，從格式化的輸入通道 `ic` 讀取格式字串符號，並將 `f` 應用於產生的格式字串值。
bscanf_opt [Scanf]	與 `Scanf.bscanf` 相同，但如果掃描失敗，則返回 `None`。
bufput_acc [CamlinternalFormat]
bytes [Digest.S]	傳回給定位元組序列的摘要。
bytes [Digest]	傳回給定位元組序列的摘要。
C
c_layout [Bigarray]
capacity [Dynarray]	`capacity a` 是 `a` 的支援陣列的長度。
capitalize_ascii [String]	`capitalize_ascii s` 會傳回 `s`，並使用 US-ASCII 字元集將第一個字元設定為大寫。
capitalize_ascii [StringLabels]	`capitalize_ascii s` 會傳回 `s`，並使用 US-ASCII 字元集將第一個字元設定為大寫。
capitalize_ascii [BytesLabels]	傳回引數的副本，並使用 US-ASCII 字元集將第一個字元設定為大寫。
capitalize_ascii [Bytes]	傳回引數的副本，並使用 US-ASCII 字元集將第一個字元設定為大寫。
cardinal [Set.S]	傳回集合中的元素數目。
cardinal [MoreLabels.Set.S]	傳回集合中的元素數目。
cardinal [MoreLabels.Map.S]	傳回對應中的繫結數目。
cardinal [Map.S]	傳回對應中的繫結數目。
cat [String]	`cat s1 s2` 會串連 s1 和 s2 (`s1 ^ s2`)。
cat [StringLabels]	`cat s1 s2` 會串連 s1 和 s2 (`s1 ^ s2`)。
cat [BytesLabels]	`cat s1 s2` 會串連 `s1` 和 `s2`，並以新的位元組序列傳回結果。
cat [Bytes]	`cat s1 s2` 會串連 `s1` 和 `s2`，並以新的位元組序列傳回結果。
catch [Printexc]	`Printexc.catch fn x` 類似於 `Printexc.print`，但在列印未捕獲的例外狀況後，會中止程式並返回結束代碼 2。
catch_break [Sys]	`catch_break` 控制互動式中斷 (ctrl-C) 是終止程式，還是引發 `Break` 例外狀況。
cbrt [Float]	立方根。
ceil [Stdlib]	向上捨入到整數值。
ceil [Float]	向上捨入到整數值。
change_layout [Bigarray.Array3]	`Array3.change_layout a layout` 會傳回具有指定 `layout` 的 Bigarray，並與 `a` 共用資料 (因此具有與 `a` 相同的維度)。
change_layout [Bigarray.Array2]	`Array2.change_layout a layout` 會傳回具有指定 `layout` 的 Bigarray，並與 `a` 共用資料 (因此具有與 `a` 相同的維度)。
change_layout [Bigarray.Array1]	`Array1.change_layout a layout` 會傳回具有指定 `layout` 的 Bigarray，並與 `a` 共用資料 (因此具有與 `a` 相同的維度)。
change_layout [Bigarray.Array0]	`Array0.change_layout a layout` 會傳回具有指定 `layout` 的 Bigarray，並與 `a` 共用資料。
change_layout [Bigarray.Genarray]	`Genarray.change_layout a layout` 會傳回具有指定 `layout` 的 Bigarray，並與 `a` 共用資料 (因此具有與 `a` 相同的維度)。
channel [Digest.S]	從通道讀取字元並傳回其摘要。
channel [Digest]	如果 `len` 為非負數，則 `Digest.channel ic len` 會從通道 `ic` 讀取 `len` 個字元並傳回其摘要，或者如果在讀取 `len` 個字元之前到達檔案結尾，則會拋出 `End_of_file` 例外狀況。
char [Bigarray]	如以上值的類型所示，使用 OCaml 類型 `float` 存取 `float16_elt`、`float32_elt` 和 `float64_elt` 類型的 Bigarray。
char_of_iconv [CamlinternalFormat]
char_of_int [Stdlib]	傳回具有給定 ASCII 碼的字元。
chdir [UnixLabels]	變更處理程序的工作目錄。
chdir [Unix]	變更處理程序的工作目錄。
chdir [Sys]	變更處理程序的目前工作目錄。
check [Weak]	`Weak.check ar n` 如果 `ar` 的第 `n` 個儲存格已滿，則傳回 `true`，如果為空，則傳回 `false`。
check_data [Obj.Ephemeron]
check_geometry [Format]	檢查格式器幾何是否有效：`1 < max_indent < margin <` `Format.pp_infinity`
check_key [Obj.Ephemeron]
check_suffix [Filename]	如果檔案名稱 `name` 以字尾 `suff` 結尾，則 `check_suffix name suff` 傳回 `true`。
chmod [UnixLabels]	變更具名檔案的權限。
chmod [Unix]	變更具名檔案的權限。
choose [Set.S]	傳回給定集合的一個元素，如果集合為空，則拋出 `Not_found` 例外狀況。
choose [MoreLabels.Set.S]	傳回給定集合的一個元素，如果集合為空，則拋出 `Not_found` 例外狀況。
choose [MoreLabels.Map.S]	傳回給定對應的一個繫結，如果對應為空，則拋出 `Not_found` 例外狀況。
choose [Map.S]	傳回給定對應的一個繫結，如果對應為空，則拋出 `Not_found` 例外狀況。
choose [Event]	`choose evl` 會傳回清單 `evl` 中所有事件的替代事件。
choose_opt [Set.S]	傳回給定集合的一個元素，如果集合為空，則傳回 `None`。
choose_opt [MoreLabels.Set.S]	傳回給定集合的一個元素，如果集合為空，則傳回 `None`。
choose_opt [MoreLabels.Map.S]	傳回給定對應的一個繫結，如果對應為空，則傳回 `None`。
choose_opt [Map.S]	傳回給定對應的一個繫結，如果對應為空，則傳回 `None`。
chop_extension [Filename]	與 `Filename.remove_extension` 相同，但如果給定的名稱具有空的副檔名，則會引發 `Invalid_argument`。
chop_suffix [Filename]	`chop_suffix name suff` 從檔名 `name` 中移除後綴 `suff`。
chop_suffix_opt [Filename]	`chop_suffix_opt ~suffix filename` 如果可能，則從 `filename` 移除後綴，否則如果檔名不是以後綴結尾，則返回 `None`。
chown [UnixLabels]	變更指定檔案的擁有者 uid 和擁有者 gid。
chown [Unix]	變更指定檔案的擁有者 uid 和擁有者 gid。
chr [Char]	傳回具有給定 ASCII 碼的字元。
chroot [UnixLabels]	變更程序根目錄。
chroot [Unix]	變更程序根目錄。
classify_float [Stdlib]	返回給定浮點數的類別：正常、次正常、零、無限或非數字。
classify_float [Float]	返回給定浮點數的類別：正常、次正常、零、無限或非數字。
clean [Ephemeron.SeededS]	移除所有已失效的綁定。
clean [Ephemeron.S]	移除所有已失效的綁定。
clear [Weak.S]	從表格中移除所有元素。
clear [Stack]	從堆疊中捨棄所有元素。
clear [Queue]	從佇列中捨棄所有元素。
clear [MoreLabels.Hashtbl.SeededS]
clear [MoreLabels.Hashtbl.S]
clear [MoreLabels.Hashtbl]	清空雜湊表。
clear [Hashtbl.SeededS]
clear [Hashtbl.S]
clear [Hashtbl]	清空雜湊表。
clear [Ephemeron.Kn.Bucket]	從儲存桶中移除所有暫存對象。
clear [Ephemeron.K2.Bucket]	從儲存桶中移除所有暫存對象。
clear [Ephemeron.K1.Bucket]	從儲存桶中移除所有暫存對象。
clear [Ephemeron.SeededS]
clear [Ephemeron.S]
clear [Dynarray]	`clear a` 等同於 `truncate a 0`，它會移除 `a` 的所有元素。
clear [Buffer]	清空緩衝區。
clear_close_on_exec [UnixLabels]	清除給定描述符上的「執行時關閉」旗標。
clear_close_on_exec [Unix]	清除給定描述符上的「執行時關閉」旗標。
clear_nonblock [UnixLabels]	清除給定描述符上的「非阻塞」旗標。
clear_nonblock [Unix]	清除給定描述符上的「非阻塞」旗標。
clear_parser [Parsing]	清空剖析器堆疊。
clear_symbolic_output_buffer [Format]	`clear_symbolic_output_buffer sob` 重設緩衝區 `sob`。
close [UnixLabels]	關閉檔案描述符。
close [Unix]	關閉檔案描述符。
close [Out_channel]	關閉指定的通道，並刷新所有緩衝的寫入操作。
close [In_channel]	關閉指定的通道。
close_box [Format]	關閉最近開啟的漂亮列印方塊。
close_in [Stdlib]	關閉指定的通道。
close_in [Scanf.Scanning]	關閉與給定的 `Scanf.Scanning.in_channel` 格式化輸入通道相關聯的 `in_channel`。
close_in_noerr [Stdlib]	與 `close_in` 相同，但會忽略所有錯誤。
close_noerr [Out_channel]	與 `Out_channel.close` 相同，但會忽略所有錯誤。
close_noerr [In_channel]	與 `In_channel.close` 相同，但會忽略所有錯誤。
close_out [Stdlib]	關閉指定的通道，並刷新所有緩衝的寫入操作。
close_out_noerr [Stdlib]	與 `close_out` 相同，但會忽略所有錯誤。
close_process [UnixLabels]	關閉由 `UnixLabels.open_process` 開啟的通道，等待相關聯的命令終止，並返回其終止狀態。
close_process [Unix]	關閉由 `Unix.open_process` 開啟的通道，等待相關聯的命令終止，並返回其終止狀態。
close_process_full [UnixLabels]	關閉由 `UnixLabels.open_process_full` 開啟的通道，等待相關聯的命令終止，並返回其終止狀態。
close_process_full [Unix]	關閉由 `Unix.open_process_full` 開啟的通道，等待相關聯的命令終止，並返回其終止狀態。
close_process_in [UnixLabels]	關閉由 `UnixLabels.open_process_in` 開啟的通道，等待相關聯的命令終止，並返回其終止狀態。
close_process_in [Unix]	關閉由 `Unix.open_process_in` 開啟的通道，等待相關聯的命令終止，並返回其終止狀態。
close_process_out [UnixLabels]	關閉由 `UnixLabels.open_process_out` 開啟的通道，等待相關聯的命令終止，並返回其終止狀態。
close_process_out [Unix]	關閉由 `Unix.open_process_out` 開啟的通道，等待相關聯的命令終止，並返回其終止狀態。
close_stag [Format]	`pp_close_stag ppf ()` 關閉最近開啟的語義標籤 `t`。
close_tbox [Format]	關閉最近開啟的製表方塊。
closedir [UnixLabels]	關閉目錄描述符。
closedir [Unix]	關閉目錄描述符。
closure_tag [Obj]
code [Char]	返回引數的 ASCII 碼。
combine [ListLabels]	將一對列表轉換為一對列表： `combine [a1; ...; an] [b1; ...; bn]` 是 `[(a1,b1); ...; (an,bn)]`。
combine [List]	將一對列表轉換為一對列表： `combine [a1; ...; an] [b1; ...; bn]` 是 `[(a1,b1); ...; (an,bn)]`。
combine [ArrayLabels]	`combine [\|a1; ...; an\|] [\|b1; ...; bn\|]` 是 `[\|(a1,b1); ...; (an,bn)\|]`。
combine [Array]	`combine [\|a1; ...; an\|] [\|b1; ...; bn\|]` 是 `[\|(a1,b1); ...; (an,bn)\|]`。
command [Sys]	執行指定的 shell 命令並返回其退出代碼。
compact [Gc]	執行完整的完整垃圾收集並壓縮堆積。
compare [Unit]	`compare u1 u2` 為 `0`。
compare [Uchar]	`compare u u'` 是 `Stdlib.compare u u'`。
compare [String]	`compare s0 s1` 按字典順序排序 `s0` 和 `s1`。
compare [Stdlib]	如果 `x` 等於 `y`，則 `compare x y` 返回 `0`；如果 `x` 小於 `y`，則返回負整數；如果 `x` 大於 `y`，則返回正整數。
compare [StringLabels]	`compare s0 s1` 按字典順序排序 `s0` 和 `s1`。
compare [Set.OrderedType]	集合元素上的完整排序函式。
compare [Set.S]	集合之間的完整排序。
compare [Seq]	如果函式 `cmp` 定義了元素上的預排序，則 `compare cmp xs ys` 會根據字典預排序比較序列 `xs` 和 `ys`。
compare [Result]	`compare ~ok ~error r0 r1` 使用 `ok` 和 `error` 分別比較由 `Ok _` 和 `Error _` 包裝的值，完整排序 `r0` 和 `r1`。
compare [Option]	`compare cmp o0 o1` 是選項的完整排序，使用 `cmp` 來比較由 `Some _` 包裝的值。
compare [Nativeint]	原生整數的比較函式，與 `compare` 的規格相同。
compare [MoreLabels.Set.OrderedType]	集合元素上的完整排序函式。
compare [MoreLabels.Set.S]	集合之間的完整排序。
compare [MoreLabels.Map.OrderedType]	金鑰上的完整排序函式。
compare [MoreLabels.Map.S]	地圖之間的整體排序。
compare [Map.OrderedType]	金鑰上的完整排序函式。
compare [Map.S]	地圖之間的整體排序。
compare [ListLabels]	`compare cmp [a1; ...; an] [b1; ...; bm]` 使用與 `compare` 相同的 `'a -> 'a -> int` 介面，對兩個輸入列表執行字典式比較。
compare [List]	`compare cmp [a1; ...; an] [b1; ...; bm]` 使用與 `compare` 相同的 `'a -> 'a -> int` 介面，對兩個輸入列表執行字典式比較。
compare [Int64]	64 位元整數的比較函式，規格與 `compare` 相同。
compare [Int32]	32 位元整數的比較函式，規格與 `compare` 相同。
compare [Int]	`compare x y` 等同於 `compare` `x y`，但效率更高。
compare [Float]	如果 `x` 等於 `y`，則 `compare x y` 返回 `0`；如果 `x` 小於 `y`，則返回負整數；如果 `x` 大於 `y`，則返回正整數。
compare [Either]	`compare ~left ~right e0 e1` 使用 `left` 和 `right` 分別比較由 `Left _` 和 `Right _` 包裝的值，對 `e0` 和 `e1` 進行整體排序。
compare [Digest.S]	比較兩個摘要，規格與 `compare` 相同。
compare [Digest]	16 位元組摘要的比較函式，規格與 `compare` 相同，並且與 `String.compare` 共用實作。
compare [Char]	字元的比較函式，規格與 `compare` 相同。
compare [BytesLabels]	位元組序列的比較函式，規格與 `compare` 相同。
compare [Bytes]	位元組序列的比較函式，規格與 `compare` 相同。
compare [Bool]	`compare b0 b1` 是對布林值的整體排序。
compare_and_set [Atomic]	只有當 `r` 的目前值與 `seen` 物理上相等時，`compare_and_set r seen v` 才會將 `r` 的新值設為 `v` -- 比較和設定是原子性的。
compare_length_with [ListLabels]	比較列表的長度與整數。
compare_length_with [List]	比較列表的長度與整數。
compare_lengths [ListLabels]	比較兩個列表的長度。
compare_lengths [List]	比較兩個列表的長度。
complex32 [Bigarray]	請參閱 `Bigarray.char`。
complex64 [Bigarray]	請參閱 `Bigarray.char`。
compose [Fun]	`compose f g` 是先套用 `g` 再套用 `f` 的函式組合。
concat [String]	`concat sep ss` 將字串列表 `ss` 連接起來，並在每個字串之間插入分隔字串 `sep`。
concat [StringLabels]	`concat ~sep ss` 將字串列表 `ss` 連接起來，並在每個字串之間插入分隔字串 `sep`。
concat [Seq]	如果 `xss` 是序列的序列，則 `concat xss` 是它的串連。
concat [ListLabels]	串連列表的列表。
concat [List]	串連列表的列表。
concat [Float.ArrayLabels]	與 `Float.ArrayLabels.append` 相同，但會串連浮點數陣列的列表。
concat [Float.Array]	與 `Float.Array.append` 相同，但會串連浮點數陣列的列表。
concat [Filename]	`concat dir file` 會傳回一個檔案名稱，該名稱指定目錄 `dir` 中的檔案 `file`。
concat [BytesLabels]	`concat ~sep sl` 會將位元組序列列表 `sl` 連接起來，並在每個序列之間插入分隔位元組序列 `sep`，然後將結果做為新的位元組序列傳回。
concat [Bytes]	`concat sep sl` 會將位元組序列列表 `sl` 連接起來，並在每個序列之間插入分隔位元組序列 `sep`，然後將結果做為新的位元組序列傳回。
concat [ArrayLabels]	與 `ArrayLabels.append` 相同，但會串連陣列的列表。
concat [Array]	與 `Array.append` 相同，但會串連陣列的列表。
concat_fmt [CamlinternalFormatBasics]
concat_fmtty [CamlinternalFormatBasics]
concat_map [Seq]	`concat_map f xs` 等同於 `concat (map f xs)`。
concat_map [ListLabels]	`concat_map ~f l` 會產生與 `ListLabels.concat` `(ListLabels.map` `f l)` 相同的結果。
concat_map [List]	`concat_map f l` 會產生與 `List.concat` `(List.map` `f l)` 相同的結果。
conj [Complex]	共軛：給定複數 `x + i.y`，傳回 `x - i.y`。
connect [UnixLabels]	將 socket 連接到位址。
connect [Unix]	將 socket 連接到位址。
cons [Seq]	`cons x xs` 是以元素 `x` 開頭，然後是序列 `xs` 的序列。
cons [ListLabels]	`cons x xs` 等同於 `x :: xs`
cons [List]	`cons x xs` 等同於 `x :: xs`
const [Fun]	`const c` 是一個總是傳回值 `c` 的函式。
cont_tag [Obj]
contains [String]	`contains s c` 等同於 `String.contains_from` `s 0 c`。
contains [StringLabels]	`contains s c` 等同於 `String.contains_from` `s 0 c`。
contains [BytesLabels]	`contains s c` 測試位元組 `c` 是否出現在 `s` 中。
contains [Bytes]	`contains s c` 測試位元組 `c` 是否出現在 `s` 中。
contains_from [String]	當且僅當 `c` 出現在 `s` 中位置 `start` 之後時，`contains_from s start c` 為 `true`。
contains_from [StringLabels]	當且僅當 `c` 出現在 `s` 中位置 `start` 之後時，`contains_from s start c` 為 `true`。
contains_from [BytesLabels]	`contains_from s start c` 測試位元組 `c` 是否出現在 `s` 中位置 `start` 之後。
contains_from [Bytes]	`contains_from s start c` 測試位元組 `c` 是否出現在 `s` 中位置 `start` 之後。
contents [Buffer]	傳回緩衝區目前內容的副本。
continue [Effect.Deep]	`continue k x` 將 `x` 傳遞給 `k` 來恢復延續 `k`。
continue_with [Effect.Shallow]	`continue_with k v h` 會使用值 `v` 和處理常式 `h` 來恢復延續 `k`。
convert_raw_backtrace_slot [Printexc]	從低階 `raw_backtrace_slot` 中擷取使用者易讀的 `backtrace_slot`。
copy [CamlinternalOO]
copy [Stack]	傳回給定堆疊的副本。
copy [Random.State]	傳回給定狀態的副本。
copy [Queue]	傳回給定佇列的副本。
copy [Oo]	`Oo.copy o` 會傳回物件 `o` 的副本，也就是一個具有與 `o` 相同方法和實例變數的新物件。
copy [MoreLabels.Hashtbl.SeededS]
copy [MoreLabels.Hashtbl.S]
copy [MoreLabels.Hashtbl]	傳回給定雜湊表的副本。
copy [Hashtbl.SeededS]
copy [Hashtbl.S]
copy [Hashtbl]	傳回給定雜湊表的副本。
copy [Float.ArrayLabels]	`copy a` 傳回 `a` 的副本，也就是一個包含與 `a` 相同元素的新浮點數陣列。
copy [Float.Array]	`copy a` 傳回 `a` 的副本，也就是一個包含與 `a` 相同元素的新浮點數陣列。
copy [Ephemeron.SeededS]
copy [Ephemeron.S]
copy [Dynarray]	`copy a` 是 `a` 的淺層複製，一個包含與 `a` 相同元素的新陣列。
copy [BytesLabels]	傳回一個新的位元組序列，其中包含與引數相同的位元組。
copy [Bytes]	傳回一個新的位元組序列，其中包含與引數相同的位元組。
copy [ArrayLabels]	`copy a` 傳回 `a` 的副本，也就是一個包含與 `a` 相同元素的新陣列。
copy [Array]	`copy a` 傳回 `a` 的副本，也就是一個包含與 `a` 相同元素的新陣列。
copy_sign [Float]	`copy_sign x y` 傳回一個浮點數，其絕對值與 `x` 相同，符號與 `y` 相同。
copysign [Stdlib]	`copysign x y` 傳回一個浮點數，其絕對值與 `x` 相同，符號與 `y` 相同。
cos [Stdlib]	餘弦。
cos [Float]	餘弦。
cosh [Stdlib]	雙曲餘弦。
cosh [Float]	雙曲餘弦。
count [Weak.S]	計算表格中的元素數量。
counters [Gc]	傳回目前網域或先前網域的 `(minor_words, promoted_words, major_words)`。
cpu_relax [Domain]	如果正在忙碌等待，在迭代之間呼叫 cpu_relax () 將改善某些 CPU 架構的效能
create [Thread]	`Thread.create funct arg` 建立一個新的控制執行緒，其中函式應用 `funct arg` 與網域的其他執行緒並行執行。
create [Weak.S]	`create n` 建立一個新的空弱式雜湊集，初始大小為 `n`。
create [Weak]	`Weak.create n` 傳回長度為 `n` 的新弱式陣列。
create [Stack]	傳回一個新的堆疊，初始為空。
create [Runtime_events.Callbacks]	建立一個 `Callback`，可選擇訂閱一個或多個執行階段事件。
create [Queue]	傳回一個新的佇列，初始為空。
create [Obj.Ephemeron]	`create n` 傳回一個具有 `n` 個鍵的暫時性物件。
create [Mutex]	傳回一個新的互斥鎖。
create [MoreLabels.Hashtbl.SeededS]
create [MoreLabels.Hashtbl.S]
create [MoreLabels.Hashtbl]	`Hashtbl.create n` 建立一個新的空雜湊表，初始大小為 `n`。
create [Hashtbl.SeededS]
create [Hashtbl.S]
create [Hashtbl]	`Hashtbl.create n` 建立一個新的空雜湊表，初始大小為 `n`。
create [Float.ArrayLabels]	`create n` 傳回一個長度為 `n` 的新浮點數陣列，其中包含未初始化的資料。
create [Float.Array]	`create n` 傳回一個長度為 `n` 的新浮點數陣列，其中包含未初始化的資料。
create [Ephemeron.SeededS]
create [Ephemeron.S]
create [Dynarray]	`create ()` 是一個新的空陣列。
create [Condition]	`create()` 建立並傳回一個新的條件變數。
create [BytesLabels]	`create n` 傳回一個長度為 `n` 的新位元組序列。
create [Bytes]	`create n` 傳回一個長度為 `n` 的新位元組序列。
create [Buffer]	`create n` 傳回一個初始為空的新緩衝區。
create [Bigarray.Array3]	`Array3.create kind layout dim1 dim2 dim3` 傳回一個三維的新 Bigarray，其大小在第一維為 `dim1`，在第二維為 `dim2`，在第三維為 `dim3`。
create [Bigarray.Array2]	`Array2.create kind layout dim1 dim2` 傳回一個二維的新 Bigarray，其大小在第一維為 `dim1`，在第二維為 `dim2`。
create [Bigarray.Array1]	`Array1.create kind layout dim` 傳回一個一維的新 Bigarray，其大小為 `dim`。
create [Bigarray.Array0]	`Array0.create kind layout` 傳回一個零維的新 Bigarray。
create [Bigarray.Genarray]	`Genarray.create kind layout dimensions` 傳回一個新的 Bigarray，其元素種類由參數 `kind` 決定（`float32`、`float64`、`int8_signed` 等之一），其版面配置由參數 `layout` 決定（`c_layout` 或 `fortran_layout` 之一）。
create_alarm [Gc]	`create_alarm f` 將安排在主 GC 週期結束時呼叫 `f`，此週期不是由 `f` 本身所導致的，從目前的週期或下一個週期開始。
create_char_set [CamlinternalFormat]
create_cursor [Runtime_events]	`create_cursor path_pid` 建立一個游標，從 runtime_events 讀取。
create_float [ArrayLabels]	`create_float n` 傳回一個長度為 `n` 的新浮點數陣列，其中包含未初始化的資料。
create_float [Array]	`create_float n` 傳回一個長度為 `n` 的新浮點數陣列，其中包含未初始化的資料。
create_object [CamlinternalOO]
create_object_and_run_initializers [CamlinternalOO]
create_object_opt [CamlinternalOO]
create_process [UnixLabels]	`create_process ~prog ~args ~stdin ~stdout ~stderr` 建立一個新的程序，執行檔案 `prog` 中的程式，並使用引數 `args`。
create_process [Unix]	`create_process prog args stdin stdout stderr` 建立一個新的程序，執行檔案 `prog` 中的程式，並使用引數 `args`。
create_process_env [UnixLabels]	`create_process_env ~prog ~args ~env ~stdin ~stdout ~stderr` 的作用與 `UnixLabels.create_process` 相同，但額外的引數 `env` 指定傳遞給程式的環境。
create_process_env [Unix]	`create_process_env prog args env stdin stdout stderr` 的作用與 `Unix.create_process` 相同，但額外的引數 `env` 指定傳遞給程式的環境。
create_table [CamlinternalOO]
current [Arg]	正在處理的引數在 `Sys.argv` 中的位置。
current_dir_name [Filename]	目前目錄的傳統名稱 (例如
custom_tag [Obj]
cycle [Seq]	`cycle xs` 是由序列 `xs` 無限重複構成的無限序列。
cygwin [Sys]	如果 `Sys.os_type = "Cygwin"`，則為 True。
D
data_size [Marshal]	請參閱 `Marshal.header_size`。
decr [Stdlib]	遞減給定參考中包含的整數。
decr [Atomic]	`decr r` 原子地將 `r` 的值遞減 `1`。
default_uncaught_exception_handler [Thread]	`Thread.default_uncaught_exception_handler` 會印出執行緒的 ID、例外狀況和回溯追蹤（如果有的話）。
default_uncaught_exception_handler [Printexc]	`Printexc.default_uncaught_exception_handler` 會將例外狀況和回溯追蹤列印到標準錯誤輸出。
delay [Thread]	`delay d` 會暫停呼叫執行緒的執行 `d` 秒。
delete_alarm [Gc]	`delete_alarm a` 將停止呼叫與 `a` 關聯的函式。
descr_of_in_channel [UnixLabels]	傳回對應於輸入通道的描述符。
descr_of_in_channel [Unix]	傳回對應於輸入通道的描述符。
descr_of_out_channel [UnixLabels]	傳回對應於輸出通道的描述符。
descr_of_out_channel [Unix]	傳回對應於輸出通道的描述符。
development_version [Sys]	如果這是開發版本，則為 `true`，否則為 `false`。
diff [Set.S]	集合差集：`diff s1 s2` 包含 `s1` 中不在 `s2` 中的元素。
diff [MoreLabels.Set.S]	集合差集：`diff s1 s2` 包含 `s1` 中不在 `s2` 中的元素。
dim [Bigarray.Array1]	傳回給定一維 Bigarray 的大小（維度）。
dim1 [Bigarray.Array3]	傳回給定三維 Bigarray 的第一個維度。
dim1 [Bigarray.Array2]	傳回給定二維 Bigarray 的第一個維度。
dim2 [Bigarray.Array3]	傳回給定三維 Bigarray 的第二個維度。
dim2 [Bigarray.Array2]	傳回給定二維 Bigarray 的第二個維度。
dim3 [Bigarray.Array3]	傳回給定三維 Bigarray 的第三個維度。
dims [Bigarray.Genarray]	`Genarray.dims a` 以長度為 `Genarray.num_dims a` 的整數陣列形式傳回 Bigarray `a` 的所有維度。
dir_sep [Filename]	目錄分隔符（例如。
dirname [Filename]	請參閱 `Filename.basename`。
discard [Gc.Memprof]	捨棄已停止設定檔的所有設定檔狀態，這會阻止它進行任何進一步的回呼。
discontinue [Effect.Deep]	`discontinue k e` 會在 `k` 中引發例外狀況 `e` 來恢復 continuation `k`。
discontinue_with [Effect.Shallow]	`discontinue_with k e h` 會使用處理常式 `h` 引發例外狀況 `e` 來恢復 continuation `k`。
discontinue_with_backtrace [Effect.Shallow]	`discontinue_with k e bt h` 會使用原始回溯追蹤 `bt` 作為例外狀況的來源，使用處理常式 `h` 引發例外狀況 `e` 來恢復 continuation `k`。
discontinue_with_backtrace [Effect.Deep]	`discontinue_with_backtrace k e bt` 會在 `k` 中引發例外狀況 `e` 來恢復 continuation `k`，並使用 `bt` 作為例外狀況的來源。
disjoint [Set.S]	測試兩個集合是否不相交。
disjoint [MoreLabels.Set.S]	測試兩個集合是否不相交。
div [Nativeint]	整數除法。
div [Int64]	整數除法。
div [Int32]	整數除法。
div [Int]	`div x y` 是除法 `x / y`。
div [Float]	浮點數除法。
div [Complex]	除法
domain_of_sockaddr [UnixLabels]	傳回適合給定 Socket 位址的 Socket 網域。
domain_of_sockaddr [Unix]	傳回適合給定 Socket 位址的 Socket 網域。
double_array_tag [Obj]
double_field [Obj]
double_tag [Obj]
dprintf [Format]	與 `Format.fprintf` 相同，但格式化工具是最後一個引數。
drop [Stack]	`drop s` 會移除堆疊 `s` 中最頂端的元素，如果堆疊為空，則會引發 `Stack.Empty`。
drop [Seq]	`drop n xs` 是序列 `xs`，其中不包含前 `n` 個元素。
drop_while [Seq]	`drop_while p xs` 是序列 `xs`，其中不包含前置詞 `take_while p xs`。
dummy_class [CamlinternalOO]
dummy_pos [Lexing]	類型為 `position` 的值，保證與任何有效位置不同。
dummy_table [CamlinternalOO]
dup [UnixLabels]	傳回參照與給定描述符相同檔案的新檔案描述符。
dup [Unix]	傳回參照與給定描述符相同檔案的新檔案描述符。
dup [Obj]
dup2 [UnixLabels]	`dup2 ~src ~dst` 將 `src` 複製到 `dst`，如果 `dst` 已開啟則將其關閉。
dup2 [Unix]	`dup2 src dst` 將 `src` 複製到 `dst`，如果 `dst` 已開啟則將其關閉。
E
elements [Set.S]	傳回給定集合的所有元素清單。
elements [MoreLabels.Set.S]	傳回給定集合的所有元素清單。
empty [String]	空字串。
empty [StringLabels]	空字串。
empty [Set.S]	空集合。
empty [Seq]	`empty` 是空序列。
empty [MoreLabels.Set.S]	空集合。
empty [MoreLabels.Map.S]	空地圖。
empty [Map.S]	空地圖。
empty [BytesLabels]	大小為 0 的位元組序列。
empty [Bytes]	大小為 0 的位元組序列。
enable_runtime_warnings [Sys]	控制 OCaml 執行階段系統是否可以在 stderr 上發出警告。
end_of_input [Scanf.Scanning]	`Scanning.end_of_input ic` 測試給定 `Scanf.Scanning.in_channel` 格式化輸入通道的輸入結束條件。
ends_with [String]	當且僅當 `s` 以 `suffix` 結尾時，`ends_with` `~suffix s` 為 `true`。
ends_with [StringLabels]	當且僅當 `s` 以 `suffix` 結尾時，`ends_with` `~suffix s` 為 `true`。
ends_with [BytesLabels]	當且僅當 `s` 以 `suffix` 結尾時，`ends_with` `~suffix s` 為 `true`。
ends_with [Bytes]	當且僅當 `s` 以 `suffix` 結尾時，`ends_with` `~suffix s` 為 `true`。
ensure_capacity [Dynarray]	`ensure_capacity a n` 確保 `a` 的容量至少為 `n`。
ensure_extra_capacity [Dynarray]	`ensure_extra_capacity a n` 為 `ensure_capacity a (length a + n)`，它確保 `a` 有空間容納 `n` 個額外項目。
environment [UnixLabels]	以 ``variable=value'' 格式的字串陣列形式傳回程序環境。
environment [Unix]	以 ``variable=value'' 格式的字串陣列形式傳回程序環境。
eprintf [Printf]	與 `Printf.fprintf` 相同，但在 `stderr` 上輸出。
eprintf [Format]	與上述 `fprintf` 相同，但在 `get_err_formatter ()` 上輸出。
epsilon [Float]	`1.0` 與大於 `1.0` 的最小精確可表示浮點數之間的差值。
epsilon_float [Stdlib]	`1.0` 與大於 `1.0` 的最小精確可表示浮點數之間的差值。
equal [Unit]	`equal u1 u2` 為 `true`。
equal [Uchar]	`equal u u'` 為 `u = u'`。
equal [String]	當且僅當 `s0` 和 `s1` 在字元上相等時，`equal s0 s1` 為 `true`。
equal [StringLabels]	當且僅當 `s0` 和 `s1` 在字元上相等時，`equal s0 s1` 為 `true`。
equal [Set.S]	`equal s1 s2` 測試集合 `s1` 和 `s2` 是否相等，也就是說，是否包含相等的元素。
equal [Seq]	如果函式 `eq` 定義元素上的相等性，則 `equal eq xs ys` 會決定序列 `xs` 和 `ys` 是否逐點相等。
equal [Result]	`equal ~ok ~error r0 r1` 使用 `ok` 和 `error` 分別比較由 `Ok _` 和 `Error _` 包裝的值，來測試 `r0` 和 `r1` 的相等性。
equal [Option]	`equal eq o0 o1` 在且僅在 `o0` 和 `o1` 皆為 `None`，或者它們分別為 `Some v0` 和 `Some v1` 且 `eq v0 v1` 為 `true` 時，才會是 `true`。
equal [Nativeint]	用於原生整數的相等函數。
equal [MoreLabels.Set.S]	`equal s1 s2` 測試集合 `s1` 和 `s2` 是否相等，也就是說，是否包含相等的元素。
equal [MoreLabels.Map.S]	`equal ~cmp m1 m2` 測試映射 `m1` 和 `m2` 是否相等，亦即是否包含相等的鍵並將它們與相等的資料關聯。
equal [MoreLabels.Hashtbl.SeededHashedType]	用於比較鍵的相等謂詞。
equal [MoreLabels.Hashtbl.HashedType]	用於比較鍵的相等謂詞。
equal [Map.S]	`equal cmp m1 m2` 測試映射 `m1` 和 `m2` 是否相等，亦即是否包含相等的鍵並將它們與相等的資料關聯。
equal [ListLabels]	`equal eq [a1; ...; an] [b1; ..; bm]` 在兩個輸入列表具有相同長度，且對於每個位置相同的元素對 `ai`, `bi`，我們都有 `eq ai bi` 時成立。
equal [List]	`equal eq [a1; ...; an] [b1; ..; bm]` 在兩個輸入列表具有相同長度，且對於每個位置相同的元素對 `ai`, `bi`，我們都有 `eq ai bi` 時成立。
equal [Int64]	用於 int64 值的相等函數。
equal [Int32]	用於 int32 值的相等函數。
equal [Int]	`equal x y` 在且僅在 `x = y` 時，才會是 `true`。
equal [Hashtbl.SeededHashedType]	用於比較鍵的相等謂詞。
equal [Hashtbl.HashedType]	用於比較鍵的相等謂詞。
equal [Float]	用於浮點數的相等函數，使用 `Float.compare` 比較。
equal [Either]	`equal ~left ~right e0 e1` 使用 `left` 和 `right` 分別比較 `Left _` 和 `Right _` 包裹的值，測試 `e0` 和 `e1` 的相等性。
equal [Digest.S]	測試兩個摘要是否相等。
equal [Digest]	用於 16 位元組摘要的相等函數。
equal [Char]	用於字元的相等函數。
equal [BytesLabels]	用於位元組序列的相等函數。
equal [Bytes]	用於位元組序列的相等函數。
equal [Bool]	`equal b0 b1` 在且僅在 `b0` 和 `b1` 皆為 `true` 或皆為 `false` 時，才會是 `true`。
erase_rel [CamlinternalFormatBasics]
erf [Float]	誤差函數。
erfc [Float]	互補誤差函數 (`erfc x = 1 - erf x`)。
err_formatter [Format]	用於寫入標準錯誤的初始域格式器。
error [Result]	`error e` 為 `Error e`。
error_message [UnixLabels]	傳回描述給定錯誤碼的字串。
error_message [Unix]	傳回描述給定錯誤碼的字串。
error_message [Dynlink]	將錯誤描述轉換為可列印訊息。
escaped [String]	`escaped s` 是 `s`，其中的特殊字元會按照 OCaml 的詞法慣例以跳脫序列表示。
escaped [StringLabels]	`escaped s` 是 `s`，其中的特殊字元會按照 OCaml 的詞法慣例以跳脫序列表示。
escaped [Char]	傳回代表給定字元的字串，其中特殊字元會按照 OCaml 的詞法慣例跳脫。
escaped [BytesLabels]	傳回引數的副本，其中的特殊字元會按照 OCaml 的詞法慣例以跳脫序列表示。
escaped [Bytes]	傳回引數的副本，其中的特殊字元會按照 OCaml 的詞法慣例以跳脫序列表示。
establish_server [UnixLabels]	在給定位址建立伺服器。
establish_server [Unix]	在給定位址建立伺服器。
eventlog_pause [Gc]
eventlog_resume [Gc]
exchange [Atomic]	為原子引用設定新值，並傳回目前的值。
executable_name [Sys]	包含目前執行中可執行檔的檔案名稱。
execv [UnixLabels]	`execv prog args` 使用引數 `args` 和目前程序環境，執行檔案 `prog` 中的程式。
execv [Unix]	`execv prog args` 使用引數 `args` 和目前程序環境，執行檔案 `prog` 中的程式。
execve [UnixLabels]	與 `UnixLabels.execv` 相同，但第三個引數提供要執行的程式的環境。
execve [Unix]	與 `Unix.execv` 相同，但第三個引數提供要執行的程式的環境。
execvp [UnixLabels]	與 `UnixLabels.execv` 相同，但會在路徑中搜尋程式。
execvp [Unix]	與 `Unix.execv` 相同，但會在路徑中搜尋程式。
execvpe [UnixLabels]	與 `UnixLabels.execve` 相同，但會在路徑中搜尋程式。
execvpe [Unix]	與 `Unix.execve` 相同，但會在路徑中搜尋程式。
exists [String]	`exists p s` 檢查 `s` 中是否至少有一個字元符合述詞 `p`。
exists [StringLabels]	`exists p s` 檢查 `s` 中是否至少有一個字元符合述詞 `p`。
exists [Set.S]	`exists f s` 檢查集合中是否至少有一個元素符合述詞 `f`。
exists [Seq]	`exists xs p` 判斷序列 `xs` 中是否至少有一個元素 `x` 符合 `p x`。
exists [MoreLabels.Set.S]	`exists ~f s` 檢查集合中是否至少有一個元素符合述詞 `f`。
exists [MoreLabels.Map.S]	`exists ~f m` 檢查映射中是否至少有一個繫結符合述詞 `f`。
exists [Map.S]	`exists f m` 檢查映射中是否至少有一個繫結符合述詞 `f`。
exists [ListLabels]	`exists ~f [a1; ...; an]` 檢查列表中是否至少有一個元素符合述詞 `f`。
exists [List]	`exists f [a1; ...; an]` 檢查列表中是否至少有一個元素符合述詞 `f`。
exists [Float.ArrayLabels]	`exists f [\|a1; ...; an\|]` 檢查浮點數陣列中是否至少有一個元素符合述詞 `f`。
exists [Float.Array]	`exists f [\|a1; ...; an\|]` 檢查浮點數陣列中是否至少有一個元素符合述詞 `f`。
exists [Dynarray]	`exists f a` 在 `a` 的某些元素符合 `f` 時為 `true`。
exists [BytesLabels]	`exists p s` 檢查 `s` 中是否至少有一個字元符合述詞 `p`。
exists [Bytes]	`exists p s` 檢查 `s` 中是否至少有一個字元符合述詞 `p`。
exists [ArrayLabels]	`exists ~f [\|a1; ...; an\|]` 檢查陣列中是否至少有一個元素符合述詞 `f`。
exists [Array]	`exists f [\|a1; ...; an\|]` 檢查陣列中是否至少有一個元素符合述詞 `f`。
exists2 [Seq]	`exists2 p xs ys` 判斷是否有一些從序列 `xs` 和 `ys` 同步提取的元素對 `(x, y)` 符合 `p x y`。
exists2 [ListLabels]	與 `ListLabels.exists` 相同，但用於接受兩個引數的述詞。
exists2 [List]	與 `List.exists` 相同，但用於接受兩個參數的謂詞。
exists2 [ArrayLabels]	與 `ArrayLabels.exists` 相同，但用於接受兩個參數的謂詞。
exists2 [Array]	與 `Array.exists` 相同，但用於接受兩個參數的謂詞。
exit [Thread]	引發 `Thread.Exit` 例外。
exit [Stdlib]	終止程序，並將給定的狀態碼返回給作業系統：通常 0 表示沒有錯誤，而較小的正整數表示失敗。
exn_slot_id [Printexc]	`Printexc.exn_slot_id` 返回一個整數，該整數唯一地標識用於建立例外值 `exn` 的建構函式（在目前的執行階段中）。
exn_slot_name [Printexc]	`Printexc.exn_slot_name exn` 返回用於建立例外值 `exn` 的建構函式的內部名稱。
exp [Stdlib]	指數函數。
exp [Float]	指數函數。
exp [Complex]	指數運算。
exp2 [Float]	以 2 為底的指數函數。
expm1 [Stdlib]	`expm1 x` 計算 `exp x -. 1.0`，即使 `x` 接近 `0.0` 也能提供數值精確的結果。
expm1 [Float]	`expm1 x` 計算 `exp x -. 1.0`，即使 `x` 接近 `0.0` 也能提供數值精確的結果。
extend [BytesLabels]	`extend s ~left ~right` 返回一個新的位元組序列，其中包含 `s` 的位元組，並且在其前面附加了 `left` 個未初始化的位元組，在其後面附加了 `right` 個未初始化的位元組。
extend [Bytes]	`extend s left right` 返回一個新的位元組序列，其中包含 `s` 的位元組，並且在其前面附加了 `left` 個未初始化的位元組，在其後面附加了 `right` 個未初始化的位元組。
extension [Filename]	`extension name` 是 `name0` 的最短後綴 `ext`，其中
F
failwith [Stdlib]	引發帶有給定字串的例外 `Failure`。
fast_sort [ListLabels]	與 `ListLabels.sort` 或 `ListLabels.stable_sort` 相同，具體取決於哪一個在典型輸入上更快。
fast_sort [List]	與 `List.sort` 或 `List.stable_sort` 相同，具體取決於哪一個在典型輸入上更快。
fast_sort [Float.ArrayLabels]	與 `Float.ArrayLabels.sort` 或 `Float.ArrayLabels.stable_sort` 相同，具體取決於哪一個在典型輸入上更快。
fast_sort [Float.Array]	與 `Float.Array.sort` 或 `Float.Array.stable_sort` 相同，具體取決於哪一個在典型輸入上更快。
fast_sort [ArrayLabels]	與 `ArrayLabels.sort` 或 `ArrayLabels.stable_sort` 相同，具體取決於哪一個在典型輸入上更快。
fast_sort [Array]	與 `Array.sort` 或 `Array.stable_sort` 相同，具體取決於哪一個在典型輸入上更快。
fchmod [UnixLabels]	變更已開啟檔案的權限。
fchmod [Unix]	變更已開啟檔案的權限。
fchown [UnixLabels]	變更已開啟檔案的擁有者 uid 和擁有者 gid。
fchown [Unix]	變更已開啟檔案的擁有者 uid 和擁有者 gid。
fetch_and_add [Atomic]	`fetch_and_add r n` 以原子方式將 `r` 的值遞增 `n`，並返回當前值（遞增之前的值）。
fiber [Effect.Shallow]	`fiber f` 建構一個繼續，該繼續會執行計算 `f`。
field [Obj]
file [Digest.S]	返回給定名稱檔案的摘要。
file [Digest]	返回給定名稱檔案的摘要。
file_exists [Sys]	測試具有給定名稱的檔案是否存在。
fill [Weak]	`Weak.fill ar ofs len el` 將 `ar` 中從 `ofs` 到 `ofs + len - 1` 的所有指標都設定為 `el`。
fill [Float.ArrayLabels]	`fill a ~pos ~len x` 就地修改浮點數陣列 `a`，將 `x` 儲存到編號為 `pos` 到 `pos + len - 1` 的元素中。
fill [Float.Array]	`fill a pos len x` 就地修改浮點數陣列 `a`，將 `x` 儲存到編號為 `pos` 到 `pos + len - 1` 的元素中。
fill [BytesLabels]	`fill s ~pos ~len c` 就地修改 `s`，從 `pos` 開始，將 `len` 個字元取代為 `c`。
fill [Bytes]	`fill s pos len c` 就地修改 `s`，從 `pos` 開始，將 `len` 個字元取代為 `c`。
fill [Bigarray.Array3]	使用給定的值填滿給定的 Bigarray。
fill [Bigarray.Array2]	使用給定的值填滿給定的 Bigarray。
fill [Bigarray.Array1]	使用給定的值填滿給定的 Bigarray。
fill [Bigarray.Array0]	使用給定的值填滿給定的 Bigarray。
fill [Bigarray.Genarray]	將 Bigarray 的所有元素設定為給定的值。
fill [ArrayLabels]	`fill a ~pos ~len x` 就地修改陣列 `a`，將 `x` 儲存到編號為 `pos` 到 `pos + len - 1` 的元素中。
fill [Array]	`fill a pos len x` 就地修改陣列 `a`，將 `x` 儲存到編號為 `pos` 到 `pos + len - 1` 的元素中。
filter [Set.S]	`filter f s` 返回 `s` 中滿足謂詞 `f` 的所有元素的集合。
filter [Seq]	`filter p xs` 是 `xs` 中滿足 `p x` 的元素 `x` 的序列。
filter [MoreLabels.Set.S]	`filter ~f s` 返回 `s` 中滿足謂詞 `f` 的所有元素的集合。
filter [MoreLabels.Map.S]	`filter ~f m` 返回具有 `m` 中滿足謂詞 `p` 的所有繫結的映射。
filter [Map.S]	`filter f m` 返回具有 `m` 中滿足謂詞 `p` 的所有繫結的映射。
filter [ListLabels]	`filter ~f l` 返回列表 `l` 中滿足謂詞 `f` 的所有元素。
filter [List]	`filter f l` 返回列表 `l` 中滿足謂詞 `f` 的所有元素。
filter [Dynarray]	`filter f a` 是一個新的陣列，其中包含 `a` 中滿足 `f` 的所有元素。
filter_map [Set.S]	`filter_map f s` 返回所有 `v` 的集合，其中對於 `s` 的某些元素 `x`，`f x = Some v`。
filter_map [Seq]	`filter_map f xs` 是元素 `y` 的序列，其中 `f x = Some y`，且 `x` 遍歷 `xs`。
filter_map [MoreLabels.Set.S]	`filter_map ~f s` 返回所有 `v` 的集合，其中對於 `s` 的某些元素 `x`，`f x = Some v`。
filter_map [MoreLabels.Map.S]	`filter_map ~f m` 將函數 `f` 應用於 `m` 的每個繫結，並從結果建立映射。
filter_map [Map.S]	`filter_map f m` 將函數 `f` 應用於 `m` 的每個繫結，並從結果建立映射。
filter_map [ListLabels]	`filter_map ~f l` 將 `f` 應用於 `l` 的每個元素，篩選掉 `None` 元素，並返回 `Some` 元素的引數列表。
filter_map [List]	`filter_map f l` 將 `f` 應用於 `l` 的每個元素，過濾掉 `None` 元素，並返回 `Some` 元素的參數列表。
filter_map [Dynarray]	`filter_map f a` 是一個新的元素陣列 `y`，使得 `f x` 對於 `a` 的元素 `x` 為 `Some y`。
filter_map_inplace [MoreLabels.Hashtbl.SeededS]
filter_map_inplace [MoreLabels.Hashtbl.S]
filter_map_inplace [MoreLabels.Hashtbl]	`Hashtbl.filter_map_inplace ~f tbl` 將 `f` 應用於表格 `tbl` 中的所有綁定，並根據 `f` 的結果更新每個綁定。
filter_map_inplace [Hashtbl.SeededS]
filter_map_inplace [Hashtbl.S]
filter_map_inplace [Hashtbl]	`Hashtbl.filter_map_inplace f tbl` 將 `f` 應用於表格 `tbl` 中的所有綁定，並根據 `f` 的結果更新每個綁定。
filteri [ListLabels]	與 `ListLabels.filter` 相同，但謂詞會將元素的索引（從 0 開始計數）作為第一個參數，元素本身作為第二個參數應用。
filteri [List]	與 `List.filter` 相同，但謂詞會將元素的索引（從 0 開始計數）作為第一個參數，元素本身作為第二個參數應用。
finalise [Gc]	`finalise f v` 將 `f` 註冊為 `v` 的最終化函數。
finalise_last [Gc]	與 `Gc.finalise` 相同，只是該值不作為參數給定。
finalise_release [Gc]	最終化函數可以調用 `finalise_release` 來告知 GC，它可以啟動下一個最終化函數，而無需等待當前函數返回。
find [Weak.S]	`find t x` 返回在 `t` 中找到的 `x` 的一個實例。
find [Set.S]	`find x s` 返回 `s` 中與 `x` 相等的元素（根據 `Ord.compare`），如果沒有這樣的元素則引發 `Not_found`。
find [Seq]	`find p xs` 返回 `Some x`，其中 `x` 是序列 `xs` 中第一個滿足 `p x` 的元素（如果存在這樣一個元素）。
find [MoreLabels.Set.S]	`find x s` 返回 `s` 中與 `x` 相等的元素（根據 `Ord.compare`），如果沒有這樣的元素則引發 `Not_found`。
find [MoreLabels.Map.S]	`find x m` 返回 `m` 中 `x` 的當前值，如果不存在 `x` 的綁定則引發 `Not_found`。
find [MoreLabels.Hashtbl.SeededS]
find [MoreLabels.Hashtbl.S]
find [MoreLabels.Hashtbl]	`Hashtbl.find tbl x` 返回 `tbl` 中 `x` 的當前綁定，如果不存在這樣的綁定則引發 `Not_found`。
find [Map.S]	`find x m` 返回 `m` 中 `x` 的當前值，如果不存在 `x` 的綁定則引發 `Not_found`。
find [ListLabels]	`find ~f l` 返回列表 `l` 中第一個滿足謂詞 `f` 的元素。
find [List]	`find f l` 返回列表 `l` 中第一個滿足謂詞 `f` 的元素。
find [Hashtbl.SeededS]
find [Hashtbl.S]
find [Hashtbl]	`Hashtbl.find tbl x` 返回 `tbl` 中 `x` 的當前綁定，如果不存在這樣的綁定則引發 `Not_found`。
find [Ephemeron.Kn.Bucket]	返回具有給定鍵的最新添加的弱鍵值對的資料，如果沒有這樣的弱鍵值對，則返回 `None`。
find [Ephemeron.K2.Bucket]	返回具有給定鍵的最新添加的弱鍵值對的資料，如果沒有這樣的弱鍵值對，則返回 `None`。
find [Ephemeron.K1.Bucket]	返回具有給定鍵的最新添加的弱鍵值對的資料，如果沒有這樣的弱鍵值對，則返回 `None`。
find [Ephemeron.SeededS]
find [Ephemeron.S]
find_all [Weak.S]	`find_all t x` 返回在 `t` 中找到的 `x` 的所有實例的列表。
find_all [MoreLabels.Hashtbl.SeededS]
find_all [MoreLabels.Hashtbl.S]
find_all [MoreLabels.Hashtbl]	`Hashtbl.find_all tbl x` 返回在 `tbl` 中與 `x` 關聯的所有資料的列表。
find_all [ListLabels]	`find_all` 是 `ListLabels.filter` 的另一個名稱。
find_all [List]	`find_all` 是 `List.filter` 的另一個名稱。
find_all [Hashtbl.SeededS]
find_all [Hashtbl.S]
find_all [Hashtbl]	`Hashtbl.find_all tbl x` 返回在 `tbl` 中與 `x` 關聯的所有資料的列表。
find_all [Ephemeron.SeededS]
find_all [Ephemeron.S]
find_first [Set.S]	`find_first f s`，其中 `f` 是一個單調遞增的函數，返回 `s` 中最低的元素 `e`，使得 `f e`，如果不存在這樣的元素則引發 `Not_found`。
find_first [MoreLabels.Set.S]	`find_first ~f s`，其中 `f` 是一個單調遞增的函數，返回 `s` 中最低的元素 `e`，使得 `f e`，如果不存在這樣的元素則引發 `Not_found`。
find_first [MoreLabels.Map.S]	`find_first ~f m`，其中 `f` 是一個單調遞增的函數，返回 `m` 中最低的鍵 `k` 的綁定，使得 `f k`，如果不存在這樣的鍵則引發 `Not_found`。
find_first [Map.S]	`find_first f m`，其中 `f` 是一個單調遞增的函數，返回 `m` 中最低的鍵 `k` 的綁定，使得 `f k`，如果不存在這樣的鍵則引發 `Not_found`。
find_first_opt [Set.S]	`find_first_opt f s`，其中 `f` 是一個單調遞增的函數，返回一個選項，其中包含 `s` 中最低的元素 `e`，使得 `f e`，如果不存在這樣的元素則返回 `None`。
find_first_opt [MoreLabels.Set.S]	`find_first_opt ~f s`，其中 `f` 是一個單調遞增的函數，返回一個選項，其中包含 `s` 中最低的元素 `e`，使得 `f e`，如果不存在這樣的元素則返回 `None`。
find_first_opt [MoreLabels.Map.S]	`find_first_opt ~f m`，其中 `f` 是一個單調遞增的函數，返回一個選項，其中包含 `m` 中最低的鍵 `k` 的綁定，使得 `f k`，如果不存在這樣的鍵則返回 `None`。
find_first_opt [Map.S]	`find_first_opt f m`，其中 `f` 是一個單調遞增的函數，返回一個選項，其中包含 `m` 中最低的鍵 `k` 的綁定，使得 `f k`，如果不存在這樣的鍵則返回 `None`。
find_index [Seq]	`find_index p xs` 返回 `Some i`，其中 `i` 是序列 `xs` 中第一個滿足 `p x` 的元素的索引（如果存在這樣一個元素）。
find_index [ListLabels]	`find_index ~f xs` 返回 `Some i`，其中 `i` 是列表 `xs` 中第一個滿足 `f x` 的元素的索引（如果存在這樣一個元素）。
find_index [List]	`find_index f xs` 傳回 `Some i`，其中 `i` 是列表 `xs` 中第一個滿足 `f x` 條件的元素的索引，如果存在這樣的元素。
find_index [Float.ArrayLabels]	`find_index ~f a` 傳回 `Some i`，其中 `i` 是陣列 `a` 中第一個滿足 `f x` 條件的元素的索引，如果存在這樣的元素。
find_index [Float.Array]	`find_index f a` 傳回 `Some i`，其中 `i` 是陣列 `a` 中第一個滿足 `f x` 條件的元素的索引，如果存在這樣的元素。
find_index [ArrayLabels]	`find_index ~f a` 傳回 `Some i`，其中 `i` 是陣列 `a` 中第一個滿足 `f x` 條件的元素的索引，如果存在這樣的元素。
find_index [Array]	`find_index f a` 傳回 `Some i`，其中 `i` 是陣列 `a` 中第一個滿足 `f x` 條件的元素的索引，如果存在這樣的元素。
find_last [Set.S]	`find_last f s`，其中 `f` 是一個單調遞減的函數，它會傳回 `s` 中最高的元素 `e`，使得 `f e` 成立，如果不存在這樣的元素，則會引發 `Not_found` 例外。
find_last [MoreLabels.Set.S]	`find_last ~f s`，其中 `f` 是一個單調遞減的函數，它會傳回 `s` 中最高的元素 `e`，使得 `f e` 成立，如果不存在這樣的元素，則會引發 `Not_found` 例外。
find_last [MoreLabels.Map.S]	`find_last ~f m`，其中 `f` 是一個單調遞減的函數，它會傳回 `m` 中具有最高鍵 `k` 的綁定，使得 `f k` 成立，如果不存在這樣的鍵，則會引發 `Not_found` 例外。
find_last [Map.S]	`find_last f m`，其中 `f` 是一個單調遞減的函數，它會傳回 `m` 中具有最高鍵 `k` 的綁定，使得 `f k` 成立，如果不存在這樣的鍵，則會引發 `Not_found` 例外。
find_last [Dynarray]	`find_last a` 如果 `a` 為空，則為 `None`，否則為 `Some (get_last a)`。
find_last_opt [Set.S]	`find_last_opt f s`，其中 `f` 是一個單調遞減的函數，它會傳回一個選項，其中包含 `s` 中最高的元素 `e`，使得 `f e` 成立，如果不存在這樣的元素，則為 `None`。
find_last_opt [MoreLabels.Set.S]	`find_last_opt ~f s`，其中 `f` 是一個單調遞減的函數，它會傳回一個選項，其中包含 `s` 中最高的元素 `e`，使得 `f e` 成立，如果不存在這樣的元素，則為 `None`。
find_last_opt [MoreLabels.Map.S]	`find_last_opt ~f m`，其中 `f` 是一個單調遞減的函數，它會傳回一個選項，其中包含 `m` 中具有最高鍵 `k` 的綁定，使得 `f k` 成立，如果不存在這樣的鍵，則為 `None`。
find_last_opt [Map.S]	`find_last_opt f m`，其中 `f` 是一個單調遞減的函數，它會傳回一個選項，其中包含 `m` 中具有最高鍵 `k` 的綁定，使得 `f k` 成立，如果不存在這樣的鍵，則為 `None`。
find_left [Either]	`find_left (Left v)` 為 `Some v`，`find_left (Right _)` 為 `None`
find_map [Seq]	`find_map f xs` 傳回 `Some y`，其中 `x` 是序列 `xs` 中第一個使得 `f x = Some _` 的元素，如果存在這樣的元素，且 `y` 由 `f x = Some y` 定義。
find_map [ListLabels]	`find_map ~f l` 依序將 `f` 應用於 `l` 的元素，並傳回第一個 `Some v` 形式的結果，如果不存在，則傳回 `None`。
find_map [List]	`find_map f l` 依序將 `f` 應用於 `l` 的元素，並傳回第一個 `Some v` 形式的結果，如果不存在，則傳回 `None`。
find_map [Float.ArrayLabels]
find_map [Float.Array]
find_map [ArrayLabels]	`find_map ~f a` 依序將 `f` 應用於 `a` 的元素，並傳回第一個 `Some v` 形式的結果，如果不存在，則傳回 `None`。
find_map [Array]	`find_map f a` 依序將 `f` 應用於 `a` 的元素，並傳回第一個 `Some v` 形式的結果，如果不存在，則傳回 `None`。
find_mapi [Seq]	與 `find_map` 相同，但謂詞會將元素的索引（從 0 開始計數）作為第一個引數，並將元素本身作為第二個引數。
find_mapi [ListLabels]	與 `find_map` 相同，但謂詞會將元素的索引（從 0 開始計數）作為第一個引數，並將元素本身作為第二個引數。
find_mapi [List]	與 `find_map` 相同，但謂詞會將元素的索引（從 0 開始計數）作為第一個引數，並將元素本身作為第二個引數。
find_mapi [Float.ArrayLabels]	與 `find_map` 相同，但謂詞會將元素的索引（從 0 開始計數）作為第一個引數，並將元素本身作為第二個引數。
find_mapi [Float.Array]	與 `find_map` 相同，但謂詞會將元素的索引（從 0 開始計數）作為第一個引數，並將元素本身作為第二個引數。
find_mapi [ArrayLabels]	與 `find_map` 相同，但謂詞會將元素的索引（從 0 開始計數）作為第一個引數，並將元素本身作為第二個引數。
find_mapi [Array]	與 `find_map` 相同，但謂詞會將元素的索引（從 0 開始計數）作為第一個引數，並將元素本身作為第二個引數。
find_opt [Weak.S]	`find_opt t x` 傳回在 `t` 中找到的 `x` 的實例，如果沒有這樣的元素，則傳回 `None`。
find_opt [Set.S]	`find_opt x s` 傳回 `s` 中與 `x` 相等的元素（根據 `Ord.compare`），如果不存在這樣的元素，則傳回 `None`。
find_opt [MoreLabels.Set.S]	`find_opt x s` 傳回 `s` 中與 `x` 相等的元素（根據 `Ord.compare`），如果不存在這樣的元素，則傳回 `None`。
find_opt [MoreLabels.Map.S]	`find_opt x m` 如果 `m` 中 `x` 的目前值為 `v`，則傳回 `Some v`，如果不存在 `x` 的綁定，則傳回 `None`。
find_opt [MoreLabels.Hashtbl.SeededS]
find_opt [MoreLabels.Hashtbl.S]
find_opt [MoreLabels.Hashtbl]	`Hashtbl.find_opt tbl x` 傳回 `tbl` 中 `x` 的目前綁定，如果不存在這樣的綁定，則傳回 `None`。
find_opt [Map.S]	`find_opt x m` 如果 `m` 中 `x` 的目前值為 `v`，則傳回 `Some v`，如果不存在 `x` 的綁定，則傳回 `None`。
find_opt [ListLabels]	`find ~f l` 返回列表 `l` 中第一個滿足謂詞 `f` 的元素。
find_opt [List]	`find f l` 返回列表 `l` 中第一個滿足謂詞 `f` 的元素。
find_opt [Hashtbl.SeededS]
find_opt [Hashtbl.S]
find_opt [Hashtbl]	`Hashtbl.find_opt tbl x` 傳回 `tbl` 中 `x` 的目前綁定，如果不存在這樣的綁定，則傳回 `None`。
find_opt [Float.ArrayLabels]
find_opt [Float.Array]
find_opt [Ephemeron.SeededS]
find_opt [Ephemeron.S]
find_opt [ArrayLabels]	`find_opt ~f a` 傳回陣列 `a` 中第一個滿足謂詞 `f` 的元素，如果陣列 `a` 中沒有任何值滿足 `f`，則傳回 `None`。
find_opt [Array]	`find_opt f a` 傳回陣列 `a` 中第一個滿足謂詞 `f` 的元素，如果陣列 `a` 中沒有任何值滿足 `f`，則傳回 `None`。
find_right [Either]	`find_right (Right v)` 為 `Some v`，`find_right (Left _)` 為 `None`
first_chars [Str]	`first_chars s n` 傳回 `s` 的前 `n` 個字元。
first_non_constant_constructor_tag [Obj]
fit_capacity [Dynarray]	`fit_capacity a` 如果有必要，會重新配置後備陣列，使產生的容量恰好為 `length a`，且末尾沒有額外的空白空間。
flat_map [Seq]	`flat_map f xs` 等同於 `concat (map f xs)`。
flatten [ListLabels]	與 `ListLabels.concat` 相同。
flatten [List]	與 `List.concat` 相同。
flip [Fun]	`flip f` 反轉二元函數 `f` 的引數順序。
float [Stdlib]	與 `float_of_int` 相同。
float [Random.State]
float [Random]	`Random.float bound` 傳回一個介於 0 和 `bound` (含) 之間的隨機浮點數。
float16 [Bigarray]	請參閱 `Bigarray.char`。
float32 [Bigarray]	請參閱 `Bigarray.char`。
float64 [Bigarray]	請參閱 `Bigarray.char`。
float_of_bits [Int64]	傳回浮點數，其內部表示形式根據 IEEE 754 浮點數「雙精度格式」位元佈局，為給定的 `int64`。
float_of_bits [Int32]	根據 IEEE 754 浮點數「單精度格式」位元佈局，傳回內部表示法為給定 `int32` 的浮點數。
float_of_int [Stdlib]	將整數轉換為浮點數。
float_of_string [Stdlib]	與 `float_of_string_opt` 相同，但會引發 `Failure "float_of_string"` 而不是傳回 `None`。
float_of_string_opt [Stdlib]	將給定的字串轉換為浮點數。
floor [Stdlib]	向下捨入為整數值。
floor [Float]	向下捨入為整數值。
flush [Stdlib]	刷新與給定輸出通道關聯的緩衝區，對該通道執行所有暫止的寫入操作。
flush [Out_channel]	刷新與給定輸出通道關聯的緩衝區，對該通道執行所有暫止的寫入操作。
flush_all [Stdlib]	刷新所有開啟的輸出通道；忽略錯誤。
flush_all [Out_channel]	刷新所有開啟的輸出通道；忽略錯誤。
flush_input [Lexing]	捨棄緩衝區的內容，並將目前位置重設為 0。
flush_str_formatter [Format]	傳回以目前網域的 `str_formatter` 列印的資料，刷新格式器並重設對應的緩衝區。
flush_symbolic_output_buffer [Format]	`flush_symbolic_output_buffer sob` 傳回緩衝區 `sob` 的內容，並重設緩衝區 `sob`。
fma [Float]	`fma x y z` 傳回 `x * y + z`，並盡力使用單一捨入來計算此運算式，使用硬體指令 (提供完整的 IEEE 相容性) 或軟體模擬。
fmt_ebb_of_string [CamlinternalFormat]
fold [Weak.S]	`fold f t init` 計算 `(f d1 (... (f dN init)))`，其中 `d1 ... dN` 是 `t` 中的元素，順序未指定。
fold [Stack]	`fold f accu s` 是 `(f (... (f (f accu x1) x2) ...) xn)`，其中 `x1` 是堆疊的頂端元素，`x2` 是第二個元素，而 `xn` 是底部元素。
fold [Set.S]	`fold f s init` 計算 `(f xN ... (f x2 (f x1 init))...)`，其中 `x1 ... xN` 是 `s` 中的元素，依遞增順序排列。
fold [Result]	如果 `r` 是 `Ok v`，則 `fold ~ok ~error r` 是 `ok v`，如果 `r` 是 `Error e`，則為 `error e`。
fold [Queue]	`fold f accu q` 等同於 `List.fold_left f accu l`，其中 `l` 是 `q` 元素的列表。
fold [Option]	如果 `o` 是 `None`，則 `fold ~none ~some o` 是 `none`，如果 `o` 是 `Some v`，則為 `some v`。
fold [MoreLabels.Set.S]	`fold ~f s init` 計算 `(f xN ... (f x2 (f x1 init))...)`，其中 `x1 ... xN` 是 `s` 中的元素，依遞增順序排列。
fold [MoreLabels.Map.S]	`fold ~f m ~init` 計算 `(f kN dN ... (f k1 d1 init)...)`，其中 `k1 ... kN` 是 `m` 中所有綁定的索引鍵 (依遞增順序排列)，而 `d1 ... dN` 是關聯的資料。
fold [MoreLabels.Hashtbl.SeededS]
fold [MoreLabels.Hashtbl.S]
fold [MoreLabels.Hashtbl]	`Hashtbl.fold ~f tbl ~init` 計算 `(f kN dN ... (f k1 d1 init)...)`，其中 `k1 ... kN` 是 `tbl` 中所有綁定的索引鍵，而 `d1 ... dN` 是關聯的值。
fold [Map.S]	`fold f m init` 計算 `(f kN dN ... (f k1 d1 init)...)`，其中 `k1 ... kN` 是 `m` 中所有綁定的索引鍵 (依遞增順序排列)，而 `d1 ... dN` 是關聯的資料。
fold [Hashtbl.SeededS]
fold [Hashtbl.S]
fold [Hashtbl]	`Hashtbl.fold f tbl init` 計算 `(f kN dN ... (f k1 d1 init)...)`，其中 `k1 ... kN` 是 `tbl` 中所有綁定的索引鍵，而 `d1 ... dN` 是關聯的值。
fold [Either]	`fold ~left ~right (Left v)` 是 `left v`，而 `fold ~left ~right (Right v)` 是 `right v`。
fold_left [String]	`fold_left f x s` 計算 `f (... (f (f x s.[0]) s.[1]) ...) s.[n-1]`，其中 `n` 是字串 `s` 的長度。
fold_left [StringLabels]	`fold_left f x s` 計算 `f (... (f (f x s.[0]) s.[1]) ...) s.[n-1]`，其中 `n` 是字串 `s` 的長度。
fold_left [Seq]	`fold_left f _ xs` 對序列 `xs` 的每個元素 `x`，從左到右依序呼叫 `f _ x`。
fold_left [ListLabels]	`fold_left ~f ~init [b1; ...; bn]` 是 `f (... (f (f init b1) b2) ...) bn`。
fold_left [List]	`fold_left f init [b1; ...; bn]` 是 `f (... (f (f init b1) b2) ...) bn`。
fold_left [Float.ArrayLabels]	`fold_left ~f x ~init` 計算 `f (... (f (f x init.(0)) init.(1)) ...) init.(n-1)`，其中 `n` 是浮點數陣列 `init` 的長度。
fold_left [Float.Array]	`fold_left f x init` 計算 `f (... (f (f x init.(0)) init.(1)) ...) init.(n-1)`，其中 `n` 是浮點數陣列 `init` 的長度。
fold_left [Dynarray]	`fold_left f acc a` 依序將 `f` 折疊到 `a` 上，從累加器 `acc` 開始。
fold_left [BytesLabels]	`fold_left f x s` 計算 `f (... (f (f x (get s 0)) (get s 1)) ...) (get s (n-1))`，其中 `n` 是 `s` 的長度。
fold_left [Bytes]	`fold_left f x s` 計算 `f (... (f (f x (get s 0)) (get s 1)) ...) (get s (n-1))`，其中 `n` 是 `s` 的長度。
fold_left [ArrayLabels]	`fold_left ~f ~init a` 計算 `f (... (f (f init a.(0)) a.(1)) ...) a.(n-1)`，其中 `n` 是陣列 `a` 的長度。
fold_left [Array]	`fold_left f init a` 計算 `f (... (f (f init a.(0)) a.(1)) ...) a.(n-1)`，其中 `n` 是陣列 `a` 的長度。
fold_left2 [Seq]	`fold_left2 f _ xs ys` 對從序列 `xs` 和 `ys` 同步提取的每一對元素 `(x, y)` 依序呼叫 `f _ x y`。
fold_left2 [ListLabels]	`fold_left2 ~f ~init [a1; ...; an] [b1; ...; bn]` 是 `f (... (f (f init a1 b1) a2 b2) ...) an bn`。
fold_left2 [List]	`fold_left2 f init [a1; ...; an] [b1; ...; bn]` 是 `f (... (f (f init a1 b1) a2 b2) ...) an bn`。
fold_left_map [ListLabels]	`fold_left_map` 是 `fold_left` 和 `map` 的組合，它透過對 `f` 的呼叫來傳遞累加器。
fold_left_map [List]	`fold_left_map` 是 `fold_left` 和 `map` 的組合，它透過對 `f` 的呼叫來傳遞累加器。
fold_left_map [ArrayLabels]	`fold_left_map` 是 `ArrayLabels.fold_left` 和 `ArrayLabels.map` 的組合，它透過對 `f` 的呼叫來傳遞累加器。
fold_left_map [Array]	`fold_left_map` 是 `Array.fold_left` 和 `Array.map` 的組合，它透過對 `f` 的呼叫來傳遞累加器。
fold_lefti [Seq]	`fold_lefti f _ xs` 對序列 `xs` 中位於索引 `i` 的每個元素 `x`，依序呼叫 `f _ i x`。
fold_lines [In_channel]	`fold_lines f init ic` 使用 `In_channel.input_line` 從 `ic` 讀取行，直到到達檔案結尾，並以折疊樣式將每一行依序傳遞給函數 `f`。
fold_right [String]	`fold_right f s x` 計算 `f s.[0] (f s.[1] ( ... (f s.[n-1] x) ...))`，其中 `n` 是字串 `s` 的長度。
fold_right [StringLabels]	`fold_right f s x` 計算 `f s.[0] (f s.[1] ( ... (f s.[n-1] x) ...))`，其中 `n` 是字串 `s` 的長度。
fold_right [ListLabels]	`fold_right ~f [a1; ...; an] ~init` 是 `f a1 (f a2 (... (f an init) ...))`。
fold_right [List]	`fold_right f [a1; ...; an] init` 的計算結果為 `f a1 (f a2 (... (f an init) ...))`。
fold_right [Float.ArrayLabels]	`fold_right f a init` 計算結果為 `f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...))`，其中 `n` 是浮點數陣列 `a` 的長度。
fold_right [Float.Array]	`fold_right f a init` 計算結果為 `f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...))`，其中 `n` 是浮點數陣列 `a` 的長度。
fold_right [Dynarray]	`fold_right f a acc` 計算結果為 `f x0 (f x1 (... (f xn acc) ...))`，其中 `x0`、`x1`、...、`xn` 是 `a` 的元素。
fold_right [BytesLabels]	`fold_right f s x` 計算結果為 `f (get s 0) (f (get s 1) ( ... (f (get s (n-1)) x) ...))`，其中 `n` 是 `s` 的長度。
fold_right [Bytes]	`fold_right f s x` 計算結果為 `f (get s 0) (f (get s 1) ( ... (f (get s (n-1)) x) ...))`，其中 `n` 是 `s` 的長度。
fold_right [ArrayLabels]	`fold_right ~f a ~init` 計算結果為 `f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...))`，其中 `n` 是陣列 `a` 的長度。
fold_right [Array]	`fold_right f a init` 計算結果為 `f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...))`，其中 `n` 是陣列 `a` 的長度。
fold_right2 [ListLabels]	`fold_right2 ~f [a1; ...; an] [b1; ...; bn] ~init` 的計算結果為 `f a1 b1 (f a2 b2 (... (f an bn init) ...))`。
fold_right2 [List]	`fold_right2 f [a1; ...; an] [b1; ...; bn] init` 的計算結果為 `f a1 b1 (f a2 b2 (... (f an bn init) ...))`。
for_all [String]	`for_all p s` 檢查 `s` 中是否所有字元都滿足謂詞 `p`。
for_all [StringLabels]	`for_all p s` 檢查 `s` 中是否所有字元都滿足謂詞 `p`。
for_all [Set.S]	`for_all f s` 檢查集合中是否所有元素都滿足謂詞 `f`。
for_all [Seq]	`for_all p xs` 判斷序列 `xs` 的所有元素 `x` 是否都滿足 `p x`。
for_all [MoreLabels.Set.S]	`for_all ~f s` 檢查集合中是否所有元素都滿足謂詞 `f`。
for_all [MoreLabels.Map.S]	`for_all ~f m` 檢查映射中是否所有綁定都滿足謂詞 `f`。
for_all [Map.S]	`for_all f m` 檢查映射中是否所有綁定都滿足謂詞 `f`。
for_all [ListLabels]	`for_all ~f [a1; ...; an]` 檢查列表中是否所有元素都滿足謂詞 `f`。
for_all [List]	`for_all f [a1; ...; an]` 檢查列表中是否所有元素都滿足謂詞 `f`。
for_all [Float.ArrayLabels]	`for_all ~f [\|a1; ...; an\|]` 檢查浮點數陣列中是否所有元素都滿足謂詞 `f`。
for_all [Float.Array]	`for_all f [\|a1; ...; an\|]` 檢查浮點數陣列中是否所有元素都滿足謂詞 `f`。
for_all [Either]	`for_all ~left ~right (Left v)` 的結果為 `left v`，而 `for_all ~left ~right (Right v)` 的結果為 `right v`。
for_all [Dynarray]	`for_all f a` 如果 `a` 的所有元素都滿足 `f`，則結果為 `true`。
for_all [BytesLabels]	`for_all p s` 檢查 `s` 中是否所有字元都滿足謂詞 `p`。
for_all [Bytes]	`for_all p s` 檢查 `s` 中是否所有字元都滿足謂詞 `p`。
for_all [ArrayLabels]	`for_all ~f [\|a1; ...; an\|]` 檢查陣列中是否所有元素都滿足謂詞 `f`。
for_all [Array]	`for_all f [\|a1; ...; an\|]` 檢查陣列中是否所有元素都滿足謂詞 `f`。
for_all2 [Seq]	`for_all2 p xs ys` 判斷從序列 `xs` 和 `ys` 同步提取的所有元素對 `(x, y)` 是否都滿足 `p x y`。
for_all2 [ListLabels]	與 `ListLabels.for_all` 相同，但適用於接受兩個參數的謂詞。
for_all2 [List]	與 `List.for_all` 相同，但適用於接受兩個參數的謂詞。
for_all2 [ArrayLabels]	與 `ArrayLabels.for_all` 相同，但適用於接受兩個參數的謂詞。
for_all2 [Array]	與 `Array.for_all` 相同，但適用於接受兩個參數的謂詞。
force [Lazy]	`force x` 強制執行延遲計算 `x` 並傳回其結果。
force_gen [CamlinternalLazy]
force_lazy_block [CamlinternalLazy]
force_newline [Format]	在目前的格式化輸出方塊中強制換行。
force_val [Lazy]	`force_val x` 強制執行延遲計算 `x` 並傳回其結果。
forcing_tag [Obj]
forever [Seq]	`forever f` 是一個無限序列，其中每個元素都由函數呼叫 `f()` (在需要時) 產生。
fork [UnixLabels]	分叉一個新的處理程序。
fork [Unix]	分叉一個新的處理程序。
format [Printexc.Slot]	`format pos slot` 會傳回 `slot` 的字串表示法，如同 `raw_backtrace_to_string` 的格式化方式，假設它是回溯的第 `pos` 個元素：第 `0` 個元素的列印格式與其他元素不同。
format_from_string [Scanf]	`format_from_string s fmt` 會根據給定的格式字串 `fmt`，將字串引數轉換為格式字串。
format_of_string [Stdlib]	`format_of_string s` 會傳回從字串常值 `s` 讀取的格式字串。
format_of_string_fmtty [CamlinternalFormat]
format_of_string_format [CamlinternalFormat]
formatter_of_buffer [Format]	`formatter_of_buffer b` 會傳回一個新的格式器，該格式器會寫入緩衝區 `b`。
formatter_of_out_channel [Format]	`formatter_of_out_channel oc` 會傳回一個新的格式器，該格式器會寫入對應的輸出通道 `oc`。
formatter_of_out_functions [Format]	`formatter_of_out_functions out_funs` 會傳回一個新的格式器，該格式器會使用輸出函數集 `out_funs` 寫入。
formatter_of_symbolic_output_buffer [Format]	`formatter_of_symbolic_output_buffer sob` 會傳回一個符號格式器，該格式器會輸出到 `symbolic_output_buffer` `sob`。
fortran_layout [Bigarray]
forward_tag [Obj]
fprintf [Printf]	`fprintf outchan format arg1 ... argN` 會根據格式字串 `format` 格式化引數 `arg1` 到 `argN`，並將結果字串輸出到通道 `outchan`。
fprintf [Format]
free_cursor [Runtime_events]	釋放先前建立的 runtime_events 指標。
freeze_char_set [CamlinternalFormat]
frexp [Stdlib]	`frexp f` 會傳回 `f` 的有效數和指數配對。
frexp [Float]	`frexp f` 會傳回 `f` 的有效數和指數配對。
from_bytes [Marshal]	`Marshal.from_bytes buff ofs` 會解除序列化結構化值，如同 `Marshal.from_channel` 一樣，但位元組表示法不是從通道讀取，而是從位元組序列 `buff` 中取得，從位置 `ofs` 開始。
from_channel [Scanf.Scanning]	`Scanning.from_channel ic` 會傳回一個 `Scanf.Scanning.in_channel` 格式化的輸入通道，該通道會從正規的 `in_channel` 輸入通道 `ic` 引數讀取。
from_channel [Marshal]	`Marshal.from_channel chan` 會從通道 `chan` 讀取結構化值的位元組表示法 (由 `Marshal.to_*` 函數之一產生)，並重建和傳回對應的值。
from_channel [Lexing]	在給定的輸入通道上建立一個詞法分析器緩衝區。
from_file [Scanf.Scanning]	是上述 `Scanf.Scanning.open_in` 的別名。
from_file_bin [Scanf.Scanning]	是上述 `Scanf.Scanning.open_in_bin` 的別名。
from_fun [Lazy]	`from_fun f` 與 `lazy (f ())` 相同，但效率稍微高一些。
from_function [Scanf.Scanning]	`Scanning.from_function f` 會傳回一個 `Scanf.Scanning.in_channel` 格式化的輸入通道，該通道會使用給定的函數作為其讀取方法。
from_function [Lexing]	使用給定的函數作為其讀取方法建立詞法分析器緩衝區。
from_hex [Digest]	與 `Digest.of_hex` 函數相同。
from_string [Scanf.Scanning]	`Scanning.from_string s` 傳回一個 `Scanf.Scanning.in_channel` 格式化的輸入通道，該通道從給定的字串讀取資料。
from_string [Marshal]	與 `from_bytes` 相同，但接受字串作為引數，而非位元組序列。
from_string [Lexing]	建立一個從給定字串讀取的詞法分析器緩衝區。
from_val [Lazy]	`from_val v` 會先評估 `v`（如同任何函式一樣），並傳回已強制執行的結果暫停。
fst [Stdlib]	傳回配對的第一個元件。
fstat [UnixLabels.LargeFile]
fstat [UnixLabels]	傳回與給定描述符相關聯的檔案資訊。
fstat [Unix.LargeFile]
fstat [Unix]	傳回與給定描述符相關聯的檔案資訊。
fsync [UnixLabels]	將檔案緩衝區刷新到磁碟。
fsync [Unix]	將檔案緩衝區刷新到磁碟。
ftruncate [UnixLabels.LargeFile]	請參閱 `ftruncate`。
ftruncate [UnixLabels]	將與給定描述符相對應的檔案截斷為給定的大小。
ftruncate [Unix.LargeFile]	請參閱 `ftruncate`。
ftruncate [Unix]	將與給定描述符相對應的檔案截斷為給定的大小。
full_init [Random]	與 `Random.init` 相同，但接受更多資料作為種子。
full_int [Random.State]
full_int [Random]	`Random.full_int bound` 傳回一個介於 0（包含）和 `bound`（不包含）之間的隨機整數。
full_major [Gc]	執行一次次要的記憶體回收，完成目前的主要記憶體回收週期，並執行一個完整的新週期。
full_split [Str]	與 `Str.split_delim` 相同，但會傳回分隔符號以及分隔符號之間包含的子字串。
G
genarray_of_array0 [Bigarray]	傳回與給定零維 Bigarray 對應的泛型 Bigarray。
genarray_of_array1 [Bigarray]	傳回與給定一維 Bigarray 對應的泛型 Bigarray。
genarray_of_array2 [Bigarray]	傳回與給定二維 Bigarray 對應的泛型 Bigarray。
genarray_of_array3 [Bigarray]	傳回與給定三維 Bigarray 對應的泛型 Bigarray。
get [Weak]	`Weak.get ar n` 如果 `ar` 的第 `n` 個儲存格為空，則傳回 None，如果已滿，則傳回 `Some x`（其中 `x` 是值）。
get [String]	`get s i` 是 `s` 中索引為 `i` 的字元。
get [StringLabels]	`get s i` 是 `s` 中索引為 `i` 的字元。
get [Option]	如果 `o` 為 `Some v`，則 `get o` 為 `v`，否則會引發例外。
get [Gc]	在 `control` 記錄中傳回 GC 參數的目前值。
get [Float.ArrayLabels]	`get a n` 傳回浮點數陣列 `a` 的第 `n` 個元素。
get [Float.Array]	`get a n` 傳回浮點數陣列 `a` 的第 `n` 個元素。
get [Dynarray]	`get a i` 是 `a` 的第 `i` 個元素，從索引 `0` 開始。
get [Domain.DLS]	如果值 `v` 與呼叫網域的網域本機狀態中的鍵 `k` 相關聯，則 `get k` 會傳回 `v`。
get [BytesLabels]	`get s n` 傳回引數 `s` 中索引為 `n` 的位元組。
get [Bytes]	`get s n` 傳回引數 `s` 中索引為 `n` 的位元組。
get [Bigarray.Array3]	`Array3.get a x y z`，也寫作 `a.{x,y,z}`，會傳回 `a` 中座標 (`x`, `y`, `z`) 的元素。
get [Bigarray.Array2]	`Array2.get a x y`，也寫作 `a.{x,y}`，會傳回 `a` 中座標 (`x`, `y`) 的元素。
get [Bigarray.Array1]	`Array1.get a x`，或另一種寫法 `a.{x}`，會傳回 `a` 中索引為 `x` 的元素。
get [Bigarray.Array0]	`Array0.get a` 傳回 `a` 中的唯一元素。
get [Bigarray.Genarray]	讀取泛型 Bigarray 的元素。
get [Atomic]	取得原子參考的目前值。
get [ArrayLabels]	`get a n` 傳回陣列 `a` 的第 `n` 個元素。
get [Array]	`get a n` 傳回陣列 `a` 的第 `n` 個元素。
get_backtrace [Printexc]	`Printexc.get_backtrace ()` 傳回一個字串，其中包含與 `Printexc.print_backtrace` 將列印的相同的例外回溯。
get_callstack [Printexc]	`Printexc.get_callstack n` 傳回目前程式點（針對目前的執行緒）呼叫堆疊頂端的描述，最多包含 `n` 個項目。
get_callstack [Effect.Shallow]	`get_callstack c n` 傳回接續 `c` 上呼叫堆疊頂端的描述，最多包含 `n` 個項目。
get_callstack [Effect.Deep]	`get_callstack c n` 傳回接續 `c` 上呼叫堆疊頂端的描述，最多包含 `n` 個項目。
get_copy [Weak]	`Weak.get_copy ar n` 如果 `ar` 的第 `n` 個儲存格為空，則傳回 None，如果已滿，則傳回 `Some x`（其中 `x` 是值的（淺層）副本）。
get_data [Obj.Ephemeron]
get_data_copy [Obj.Ephemeron]
get_ellipsis_text [Format]	傳回省略符號的文字。
get_err_formatter [Format]	`get_err_formatter ()` 傳回目前網域用於寫入標準錯誤的格式器。
get_error [Result]	如果 `r` 為 `Error e`，則 `get_error r` 為 `e`，否則會引發例外。
get_formatter_out_functions [Format]	傳回美化列印器的目前輸出函式，包括分行和縮排函式。
get_formatter_output_functions [Format]	傳回標準美化列印器的目前輸出函式。
get_formatter_stag_functions [Format]	傳回標準美化列印器的目前語義標籤運算函式。
get_geometry [Format]	傳回格式器的目前幾何資訊。
get_id [Domain]	`get_id d` 傳回網域 `d` 的識別碼。
get_int16_be [String]	`get_int16_be b i` 是 `b` 從字元索引 `i` 開始的大端有號 16 位元整數。
get_int16_be [StringLabels]	`get_int16_be b i` 是 `b` 從字元索引 `i` 開始的大端有號 16 位元整數。
get_int16_be [BytesLabels]	`get_int16_be b i` 是 `b` 從位元組索引 `i` 開始的大端有號 16 位元整數。
get_int16_be [Bytes]	`get_int16_be b i` 是 `b` 從位元組索引 `i` 開始的大端有號 16 位元整數。
get_int16_le [String]	`get_int16_le b i` 是 `b` 從字元索引 `i` 開始的小端有號 16 位元整數。
get_int16_le [StringLabels]	`get_int16_le b i` 是 `b` 從字元索引 `i` 開始的小端有號 16 位元整數。
get_int16_le [BytesLabels]	`get_int16_le b i` 是 `b` 從位元組索引 `i` 開始的小端有號 16 位元整數。
get_int16_le [Bytes]	`get_int16_le b i` 是 `b` 從位元組索引 `i` 開始的小端有號 16 位元整數。
get_int16_ne [String]	`get_int16_ne b i` 是從字元索引 `i` 開始的 `b` 的原生位元組序有號 16 位元整數。
get_int16_ne [StringLabels]	`get_int16_ne b i` 是從字元索引 `i` 開始的 `b` 的原生位元組序有號 16 位元整數。
get_int16_ne [BytesLabels]	`get_int16_ne b i` 是從位元組索引 `i` 開始的 `b` 的原生位元組序有號 16 位元整數。
get_int16_ne [Bytes]	`get_int16_ne b i` 是從位元組索引 `i` 開始的 `b` 的原生位元組序有號 16 位元整數。
get_int32_be [String]	`get_int32_be b i` 是從字元索引 `i` 開始的 `b` 的大端序 32 位元整數。
get_int32_be [StringLabels]	`get_int32_be b i` 是從字元索引 `i` 開始的 `b` 的大端序 32 位元整數。
get_int32_be [BytesLabels]	`get_int32_be b i` 是從位元組索引 `i` 開始的 `b` 的大端序 32 位元整數。
get_int32_be [Bytes]	`get_int32_be b i` 是從位元組索引 `i` 開始的 `b` 的大端序 32 位元整數。
get_int32_le [String]	`get_int32_le b i` 是從字元索引 `i` 開始的 `b` 的小端序 32 位元整數。
get_int32_le [StringLabels]	`get_int32_le b i` 是從字元索引 `i` 開始的 `b` 的小端序 32 位元整數。
get_int32_le [BytesLabels]	`get_int32_le b i` 是從位元組索引 `i` 開始的 `b` 的小端序 32 位元整數。
get_int32_le [Bytes]	`get_int32_le b i` 是從位元組索引 `i` 開始的 `b` 的小端序 32 位元整數。
get_int32_ne [String]	`get_int32_ne b i` 是從字元索引 `i` 開始的 `b` 的原生位元組序 32 位元整數。
get_int32_ne [StringLabels]	`get_int32_ne b i` 是從字元索引 `i` 開始的 `b` 的原生位元組序 32 位元整數。
get_int32_ne [BytesLabels]	`get_int32_ne b i` 是從位元組索引 `i` 開始的 `b` 的原生位元組序 32 位元整數。
get_int32_ne [Bytes]	`get_int32_ne b i` 是從位元組索引 `i` 開始的 `b` 的原生位元組序 32 位元整數。
get_int64_be [String]	`get_int64_be b i` 是從字元索引 `i` 開始的 `b` 的大端序 64 位元整數。
get_int64_be [StringLabels]	`get_int64_be b i` 是從字元索引 `i` 開始的 `b` 的大端序 64 位元整數。
get_int64_be [BytesLabels]	`get_int64_be b i` 是從位元組索引 `i` 開始的 `b` 的大端序 64 位元整數。
get_int64_be [Bytes]	`get_int64_be b i` 是從位元組索引 `i` 開始的 `b` 的大端序 64 位元整數。
get_int64_le [String]	`get_int64_le b i` 是從字元索引 `i` 開始的 `b` 的小端序 64 位元整數。
get_int64_le [StringLabels]	`get_int64_le b i` 是從字元索引 `i` 開始的 `b` 的小端序 64 位元整數。
get_int64_le [BytesLabels]	`get_int64_le b i` 是從位元組索引 `i` 開始的 `b` 的小端序 64 位元整數。
get_int64_le [Bytes]	`get_int64_le b i` 是從位元組索引 `i` 開始的 `b` 的小端序 64 位元整數。
get_int64_ne [String]	`get_int64_ne b i` 是從字元索引 `i` 開始的 `b` 的原生位元組序 64 位元整數。
get_int64_ne [StringLabels]	`get_int64_ne b i` 是從字元索引 `i` 開始的 `b` 的原生位元組序 64 位元整數。
get_int64_ne [BytesLabels]	`get_int64_ne b i` 是從位元組索引 `i` 開始的 `b` 的原生位元組序 64 位元整數。
get_int64_ne [Bytes]	`get_int64_ne b i` 是從位元組索引 `i` 開始的 `b` 的原生位元組序 64 位元整數。
get_int8 [String]	`get_int8 b i` 是從字元索引 `i` 開始的 `b` 的有號 8 位元整數。
get_int8 [StringLabels]	`get_int8 b i` 是從字元索引 `i` 開始的 `b` 的有號 8 位元整數。
get_int8 [BytesLabels]	`get_int8 b i` 是從位元組索引 `i` 開始的 `b` 的有號 8 位元整數。
get_int8 [Bytes]	`get_int8 b i` 是從位元組索引 `i` 開始的 `b` 的有號 8 位元整數。
get_key [Obj.Ephemeron]
get_key_copy [Obj.Ephemeron]
get_last [Dynarray]	`get_last a` 是 `a` 在索引 `length a - 1` 的元素。
get_margin [Format]	傳回右邊界的位置。
get_mark_tags [Format]	傳回標記操作的目前狀態。
get_max_boxes [Format]	傳回在省略號之前允許的最大美觀列印方塊數。
get_max_indent [Format]	傳回最大縮排限制（以字元為單位）。
get_method [CamlinternalOO]
get_method_label [CamlinternalOO]
get_method_labels [CamlinternalOO]
get_minor_free [Gc]	傳回此網域次要堆積內可用空間的目前大小。
get_ok [Result]	`get_ok r` 若 `r` 為 `Ok v` 則為 `v`，否則會引發例外。
get_print_tags [Format]	傳回標籤列印操作的目前狀態。
get_public_method [CamlinternalOO]
get_raw_backtrace [Printexc]	`Printexc.get_raw_backtrace ()` 會傳回與 `Printexc.print_backtrace` 將會列印的相同例外回溯，但格式為原始格式。
get_raw_backtrace_next_slot [Printexc]	`get_raw_backtrace_next_slot slot` 傳回下一個內嵌的 slot，如果有的話。
get_raw_backtrace_slot [Printexc]	`get_raw_backtrace_slot bckt pos` 傳回回溯 `bckt` 中位置 `pos` 的 slot。
get_state [Random]	`get_state()` 傳回網域本機產生器 (由基本函式使用) 目前狀態的全新複本。
get_std_formatter [Format]	`get_std_formatter ()` 傳回目前網域用來寫入標準輸出的標準格式化器。
get_stdbuf [Format]	`get_stdbuf ()` 傳回目前網域的字串緩衝區，目前網域的字串格式化器會寫入該緩衝區。
get_str_formatter [Format]	目前網域的格式化器，用於輸出到目前網域的字串緩衝區。
get_symbolic_output_buffer [Format]	`get_symbolic_output_buffer sob` 傳回緩衝區 `sob` 的內容。
get_temp_dir_name [Filename]	暫存目錄的名稱：在 Unix 下，為 `TMPDIR` 環境變數的值，如果未設定該變數，則為 "/tmp"。
get_uint16_be [String]	`get_uint16_be b i` 是從字元索引 `i` 開始的 `b` 的大端序無號 16 位元整數。
get_uint16_be [StringLabels]	`get_uint16_be b i` 是從字元索引 `i` 開始的 `b` 的大端序無號 16 位元整數。
get_uint16_be [BytesLabels]	`get_uint16_be b i` 是從位元組索引 `i` 開始的 `b` 的大端序無號 16 位元整數。
get_uint16_be [Bytes]	`get_uint16_be b i` 是從位元組索引 `i` 開始的 `b` 的大端序無號 16 位元整數。
get_uint16_le [String]	`get_uint16_le b i` 是從字元索引 `i` 開始的 `b` 的小端序無號 16 位元整數。
get_uint16_le [StringLabels]	`get_uint16_le b i` 是從字元索引 `i` 開始的 `b` 的小端序無號 16 位元整數。
get_uint16_le [BytesLabels]	`get_uint16_le b i` 是從位元組索引 `i` 開始的 `b` 的小端序無號 16 位元整數。
get_uint16_le [Bytes]	`get_uint16_le b i` 是從位元組索引 `i` 開始的 `b` 的小端序無號 16 位元整數。
get_uint16_ne [String]	`get_uint16_ne b i` 是從字元索引 `i` 開始的 `b` 的原生位元組序無號 16 位元整數。
get_uint16_ne [StringLabels]	`get_uint16_ne b i` 是從字元索引 `i` 開始的 `b` 的原生位元組序無號 16 位元整數。
get_uint16_ne [BytesLabels]	`get_uint16_ne b i` 是從位元組索引 `i` 開始的 `b` 的原生位元組序無號 16 位元整數。
get_uint16_ne [Bytes]	`get_uint16_ne b i` 是從位元組索引 `i` 開始的 `b` 的原生位元組序無號 16 位元整數。
get_uint8 [String]	`get_uint8 b i` 是從字元索引 `i` 開始的 `b` 的無號 8 位元整數。
get_uint8 [StringLabels]	`get_uint8 b i` 是從字元索引 `i` 開始的 `b` 的無號 8 位元整數。
get_uint8 [BytesLabels]	`get_uint8 b i` 是從位元組索引 `i` 開始的 `b` 的無號 8 位元整數。
get_uint8 [Bytes]	`get_uint8 b i` 是從位元組索引 `i` 開始的 `b` 的無號 8 位元整數。
get_utf_16be_uchar [String]	`get_utf_16be_uchar b i` 解碼 `b` 中索引 `i` 的 UTF-16BE 字元。
get_utf_16be_uchar [StringLabels]	`get_utf_16be_uchar b i` 解碼 `b` 中索引 `i` 的 UTF-16BE 字元。
get_utf_16be_uchar [BytesLabels]	`get_utf_16be_uchar b i` 解碼 `b` 中索引 `i` 的 UTF-16BE 字元。
get_utf_16be_uchar [Bytes]	`get_utf_16be_uchar b i` 解碼 `b` 中索引 `i` 的 UTF-16BE 字元。
get_utf_16le_uchar [String]	`get_utf_16le_uchar b i` 解碼 `b` 中索引 `i` 的 UTF-16LE 字元。
get_utf_16le_uchar [StringLabels]	`get_utf_16le_uchar b i` 解碼 `b` 中索引 `i` 的 UTF-16LE 字元。
get_utf_16le_uchar [BytesLabels]	`get_utf_16le_uchar b i` 解碼 `b` 中索引 `i` 的 UTF-16LE 字元。
get_utf_16le_uchar [Bytes]	`get_utf_16le_uchar b i` 解碼 `b` 中索引 `i` 的 UTF-16LE 字元。
get_utf_8_uchar [String]	`get_utf_8_uchar b i` 解碼 `b` 中索引 `i` 的 UTF-8 字元。
get_utf_8_uchar [StringLabels]	`get_utf_8_uchar b i` 解碼 `b` 中索引 `i` 的 UTF-8 字元。
get_utf_8_uchar [BytesLabels]	`get_utf_8_uchar b i` 解碼 `b` 中索引 `i` 的 UTF-8 字元。
get_utf_8_uchar [Bytes]	`get_utf_8_uchar b i` 解碼 `b` 中索引 `i` 的 UTF-8 字元。
get_value [Semaphore.Counting]	`get_value s` 傳回號誌 `s` 的目前值。
get_variable [CamlinternalOO]
get_variables [CamlinternalOO]
getaddrinfo [UnixLabels]	`getaddrinfo host service opts` 傳回 `UnixLabels.addr_info` 記錄的清單，其中描述適用於與指定主機和服務通訊的 socket 參數和位址。
getaddrinfo [Unix]	`getaddrinfo host service opts` 傳回 `Unix.addr_info` 記錄的清單，其中描述適用於與指定主機和服務通訊的 socket 參數和位址。
getcwd [UnixLabels]	傳回目前工作目錄的名稱。
getcwd [Unix]	傳回目前工作目錄的名稱。
getcwd [Sys]	傳回程序的目前工作目錄。
getegid [UnixLabels]	傳回程序執行的有效群組 ID。
getegid [Unix]	傳回程序執行的有效群組 ID。
getenv [UnixLabels]	傳回程序環境中與變數關聯的值，除非該程序具有特殊權限。
getenv [Unix]	傳回程序環境中與變數關聯的值，除非該程序具有特殊權限。
getenv [Sys]	傳回程序環境中與變數關聯的值。
getenv_opt [Sys]	傳回程序環境中與變數關聯的值，如果該變數未綁定，則傳回 `None`。
geteuid [UnixLabels]	傳回程序執行的有效使用者 ID。
geteuid [Unix]	傳回程序執行的有效使用者 ID。
getgid [UnixLabels]	傳回執行程序之使用者的群組 ID。
getgid [Unix]	傳回執行程序之使用者的群組 ID。
getgrgid [UnixLabels]	在具有給定群組 ID 的 `group` 中尋找條目。
getgrgid [Unix]	在具有給定群組 ID 的 `group` 中尋找條目。
getgrnam [UnixLabels]	在具有給定名稱的 `group` 中尋找條目。
getgrnam [Unix]	在具有給定名稱的 `group` 中尋找條目。
getgroups [UnixLabels]	傳回執行程序之使用者所屬的群組列表。
getgroups [Unix]	傳回執行程序之使用者所屬的群組列表。
gethostbyaddr [UnixLabels]	在具有給定位址的 `hosts` 中尋找條目。
gethostbyaddr [Unix]	在具有給定位址的 `hosts` 中尋找條目。
gethostbyname [UnixLabels]	在具有給定名稱的 `hosts` 中尋找條目。
gethostbyname [Unix]	在具有給定名稱的 `hosts` 中尋找條目。
gethostname [UnixLabels]	傳回本機主機的名稱。
gethostname [Unix]	傳回本機主機的名稱。
getitimer [UnixLabels]	傳回給定間隔計時器的目前狀態。
getitimer [Unix]	傳回給定間隔計時器的目前狀態。
getlogin [UnixLabels]	傳回執行程序之使用者的登入名稱。
getlogin [Unix]	傳回執行程序之使用者的登入名稱。
getnameinfo [UnixLabels]	`getnameinfo addr opts` 傳回與通訊端位址 `addr` 對應的主機名稱和服務名稱。
getnameinfo [Unix]	`getnameinfo addr opts` 傳回與通訊端位址 `addr` 對應的主機名稱和服務名稱。
getpeername [UnixLabels]	傳回連接到給定通訊端的主機位址。
getpeername [Unix]	傳回連接到給定通訊端的主機位址。
getpid [UnixLabels]	傳回程序的 PID。
getpid [Unix]	傳回程序的 PID。
getppid [UnixLabels]	傳回父程序的 PID。
getppid [Unix]	傳回父程序的 PID。
getprotobyname [UnixLabels]	在具有給定名稱的 `protocols` 中尋找條目。
getprotobyname [Unix]	在具有給定名稱的 `protocols` 中尋找條目。
getprotobynumber [UnixLabels]	在具有給定協定號碼的 `protocols` 中尋找條目。
getprotobynumber [Unix]	在具有給定協定號碼的 `protocols` 中尋找條目。
getpwnam [UnixLabels]	在具有給定名稱的 `passwd` 中尋找條目。
getpwnam [Unix]	在具有給定名稱的 `passwd` 中尋找條目。
getpwuid [UnixLabels]	在具有給定使用者 ID 的 `passwd` 中尋找條目。
getpwuid [Unix]	在具有給定使用者 ID 的 `passwd` 中尋找條目。
getservbyname [UnixLabels]	在具有給定名稱的 `services` 中尋找條目。
getservbyname [Unix]	在具有給定名稱的 `services` 中尋找條目。
getservbyport [UnixLabels]	在具有給定服務號碼的 `services` 中尋找條目。
getservbyport [Unix]	在具有給定服務號碼的 `services` 中尋找條目。
getsockname [UnixLabels]	傳回給定通訊端的位址。
getsockname [Unix]	傳回給定通訊端的位址。
getsockopt [UnixLabels]	傳回給定通訊端中布林值選項的目前狀態。
getsockopt [Unix]	傳回給定通訊端中布林值選項的目前狀態。
getsockopt_error [UnixLabels]	傳回與給定通訊端關聯的錯誤條件，並清除它。
getsockopt_error [Unix]	傳回與給定通訊端關聯的錯誤條件，並清除它。
getsockopt_float [UnixLabels]	與 `UnixLabels.getsockopt` 相同，適用於其值為浮點數的通訊端選項。
getsockopt_float [Unix]	與 `Unix.getsockopt` 相同，適用於其值為浮點數的通訊端選項。
getsockopt_int [UnixLabels]	與 `UnixLabels.getsockopt` 相同，適用於整數值的通訊端選項。
getsockopt_int [Unix]	與 `Unix.getsockopt` 相同，適用於整數值的通訊端選項。
getsockopt_optint [UnixLabels]	與 `UnixLabels.getsockopt` 相同，適用於其值為 `int option` 的通訊端選項。
getsockopt_optint [Unix]	與 `Unix.getsockopt` 相同，適用於其值為 `int option` 的通訊端選項。
gettimeofday [UnixLabels]	與 `UnixLabels.time` 相同，但解析度優於 1 秒。
gettimeofday [Unix]	與 `Unix.time` 相同，但解析度優於 1 秒。
getuid [UnixLabels]	傳回執行程序之使用者的使用者 ID。
getuid [Unix]	傳回執行程序之使用者的使用者 ID。
global_replace [Str]	`global_replace regexp templ s` 傳回一個與 `s` 相同的字串，除了 `s` 中所有符合 `regexp` 的子字串都已由 `templ` 取代之外。
global_substitute [Str]	`global_substitute regexp subst s` 傳回一個與 `s` 相同的字串，除了 `s` 中所有符合 `regexp` 的子字串都已由函數 `subst` 的結果取代之外。
gmtime [UnixLabels]	將 `UnixLabels.time` 傳回的以秒為單位的時間轉換為日期和時間。
gmtime [Unix]	將 `Unix.time` 傳回的以秒為單位的時間轉換為日期和時間。
group [Seq]	如果函數 `eq` 定義了元素之間的相等性，則 `group eq xs` 是序列 `xs` 中相鄰重複元素的最大執行次數序列。
group_beginning [Str]	`group_beginning n` 傳回上次呼叫比對或搜尋函數所比對的正規表示式第 `n` 個群組所比對的子字串的第一個字元位置（詳細資訊請參閱 `Str.matched_string`）。
group_end [Str]	`group_end n` 傳回上次呼叫比對或搜尋函數所比對的正規表示式第 `n` 個群組所比對的子字串的最後一個字元後面的字元位置（詳細資訊請參閱 `Str.matched_string`）。
guard [Event]	`guard fn` 傳回一個事件，該事件在同步時，會計算 `fn()` 並以結果事件的方式執行。
H
handle_unix_error [UnixLabels]	`handle_unix_error f x` 將 `f` 應用於 `x` 並傳回結果。
handle_unix_error [Unix]	`handle_unix_error f x` 將 `f` 應用於 `x` 並傳回結果。
has_symlink [UnixLabels]	如果使用者能夠建立符號連結，則傳回 `true`。
has_symlink [Unix]	如果使用者能夠建立符號連結，則傳回 `true`。
hash [Uchar]	`hash u` 將一個非負整數與 `u` 關聯。
hash [String]	字串的未設定種子的雜湊函數，具有與 `Hashtbl.hash` 相同的輸出值。
hash [StringLabels]	字串的未設定種子的雜湊函數，具有與 `Hashtbl.hash` 相同的輸出值。
hash [Nativeint]	原生整數的未設定種子的雜湊函數，具有與 `Hashtbl.hash` 相同的輸出值。
hash [MoreLabels.Hashtbl.HashedType]	索引鍵的雜湊函數。
hash [MoreLabels.Hashtbl]	`Hashtbl.hash x` 將一個非負整數與任何類型的任何值關聯。
hash [Int64]	64 位元整數的未設定種子的雜湊函數，具有與 `Hashtbl.hash` 相同的輸出值。
hash [Int32]	32 位元整數的未設定種子的雜湊函數，具有與 `Hashtbl.hash` 相同的輸出值。
hash [Int]	整數的未設定種子的雜湊函數，具有與 `Hashtbl.hash` 相同的輸出值。
hash [Hashtbl.HashedType]	索引鍵的雜湊函數。
hash [Hashtbl]	`Hashtbl.hash x` 將一個非負整數與任何類型的任何值關聯。
hash [Float]	浮點數的未設定種子的雜湊函數，具有與 `Hashtbl.hash` 相同的輸出值。
hash [Char]	字元的未設定種子的雜湊函數，具有與 `Hashtbl.hash` 相同的輸出值。
hash [Bool]	布林值的未設定種子的雜湊函數，具有與 `Hashtbl.hash` 相同的輸出值。
hash_length [Digest.S]	摘要的長度，以位元組為單位。
hash_param [MoreLabels.Hashtbl]	`Hashtbl.hash_param meaningful total x` 計算 `x` 的雜湊值，其屬性與 `hash` 相同。
hash_param [Hashtbl]	`Hashtbl.hash_param meaningful total x` 計算 `x` 的雜湊值，其屬性與 `hash` 相同。
hd [ListLabels]	傳回給定列表的第一個元素。
hd [List]	傳回給定列表的第一個元素。
header_size [Marshal]	代表 marshaled 值的位元組由固定大小的標頭和可變大小的資料部分組成，其大小可從標頭確定。
hypot [Stdlib]	`hypot x y` 傳回 `sqrt(x . x + y . y)`，也就是邊長為 `x` 和 `y` 的直角三角形的斜邊長度，或者等價地說，點 `(x,y)` 到原點的距離。
hypot [Float]	`hypot x y` 傳回 `sqrt(x . x +. y . y)`，也就是邊長為 `x` 和 `y` 的直角三角形的斜邊長度，或者等價地說，點 `(x,y)` 到原點的距離。
I
i [Complex]	複數 `i`。
ibprintf [Printf]	與 `Printf.bprintf` 相同，但不列印任何內容。
id [Thread]	傳回給定執行緒的識別碼。
id [Oo]	傳回一個識別此物件的整數，在程式的目前執行中是唯一的。
id [Obj.Extension_constructor]
id [Fun]	`id` 是恆等函式。
ifprintf [Printf]	與 `Printf.fprintf` 相同，但不列印任何內容。
ifprintf [Format]	與上面的 `fprintf` 相同，但不列印任何內容。
ignore [Stdlib]	捨棄其引數的值並傳回 `()`。
ikbprintf [Printf]	與上面的 `kbprintf` 相同，但不列印任何內容。
ikfprintf [Printf]	與上面的 `kfprintf` 相同，但不列印任何內容。
ikfprintf [Format]	與上面的 `kfprintf` 相同，但不列印任何內容。
in_channel_length [Stdlib.LargeFile]
in_channel_length [Stdlib]	傳回開啟給定通道的常規檔案的大小（字元數）。
in_channel_of_descr [UnixLabels]	建立從給定描述符讀取的輸入通道。
in_channel_of_descr [Unix]	建立從給定描述符讀取的輸入通道。
incr [Stdlib]	遞增給定參考中包含的整數。
incr [Atomic]	`incr r` 以原子方式將 `r` 的值遞增 `1`。
index [String]	`index s c` 為 `String.index_from` `s 0 c`。
index [StringLabels]	`index s c` 為 `String.index_from` `s 0 c`。
index [BytesLabels]	`index s c` 傳回 `s` 中位元組 `c` 的第一次出現的索引。
index [Bytes]	`index s c` 傳回 `s` 中位元組 `c` 的第一次出現的索引。
index_from [String]	`index_from s i c` 是 `c` 在位置 `i` 之後的 `s` 中第一次出現的索引。
index_from [StringLabels]	`index_from s i c` 是 `c` 在位置 `i` 之後的 `s` 中第一次出現的索引。
index_from [BytesLabels]	`index_from s i c` 傳回 `s` 中位置 `i` 之後的位元組 `c` 的第一次出現的索引。
index_from [Bytes]	`index_from s i c` 傳回 `s` 中位置 `i` 之後的位元組 `c` 的第一次出現的索引。
index_from_opt [String]	`index_from_opt s i c` 是 `c` 在位置 `i` 之後的 `s` 中第一次出現的索引（如果有的話）。
index_from_opt [StringLabels]	`index_from_opt s i c` 是 `c` 在位置 `i` 之後的 `s` 中第一次出現的索引（如果有的話）。
index_from_opt [BytesLabels]	`index_from_opt s i c` 傳回 `s` 中位置 `i` 之後的位元組 `c` 的第一次出現的索引，如果 `c` 在位置 `i` 之後的 `s` 中沒有出現，則傳回 `None`。
index_from_opt [Bytes]	`index_from_opt s i c` 傳回 `s` 中位置 `i` 之後的位元組 `c` 的第一次出現的索引，如果 `c` 在位置 `i` 之後的 `s` 中沒有出現，則傳回 `None`。
index_opt [String]	`index_opt s c` 為 `String.index_from_opt` `s 0 c`。
index_opt [StringLabels]	`index_opt s c` 為 `String.index_from_opt` `s 0 c`。
index_opt [BytesLabels]	`index_opt s c` 傳回 `s` 中位元組 `c` 的第一次出現的索引，如果 `c` 在 `s` 中沒有出現，則傳回 `None`。
index_opt [Bytes]	`index_opt s c` 傳回 `s` 中位元組 `c` 的第一次出現的索引，如果 `c` 在 `s` 中沒有出現，則傳回 `None`。
inet6_addr_any [UnixLabels]	一個特殊的 IPv6 位址，僅用於 `bind`，代表主機所擁有的所有網際網路位址。
inet6_addr_any [Unix]	一個特殊的 IPv6 位址，僅用於 `bind`，代表主機所擁有的所有網際網路位址。
inet6_addr_loopback [UnixLabels]	一個特殊的 IPv6 位址，代表主機 (`::1`)。
inet6_addr_loopback [Unix]	一個特殊的 IPv6 位址，代表主機 (`::1`)。
inet_addr_any [UnixLabels]	一個特殊的 IPv4 位址，僅用於 `bind`，代表主機所擁有的所有網際網路位址。
inet_addr_any [Unix]	一個特殊的 IPv4 位址，僅用於 `bind`，代表主機所擁有的所有網際網路位址。
inet_addr_loopback [UnixLabels]	一個特殊的 IPv4 位址，代表主機 (`127.0.0.1`)。
inet_addr_loopback [Unix]	一個特殊的 IPv4 位址，代表主機 (`127.0.0.1`)。
inet_addr_of_string [UnixLabels]	從網際網路位址的可列印表示法轉換為其內部表示法。
inet_addr_of_string [Unix]	從網際網路位址的可列印表示法轉換為其內部表示法。
infinity [Stdlib]	正無限大。
infinity [Float]	正無限大。
infix_tag [Obj]
inherits [CamlinternalOO]
init [String]	`init n f` 是一個長度為 `n` 的字串，其索引 `i` 包含字元 `f i` （以遞增的索引順序呼叫）。
init [StringLabels]	`init n ~f` 是一個長度為 `n` 的字串，其索引 `i` 包含字元 `f i` （以遞增的索引順序呼叫）。
init [Seq]	`init n f` 是序列 `f 0; f 1; ...; f (n-1)`。
init [Random]	使用引數作為種子初始化網域本機產生器。
init [ListLabels]	`init ~len ~f` 是 `[f 0; f 1; ...; f (len-1)]`，從左至右評估。
init [List]	`init len f` 是 `[f 0; f 1; ...; f (len-1)]`，從左至右評估。
init [Float.ArrayLabels]	`init n ~f` 傳回長度為 `n` 的新 floatarray，其中數字為 `i` 的元素初始化為 `f i` 的結果。
init [Float.Array]	`init n f` 傳回長度為 `n` 的新 floatarray，其中數字為 `i` 的元素初始化為 `f i` 的結果。
init [Dynarray]	`init n f` 是一個長度為 `n` 的新陣列 `a`，其中 `get a i` 為 `f i`。
init [BytesLabels]	`init n f` 傳回長度為 `n` 的新位元組序列，其中字元 `i` 初始化為 `f i` 的結果（以遞增的索引順序）。
init [Bytes]	`init n f` 傳回長度為 `n` 的新位元組序列，其中字元 `i` 初始化為 `f i` 的結果（以遞增的索引順序）。
init [Bigarray.Array3]	`Array3.init kind layout dim1 dim2 dim3 f` 傳回一個新的三維 Bigarray `b`，其大小在第一維中為 `dim1`，在第二維中為 `dim2`，在第三維中為 `dim3`。
init [Bigarray.Array2]	`Array2.init kind layout dim1 dim2 f` 會回傳一個新的二維 Bigarray `b`，其第一維的大小為 `dim2`，第二維的大小為 `dim2`。
init [Bigarray.Array1]	`Array1.init kind layout dim f` 會回傳一個新的一維 Bigarray `b`，其大小為 `dim`。
init [Bigarray.Array0]	`Array0.init kind layout v` 的行為類似 `Array0.create kind layout`，但額外將元素初始化為值 `v`。
init [Bigarray.Genarray]	`Genarray.init kind layout dimensions f` 會回傳一個新的 Bigarray `b`，其元素種類由參數 `kind` 決定（為 `float32`、`float64`、`int8_signed` 等其中之一），而其佈局由參數 `layout` 決定（為 `c_layout` 或 `fortran_layout` 其中之一）。
init [ArrayLabels]	`init n ~f` 會回傳一個長度為 `n` 的新陣列，其中元素編號 `i` 初始化為 `f i` 的結果。
init [Array]	`init n f` 會回傳一個長度為 `n` 的新陣列，其中元素編號 `i` 初始化為 `f i` 的結果。
init_class [CamlinternalOO]
init_matrix [Float.ArrayLabels]	`init_matrix ~dimx ~dimy ~f` 會回傳一個二維陣列（陣列的陣列），其第一維為 `dimx`，第二維為 `dimy`，其中索引 (`x,y`) 的元素會初始化為 `f x y`。
init_matrix [Float.Array]	`init_matrix dimx dimy f` 會回傳一個二維陣列（陣列的陣列），其第一維為 `dimx`，第二維為 `dimy`，其中索引 (`x,y`) 的元素會初始化為 `f x y`。
init_matrix [ArrayLabels]	`init_matrix ~dimx ~dimy ~f` 會回傳一個二維陣列（陣列的陣列），其第一維為 `dimx`，第二維為 `dimy`，其中索引 (`x,y`) 的元素會初始化為 `f x y`。
init_matrix [Array]	`init_matrix dimx dimy f` 會回傳一個二維陣列（陣列的陣列），其第一維為 `dimx`，第二維為 `dimy`，其中索引 (`x,y`) 的元素會初始化為 `f x y`。
init_mod [CamlinternalMod]
initgroups [UnixLabels]	`initgroups user group` 會透過讀取群組資料庫 /etc/group 並使用 `user` 所屬的所有群組來初始化群組存取列表。
initgroups [Unix]	`initgroups user group` 會透過讀取群組資料庫 /etc/group 並使用 `user` 所屬的所有群組來初始化群組存取列表。
input [Stdlib]	`input ic buf pos len` 會從給定的通道 `ic` 讀取最多 `len` 個字元，並將它們儲存在位元組序列 `buf` 中，從字元編號 `pos` 開始。
input [In_channel]	`input ic buf pos len` 會從給定的通道 `ic` 讀取最多 `len` 個字元，並將它們儲存在位元組序列 `buf` 中，從字元編號 `pos` 開始。
input [Digest.S]	從給定的輸入通道讀取摘要。
input [Digest]	從給定的輸入通道讀取摘要。
input_all [In_channel]	`input_all ic` 會從 `ic` 讀取所有剩餘的資料。
input_bigarray [In_channel]	與 `In_channel.input` 相同，但將資料讀取到 bigarray 中。
input_binary_int [Stdlib]	從給定的輸入通道讀取以二進制格式編碼的整數（4 個位元組，大端序）。
input_byte [Stdlib]	與 `input_char` 相同，但會回傳代表字元的 8 位元整數。
input_byte [In_channel]	與 `In_channel.input_char` 相同，但會回傳代表字元的 8 位元整數。
input_char [Stdlib]	從給定的輸入通道讀取一個字元。
input_char [In_channel]	從給定的輸入通道讀取一個字元。
input_line [Stdlib]	從給定的輸入通道讀取字元，直到遇到換行字元。
input_line [In_channel]	`input_line ic` 會從 `ic` 讀取字元，直到遇到換行符號或檔案結尾。
input_lines [In_channel]	`input_lines ic` 會使用 `In_channel.input_line` 讀取行，直到到達檔案結尾。
input_value [Stdlib]	讀取由 `output_value` 產生的結構化值表示，並回傳對應的值。
int [Runtime_events.Type]	包含整數值的事件。
int [Random.State]
int [Random]	`Random.int bound` 會回傳一個介於 0（含）和 `bound`（不含）之間的隨機整數。
int [Bigarray]	請參閱 `Bigarray.char`。
int16_signed [Bigarray]	請參閱 `Bigarray.char`。
int16_unsigned [Bigarray]	請參閱 `Bigarray.char`。
int32 [Random.State]
int32 [Random]	`Random.int32 bound` 會回傳一個介於 0（含）和 `bound`（不含）之間的隨機整數。
int32 [Bigarray]	請參閱 `Bigarray.char`。
int32_in_range [Random.State]
int32_in_range [Random]	`Random.int32_in_range ~min ~max` 會回傳一個介於 `min`（含）和 `max`（含）之間的隨機整數。
int64 [Random.State]
int64 [Random]	`Random.int64 bound` 會回傳一個介於 0（含）和 `bound`（不含）之間的隨機整數。
int64 [Bigarray]	請參閱 `Bigarray.char`。
int64_in_range [Random.State]
int64_in_range [Random]	`Random.int64_in_range ~min ~max` 會回傳一個介於 `min`（含）和 `max`（含）之間的隨機整數。
int8_signed [Bigarray]	請參閱 `Bigarray.char`。
int8_unsigned [Bigarray]	請參閱 `Bigarray.char`。
int_in_range [Random.State]
int_in_range [Random]	`Random.int_in_range ~min ~max` 會回傳一個介於 `min`（含）和 `max`（含）之間的隨機整數。
int_of_char [Stdlib]	返回引數的 ASCII 碼。
int_of_float [Stdlib]	將給定的浮點數截斷為整數。
int_of_string [Stdlib]	與 `int_of_string_opt` 相同，但會引發 `Failure "int_of_string"` 例外，而不是回傳 `None`。
int_of_string_opt [Stdlib]	將給定的字串轉換為整數。
int_size [Sys]	`int` 的大小，以位元表示。
int_tag [Obj]
inter [Set.S]	集合交集。
inter [MoreLabels.Set.S]	集合交集。
interactive [Sys]	在獨立程式中，此參考值最初設定為 `false`，如果在互動式頂層系統 `ocaml` 下執行程式碼，則設定為 `true`。
interleave [Seq]	`interleave xs ys` 是從 `xs` 的第一個元素開始的序列，接著是 `ys` 的第一個元素，依此類推。
ints [Seq]	`ints i` 是從 `i` 開始並向上計數的無限整數序列。
inv [Complex]	乘法反元素 (`1/z`)。
invalid_arg [Stdlib]	引發帶有給定字串的 `Invalid_argument` 例外。
is_binary_mode [Out_channel]	`is_binary_mode oc` 會回傳通道 `oc` 是否處於二進制模式（請參閱 `Out_channel.set_binary_mode`）。
is_binary_mode [In_channel]	`is_binary_mode ic` 會回傳通道 `ic` 是否處於二進制模式（請參閱 `In_channel.set_binary_mode`）。
is_block [Obj]
is_buffered [Out_channel]	`is_buffered oc` 會回傳通道 `oc` 是否已緩衝（請參閱 `Out_channel.set_buffered`）。
is_char [Uchar]	當且僅當 `u` 是 latin1 OCaml 字元時，`is_char u` 為 `true`。
is_directory [Sys]	如果給定的名稱指向目錄，則回傳 `true`，如果指向其他類型檔案，則回傳 `false`。
is_empty [Stack]	如果給定的堆疊為空，則回傳 `true`，否則回傳 `false`。
is_empty [Set.S]	測試集合是否為空。
is_empty [Seq]	`is_empty xs` 會判斷序列 `xs` 是否為空。
is_empty [Queue]	如果給定的佇列為空，則返回 `true`，否則返回 `false`。
is_empty [MoreLabels.Set.S]	測試集合是否為空。
is_empty [MoreLabels.Map.S]	測試映射是否為空。
is_empty [Map.S]	測試映射是否為空。
is_empty [ListLabels]	當且僅當 `l` 沒有元素時，`is_empty l` 為 true。
is_empty [List]	當且僅當 `l` 沒有元素時，`is_empty l` 為 true。
is_empty [Dynarray]	如果 `a` 為空，即如果 `length a = 0`，則 `is_empty a` 為 `true`。
is_error [Result]	當且僅當 `r` 為 `Error _` 時，`is_error r` 為 `true`。
is_finite [Float]	當且僅當 `x` 是有限的，即不是無限且不是 `Float.nan` 時，`is_finite x` 為 `true`。
is_implicit [Filename]	如果檔名是相對的，並且沒有以明確參考當前目錄（Unix 中的 `./` 或 `../`）開頭，則返回 `true`；如果它以明確參考根目錄或當前目錄開頭，則返回 `false`。
is_in_char_set [CamlinternalFormat]
is_inet6_addr [UnixLabels]	給定的 `inet_addr` 是否為 IPv6 位址。
is_inet6_addr [Unix]	給定的 `inet_addr` 是否為 IPv6 位址。
is_infinite [Float]	當且僅當 `x` 為 `Float.infinity` 或 `Float.neg_infinity` 時，`is_infinite x` 為 `true`。
is_inline [Printexc.Slot]	當 `slot` 指的是編譯器內聯的呼叫時，`is_inline slot` 為 `true`；當它來自任何其他內容時，則為 `false`。
is_int [Obj]
is_integer [Float]	當且僅當 `x` 是整數時，`is_integer x` 為 `true`。
is_left [Either]	`is_left (Left v)` 為 `true`，`is_left (Right v)` 為 `false`。
is_main_domain [Domain]	如果從初始域呼叫，`is_main_domain ()` 返回 true。
is_nan [Float]	當且僅當 `x` 不是數字時（請參閱 `Float.nan`），`is_nan x` 為 `true`。
is_native [Dynlink]	如果程式是原生程式碼，則為 `true`；如果程式是位元組碼，則為 `false`。
is_none [Option]	當且僅當 `o` 為 `None` 時，`is_none o` 為 `true`。
is_ok [Result]	當且僅當 `r` 為 `Ok _` 時，`is_ok r` 為 `true`。
is_raise [Printexc.Slot]	當 `slot` 指的是程式碼中的引發點時，`is_raise slot` 為 `true`；當它來自簡單的函數呼叫時，則為 `false`。
is_randomized [MoreLabels.Hashtbl]	如果預設情況下表格目前以隨機模式建立，則返回 `true`；否則返回 `false`。
is_randomized [Hashtbl]	如果預設情況下表格目前以隨機模式建立，則返回 `true`；否則返回 `false`。
is_regular_file [Sys]	如果給定的名稱指的是一般檔案，則返回 `true`；如果它指的是另一種檔案，則返回 `false`。
is_relative [Filename]	如果檔名相對於當前目錄，則返回 `true`；如果它是絕對的（即。
is_right [Either]	`is_right (Left v)` 為 `false`，`is_right (Right v)` 為 `true`。
is_some [Option]	當且僅當 `o` 為 `Some o` 時，`is_some o` 為 `true`。
is_val [Lazy]	如果 `x` 已被強制執行且未引發例外狀況，則 `is_val x` 返回 `true`。
is_valid [Uchar]	當且僅當 `n` 是 Unicode 純量值時（即。
is_valid_utf_16be [String]	當且僅當 `b` 包含有效的 UTF-16BE 資料時，`is_valid_utf_16be b` 為 `true`。
is_valid_utf_16be [StringLabels]	當且僅當 `b` 包含有效的 UTF-16BE 資料時，`is_valid_utf_16be b` 為 `true`。
is_valid_utf_16be [BytesLabels]	當且僅當 `b` 包含有效的 UTF-16BE 資料時，`is_valid_utf_16be b` 為 `true`。
is_valid_utf_16be [Bytes]	當且僅當 `b` 包含有效的 UTF-16BE 資料時，`is_valid_utf_16be b` 為 `true`。
is_valid_utf_16le [String]	當且僅當 `b` 包含有效的 UTF-16LE 資料時，`is_valid_utf_16le b` 為 `true`。
is_valid_utf_16le [StringLabels]	當且僅當 `b` 包含有效的 UTF-16LE 資料時，`is_valid_utf_16le b` 為 `true`。
is_valid_utf_16le [BytesLabels]	當且僅當 `b` 包含有效的 UTF-16LE 資料時，`is_valid_utf_16le b` 為 `true`。
is_valid_utf_16le [Bytes]	當且僅當 `b` 包含有效的 UTF-16LE 資料時，`is_valid_utf_16le b` 為 `true`。
is_valid_utf_8 [String]	當且僅當 `b` 包含有效的 UTF-8 資料時，`is_valid_utf_8 b` 為 `true`。
is_valid_utf_8 [StringLabels]	當且僅當 `b` 包含有效的 UTF-8 資料時，`is_valid_utf_8 b` 為 `true`。
is_valid_utf_8 [BytesLabels]	當且僅當 `b` 包含有效的 UTF-8 資料時，`is_valid_utf_8 b` 為 `true`。
is_valid_utf_8 [Bytes]	當且僅當 `b` 包含有效的 UTF-8 資料時，`is_valid_utf_8 b` 為 `true`。
isatty [UnixLabels]	如果給定的檔案描述符指的是終端或主控台視窗，則返回 `true`，否則返回 `false`。
isatty [Unix]	如果給定的檔案描述符指的是終端或主控台視窗，則返回 `true`，否則返回 `false`。
isatty [Out_channel]	如果 `oc` 指的是終端或主控台視窗，則 `isatty oc` 為 `true`，否則為 `false`。
isatty [In_channel]	如果 `ic` 指的是終端或主控台視窗，則 `isatty ic` 為 `true`，否則為 `false`。
iter [Weak.S]	`iter f t` 以某個未指定的順序對 `t` 的每個元素呼叫 `f`。
iter [String]	`iter f s` 依次將函數 `f` 應用於 `s` 的所有字元。
iter [StringLabels]	`iter ~f s` 依次將函數 `f` 應用於 `s` 的所有字元。
iter [Stack]	`iter f s` 依次將 `f` 應用於 `s` 的所有元素，從堆疊頂端的元素到堆疊底端的元素。
iter [Set.S]	`iter f s` 依次將 `f` 應用於 `s` 的所有元素。
iter [Seq]	`iter f xs` 從左到右，連續針對序列 `xs` 的每個元素 `x` 呼叫 `f x`。
iter [Result]	如果 `r` 為 `Ok v`，則 `iter f r` 為 `f v`，否則為 `()`。
iter [Queue]	`iter f q` 依次將 `f` 應用於 `q` 的所有元素，從最不常輸入到最近輸入的元素。
iter [Option]	如果 `o` 為 `Some v`，則 `iter f o` 為 `f v`，否則為 `()`。
iter [MoreLabels.Set.S]	`iter ~f s` 依次將 `f` 應用於 `s` 的所有元素。
iter [MoreLabels.Map.S]	`iter ~f m` 將 `f` 應用於映射 `m` 中的所有繫結。
iter [MoreLabels.Hashtbl.SeededS]
iter [MoreLabels.Hashtbl.S]
iter [MoreLabels.Hashtbl]	`Hashtbl.iter ~f tbl` 將 `f` 應用於表格 `tbl` 中的所有繫結。
iter [Map.S]	`iter f m` 將 `f` 應用於映射 `m` 中的所有繫結。
iter [ListLabels]	`iter ~f [a1; ...; an]` 依次將函數 `f` 應用於 `[a1; ...; an]`。
iter [List]	`iter f [a1; ...; an]` 依次將函數 `f` 應用於 `[a1; ...; an]`。
iter [Hashtbl.SeededS]
iter [Hashtbl.S]
iter [Hashtbl]	`Hashtbl.iter f tbl` 將 `f` 應用於表格 `tbl` 中的所有綁定。
iter [Float.ArrayLabels]	`iter ~f a` 依序將函數 `f` 應用於 `a` 的所有元素。
iter [Float.Array]	`iter f a` 依序將函數 `f` 應用於 `a` 的所有元素。
iter [Either]	`iter ~left ~right (Left v)` 為 `left v`，而 `iter ~left ~right (Right v)` 為 `right v`。
iter [Dynarray]	`iter f a` 對 `a` 的每個元素呼叫 `f`。
iter [BytesLabels]	`iter ~f s` 依序將函數 `f` 應用於 `s` 的所有位元組。
iter [Bytes]	`iter f s` 依序將函數 `f` 應用於 `s` 的所有位元組。
iter [ArrayLabels]	`iter ~f a` 依序將函數 `f` 應用於 `a` 的所有元素。
iter [Array]	`iter f a` 依序將函數 `f` 應用於 `a` 的所有元素。
iter2 [Seq]	`iter2 f xs ys` 對於從序列 `xs` 和 `ys` 同步提取的每個元素對 `(x, y)` 依序調用 `f x y`。
iter2 [ListLabels]	`iter2 ~f [a1; ...; an] [b1; ...; bn]` 依序呼叫 `f a1 b1; ...; f an bn`。
iter2 [List]	`iter2 f [a1; ...; an] [b1; ...; bn]` 依序呼叫 `f a1 b1; ...; f an bn`。
iter2 [Float.ArrayLabels]	`Array.iter2 ~f a b` 將函數 `f` 應用於 `a` 和 `b` 的所有元素。
iter2 [Float.Array]	`Array.iter2 f a b` 將函數 `f` 應用於 `a` 和 `b` 的所有元素。
iter2 [ArrayLabels]	`iter2 ~f a b` 將函數 `f` 應用於 `a` 和 `b` 的所有元素。
iter2 [Array]	`iter2 f a b` 將函數 `f` 應用於 `a` 和 `b` 的所有元素。
iter_error [Result]	`iter_error f r` 如果 `r` 為 `Error e` 則為 `f e`，否則為 `()`。
iterate [Seq]	`iterate f x` 是元素為 `x`、`f x`、`f (f x)` 等等的無限序列。
iteri [String]	`iteri` 類似於 `String.iter`，但該函數也會取得對應的字元索引。
iteri [StringLabels]	`iteri` 類似於 `StringLabels.iter`，但該函數也會取得對應的字元索引。
iteri [Seq]	`iteri f xs` 對於序列 `xs` 中位於索引 `i` 的每個元素 `x` 依序調用 `f i x`。
iteri [ListLabels]	與 `ListLabels.iter` 相同，但該函數的第一個參數為元素的索引（從 0 開始計數），而第二個參數為元素本身。
iteri [List]	與 `List.iter` 相同，但該函數的第一個參數為元素的索引（從 0 開始計數），而第二個參數為元素本身。
iteri [Float.ArrayLabels]	與 `Float.ArrayLabels.iter` 相同，但該函數的第一個參數為元素的索引，而第二個參數為元素本身。
iteri [Float.Array]	與 `Float.Array.iter` 相同，但該函數的第一個參數為元素的索引，而第二個參數為元素本身。
iteri [Dynarray]	`iteri f a` 對於 `a` 中索引為 `i` 的每個 `x` 呼叫 `f i x`。
iteri [BytesLabels]	與 `BytesLabels.iter` 相同，但該函數的第一個參數為位元組的索引，而第二個參數為位元組本身。
iteri [Bytes]	與 `Bytes.iter` 相同，但該函數的第一個參數為位元組的索引，而第二個參數為位元組本身。
iteri [ArrayLabels]	與 `ArrayLabels.iter` 相同，但該函數的第一個參數為元素的索引，而第二個參數為元素本身。
iteri [Array]	與 `Array.iter` 相同，但該函數的第一個參數為元素的索引，而第二個參數為元素本身。
J
join [Thread]	`join th` 暫停呼叫執行緒的執行，直到執行緒 `th` 終止。
join [Result]	`join rr` 如果 `rr` 為 `Ok r` 則為 `r`，如果 `rr` 為 `Error _` 則為 `rr`。
join [Option]	`join oo` 如果 `oo` 為 `Some (Some v)` 則為 `Some v`，否則為 `None`。
join [Domain]	`join d` 會阻塞，直到網域 `d` 執行完成。
K
kasprintf [Format]	與上述的 `asprintf` 相同，但不會傳回字串，而是將其傳遞給第一個參數。
kbprintf [Printf]	與 `bprintf` 相同，但不會立即傳回，而是在列印結束時將緩衝區傳遞給其第一個參數。
kdprintf [Format]	與上述的 `Format.dprintf` 相同，但不會立即傳回，而是在列印結束時將暫停的列印器傳遞給其第一個參數。
kfprintf [Printf]	與 `fprintf` 相同，但不會立即傳回，而是在列印結束時將輸出通道傳遞給其第一個參數。
kfprintf [Format]	與上述的 `fprintf` 相同，但不會立即傳回，而是在列印結束時將格式器傳遞給其第一個參數。
kill [UnixLabels]	`kill ~pid ~signal` 將訊號編號 `signal` 傳送至 ID 為 `pid` 的程序。
kill [Unix]	`kill pid signal` 將訊號編號 `signal` 傳送至 ID 為 `pid` 的程序。
kind [Bigarray.Array3]	傳回給定 Bigarray 的種類。
kind [Bigarray.Array2]	傳回給定 Bigarray 的種類。
kind [Bigarray.Array1]	傳回給定 Bigarray 的種類。
kind [Bigarray.Array0]	傳回給定 Bigarray 的種類。
kind [Bigarray.Genarray]	傳回給定 Bigarray 的種類。
kind_size_in_bytes [Bigarray]	`kind_size_in_bytes k` 是用於儲存 `k` 類型元素的位元組數。
kprintf [Printf]	已棄用的 `ksprintf` 同義詞。
kscanf [Scanf]	與 `Scanf.bscanf` 相同，但會額外取得一個函數參數 `ef`，該參數會在發生錯誤時被呼叫：如果掃描程序或某些轉換失敗，則掃描函數會中止並以格式化的輸入通道和中止掃描程序的例外狀況作為引數呼叫錯誤處理函數 `ef`。
ksprintf [Printf]	與上述的 `sprintf` 相同，但不會傳回字串，而是將其傳遞給第一個參數。
ksprintf [Format]	與上述的 `sprintf` 相同，但不會傳回字串，而是將其傳遞給第一個參數。
ksscanf [Scanf]	與 `Scanf.kscanf` 相同，但會從給定的字串讀取。
L
last_chars [Str]	`last_chars s n` 傳回 `s` 的最後 `n` 個字元。
last_non_constant_constructor_tag [Obj]
layout [Bigarray.Array3]	傳回給定 Bigarray 的配置。
layout [Bigarray.Array2]	傳回給定 Bigarray 的配置。
layout [Bigarray.Array1]	傳回給定 Bigarray 的配置。
layout [Bigarray.Array0]	傳回給定 Bigarray 的配置。
layout [Bigarray.Genarray]	傳回給定 Bigarray 的配置。
lazy_tag [Obj]
ldexp [Stdlib]	`ldexp x n` 傳回 `x . 2 * n`。
ldexp [Float]	`ldexp x n` 傳回 `x . 2 * n`。
left [Either]	`left v` 為 `Left v`。
length [Weak]	`Weak.length ar` 傳回 `ar` 的長度（元素數量）。
length [String]	`length s` 為 `s` 的長度（位元組/字元數量）。
length [StringLabels]	`length s` 為 `s` 的長度（位元組/字元數量）。
length [Stack]	傳回堆疊中的元素數量。
length [Seq]	`length xs` 為序列 `xs` 的長度。
length [Queue]	傳回佇列中的元素數量。
length [Out_channel]	傳回開啟給定通道的常規檔案的大小（字元數）。
length [Obj.Ephemeron]	傳回鍵的數量
length [MoreLabels.Hashtbl.SeededS]
length [MoreLabels.Hashtbl.S]
length [MoreLabels.Hashtbl]	`Hashtbl.length tbl` 傳回 `tbl` 中的綁定數量。
length [ListLabels]	傳回給定列表的長度（元素數量）。
length [List]	傳回給定列表的長度（元素數量）。
length [In_channel]	傳回開啟給定通道的常規檔案的大小（字元數）。
length [Hashtbl.SeededS]
length [Hashtbl.S]
length [Hashtbl]	`Hashtbl.length tbl` 傳回 `tbl` 中的綁定數量。
length [Float.ArrayLabels]	傳回給定浮點數陣列的長度（元素數量）。
length [Float.Array]	傳回給定浮點數陣列的長度（元素數量）。
length [Ephemeron.Kn.Bucket]	傳回 bucket 長度的上限。
length [Ephemeron.K2.Bucket]	傳回 bucket 長度的上限。
length [Ephemeron.K1.Bucket]	傳回 bucket 長度的上限。
length [Ephemeron.SeededS]
length [Ephemeron.S]
length [Dynarray]	`length a` 是陣列中的元素數量。
length [BytesLabels]	傳回參數的長度（位元組數）。
length [Bytes]	傳回參數的長度（位元組數）。
length [Buffer]	傳回目前緩衝區中包含的字元數量。
length [ArrayLabels]	傳回給定陣列的長度（元素數量）。
length [Array]	傳回給定陣列的長度（元素數量）。
lexeme [Lexing]	`Lexing.lexeme lexbuf` 傳回正規表示式所匹配的字串。
lexeme_char [Lexing]	`Lexing.lexeme_char lexbuf i` 傳回匹配字串中第 `i` 個字元。
lexeme_end [Lexing]	`Lexing.lexeme_end lexbuf` 傳回輸入流中匹配字串最後一個字元後面的字元偏移量。
lexeme_end_p [Lexing]	與 `lexeme_end` 類似，但傳回完整的 `position` 而不是偏移量。
lexeme_start [Lexing]	`Lexing.lexeme_start lexbuf` 傳回輸入流中匹配字串第一個字元的偏移量。
lexeme_start_p [Lexing]	與 `lexeme_start` 類似，但傳回完整的 `position` 而不是偏移量。
lifecycle_name [Runtime_events]	傳回給定生命週期事件類型的字串表示形式。
link [UnixLabels]	`link ?follow ~src ~dst` 建立一個名為 `dst` 的硬連結，指向名為 `src` 的檔案。
link [Unix]	`link ?follow src dst` 建立一個名為 `dst` 的硬連結，指向名為 `src` 的檔案。
listen [UnixLabels]	設定 socket 以接收連線請求。
listen [Unix]	設定 socket 以接收連線請求。
lnot [Stdlib]	位元邏輯否定。
loadfile [Dynlink]	在位元組碼中：載入給定的位元組碼物件檔案（`.cmo` 檔案）或位元組碼程式庫檔案（`.cma` 檔案），並將其與正在執行的程式連結。
loadfile_private [Dynlink]	與 `loadfile` 相同，但剛載入的編譯單元會被隱藏起來（無法從之後動態載入的其他模組中引用）。
localtime [UnixLabels]	將 `UnixLabels.time` 傳回的以秒為單位的時間轉換為日期和時間。
localtime [Unix]	將 `Unix.time` 傳回的以秒為單位的時間轉換為日期和時間。
location [Printexc.Slot]	`location slot` 傳回 slot 的位置資訊（如果可用），否則傳回 `None`。
lock [Mutex]	鎖定給定的互斥鎖。
lockf [UnixLabels]	`lockf fd ~mode ~len` 在以 `fd` 開啟的檔案的區域上放置鎖。
lockf [Unix]	`lockf fd mode len` 在以 `fd` 開啟的檔案的區域上放置鎖。
log [Stdlib]	自然對數。
log [Float]	自然對數。
log [Complex]	自然對數（以 `e` 為底）。
log10 [Stdlib]	以 10 為底的對數。
log10 [Float]	以 10 為底的對數。
log1p [Stdlib]	`log1p x` 計算 `log(1.0 +. x)`（自然對數），即使 `x` 接近 `0.0`，也能提供數值精確的結果。
log1p [Float]	`log1p x` 計算 `log(1.0 +. x)`（自然對數），即使 `x` 接近 `0.0`，也能提供數值精確的結果。
log2 [Float]	以 2 為底的對數。
logand [Nativeint]	位元邏輯「且」。
logand [Int64]	位元邏輯「且」。
logand [Int32]	位元邏輯「且」。
logand [Int]	`logand x y` 是 `x` 和 `y` 的位元邏輯 AND。
lognot [Nativeint]	位元邏輯否定。
lognot [Int64]	位元邏輯否定。
lognot [Int32]	位元邏輯否定。
lognot [Int]	`lognot x` 是 `x` 的位元邏輯 NOT。
logor [Nativeint]	位元邏輯「或」。
logor [Int64]	位元邏輯「或」。
logor [Int32]	位元邏輯「或」。
logor [Int]	`logor x y` 是 `x` 和 `y` 的位元邏輯 OR。
logxor [Nativeint]	位元邏輯互斥「或」。
logxor [Int64]	位元邏輯互斥「或」。
logxor [Int32]	位元邏輯互斥「或」。
logxor [Int]	`logxor x y` 是 `x` 和 `y` 的位元邏輯互斥 OR。
lookup_tables [CamlinternalOO]
lowercase_ascii [String]	`lowercase_ascii s` 是 `s`，其中所有大寫字母都使用 US-ASCII 字元集轉換為小寫字母。
lowercase_ascii [StringLabels]	`lowercase_ascii s` 是 `s`，其中所有大寫字母都使用 US-ASCII 字元集轉換為小寫字母。
lowercase_ascii [Char]	使用 US-ASCII 字元集，將給定的字元轉換為對應的小寫字元。
lowercase_ascii [BytesLabels]	傳回參數的副本，其中所有大寫字母都使用 US-ASCII 字元集轉換為小寫字母。
lowercase_ascii [Bytes]	傳回參數的副本，其中所有大寫字母都使用 US-ASCII 字元集轉換為小寫字母。
lseek [UnixLabels.LargeFile]	請參閱 `lseek`。
lseek [UnixLabels]	設定檔案描述器的目前位置，並傳回結果偏移量（從檔案開頭開始）。
lseek [Unix.LargeFile]	請參閱 `lseek`。
lseek [Unix]	設定檔案描述器的目前位置，並傳回結果偏移量（從檔案開頭開始）。
lstat [UnixLabels.LargeFile]
lstat [UnixLabels]	與 `UnixLabels.stat` 相同，但如果檔案是符號連結，則傳回連結本身的資訊。
lstat [Unix.LargeFile]
lstat [Unix]	與 `Unix.stat` 相同，但如果檔案是符號連結，則傳回連結本身的資訊。
M
magic [Obj]
main_program_units [Dynlink]	傳回構成主程式的編譯單元清單（即
major [Gc]	執行小型垃圾收集並完成目前的主要垃圾收集週期。
major_slice [Gc]	`major_slice n` 執行小型垃圾收集和主要垃圾收集的片段。
make [Type.Id]	`make ()` 是一個新的型別識別符。
make [String]	`make n c` 是一個長度為 `n` 的字串，每個索引位置都持有字元 `c`。
make [StringLabels]	`make n c` 是一個長度為 `n` 的字串，每個索引位置都持有字元 `c`。
make [Semaphore.Binary]	`make b` 返回一個新的二元號誌。
make [Semaphore.Counting]	`make n` 返回一個新的計數號誌，初始值為 `n`。
make [Random.State]	建立一個新的狀態，並使用給定的種子初始化它。
make [Float.ArrayLabels]	`make n x` 返回一個長度為 `n` 的新浮點數陣列，並使用 `x` 初始化。
make [Float.Array]	`make n x` 返回一個長度為 `n` 的新浮點數陣列，並使用 `x` 初始化。
make [Ephemeron.Kn.Bucket]	建立一個新的桶。
make [Ephemeron.Kn]	與 `Ephemeron.K1.make` 相同。
make [Ephemeron.K2.Bucket]	建立一個新的桶。
make [Ephemeron.K2]	與 `Ephemeron.K1.make` 相同。
make [Ephemeron.K1.Bucket]	建立一個新的桶。
make [Ephemeron.K1]	`Ephemeron.K1.make k d` 建立一個具有鍵 `k` 和資料 `d` 的暫存值。
make [Dynarray]	`make n x` 是一個長度為 `n` 的新陣列，並使用 `x` 填充。
make [BytesLabels]	`make n c` 返回一個長度為 `n` 的新位元組序列，並使用位元組 `c` 填充。
make [Bytes]	`make n c` 返回一個長度為 `n` 的新位元組序列，並使用位元組 `c` 填充。
make [Atomic]	建立一個原子參考。
make [ArrayLabels]	`make n x` 返回一個長度為 `n` 的新陣列，並使用 `x` 初始化。
make [Array]	`make n x` 返回一個長度為 `n` 的新陣列，並使用 `x` 初始化。
make_class [CamlinternalOO]
make_class_store [CamlinternalOO]
make_contended [Atomic]	建立一個原子參考，該參考獨佔一個快取行。
make_formatter [Format]	`make_formatter out flush` 返回一個新的格式化器，該格式化器使用函式 `out` 輸出，並使用函式 `flush` 刷新。
make_iprintf [CamlinternalFormat]
make_matrix [Float.ArrayLabels]	`make_matrix ~dimx ~dimy e` 返回一個二維陣列（陣列的陣列），其第一維為 `dimx`，第二維為 `dimy`，其中所有元素都使用 `e` 初始化。
make_matrix [Float.Array]	`make_matrix dimx dimy e` 返回一個二維陣列（陣列的陣列），其第一維為 `dimx`，第二維為 `dimy`，其中所有元素都使用 `e` 初始化。
make_matrix [ArrayLabels]	`make_matrix ~dimx ~dimy e` 返回一個二維陣列（陣列的陣列），其第一維為 `dimx`，第二維為 `dimy`。
make_matrix [Array]	`make_matrix dimx dimy e` 返回一個二維陣列（陣列的陣列），其第一維為 `dimx`，第二維為 `dimy`。
make_printf [CamlinternalFormat]
make_self_init [Random.State]	建立一個新的狀態，並使用以系統相關方式選擇的隨機種子初始化它。
make_symbolic_output_buffer [Format]	`make_symbolic_output_buffer ()` 返回一個用於符號輸出的新緩衝區。
make_synchronized_formatter [Format]	`make_synchronized_formatter out flush` 返回持有網域本地格式化器的網域本地狀態的金鑰，該格式化器使用函式 `out` 輸出，並使用函式 `flush` 刷新。
map [String]	`map f s` 是將 `f` 應用於 `s` 的所有字元（按遞增順序）所產生的字串。
map [StringLabels]	`map f s` 是將 `f` 應用於 `s` 的所有字元（按遞增順序）所產生的字串。
map [Set.S]	`map f s` 是元素為 `f a0`、`f a1`... 的集合。
map [Seq]	`map f xs` 是透過轉換 `f` 產生的序列 `xs` 的映射。
map [Result]	如果 `r` 為 `Ok v`，則 `map f r` 為 `Ok (f v)`；如果 `r` 為 `Error _`，則為 `r`。
map [Option]	如果 `o` 為 `None`，則 `map f o` 為 `None`；如果 `o` 為 `Some v`，則為 `Some (f v)`。
map [MoreLabels.Set.S]	`map ~f s` 是元素為 `f a0`、`f a1`... 的集合。
map [MoreLabels.Map.S]	`map ~f m` 返回一個與 `m` 具有相同網域的映射，其中 `m` 的所有繫結的關聯值 `a` 已被 `f` 應用於 `a` 的結果所取代。
map [Map.S]	`map f m` 返回一個與 `m` 具有相同網域的映射，其中 `m` 的所有繫結的關聯值 `a` 已被 `f` 應用於 `a` 的結果所取代。
map [ListLabels]	`map ~f [a1; ...; an]` 將函式 `f` 應用於 `a1, ..., an`，並使用 `f` 返回的結果建構列表 `[f a1; ...; f an]`。
map [List]	`map f [a1; ...; an]` 將函式 `f` 應用於 `a1, ..., an`，並使用 `f` 返回的結果建構列表 `[f a1; ...; f an]`。
map [Lazy]	`map f x` 返回一個暫停，當強制執行時，該暫停會強制執行 `x` 並將 `f` 應用於其值。
map [Float.ArrayLabels]	`map ~f a` 將函式 `f` 應用於 `a` 的所有元素，並使用 `f` 返回的結果建構浮點數陣列。
map [Float.Array]	`map f a` 將函式 `f` 應用於 `a` 的所有元素，並使用 `f` 返回的結果建構浮點數陣列。
map [Either]	`map ~left ~right (Left v)` 為 `Left (left v)`，`map ~left ~right (Right v)` 為 `Right (right v)`。
map [Dynarray]	`map f a` 是一個新陣列，其元素形式為 `f x`（對於 `a` 的每個元素 `x`）。
map [BytesLabels]	`map ~f s` 依序將函式 `f` 應用於 `s` 的所有位元組（按遞增的索引順序），並將結果位元組儲存在新序列中，並將該序列作為結果返回。
map [Bytes]	`map f s` 依序將函式 `f` 應用於 `s` 的所有位元組（按遞增的索引順序），並將結果位元組儲存在新序列中，並將該序列作為結果返回。
map [ArrayLabels]	`map ~f a` 將函式 `f` 應用於 `a` 的所有元素，並使用 `f` 返回的結果建構一個陣列：`[\| f a.(0); f a.(1); ...; f a.(length a - 1) \|]`。
map [Array]	`map f a` 將函式 `f` 應用於 `a` 的所有元素，並使用 `f` 返回的結果建構一個陣列：`[\| f a.(0); f a.(1); ...; f a.(length a - 1) \|]`。
map2 [Seq]	`map2 f xs ys` 是元素 `f x y` 的序列，其中配對 `(x, y)` 是從序列 `xs` 和 `ys` 同步提取的。
map2 [ListLabels]	`map2 ~f [a1; ...; an] [b1; ...; bn]` 為 `[f a1 b1; ...; f an bn]`。
map2 [List]	`map2 f [a1; ...; an] [b1; ...; bn]` 為 `[f a1 b1; ...; f an bn]`。
map2 [Float.ArrayLabels]	`map2 ~f a b` 將函式 `f` 應用於 `a` 和 `b` 的所有元素，並使用 `f` 返回的結果建構浮點數陣列：`[\| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)\|]`。
map2 [Float.Array]	`map2 f a b` 將函式 `f` 應用於 `a` 和 `b` 的所有元素，並使用 `f` 返回的結果建構浮點數陣列：`[\| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)\|]`。
map2 [ArrayLabels]	`map2 ~f a b` 將函式 `f` 應用於 `a` 和 `b` 的所有元素，並使用 `f` 返回的結果建構一個陣列：`[\| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)\|]`。
map2 [Array]	`map2 f a b` 將函數 `f` 應用於 `a` 和 `b` 的所有元素，並建立一個包含 `f` 返回結果的陣列： `[\| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)\|]`。
map_error [Result]	如果 `r` 是 `Error e`，則 `map_error f r` 為 `Error (f e)`；如果 `r` 是 `Ok _`，則為 `r`。
map_file [UnixLabels]	將檔案記憶體映射為 Bigarray。
map_file [Unix]	將檔案記憶體映射為 Bigarray。
map_from_array [Float.ArrayLabels]	`map_from_array ~f a` 將函數 `f` 應用於 `a` 的所有元素，並建立一個包含 `f` 返回結果的浮點數陣列。
map_from_array [Float.Array]	`map_from_array f a` 將函數 `f` 應用於 `a` 的所有元素，並建立一個包含 `f` 返回結果的浮點數陣列。
map_inplace [Float.ArrayLabels]	`map_inplace f a` 將函數 `f` 應用於 `a` 的所有元素，並就地更新它們的值。
map_inplace [Float.Array]	`map_inplace f a` 將函數 `f` 應用於 `a` 的所有元素，並就地更新它們的值。
map_inplace [ArrayLabels]	`map_inplace ~f a` 將函數 `f` 應用於 `a` 的所有元素，並就地更新它們的值。
map_inplace [Array]	`map_inplace f a` 將函數 `f` 應用於 `a` 的所有元素，並就地更新它們的值。
map_left [Either]	如果 `e` 是 `Left v`，則 `map_left f e` 為 `Left (f v)`；如果 `e` 是 `Right _`，則為 `e`。
map_product [Seq]	序列 `map_product f xs ys` 是序列 `xs` 和 `ys` 的笛卡爾積通過 `f` 的映射。
map_right [Either]	如果 `e` 是 `Right v`，則 `map_right f e` 為 `Right (f v)`；如果 `e` 是 `Left _`，則為 `e`。
map_to_array [Float.ArrayLabels]	`map_to_array ~f a` 將函數 `f` 應用於 `a` 的所有元素，並建立一個包含 `f` 返回結果的陣列： `[\| f a.(0); f a.(1); ...; f a.(length a - 1) \|]`。
map_to_array [Float.Array]	`map_to_array f a` 將函數 `f` 應用於 `a` 的所有元素，並建立一個包含 `f` 返回結果的陣列： `[\| f a.(0); f a.(1); ...; f a.(length a - 1) \|]`。
map_val [Lazy]	如果 `x` 已經強制執行，則 `map_val f x` 直接應用 `f`，否則其行為與 `map f x` 相同。
mapi [String]	`mapi f s` 類似於 `String.map`，但字元的索引也會傳遞給 `f`。
mapi [StringLabels]	`mapi ~f s` 類似於 `StringLabels.map`，但字元的索引也會傳遞給 `f`。
mapi [Seq]	`mapi` 類似於 `map`，但將函數 `f` 應用於索引和元素。
mapi [MoreLabels.Map.S]	與 `MoreLabels.Map.S.map` 相同，但該函數會接收映射的每個綁定的鍵和關聯值作為參數。
mapi [Map.S]	與 `Map.S.map` 相同，但該函數會接收映射的每個綁定的鍵和關聯值作為參數。
mapi [ListLabels]	與 `ListLabels.map` 相同，但該函數會將元素的索引（從 0 開始計數）作為第一個參數，將元素本身作為第二個參數應用。
mapi [List]	與 `List.map` 相同，但該函數會將元素的索引（從 0 開始計數）作為第一個參數，將元素本身作為第二個參數應用。
mapi [Float.ArrayLabels]	與 `Float.ArrayLabels.map` 相同，但該函數會將元素的索引作為第一個參數，將元素本身作為第二個參數應用。
mapi [Float.Array]	與 `Float.Array.map` 相同，但該函數會將元素的索引作為第一個參數，將元素本身作為第二個參數應用。
mapi [Dynarray]	`mapi f a` 是一個新陣列，其元素形式為 `f i x`，其中 `x` 是 `a` 中索引為 `i` 的每個元素。
mapi [BytesLabels]	`mapi ~f s` 會使用 `s` 的每個字元及其索引（以遞增的索引順序）呼叫 `f`，並將結果位元組儲存在一個新的序列中，該序列會作為結果傳回。
mapi [Bytes]	`mapi f s` 會使用 `s` 的每個字元及其索引（以遞增的索引順序）呼叫 `f`，並將結果位元組儲存在一個新的序列中，該序列會作為結果傳回。
mapi [ArrayLabels]	與 `ArrayLabels.map` 相同，但該函數會將元素的索引作為第一個參數，將元素本身作為第二個參數應用。
mapi [Array]	與 `Array.map` 相同，但該函數會將元素的索引作為第一個參數，將元素本身作為第二個參數應用。
mapi_inplace [Float.ArrayLabels]	與 `Float.ArrayLabels.map_inplace` 相同，但該函數會將元素的索引作為第一個參數，將元素本身作為第二個參數應用。
mapi_inplace [Float.Array]	與 `Float.Array.map_inplace` 相同，但該函數會將元素的索引作為第一個參數，將元素本身作為第二個參數應用。
mapi_inplace [ArrayLabels]	與 `ArrayLabels.map_inplace` 相同，但該函數會將元素的索引作為第一個參數，將元素本身作為第二個參數應用。
mapi_inplace [Array]	與 `Array.map_inplace` 相同，但該函數會將元素的索引作為第一個參數，將元素本身作為第二個參數應用。
match_beginning [Str]	`match_beginning()` 返回上次呼叫匹配或搜尋函數所匹配的子字串的第一個字元的位置（詳情請參閱 `Str.matched_string`）。
match_end [Str]	`match_end()` 返回上次呼叫匹配或搜尋函數所匹配的子字串的最後一個字元後面的字元位置（詳情請參閱 `Str.matched_string`）。
match_with [Effect.Deep]	`match_with f v h` 在處理器 `h` 中執行計算 `f v`。
matched_group [Str]	`matched_group n s` 返回 `s` 的子字串，該子字串是由上次呼叫匹配或搜尋函數所匹配的正規表示式中的第 `n` 個群組 `\(...\)` 所匹配的（詳情請參閱 `Str.matched_string`）。
matched_string [Str]	`matched_string s` 傳回字串 `s` 中，最後一次呼叫以下匹配或搜尋函式所匹配到的子字串：`Str.string_match`、`Str.search_forward`、`Str.search_backward`、`Str.string_partial_match`、`Str.global_substitute`、`Str.substitute_first`。但前提是，在這些函式呼叫之間，沒有呼叫過以下任何函式：`Str.global_replace`、`Str.replace_first`、`Str.split`、`Str.bounded_split`、`Str.split_delim`、`Str.bounded_split_delim`、`Str.full_split`、`Str.bounded_full_split`。注意：在 `global_substitute` 和 `substitute_first` 的情況下，呼叫 `matched_string` 僅在 `subst` 引數內有效，在 `global_substitute` 或 `substitute_first` 回傳後無效。
max [Uchar]	`max` 為 U+10FFFF。
max [Stdlib]	傳回兩個引數中較大的那個。
max [Nativeint]	傳回兩個引數中較大的那個。
max [Int64]	傳回兩個引數中較大的那個。
max [Int32]	傳回兩個引數中較大的那個。
max [Int]	傳回兩個引數中較大的那個。
max [Float]	`max x y` 傳回 `x` 和 `y` 中較大的值。
max_array_length [Sys]	一般陣列的最大長度 (即。
max_binding [MoreLabels.Map.S]	與 `MoreLabels.Map.S.min_binding` 相同，但傳回給定映射中具有最大鍵的繫結。
max_binding [Map.S]	與 `Map.S.min_binding` 相同，但傳回給定映射中具有最大鍵的繫結。
max_binding_opt [MoreLabels.Map.S]	與 `MoreLabels.Map.S.min_binding_opt` 相同，但傳回給定映射中具有最大鍵的繫結。
max_binding_opt [Map.S]	與 `Map.S.min_binding_opt` 相同，但傳回給定映射中具有最大鍵的繫結。
max_elt [Set.S]	與 `Set.S.min_elt` 相同，但傳回給定集合中最大的元素。
max_elt [MoreLabels.Set.S]	與 `MoreLabels.Set.S.min_elt` 相同，但傳回給定集合中最大的元素。
max_elt_opt [Set.S]	與 `Set.S.min_elt_opt` 相同，但傳回給定集合中最大的元素。
max_elt_opt [MoreLabels.Set.S]	與 `MoreLabels.Set.S.min_elt_opt` 相同，但傳回給定集合中最大的元素。
max_ephe_length [Obj.Ephemeron]	暫存物件的最大長度，即暫存物件可能包含的最大鍵數
max_float [Stdlib]	類型為 `float` 的最大正有限值。
max_float [Float]	類型為 `float` 的最大正有限值。
max_floatarray_length [Sys]	浮點數陣列的最大長度。
max_int [Stdlib]	可表示的最大整數。
max_int [Nativeint]	可表示的最大原生整數，在 32 位元平台上為 2³¹ - 1，在 64 位元平台上為 2⁶³ - 1。
max_int [Int64]	可表示的最大 64 位元整數，2⁶³ - 1。
max_int [Int32]	可表示的最大 32 位元整數，2³¹ - 1。
max_int [Int]	`max_int` 是可表示的最大整數，`2`^{Sys.int_size - 1}`-1`。
max_num [Float]	`max_num x y` 傳回 `x` 和 `y` 中較大的值，將 `nan` 視為遺失值。
max_string_length [Sys]	字串和位元組序列的最大長度。
mem [Weak.S]	如果 `t` 中至少有一個 `x` 的實例，則 `mem t x` 傳回 `true`，否則傳回 false。
mem [Set.S]	`mem x s` 測試 `x` 是否屬於集合 `s`。
mem [MoreLabels.Set.S]	`mem x s` 測試 `x` 是否屬於集合 `s`。
mem [MoreLabels.Map.S]	如果 `m` 包含 `x` 的繫結，則 `mem x m` 傳回 `true`，否則傳回 `false`。
mem [MoreLabels.Hashtbl.SeededS]
mem [MoreLabels.Hashtbl.S]
mem [MoreLabels.Hashtbl]	`Hashtbl.mem tbl x` 檢查 `x` 是否在 `tbl` 中繫結。
mem [Map.S]	如果 `m` 包含 `x` 的繫結，則 `mem x m` 傳回 `true`，否則傳回 `false`。
mem [ListLabels]	當且僅當 `a` 等於 `set` 的一個元素時，`mem a ~set` 為 true。
mem [List]	當且僅當 `a` 等於 `set` 的一個元素時，`mem a set` 為 true。
mem [Hashtbl.SeededS]
mem [Hashtbl.S]
mem [Hashtbl]	`Hashtbl.mem tbl x` 檢查 `x` 是否在 `tbl` 中繫結。
mem [Float.ArrayLabels]	當且僅當 `set` 中有一個元素在結構上與 `a` 相等時，`mem a ~set` 為 true，即
mem [Float.Array]	當且僅當 `set` 中有一個元素在結構上與 `a` 相等時，`mem a set` 為 true，即
mem [Ephemeron.SeededS]
mem [Ephemeron.S]
mem [ArrayLabels]	當且僅當 `a` 在結構上等於 `set` 的一個元素時（即，`mem a ~set` 為 true）。
mem [Array]	當且僅當 `a` 在結構上等於 `set` 的一個元素時（即，`mem a set` 為 true）。
mem_assoc [ListLabels]	與 `ListLabels.assoc` 相同，但如果存在繫結則簡單地傳回 `true`，如果給定鍵不存在繫結則傳回 `false`。
mem_assoc [List]	與 `List.assoc` 相同，但如果存在繫結則簡單地傳回 `true`，如果給定鍵不存在繫結則傳回 `false`。
mem_assq [ListLabels]	與 `ListLabels.mem_assoc` 相同，但使用物理相等性而不是結構相等性來比較鍵。
mem_assq [List]	與 `List.mem_assoc` 相同，但使用物理相等性而不是結構相等性來比較鍵。
mem_ieee [Float.ArrayLabels]	與 `Float.ArrayLabels.mem` 相同，但使用 IEEE 相等性而不是結構相等性。
mem_ieee [Float.Array]	與 `Float.Array.mem` 相同，但使用 IEEE 相等性而不是結構相等性。
memoize [Seq]	序列 `memoize xs` 具有與序列 `xs` 相同的元素。
memq [ListLabels]	與 `ListLabels.mem` 相同，但使用物理相等性而不是結構相等性來比較列表元素。
memq [List]	與 `List.mem` 相同，但使用物理相等性而不是結構相等性來比較列表元素。
memq [ArrayLabels]	與 `ArrayLabels.mem` 相同，但使用物理相等性而不是結構相等性來比較陣列元素。
memq [Array]	與 `Array.mem` 相同，但使用物理相等性而不是結構相等性來比較陣列元素。
merge [Weak.S]	如果 `t` 中找到 `x` 的實例，則 `merge t x` 傳回該實例，否則將 `x` 新增至 `t` 並傳回 `x`。
merge [MoreLabels.Map.S]	`merge ~f m1 m2` 計算一個 map，其鍵值是 `m1` 和 `m2` 的鍵值的子集。
merge [Map.S]	`merge f m1 m2` 計算一個 map，其鍵值是 `m1` 和 `m2` 的鍵值的子集。
merge [ListLabels]	合併兩個列表：假設 `l1` 和 `l2` 根據比較函式 `cmp` 排序，`merge ~cmp l1 l2` 將返回一個包含 `l1` 和 `l2` 所有元素的排序列表。
merge [List]	合併兩個列表：假設 `l1` 和 `l2` 根據比較函式 `cmp` 排序，`merge cmp l1 l2` 將返回一個包含 `l1` 和 `l2` 所有元素的排序列表。
min [Uchar]	`min` 是 U+0000。
min [Stdlib]	返回兩個參數中較小的一個。
min [Nativeint]	返回兩個參數中較小的一個。
min [Int64]	返回兩個參數中較小的一個。
min [Int32]	返回兩個參數中較小的一個。
min [Int]	返回兩個參數中較小的一個。
min [Float]	`min x y` 返回 `x` 和 `y` 中較小的值。
min_binding [MoreLabels.Map.S]	返回給定 map 中鍵值最小的綁定（相對於 `Ord.compare` 排序），如果 map 為空則引發 `Not_found` 例外。
min_binding [Map.S]	返回給定 map 中鍵值最小的綁定（相對於 `Ord.compare` 排序），如果 map 為空則引發 `Not_found` 例外。
min_binding_opt [MoreLabels.Map.S]	返回給定 map 中鍵值最小的綁定（相對於 `Ord.compare` 排序），如果 map 為空則返回 `None`。
min_binding_opt [Map.S]	返回給定 map 中鍵值最小的綁定（相對於 `Ord.compare` 排序），如果 map 為空則返回 `None`。
min_elt [Set.S]	返回給定集合中最小的元素（相對於 `Ord.compare` 排序），如果集合為空則引發 `Not_found` 例外。
min_elt [MoreLabels.Set.S]	返回給定集合中最小的元素（相對於 `Ord.compare` 排序），如果集合為空則引發 `Not_found` 例外。
min_elt_opt [Set.S]	返回給定集合中最小的元素（相對於 `Ord.compare` 排序），如果集合為空則返回 `None`。
min_elt_opt [MoreLabels.Set.S]	返回給定集合中最小的元素（相對於 `Ord.compare` 排序），如果集合為空則返回 `None`。
min_float [Stdlib]	類型為 `float` 的最小正數、非零、非正規化值。
min_float [Float]	類型為 `float` 的最小正數、非零、非正規化值。
min_int [Stdlib]	最小的可表示整數。
min_int [Nativeint]	最小的可表示原生整數，在 32 位平台上為 -2³¹，在 64 位平台上為 -2⁶³。
min_int [Int64]	最小的可表示 64 位整數，-2⁶³。
min_int [Int32]	最小的可表示 32 位整數，-2³¹。
min_int [Int]	`min_int` 是最小的可表示整數，`-2`^{Sys.int_size - 1}。
min_max [Float]	`min_max x y` 是 `(min x y, max x y)`，只是更有效率。
min_max_num [Float]	`min_max_num x y` 是 `(min_num x y, max_num x y)`，只是更有效率。
min_num [Float]	`min_num x y` 返回 `x` 和 `y` 中較小的值，將 `nan` 視為缺失值。
minor [Gc]	觸發一次小回收。
minor_words [Gc]	此域或可能先前域在小堆積中分配的字數。
minus_one [Nativeint]	原生整數 -1。
minus_one [Int64]	64 位整數 -1。
minus_one [Int32]	32 位整數 -1。
minus_one [Int]	`minus_one` 是整數 `-1`。
minus_one [Float]	浮點數 -1。
mkdir [UnixLabels]	使用給定的權限建立一個目錄（請參閱 `UnixLabels.umask`）。
mkdir [Unix]	使用給定的權限建立一個目錄（請參閱 `Unix.umask`）。
mkdir [Sys]	使用給定的權限建立一個目錄。
mkfifo [UnixLabels]	使用給定的權限建立一個具名管道（請參閱 `UnixLabels.umask`）。
mkfifo [Unix]	使用給定的權限建立一個具名管道（請參閱 `Unix.umask`）。
mktime [UnixLabels]	將由 `tm` 參數指定的日期和時間轉換為以秒為單位的時間，如 `UnixLabels.time` 返回的時間。
mktime [Unix]	將由 `tm` 參數指定的日期和時間轉換為以秒為單位的時間，如 `Unix.time` 返回的時間。
mod_float [Stdlib]	`mod_float a b` 返回 `a` 相對於 `b` 的餘數。
modf [Stdlib]	`modf f` 返回 `f` 的小數部分和整數部分的配對。
modf [Float]	`modf f` 返回 `f` 的小數部分和整數部分的配對。
mul [Nativeint]	乘法。
mul [Int64]	乘法。
mul [Int32]	乘法。
mul [Int]	`mul x y` 是乘法 `x * y`。
mul [Float]	浮點數乘法。
mul [Complex]	乘法
N
name [Runtime_events.User]	`name t` 是事件 `t` 的唯一識別名稱。
name [Printexc.Slot]	`name slot` 返回封閉 slot 所引用位置的函式或定義名稱。
name [Obj.Extension_constructor]
name_of_input [Scanf.Scanning]	`Scanning.name_of_input ic` 返回給定 `Scanf.Scanning.in_channel` 格式化輸入通道的字元來源名稱。
nan [Stdlib]	一個特殊的浮點數值，表示未定義運算的結果，例如 `0.0 /. 0.0`。
nan [Float]	一個特殊的浮點數值，表示未定義運算的結果，例如 `0.0 /. 0.0`。
narrow [CamlinternalOO]
nativebits [Random.State]	這些函式與基本函式相同，只是它們使用（並更新）給定的 PRNG 狀態，而不是預設狀態。
nativebits [Random]	`Random.nativebits ()` 返回 32 或 64 個隨機位（取決於平台的位寬度），作為介於 `Nativeint.min_int` 和 `Nativeint.max_int` 之間的整數。
nativeint [Random.State]
nativeint [Random]	`Random.nativeint bound` 返回 0（包含）和 `bound`（不包含）之間的隨機整數。
nativeint [Bigarray]	請參閱 `Bigarray.char`。
nativeint_in_range [Random.State]
nativeint_in_range [Random]	`Random.nativeint_in_range ~min ~max` 返回 `min`（包含）和 `max`（包含）之間的隨機整數。
neg [Nativeint]	一元否定。
neg [Int64]	一元否定。
neg [Int32]	一元否定。
neg [Int]	`neg x` 是 `~-x`。
neg [Float]	一元否定。
neg [Complex]	一元否定。
neg_infinity [Stdlib]	負無窮大。
neg_infinity [Float]	負無窮大。
negate [Fun]	`negate p` 是謂詞函式 `p` 的否定。
new_block [Obj]
new_channel [Event]	返回一個新的通道。
new_key [Domain.DLS]	`new_key f` 返回一個新的鍵，該鍵綁定到初始化程式 `f` 以用於存取網域本機變數。
new_line [Lexing]	更新 lexbuf 的 `lex_curr_p` 欄位，以反映新行的開始。
new_method [CamlinternalOO]
new_methods_variables [CamlinternalOO]
new_variable [CamlinternalOO]
next_after [Float]	`next_after x y` 會回傳在 `y` 的方向上，緊接在 `x` 之後的下一個可表示的浮點數值。
nice [UnixLabels]	變更程序優先權。
nice [Unix]	變更程序優先權。
no_scan_tag [Obj]
none [Option]	`none` 為 `None`。
norm [Complex]	範數：給定 `x + i.y`，回傳 `sqrt(x^2 + y^2)`。
norm2 [Complex]	範數平方：給定 `x + i.y`，回傳 `x^2 + y^2`。
not [Stdlib]	布林否定。
not [Bool]	`not b` 為 `b` 的布林否定。
nth [ListLabels]	回傳給定列表的第 `n` 個元素。
nth [List]	回傳給定列表的第 `n` 個元素。
nth [Buffer]	取得緩衝區的第 n 個字元。
nth_dim [Bigarray.Genarray]	`Genarray.nth_dim a n` 會回傳 Bigarray `a` 的第 `n` 個維度。
nth_opt [ListLabels]	回傳給定列表的第 `n` 個元素。
nth_opt [List]	回傳給定列表的第 `n` 個元素。
null [Filename]	`null` 在 POSIX 上為 `"/dev/null"`，在 Windows 上為 `"NUL"`。
null_tracker [Gc.Memprof]	預設回呼函式僅回傳 `None` 或 `()`
num_dims [Bigarray.Genarray]	回傳給定 Bigarray 的維度數量。
O
obj [Obj]
object_tag [Obj]
ocaml_release [Sys]	`ocaml_release` 是 OCaml 的版本。
ocaml_version [Sys]	`ocaml_version` 是 OCaml 的版本。
of_array [Dynarray]	`of_array arr` 會回傳對應於固定大小陣列 `a` 的動態陣列。
of_array [Bigarray.Array3]	建立一個三維 Bigarray，並以給定的陣列的陣列的陣列初始化。
of_array [Bigarray.Array2]	建立一個二維 Bigarray，並以給定的陣列的陣列初始化。
of_array [Bigarray.Array1]	建立一個一維 Bigarray，並以給定的陣列初始化。
of_binary_string [Random.State]	還原序列化透過呼叫 `Random.State.to_binary_string` 取得的位元組序列。
of_bytes [String]	回傳一個新的字串，其中包含與給定的位元組序列相同的位元組。
of_bytes [StringLabels]	回傳一個新的字串，其中包含與給定的位元組序列相同的位元組。
of_char [Uchar]	`of_char c` 為 Unicode 字元的 `c`。
of_dispenser [Seq]	`of_dispenser it` 是由 dispenser `it` 產生的元素序列。
of_float [Nativeint]	將給定的浮點數轉換為原生整數，捨去小數部分（向 0 截斷）。
of_float [Int64]	將給定的浮點數轉換為 64 位元整數，捨去小數部分（向 0 截斷）。
of_float [Int32]	將給定的浮點數轉換為 32 位元整數，捨去小數部分（向 0 截斷）。
of_float [Int]	`of_float x` 將 `x` 截斷為整數。
of_hex [Digest.S]	將十六進位表示法轉換回對應的摘要。
of_hex [Digest]	將十六進位表示法轉換回對應的摘要。
of_int [Uchar]	`of_int i` 為 Unicode 字元的 `i`。
of_int [Nativeint]	將給定的整數（類型為 `int`）轉換為原生整數（類型為 `nativeint`）。
of_int [Int64]	將給定的整數（類型為 `int`）轉換為 64 位元整數（類型為 `int64`）。
of_int [Int32]	將給定的整數（類型為 `int`）轉換為 32 位元整數（類型為 `int32`）。
of_int [Float]	將整數轉換為浮點數。
of_int32 [Nativeint]	將給定的 32 位元整數（類型為 `int32`）轉換為原生整數。
of_int32 [Int64]	將給定的 32 位元整數（類型為 `int32`）轉換為 64 位元整數（類型為 `int64`）。
of_list [Set.S]	`of_list l` 會從元素列表建立一個集合。
of_list [MoreLabels.Set.S]	`of_list l` 會從元素列表建立一個集合。
of_list [MoreLabels.Map.S]	`of_list bs` 會將 `bs` 的綁定加入到空映射中，依照列表順序排列（如果一個鍵在 `bs` 中被綁定兩次，則最後一個會覆蓋）。
of_list [Map.S]	`of_list bs` 會將 `bs` 的綁定加入到空映射中，依照列表順序排列（如果一個鍵在 `bs` 中被綁定兩次，則最後一個會覆蓋）。
of_list [Float.ArrayLabels]	`of_list l` 會回傳一個新的浮點數陣列，其中包含 `l` 的元素。
of_list [Float.Array]	`of_list l` 會回傳一個新的浮點數陣列，其中包含 `l` 的元素。
of_list [Dynarray]	`of_list l` 是包含 `l` 元素且順序相同的陣列。
of_list [ArrayLabels]	`of_list l` 會回傳一個新的陣列，其中包含 `l` 的元素。
of_list [Array]	`of_list l` 會回傳一個新的陣列，其中包含 `l` 的元素。
of_nativeint [Int64]	將給定的原生整數（類型為 `nativeint`）轉換為 64 位元整數（類型為 `int64`）。
of_seq [String]	`of_seq s` 是由序列的字元組成的字串。
of_seq [StringLabels]	`of_seq s` 是由序列的字元組成的字串。
of_seq [Stack]	從序列建立堆疊。
of_seq [Set.S]	從給定的綁定建立集合。
of_seq [Queue]	從序列建立佇列。
of_seq [MoreLabels.Set.S]	從給定的綁定建立集合。
of_seq [MoreLabels.Map.S]	從給定的綁定建立映射。
of_seq [MoreLabels.Hashtbl.SeededS]
of_seq [MoreLabels.Hashtbl.S]
of_seq [MoreLabels.Hashtbl]	從給定的綁定建立表格。
of_seq [Map.S]	從給定的綁定建立映射。
of_seq [ListLabels]	從序列建立列表。
of_seq [List]	從序列建立列表。
of_seq [Hashtbl.SeededS]
of_seq [Hashtbl.S]
of_seq [Hashtbl]	從給定的綁定建立表格。
of_seq [Float.ArrayLabels]	從產生器建立陣列。
of_seq [Float.Array]	從產生器建立陣列。
of_seq [Ephemeron.SeededS]
of_seq [Ephemeron.S]
of_seq [Dynarray]	`of_seq seq` 是包含與 `seq` 相同元素的陣列。
of_seq [BytesLabels]	從產生器建立字串
of_seq [Bytes]	從產生器建立字串
of_seq [Buffer]	從產生器建立緩衝區
of_seq [ArrayLabels]	從產生器建立陣列。
of_seq [Array]	從產生器建立陣列。
of_string [Nativeint]	將給定的字串轉換為原生整數。
of_string [Int64]	將給定的字串轉換為 64 位元整數。
of_string [Int32]	將給定的字串轉換為 32 位元整數。
of_string [Float]	將給定的字串轉換為浮點數。
of_string [BytesLabels]	回傳一個新的位元組序列，其中包含與給定字串相同的位元組。
of_string [Bytes]	回傳一個新的位元組序列，其中包含與給定字串相同的位元組。
of_string_opt [Nativeint]	與 `of_string` 相同，但會回傳 `None` 而不是引發例外。
of_string_opt [Int64]	與 `of_string` 相同，但會回傳 `None` 而不是引發例外。
of_string_opt [Int32]	與 `of_string` 相同，但會回傳 `None` 而不是引發例外。
of_string_opt [Float]	與 `of_string` 相同，但會返回 `None` 而不是引發例外。
of_val [Obj.Extension_constructor]
of_value [Bigarray.Array0]	從給定的值建立一個零維的 Bigarray。
ok [Result]	`ok v` 為 `Ok v`。
once [Seq]	序列 `once xs` 與序列 `xs` 具有相同的元素。
one [Nativeint]	原生整數 1。
one [Int64]	64 位元整數 1。
one [Int32]	32 位元整數 1。
one [Int]	`one` 為整數 `1`。
one [Float]	浮點數 1。
one [Complex]	複數 `1`。
opaque_identity [Sys]	為了優化的目的，`opaque_identity` 的行為類似於一個未知（因此可能具有副作用）的函數。
open_bin [Out_channel]	開啟指定名稱的檔案以進行寫入，並返回該檔案上新的輸出通道，定位於檔案的開頭。
open_bin [In_channel]	開啟指定名稱的檔案以進行讀取，並返回該檔案上新的輸入通道，定位於檔案的開頭。
open_box [Format]	`pp_open_box ppf d` 在格式器 `ppf` 中開啟一個新的可壓縮美化列印盒，其偏移量為 `d`。
open_box_of_string [CamlinternalFormat]
open_connection [UnixLabels]	連線到指定位址的伺服器。
open_connection [Unix]	連線到指定位址的伺服器。
open_gen [Out_channel]	`open_gen mode perm filename` 開啟指定名稱的檔案以進行寫入，如上所述。
open_gen [In_channel]	`open_gen mode perm filename` 開啟指定名稱的檔案以進行讀取，如上所述。
open_hbox [Format]	`pp_open_hbox ppf ()` 開啟一個新的「水平」美化列印盒。
open_hovbox [Format]	`pp_open_hovbox ppf d` 開啟一個新的「水平或垂直」美化列印盒，其偏移量為 `d`。
open_hvbox [Format]	`pp_open_hvbox ppf d` 開啟一個新的「水平/垂直」美化列印盒，其偏移量為 `d`。
open_in [Stdlib]	開啟指定名稱的檔案以進行讀取，並返回該檔案上新的輸入通道，定位於檔案的開頭。
open_in [Scanf.Scanning]	`Scanning.open_in fname` 返回一個 `Scanf.Scanning.in_channel` 格式化的輸入通道，用於從檔案 `fname` 以文字模式緩衝讀取。
open_in_bin [Stdlib]	與 `open_in` 相同，但檔案以二進制模式開啟，因此在讀取期間不會進行任何轉換。
open_in_bin [Scanf.Scanning]	`Scanning.open_in_bin fname` 返回一個 `Scanf.Scanning.in_channel` 格式化的輸入通道，用於從檔案 `fname` 以二進制模式緩衝讀取。
open_in_gen [Stdlib]	`open_in_gen mode perm filename` 開啟指定名稱的檔案以進行讀取，如上所述。
open_out [Stdlib]	開啟指定名稱的檔案以進行寫入，並返回該檔案上新的輸出通道，定位於檔案的開頭。
open_out_bin [Stdlib]	與 `open_out` 相同，但檔案以二進制模式開啟，因此在寫入期間不會進行任何轉換。
open_out_gen [Stdlib]	`open_out_gen mode perm filename` 開啟指定名稱的檔案以進行寫入，如上所述。
open_process [UnixLabels]	與 `UnixLabels.open_process_out` 相同，但將命令的標準輸入和標準輸出都重新導向到連接到兩個返回通道的管道。
open_process [Unix]	與 `Unix.open_process_out` 相同，但將命令的標準輸入和標準輸出都重新導向到連接到兩個返回通道的管道。
open_process_args [UnixLabels]	`open_process_args prog args` 使用參數 `args` 執行程式 `prog`。
open_process_args [Unix]	`open_process_args prog args` 使用參數 `args` 執行程式 `prog`。
open_process_args_full [UnixLabels]	類似於 `UnixLabels.open_process_args`，但第三個參數指定傳遞給新進程的環境。
open_process_args_full [Unix]	類似於 `Unix.open_process_args`，但第三個參數指定傳遞給新進程的環境。
open_process_args_in [UnixLabels]	與 `UnixLabels.open_process_args` 相同，但僅重新導向新進程的標準輸出。
open_process_args_in [Unix]	與 `Unix.open_process_args` 相同，但僅重新導向新進程的標準輸出。
open_process_args_out [UnixLabels]	與 `UnixLabels.open_process_args` 相同，但僅重新導向新進程的標準輸入。
open_process_args_out [Unix]	與 `Unix.open_process_args` 相同，但僅重新導向新進程的標準輸入。
open_process_full [UnixLabels]	類似於 `UnixLabels.open_process`，但第二個參數指定傳遞給命令的環境。
open_process_full [Unix]	類似於 `Unix.open_process`，但第二個參數指定傳遞給命令的環境。
open_process_in [UnixLabels]	高階管道和進程管理。
open_process_in [Unix]	高階管道和進程管理。
open_process_out [UnixLabels]	與 `UnixLabels.open_process_in` 相同，但將命令的標準輸入重新導向到管道。
open_process_out [Unix]	與 `Unix.open_process_in` 相同，但將命令的標準輸入重新導向到管道。
open_stag [Format]	`pp_open_stag ppf t` 開啟名為 `t` 的語義標籤。
open_tbox [Format]	`open_tbox ()` 開啟一個新的製表盒。
open_temp_file [Filename]	與 `Filename.temp_file` 相同，但會同時返回一個新的暫存檔的名稱，以及在此檔案上（原子地）開啟的輸出通道。
open_text [Out_channel]	與 `Out_channel.open_bin` 相同，但檔案以文字模式開啟，因此在寫入期間會進行換行符號轉換。
open_text [In_channel]	與 `In_channel.open_bin` 相同，但檔案以文字模式開啟，因此在讀取期間會進行換行符號轉換。
open_vbox [Format]	`pp_open_vbox ppf d` 開啟一個新的「垂直」美化列印盒，其偏移量為 `d`。
opendir [UnixLabels]	在目錄上開啟一個描述符。
opendir [Unix]	在目錄上開啟一個描述符。
openfile [UnixLabels]	以給定的旗標開啟指定名稱的檔案。
openfile [Unix]	以給定的旗標開啟指定名稱的檔案。
os_type [Sys]	目前執行 OCaml 程式的作業系統。
out_channel_length [Stdlib.LargeFile]
out_channel_length [Stdlib]	傳回開啟給定通道的常規檔案的大小（字元數）。
out_channel_of_descr [UnixLabels]	建立一個在給定描述符上寫入的輸出通道。
out_channel_of_descr [Unix]	建立一個在給定描述符上寫入的輸出通道。
out_of_heap_tag [Obj]
output [Stdlib]	`output oc buf pos len` 將位元組序列 `buf` 中從偏移量 `pos` 開始的 `len` 個字元寫入到給定的輸出通道 `oc`。
output [Out_channel]	`output oc buf pos len` 將位元組序列 `buf` 中從偏移量 `pos` 開始的 `len` 個字元寫入到給定的輸出通道 `oc`。
output [Digest.S]	在給定的輸出通道上寫入摘要。
output [Digest]	在給定的輸出通道上寫入摘要。
output_acc [CamlinternalFormat]
output_bigarray [Out_channel]	與 `Out_channel.output` 相同，但從 bigarray 取得資料。
output_binary_int [Stdlib]	以二進制格式 (4 個位元組，大端序) 將一個整數寫入指定的輸出通道。
output_buffer [Buffer]	`output_buffer oc b` 將緩衝區 `b` 的目前內容寫入輸出通道 `oc`。
output_byte [Stdlib]	將一個 8 位元的整數 (作為該碼的單一字元) 寫入指定的輸出通道。
output_byte [Out_channel]	將一個 8 位元的整數 (作為該碼的單一字元) 寫入指定的輸出通道。
output_bytes [Stdlib]	將位元組序列寫入指定的輸出通道。
output_bytes [Out_channel]	將位元組序列寫入指定的輸出通道。
output_char [Stdlib]	將字元寫入指定的輸出通道。
output_char [Out_channel]	將字元寫入指定的輸出通道。
output_string [Stdlib]	將字串寫入指定的輸出通道。
output_string [Out_channel]	將字串寫入指定的輸出通道。
output_substring [Stdlib]	與 `output` 相同，但以字串作為引數，而非位元組序列。
output_substring [Out_channel]	與 `Out_channel.output` 相同，但以字串作為引數，而非位元組序列。
output_value [Stdlib]	將任何型別的結構化值表示形式寫入通道。
over_max_boxes [Format]	測試是否已開啟允許的最大美化列印方塊數量。
P
param_format_of_ignored_format [CamlinternalFormat]
params [CamlinternalOO]
parent_dir_name [Filename]	目前目錄的父目錄的慣用名稱 (例如。
parse [Arg]	`Arg.parse speclist anon_fun usage_msg` 解析命令列。
parse_and_expand_argv_dynamic [Arg]	與 `Arg.parse_argv_dynamic` 相同，差別在於 `argv` 引數為參考，並且可能會在解析 `Expand` 引數期間更新。
parse_argv [Arg]	`Arg.parse_argv ~current args speclist anon_fun usage_msg` 解析陣列 `args`，如同它是命令列。
parse_argv_dynamic [Arg]	與 `Arg.parse_argv` 相同，差別在於 `speclist` 引數為參考，並且可能會在解析期間更新。
parse_dynamic [Arg]	與 `Arg.parse` 相同，差別在於 `speclist` 引數為參考，並且可能會在解析期間更新。
parse_expand [Arg]	與 `Arg.parse` 相同，差別在於允許 `Expand` 引數，且不會更新 `Arg.current` 參考。
partition [Set.S]	`partition f s` 傳回一組集合 `(s1, s2)`，其中 `s1` 是 `s` 中所有符合述詞 `f` 的元素集合，而 `s2` 是 `s` 中所有不符合 `f` 的元素集合。
partition [Seq]	`partition p xs` 傳回一對 `xs` 中符合 `p` 的元素子序列，以及 `xs` 中不符合 `p` 的元素子序列。
partition [MoreLabels.Set.S]	`partition ~f s` 傳回一組集合 `(s1, s2)`，其中 `s1` 是 `s` 中所有符合述詞 `f` 的元素集合，而 `s2` 是 `s` 中所有不符合 `f` 的元素集合。
partition [MoreLabels.Map.S]	`partition ~f m` 傳回一對映射 `(m1, m2)`，其中 `m1` 包含 `m` 中所有符合述詞 `f` 的繫結，而 `m2` 是包含 `m` 中所有不符合 `f` 的繫結的映射。
partition [Map.S]	`partition f m` 傳回一對映射 `(m1, m2)`，其中 `m1` 包含 `m` 中所有符合述詞 `f` 的繫結，而 `m2` 是包含 `m` 中所有不符合 `f` 的繫結的映射。
partition [ListLabels]	`partition ~f l` 傳回一對清單 `(l1, l2)`，其中 `l1` 是 `l` 中所有符合述詞 `f` 的元素清單，而 `l2` 是 `l` 中所有不符合 `f` 的元素清單。
partition [List]	`partition f l` 傳回一對清單 `(l1, l2)`，其中 `l1` 是 `l` 中所有符合述詞 `f` 的元素清單，而 `l2` 是 `l` 中所有不符合 `f` 的元素清單。
partition_map [Seq]	`partition_map f xs` 傳回一對序列 `(ys, zs)`，其中
partition_map [ListLabels]	`partition_map f l` 傳回一對清單 `(l1, l2)`，使得對於輸入清單 `l` 的每個元素 `x`：若 `f x` 為 `Left y1`，則 `y1` 在 `l1` 中，而若 `f x` 為 `Right y2`，則 `y2` 在 `l2` 中。輸出元素會以與 `l` 中對應的輸入元素相同的相對順序包含在 `l1` 和 `l2` 中。
partition_map [List]	`partition_map f l` 傳回一對清單 `(l1, l2)`，使得對於輸入清單 `l` 的每個元素 `x`：若 `f x` 為 `Left y1`，則 `y1` 在 `l1` 中，而若 `f x` 為 `Right y2`，則 `y2` 在 `l2` 中。輸出元素會以與 `l` 中對應的輸入元素相同的相對順序包含在 `l1` 和 `l2` 中。
pause [UnixLabels]	等待，直到傳遞非忽略、非封鎖的訊號。
pause [Unix]	等待，直到傳遞非忽略、非封鎖的訊號。
pause [Runtime_events]	`pause ()` 將會暫停執行階段中的事件收集。
peek [Queue]	`peek q` 傳回佇列 `q` 中的第一個元素，而不會將其從佇列中移除；若佇列為空，則會引發 `Queue.Empty` 例外。
peek_opt [Queue]	`peek_opt q` 傳回佇列 `q` 中的第一個元素，而不會將其從佇列中移除；若佇列為空，則會傳回 `None`。
perform [Effect]	`perform e` 執行效果 `e`。
pi [Float]	常數 pi。
pipe [UnixLabels]	建立管道。
pipe [Unix]	建立管道。
polar [Complex]	`polar norm arg` 傳回具有範數 `norm` 和引數 `arg` 的複數。
poll [Event]	`Event.sync` 的非封鎖版本：將事件中指定的所有通訊可能性提供給外部，並且如果可以立即進行，則執行並傳回 `Some r`，其中 `r` 是該通訊的結果值。
pop [Stack]	`pop s` 移除並傳回堆疊 `s` 中最頂端的元素，若堆疊為空，則會引發 `Stack.Empty` 例外。
pop [Queue]	`pop` 是 `take` 的同義詞。
pop_last [Dynarray]	`pop_last a` 移除並傳回 `a` 的最後一個元素。
pop_last_opt [Dynarray]	`pop_last_opt a` 移除並傳回 `a` 的最後一個元素，若陣列為空，則會傳回 `None`。
pop_opt [Stack]	`pop_opt s` 移除並傳回堆疊 `s` 中最頂端的元素，若堆疊為空，則會傳回 `None`。
pos [Out_channel]	傳回指定通道的目前寫入位置。
pos [In_channel]	傳回指定通道的目前讀取位置。
pos_in [Stdlib.LargeFile]
pos_in [Stdlib]	傳回指定通道的目前讀取位置。
pos_out [Stdlib.LargeFile]
pos_out [Stdlib]	傳回指定通道的目前寫入位置。
pow [Float]	指數運算。
pow [Complex]	次方函數。
pp_close_box [Format]
pp_close_stag [Format]
pp_close_tbox [Format]
pp_force_newline [Format]
pp_get_ellipsis_text [Format]
pp_get_formatter_out_functions [Format]
pp_get_formatter_output_functions [Format]
pp_get_formatter_stag_functions [Format]
pp_get_geometry [Format]
pp_get_margin [Format]
pp_get_mark_tags [Format]
pp_get_max_boxes [Format]
pp_get_max_indent [Format]
pp_get_print_tags [Format]
pp_infinity [Format]	`pp_infinity` 是邊界的最大尺寸。
pp_open_box [Format]
pp_open_hbox [Format]
pp_open_hovbox [Format]
pp_open_hvbox [Format]
pp_open_stag [Format]
pp_open_tbox [Format]
pp_open_vbox [Format]
pp_over_max_boxes [Format]
pp_print_array [Format]	`pp_print_array ?pp_sep pp_v ppf a` 列印陣列 `a` 的項目，使用 `pp_v` 列印每個項目，並在項目之間呼叫 `pp_sep` (`pp_sep` 預設為 `Format.pp_print_cut`)。
pp_print_as [Format]
pp_print_bool [Format]
pp_print_break [Format]
pp_print_bytes [Format]
pp_print_char [Format]
pp_print_custom_break [Format]	`pp_print_custom_break ppf ~fits:(s1, n, s2) ~breaks:(s3, m, s4)` 發出一個自訂的斷行提示：格式化列印器可能會在此處斷行。
pp_print_cut [Format]
pp_print_either [Format]	`pp_print_either ~left ~right ppf e` 如果 `e` 是 `Either.Left _`，則使用 `left` 在 `ppf` 上列印 `e`，如果 `e` 是 `Either.Right _`，則使用 `right`。
pp_print_float [Format]
pp_print_flush [Format]
pp_print_if_newline [Format]
pp_print_int [Format]
pp_print_iter [Format]	`pp_print_iter ~pp_sep iter pp_v ppf v` 使用 `pp_v` 在 `ppf` 上格式化 `iter` 對值集合 `v` 的迭代。
pp_print_list [Format]	`pp_print_list ?pp_sep pp_v ppf l` 列印列表 `l` 的項目，使用 `pp_v` 列印每個項目，並在項目之間呼叫 `pp_sep` (`pp_sep` 預設為 `Format.pp_print_cut`)。
pp_print_newline [Format]
pp_print_nothing [Format]	列印空值。
pp_print_option [Format]	`pp_print_option ?none pp_v ppf o` 如果 `o` 是 `Some v`，則使用 `pp_v` 在 `ppf` 上列印 `o`，如果它是 `None`，則使用 `none`。
pp_print_result [Format]	`pp_print_result ~ok ~error ppf r` 如果 `r` 是 `Ok _`，則使用 `ok` 在 `ppf` 上列印 `r`，如果 `r` 是 `Error _`，則使用 `error`。
pp_print_seq [Format]	`pp_print_seq ?pp_sep pp_v ppf s` 列印序列 `s` 的項目，使用 `pp_v` 列印每個項目，並在項目之間呼叫 `pp_sep` (`pp_sep` 預設為 `Format.pp_print_cut`)。
pp_print_space [Format]
pp_print_string [Format]
pp_print_tab [Format]
pp_print_tbreak [Format]
pp_print_text [Format]	`pp_print_text ppf s` 列印 `s`，其中空格和換行符號分別使用 `Format.pp_print_space` 和 `Format.pp_force_newline` 列印。
pp_safe_set_geometry [Format]
pp_set_ellipsis_text [Format]
pp_set_formatter_out_channel [Format]	重新導向標準格式化器的輸出。
pp_set_formatter_out_functions [Format]
pp_set_formatter_output_functions [Format]
pp_set_formatter_stag_functions [Format]
pp_set_geometry [Format]
pp_set_margin [Format]
pp_set_mark_tags [Format]
pp_set_max_boxes [Format]
pp_set_max_indent [Format]
pp_set_print_tags [Format]
pp_set_tab [Format]
pp_set_tags [Format]
pp_update_geometry [Format]	`pp_update_geometry ppf (fun geo -> { geo with ... })` 允許您更新格式化器的幾何，使其能穩健地擴展具有新欄位的 `geometry` 記錄。
pred [Uchar]	`pred u` 是 Unicode 純量值集中 `u` 前面的純量值。
pred [Stdlib]	`pred x` 是 `x - 1`。
pred [Nativeint]	前一個值。
pred [Int64]	前一個值。
pred [Int32]	前一個值。
pred [Int]	`pred x` 是 `sub x 1`。
pred [Float]	`pred x` 傳回 `x` 前面的浮點數，即小於 `x` 的最大浮點數。
prerr_bytes [Stdlib]	在標準錯誤上列印位元組序列。
prerr_char [Stdlib]	在標準錯誤上列印字元。
prerr_endline [Stdlib]	在標準錯誤上列印字串，後跟一個換行符號，並刷新標準錯誤。
prerr_float [Stdlib]	在標準錯誤上以十進位列印浮點數。
prerr_int [Stdlib]	在標準錯誤上以十進位列印整數。
prerr_newline [Stdlib]	在標準錯誤上列印換行符號，並刷新標準錯誤。
prerr_string [Stdlib]	在標準錯誤上列印字串。
print [Printexc]	`Printexc.print fn x` 將 `fn` 應用於 `x` 並傳回結果。
print_as [Format]	`pp_print_as ppf len s` 在目前的格式化列印框中列印 `s`。
print_backtrace [Printexc]	`Printexc.print_backtrace oc` 在輸出通道 `oc` 上列印異常回溯。
print_bool [Format]	在目前的格式化列印框中列印布林值。
print_break [Format]	`pp_print_break ppf nspaces offset` 發出「完整」的斷行提示：格式化列印器可能會在此處斷行，否則它會列印 `nspaces` 個空格。
print_bytes [Stdlib]	在標準輸出上列印位元組序列。
print_bytes [Format]	`pp_print_bytes ppf b` 在目前的格式化列印框中列印 `b`。
print_char [Stdlib]	在標準輸出上列印字元。
print_char [Format]	在目前的格式化列印框中列印字元。
print_cut [Format]	`pp_print_cut ppf ()` 發出「刪除」的斷行提示：格式化列印器可能會在此處斷行，否則它不會列印任何內容。
print_endline [Stdlib]	在標準輸出上列印字串，後跟一個換行符號，並刷新標準輸出。
print_float [Stdlib]	在標準輸出上以十進位列印浮點數。
print_float [Format]	在目前的格式化列印框中列印浮點數。
print_flush [Format]	格式化列印結束：將格式化列印器重設為初始狀態。
print_if_newline [Format]	如果前一行剛被分割，則執行下一個格式化命令。
print_int [Stdlib]	在標準輸出上以十進位列印整數。
print_int [Format]	在目前的格式化列印框中列印整數。
print_newline [Stdlib]	在標準輸出上列印換行符號，並刷新標準輸出。
print_newline [Format]	格式化列印結束：將格式化列印器重設為初始狀態。
print_raw_backtrace [Printexc]	以與 `Printexc.print_backtrace` 使用的格式相同的格式列印原始回溯。
print_space [Format]	`pp_print_space ppf ()` 發出「空格」的斷行提示：格式化列印器可能會在此處斷行，否則它會列印一個空格。
print_stat [Gc]	將總程式的記憶體管理計數器的目前值 (以人類可讀的形式) 列印到通道參數中。
print_string [Stdlib]	在標準輸出上列印字串。
print_string [Format]	`pp_print_string ppf s` 在目前的精美列印框中印出 `s`。
print_tab [Format]	`print_tab ()` 發出「下一個」製表符斷點提示：如果尚未在製表符標記上設定，則插入點會移動到右側的第一個製表符標記，或者精美列印器會分割行，並且插入點會移動到最左側的製表符標記。
print_tbreak [Format]	`print_tbreak nspaces offset` 發出「完整」製表符斷點提示。
printf [Printf]	與 `Printf.fprintf` 相同，但輸出到 `stdout`。
printf [Format]	與上面的 `fprintf` 相同，但輸出到 `get_std_formatter ()`。
process_full_pid [UnixLabels]	傳回透過 `UnixLabels.open_process_args_full` 開啟的行程的 pid，或透過 `UnixLabels.open_process_full` 開啟的 shell 的 pid。
process_full_pid [Unix]	傳回透過 `Unix.open_process_args_full` 開啟的行程的 pid，或透過 `Unix.open_process_full` 開啟的 shell 的 pid。
process_in_pid [UnixLabels]	傳回透過 `UnixLabels.open_process_args_in` 開啟的行程的 pid，或透過 `UnixLabels.open_process_in` 開啟的 shell 的 pid。
process_in_pid [Unix]	傳回透過 `Unix.open_process_args_in` 開啟的行程的 pid，或透過 `Unix.open_process_in` 開啟的 shell 的 pid。
process_out_pid [UnixLabels]	傳回透過 `UnixLabels.open_process_args_out` 開啟的行程的 pid，或透過 `UnixLabels.open_process_out` 開啟的 shell 的 pid。
process_out_pid [Unix]	傳回透過 `Unix.open_process_args_out` 開啟的行程的 pid，或透過 `Unix.open_process_out` 開啟的 shell 的 pid。
process_pid [UnixLabels]	傳回透過 `UnixLabels.open_process_args` 開啟的行程的 pid，或透過 `UnixLabels.open_process_args` 開啟的 shell 的 pid。
process_pid [Unix]	傳回透過 `Unix.open_process_args` 開啟的行程的 pid，或透過 `Unix.open_process_args` 開啟的 shell 的 pid。
product [Seq]	`product xs ys` 是序列 `xs` 和 `ys` 的笛卡爾積。
prohibit [Dynlink]	`prohibit units` 通過從允許的單元列表中刪除清單 `units` 中命名的單元，禁止動態連結的單元引用這些單元。
protect [Mutex]	`protect mutex f` 在一個臨界區段中執行 `f()`，其中 `mutex` 被鎖定（使用 `Mutex.lock`）；然後它會處理釋放 `mutex` 的事宜，無論 `f()` 是傳回值還是引發例外狀況。
protect [Fun]	`protect ~finally work` 呼叫 `work ()`，然後在 `work ()` 傳回其值或例外狀況之前呼叫 `finally ()`。
provably_equal [Type.Id]	如果識別碼 `i0` 等於 `i1`，則 `provably_equal i0 i1` 為 `Some Equal`，否則為 `None`。
public_dynamically_loaded_units [Dynlink]	傳回透過 `loadfile`（而不是透過 `loadfile_private`）動態載入的編譯單元清單。
public_method_label [CamlinternalOO]
push [Stack]	`push x s` 將元素 `x` 加入堆疊 `s` 的頂端。
push [Queue]	`push` 是 `add` 的同義詞。
putenv [UnixLabels]	`putenv name value` 設定行程環境中與變數相關聯的值。
putenv [Unix]	`putenv name value` 設定行程環境中與變數相關聯的值。
Q
query [Ephemeron.Kn]	與 `Ephemeron.K1.query` 相同
query [Ephemeron.K2]	與 `Ephemeron.K1.query` 相同
query [Ephemeron.K1]	如果 `key` 在物理上等於 `eph` 的鍵，則 `Ephemeron.K1.query eph key` 傳回 `Some x`（其中 `x` 是 ephemeron 的資料），如果 `eph` 為空或 `key` 不等於 `eph` 的鍵，則傳回 `None`。
quick_stat [Gc]	與 `stat` 相同，但 `live_words`、`live_blocks`、`free_words`、`free_blocks`、`largest_free` 和 `fragments` 都設為 0。
quiet_nan [Float]	靜默 NaN。
quote [Str]	`Str.quote s` 傳回一個正規表示式字串，該字串恰好符合 `s`，而不會符合其他字串。
quote [Filename]	傳回檔案名稱的引號版本，適合用作命令列中的一個引數，並逸脫所有元字元。
quote_command [Filename]	`quote_command cmd args` 傳回一個帶引號的命令列，適合用作 `Sys.command`、`Unix.system` 和 `Unix.open_process` 函數的引數。
R
raise [Stdlib]	引發給定的例外值
raise_notrace [Stdlib]	較快的 `raise` 版本，不會記錄回溯。
raise_with_backtrace [Printexc]	使用給定的 raw_backtrace 重新引發例外狀況，以表示例外狀況的來源
randomize [MoreLabels.Hashtbl]	在呼叫 `Hashtbl.randomize()` 之後，雜湊表預設會以隨機模式建立：`MoreLabels.Hashtbl.create` 傳回隨機雜湊表，除非指定 `~random:false` 選用參數。
randomize [Hashtbl]	在呼叫 `Hashtbl.randomize()` 之後，雜湊表預設會以隨機模式建立：`Hashtbl.create` 傳回隨機雜湊表，除非指定 `~random:false` 選用參數。
raw_backtrace_entries [Printexc]
raw_backtrace_length [Printexc]	`raw_backtrace_length bckt` 傳回回溯 `bckt` 中的 slot 數目。
raw_backtrace_to_string [Printexc]	以 `Printexc.get_backtrace` 使用的相同格式，從原始回溯傳回字串。
raw_field [Obj]
rcontains_from [String]	當且僅當 `c` 出現在位置 `stop+1` 之前的 `s` 中時，`rcontains_from s stop c` 為 `true`。
rcontains_from [StringLabels]	當且僅當 `c` 出現在位置 `stop+1` 之前的 `s` 中時，`rcontains_from s stop c` 為 `true`。
rcontains_from [BytesLabels]	`rcontains_from s stop c` 測試位元組 `c` 是否出現在位置 `stop+1` 之前的 `s` 中。
rcontains_from [Bytes]	`rcontains_from s stop c` 測試位元組 `c` 是否出現在位置 `stop+1` 之前的 `s` 中。
reachable_words [Obj]	計算從引數可存取的所有堆積區塊的總大小（以字為單位，包含標頭）。
read [UnixLabels]	`read fd ~buf ~pos ~len` 從描述器 `fd` 讀取 `len` 個位元組，將它們儲存在位元組序列 `buf` 中，從 `buf` 中的位置 `pos` 開始。
read [Unix]	`read fd buf pos len` 從描述器 `fd` 讀取 `len` 個位元組，將它們儲存在位元組序列 `buf` 中，從 `buf` 中的位置 `pos` 開始。
read_arg [Arg]	`Arg.read_arg file` 從檔案 `file` 讀取以換行符號終止的命令列引數。
read_arg0 [Arg]	與 `Arg.read_arg` 相同，但假設以空字元終止的命令列引數。
read_bigarray [UnixLabels]	與 `UnixLabels.read` 相同，但將資料讀入 bigarray。
read_bigarray [Unix]	與 `Unix.read` 相同，但將資料讀入 bigarray。
read_float [Stdlib]	與 `read_float_opt` 相同，但引發 `Failure "float_of_string"`，而不是傳回 `None`。
read_float_opt [Stdlib]	刷新標準輸出，然後從標準輸入讀取一行，並將其轉換為浮點數。
read_int [Stdlib]	與 `read_int_opt` 相同，但會拋出 `Failure "int_of_string"` 異常，而不是回傳 `None`。
read_int_opt [Stdlib]	刷新標準輸出，然後從標準輸入讀取一行並將其轉換為整數。
read_line [Stdlib]	刷新標準輸出，然後從標準輸入讀取字元，直到遇到換行符號。
read_poll [Runtime_events]	`read_poll cursor callbacks max_option` 會在 `callbacks` 上調用相應的函式，最多處理從 `cursor` 的 runtime_events 中讀取的 `max_option` 個事件，並回傳讀取的事件數量。
readdir [UnixLabels]	回傳目錄中的下一個條目。
readdir [Unix]	回傳目錄中的下一個條目。
readdir [Sys]	回傳指定目錄中所有檔案的名稱。
readlink [UnixLabels]	讀取符號連結的內容。
readlink [Unix]	讀取符號連結的內容。
really_input [Stdlib]	`really_input ic buf pos len` 從通道 `ic` 讀取 `len` 個字元，並將它們儲存在位元組序列 `buf` 中，從字元編號 `pos` 開始。
really_input [In_channel]	`really_input ic buf pos len` 從通道 `ic` 讀取 `len` 個字元，並將它們儲存在位元組序列 `buf` 中，從字元編號 `pos` 開始。
really_input_bigarray [In_channel]	與 `In_channel.really_input` 相同，但將資料讀取到 bigarray 中。
really_input_string [Stdlib]	`really_input_string ic len` 從通道 `ic` 讀取 `len` 個字元，並將它們以新的字串形式回傳。
really_input_string [In_channel]	`really_input_string ic len` 從通道 `ic` 讀取 `len` 個字元，並將它們以新的字串形式回傳。
realpath [UnixLabels]	`realpath p` 是一個 `p` 的絕對路徑名稱，透過解析所有額外的 `/` 字元、相對路徑段和符號連結獲得。
realpath [Unix]	`realpath p` 是一個 `p` 的絕對路徑名稱，透過解析所有額外的 `/` 字元、相對路徑段和符號連結獲得。
rebuild [MoreLabels.Hashtbl]	傳回給定雜湊表的副本。
rebuild [Hashtbl]	傳回給定雜湊表的副本。
recast [CamlinternalFormat]
receive [Event]	`receive ch` 回傳一個事件，該事件包含從通道 `ch` 接收一個值。
recommended_domain_count [Domain]	建議同時執行的最大網域數量（包括已經在運行的網域）。
record_backtrace [Printexc]	`Printexc.record_backtrace b` 開啟（如果 `b = true`）或關閉（如果 `b = false`）記錄例外回溯的功能。
recv [UnixLabels]	從已連線的 socket 接收資料。
recv [Unix]	從已連線的 socket 接收資料。
recvfrom [UnixLabels]	從未連線的 socket 接收資料。
recvfrom [Unix]	從未連線的 socket 接收資料。
ref [Stdlib]	回傳一個包含給定值的新參考。
regexp [Str]	編譯正規表示式。
regexp_case_fold [Str]	與 `regexp` 相同，但編譯後的表示式將以不區分大小寫的方式比對文字：大寫和小寫字母將被視為等效。
regexp_string [Str]	`Str.regexp_string s` 回傳一個完全比對 `s` 且不比對任何其他內容的正規表示式。
regexp_string_case_fold [Str]	`Str.regexp_string_case_fold` 類似於 `Str.regexp_string`，但正規表示式會以不區分大小寫的方式比對。
register [Runtime_events.User]	`register name tag ty` 註冊一個新的事件，具有唯一的 `name`，攜帶 `tag` 和 `ty` 型別的值。
register [Runtime_events.Type]	透過提供編碼器和解碼器來註冊自訂型別。
register [Callback]	`Callback.register n v` 將值 `v` 註冊在名稱 `n` 下。
register_exception [Callback]	`Callback.register_exception n exn` 將例外值 `exn` 中包含的例外註冊在名稱 `n` 下。
register_printer [Printexc]	`Printexc.register_printer fn` 將 `fn` 註冊為例外印表機。
release [Semaphore.Binary]	`release s` 將號誌鎖 `s` 的值設定為 1，使其處於「可用」狀態。
release [Semaphore.Counting]	`release s` 增加號誌鎖 `s` 的值。
rem [Nativeint]	整數餘數。
rem [Int64]	整數餘數。
rem [Int32]	整數餘數。
rem [Int]	`rem x y` 是餘數 `x mod y`。
rem [Float]	`rem a b` 回傳 `a` 對 `b` 的餘數。
remove [Weak.S]	`remove t x` 從 `t` 中移除 `x` 的一個實例。
remove [Sys]	從檔案系統中移除給定的檔案名稱。
remove [Set.S]	`remove x s` 回傳一個包含 `s` 的所有元素的集合，但 `x` 除外。
remove [MoreLabels.Set.S]	`remove x s` 回傳一個包含 `s` 的所有元素的集合，但 `x` 除外。
remove [MoreLabels.Map.S]	`remove x m` 回傳一個包含與 `m` 相同綁定的映射，但 `x` 在回傳的映射中未綁定。
remove [MoreLabels.Hashtbl.SeededS]
remove [MoreLabels.Hashtbl.S]
remove [MoreLabels.Hashtbl]	`Hashtbl.remove tbl x` 移除 `tbl` 中 `x` 的目前綁定，如果存在，則還原先前的綁定。
remove [Map.S]	`remove x m` 回傳一個包含與 `m` 相同綁定的映射，但 `x` 在回傳的映射中未綁定。
remove [Hashtbl.SeededS]
remove [Hashtbl.S]
remove [Hashtbl]	`Hashtbl.remove tbl x` 移除 `tbl` 中 `x` 的目前綁定，如果存在，則還原先前的綁定。
remove [Ephemeron.Kn.Bucket]	`remove b k` 從 `b` 中移除最近加入的具有鍵 `k` 的 ephemeron，如果沒有這樣的 ephemeron，則不執行任何動作。
remove [Ephemeron.K2.Bucket]	`remove b k1 k2` 從 `b` 中移除最近加入的具有鍵 `k1` 和 `k2` 的 ephemeron，如果沒有這樣的 ephemeron，則不執行任何動作。
remove [Ephemeron.K1.Bucket]	`remove b k` 從 `b` 中移除最近加入的具有鍵 `k` 的 ephemeron，如果沒有這樣的 ephemeron，則不執行任何動作。
remove [Ephemeron.SeededS]
remove [Ephemeron.S]
remove_assoc [ListLabels]	`remove_assoc a l` 回傳不包含第一個具有鍵 `a` 的配對的配對列表 `l` (如果有的話)。
remove_assoc [List]	`remove_assoc a l` 回傳不包含第一個具有鍵 `a` 的配對的配對列表 `l` (如果有的話)。
remove_assq [ListLabels]	與 `ListLabels.remove_assoc` 相同，但使用實體相等性而不是結構相等性來比較鍵。
remove_assq [List]	與 `List.remove_assoc` 相同，但使用實體相等性而不是結構相等性來比較鍵。
remove_extension [Filename]	回傳不包含擴展名的指定檔案名稱，如 `Filename.extension` 中所定義。
remove_last [Dynarray]	`remove_last a` 移除 `a` 的最後一個元素 (如果有的話)。
rename [UnixLabels]	`rename ~src ~dst` 將檔案名稱從 `src` 變更為 `dst`，如有需要，會在目錄之間移動。
rename [Unix]	`rename src dst` 將檔案名稱從 `src` 變更為 `dst`，如有需要，會在目錄之間移動。
rename [Sys]	重新命名檔案或目錄。
rep [Uchar]	`rep` 是 U+FFFD，即替換字元。
repeat [Seq]	`repeat x` 是無限序列，其中元素 `x` 會無限重複。
replace [MoreLabels.Hashtbl.SeededS]
replace [MoreLabels.Hashtbl.S]
replace [MoreLabels.Hashtbl]	`Hashtbl.replace tbl ~key ~data` 將 `tbl` 中 `key` 的當前綁定替換為 `key` 到 `data` 的綁定。
replace [Hashtbl.SeededS]
replace [Hashtbl.S]
replace [Hashtbl]	`Hashtbl.replace tbl key data` 將 `tbl` 中 `key` 的當前綁定替換為 `key` 到 `data` 的綁定。
replace [Ephemeron.SeededS]
replace [Ephemeron.S]
replace_first [Str]	與 `Str.global_replace` 相同，但只替換第一個符合正規表達式的子字串。
replace_matched [Str]	`replace_matched repl s` 傳回替換文字 `repl`，其中包含 `\1`、`\2` 等。
replace_seq [MoreLabels.Hashtbl.SeededS]
replace_seq [MoreLabels.Hashtbl.S]
replace_seq [MoreLabels.Hashtbl]	使用 `MoreLabels.Hashtbl.replace` 將給定的綁定新增至表格。
replace_seq [Hashtbl.SeededS]
replace_seq [Hashtbl.S]
replace_seq [Hashtbl]	使用 `Hashtbl.replace` 將給定的綁定新增至表格。
replace_seq [Ephemeron.SeededS]
replace_seq [Ephemeron.S]
repr [Sys.Immediate64.Make]
repr [Obj]
reset [MoreLabels.Hashtbl.SeededS]
reset [MoreLabels.Hashtbl.S]
reset [MoreLabels.Hashtbl]	清空雜湊表，並將儲存桶表格的大小縮小至其初始大小。
reset [Hashtbl.SeededS]
reset [Hashtbl.S]
reset [Hashtbl]	清空雜湊表，並將儲存桶表格的大小縮小至其初始大小。
reset [Ephemeron.SeededS]
reset [Ephemeron.S]
reset [Dynarray]	`reset a` 清除 `a`，並將其後端陣列替換為空陣列。
reset [Buffer]	清空緩衝區，並釋放儲存緩衝區內容的內部位元組序列，將其替換為 `Buffer.create` `n` 配置的長度為 `n` 的初始內部位元組序列。
reshape [Bigarray]	`reshape b [\|d1;...;dN\|]` 將 Bigarray `b` 轉換為維度為 `d1`... 的 `N` 維陣列。
reshape_0 [Bigarray]	用於將形狀調整為零維陣列的 `Bigarray.reshape` 的特殊化版本。
reshape_1 [Bigarray]	用於將形狀調整為一維陣列的 `Bigarray.reshape` 的特殊化版本。
reshape_2 [Bigarray]	用於將形狀調整為二維陣列的 `Bigarray.reshape` 的特殊化版本。
reshape_3 [Bigarray]	用於將形狀調整為三維陣列的 `Bigarray.reshape` 的特殊化版本。
resume [Runtime_events]	`resume ()` 將繼續收集執行時的事件。
return [Seq]	`return x` 是唯一元素為 `x` 的序列。
rev [ListLabels]	反轉列表。
rev [List]	反轉列表。
rev_append [ListLabels]	`rev_append l1 l2` 反轉 `l1` 並將其與 `l2` 連接。
rev_append [List]	`rev_append l1 l2` 反轉 `l1` 並將其與 `l2` 連接。
rev_char_set [CamlinternalFormat]
rev_map [ListLabels]	`rev_map ~f l` 的結果與 `ListLabels.rev` `(ListLabels.map` `f l)` 相同，但效率更高。
rev_map [List]	`rev_map f l` 的結果與 `List.rev` `(List.map` `f l)` 相同，但效率更高。
rev_map2 [ListLabels]	`rev_map2 ~f l1 l2` 的結果與 `ListLabels.rev` `(ListLabels.map2` `f l1 l2)` 相同，但效率更高。
rev_map2 [List]	`rev_map2 f l1 l2` 的結果與 `List.rev` `(List.map2` `f l1 l2)` 相同，但效率更高。
rewinddir [UnixLabels]	將描述器重新定位到目錄的開頭
rewinddir [Unix]	將描述器重新定位到目錄的開頭
rhs_end [Parsing]	請參閱 `Parsing.rhs_start`。
rhs_end_pos [Parsing]	與 `rhs_end` 相同，但傳回 `position` 而不是偏移。
rhs_start [Parsing]	與 `Parsing.symbol_start` 和 `Parsing.symbol_end` 相同，但傳回符合規則右側第 `n` 個項目的字串偏移，其中 `n` 是 `rhs_start` 和 `rhs_end` 的整數參數。
rhs_start_pos [Parsing]	與 `rhs_start` 相同，但傳回 `position` 而不是偏移。
right [Either]	`right v` 是 `Right v`。
rindex [String]	`rindex s c` 是 `String.rindex_from` `s (length s - 1) c`。
rindex [StringLabels]	`rindex s c` 是 `String.rindex_from` `s (length s - 1) c`。
rindex [BytesLabels]	`rindex s c` 傳回 `s` 中最後一次出現位元組 `c` 的索引。
rindex [Bytes]	`rindex s c` 傳回 `s` 中最後一次出現位元組 `c` 的索引。
rindex_from [String]	`rindex_from s i c` 是 `c` 在 `s` 中位置 `i+1` 之前最後一次出現的索引。
rindex_from [StringLabels]	`rindex_from s i c` 是 `c` 在 `s` 中位置 `i+1` 之前最後一次出現的索引。
rindex_from [BytesLabels]	`rindex_from s i c` 傳回 `c` 在 `s` 中位置 `i+1` 之前最後一次出現的位元組索引。
rindex_from [Bytes]	`rindex_from s i c` 傳回 `c` 在 `s` 中位置 `i+1` 之前最後一次出現的位元組索引。
rindex_from_opt [String]	`rindex_from_opt s i c` 是 `c` 在 `s` 中位置 `i+1` 之前最後一次出現的索引（如果有的話）。
rindex_from_opt [StringLabels]	`rindex_from_opt s i c` 是 `c` 在 `s` 中位置 `i+1` 之前最後一次出現的索引（如果有的話）。
rindex_from_opt [BytesLabels]	`rindex_from_opt s i c` 傳回位元組 `c` 在 `s` 中位置 `i+1` 之前最後一次出現的索引，如果 `c` 在位置 `i+1` 之前沒有在 `s` 中出現，則傳回 `None`。
rindex_from_opt [Bytes]	`rindex_from_opt s i c` 傳回位元組 `c` 在 `s` 中位置 `i+1` 之前最後一次出現的索引，如果 `c` 在位置 `i+1` 之前沒有在 `s` 中出現，則傳回 `None`。
rindex_opt [String]	`rindex_opt s c` 等同於 `String.rindex_from_opt` `s (length s - 1) c`。
rindex_opt [StringLabels]	`rindex_opt s c` 等同於 `String.rindex_from_opt` `s (length s - 1) c`。
rindex_opt [BytesLabels]	`rindex_opt s c` 傳回位元組 `c` 在 `s` 中最後一次出現的索引，如果 `c` 沒有在 `s` 中出現，則傳回 `None`。
rindex_opt [Bytes]	`rindex_opt s c` 傳回位元組 `c` 在 `s` 中最後一次出現的索引，如果 `c` 沒有在 `s` 中出現，則傳回 `None`。
rmdir [UnixLabels]	移除一個空的目錄。
rmdir [Unix]	移除一個空的目錄。
rmdir [Sys]	移除一個空的目錄。
round [Float]	`round x` 將 `x` 四捨五入到最接近的整數，當小數部分為 0.5 時，無論目前的捨入方向為何，都會向遠離零的方向捨入。
run_initializers [CamlinternalOO]
run_initializers_opt [CamlinternalOO]
runtime_counter_name [Runtime_events]	傳回給定執行階段計數器類型的字串表示形式。
runtime_parameters [Sys]	傳回執行階段參數的值，格式與 `OCAMLRUNPARAM` 環境變數的內容相同。
runtime_phase_name [Runtime_events]	傳回給定執行階段階段事件類型的字串表示形式。
runtime_variant [Sys]	傳回程式正在執行的執行階段變體的名稱。
runtime_warnings_enabled [Sys]	傳回目前是否啟用執行階段警告。
S
safe_set_geometry [Format]	`pp_set_geometry ppf ~max_indent ~margin` 設定 `ppf` 的邊界和最大縮排限制。
scan [Seq]	如果 `xs` 是一個序列 `[x0; x1; x2; ...]`，則 `scan f a0 xs` 是一個累加器的序列 `[a0; a1; a2; ...]`，其中 `a1` 是 `f a0 x0`，`a2` 是 `f a1 x1`，依此類推。
scanf [Scanf]	與 `Scanf.bscanf` 相同，但從預定義的格式化輸入通道 `Scanf.Scanning.stdin` 讀取，該通道連接到 `stdin`。
scanf_opt [Scanf]	與 `Scanf.scanf` 相同，但在掃描失敗時傳回 `None`。
search_backward [Str]	`search_backward r s last` 在字串 `s` 中搜尋與正規表示式 `r` 匹配的子字串。
search_forward [Str]	`search_forward r s start` 在字串 `s` 中搜尋與正規表示式 `r` 匹配的子字串。
seeded_hash [String]	字串的種子雜湊函數，其輸出值與 `Hashtbl.seeded_hash` 相同。
seeded_hash [StringLabels]	字串的種子雜湊函數，其輸出值與 `Hashtbl.seeded_hash` 相同。
seeded_hash [Nativeint]	原生整數的種子雜湊函數，其輸出值與 `Hashtbl.seeded_hash` 相同。
seeded_hash [MoreLabels.Hashtbl.SeededHashedType]	金鑰的種子雜湊函數。
seeded_hash [MoreLabels.Hashtbl]	`MoreLabels.Hashtbl.hash` 的變體，它進一步由整數種子參數化。
seeded_hash [Int64]	64 位元整數的種子雜湊函數，其輸出值與 `Hashtbl.seeded_hash` 相同。
seeded_hash [Int32]	32 位元整數的種子雜湊函數，其輸出值與 `Hashtbl.seeded_hash` 相同。
seeded_hash [Int]	整數的種子雜湊函數，其輸出值與 `Hashtbl.seeded_hash` 相同。
seeded_hash [Hashtbl.SeededHashedType]	金鑰的種子雜湊函數。
seeded_hash [Hashtbl]	`Hashtbl.hash` 的變體，它進一步由整數種子參數化。
seeded_hash [Float]	浮點數的種子雜湊函數，其輸出值與 `Hashtbl.seeded_hash` 相同。
seeded_hash [Char]	字元的種子雜湊函數，其輸出值與 `Hashtbl.seeded_hash` 相同。
seeded_hash [Bool]	布林值的種子雜湊函數，其輸出值與 `Hashtbl.seeded_hash` 相同。
seeded_hash_param [MoreLabels.Hashtbl]	`MoreLabels.Hashtbl.hash_param` 的變體，它進一步由整數種子參數化。
seeded_hash_param [Hashtbl]	`Hashtbl.hash_param` 的變體，它進一步由整數種子參數化。
seek [Out_channel]	`seek chan pos` 將通道 `chan` 的目前寫入位置設定為 `pos`。
seek [In_channel]	`seek chan pos` 將通道 `chan` 的目前讀取位置設定為 `pos`。
seek_in [Stdlib.LargeFile]
seek_in [Stdlib]	`seek_in chan pos` 將通道 `chan` 的目前讀取位置設定為 `pos`。
seek_out [Stdlib.LargeFile]
seek_out [Stdlib]	`seek_out chan pos` 將通道 `chan` 的目前寫入位置設定為 `pos`。
select [UnixLabels]	等待某些通道上的一些輸入/輸出操作變為可能。
select [Unix]	等待某些通道上的一些輸入/輸出操作變為可能。
select [Thread]	與 `Unix.select` 相同的函式。
select [Event]	在事件的替代項上「同步」。
self [Thread]	傳回目前正在執行的執行緒的控制代碼。
self [Domain]	`self ()` 是目前正在執行的網域的識別碼
self_init [Random]	使用以系統相關方式選擇的隨機種子初始化網域本機產生器。
send [CamlinternalOO]
send [UnixLabels]	透過已連線的通訊端傳送資料。
send [Unix]	透過已連線的通訊端傳送資料。
send [Event]	`send ch v` 傳回一個事件，該事件包含透過通道 `ch` 傳送值 `v`。
send_substring [UnixLabels]	與 `send` 相同，但從字串而不是位元組序列取得資料。
send_substring [Unix]	與 `send` 相同，但從字串而不是位元組序列取得資料。
sendcache [CamlinternalOO]
sendself [CamlinternalOO]
sendto [UnixLabels]	透過未連線的通訊端傳送資料。
sendto [Unix]	透過未連線的通訊端傳送資料。
sendto_substring [UnixLabels]	與 `sendto` 相同，但從字串而不是位元組序列取得資料。
sendto_substring [Unix]	與 `sendto` 相同，但從字串而不是位元組序列取得資料。
set [Weak]	`Weak.set ar n (Some el)` 將 `ar` 的第 `n` 個儲存格設定為指向 `el` 的（完整）指標；`Weak.set ar n None` 將 `ar` 的第 `n` 個儲存格設定為空。
set [Gc]	`set r` 根據 `control` 記錄 `r` 變更 GC 參數。
set [Float.ArrayLabels]	`set a n x` 就地修改浮點數陣列 `a`，將編號 `n` 的元素替換為 `x`。
set [Float.Array]	`set a n x` 就地修改浮點數陣列 `a`，將編號 `n` 的元素替換為 `x`。
set [Dynarray]	`set a i x` 將 `a` 的第 `i` 個元素設定為 `x`。
set [Domain.DLS]	`set k v` 更新呼叫網域的網域本機狀態，以將金鑰 `k` 與值 `v` 建立關聯。
set [BytesLabels]	`set s n c` 就地修改 `s`，將索引 `n` 處的位元組替換為 `c`。
set [Bytes]	`set s n c` 就地修改 `s`，將索引 `n` 處的位元組替換為 `c`。
set [Bigarray.Array3]	`Array3.set a x y v`，或者另一個選擇是 `a.{x,y,z} <- v`，將值 `v` 儲存在 `a` 中座標 (`x`, `y`, `z`) 的位置。
set [Bigarray.Array2]	`Array2.set a x y v`，或等效地 `a.{x,y} <- v`，將值 `v` 儲存在 `a` 中座標 (`x`, `y`) 的位置。
set [Bigarray.Array1]	`Array1.set a x v`，也可寫成 `a.{x} <- v`，將值 `v` 儲存在 `a` 中索引為 `x` 的位置。
set [Bigarray.Array0]	`Array0.set a x v` 將值 `v` 儲存在 `a` 中。
set [Bigarray.Genarray]	賦值一個泛型 Bigarray 的元素。
set [Atomic]	為原子參考設定一個新值。
set [ArrayLabels]	`set a n x` 就地修改陣列 `a`，將編號為 `n` 的元素替換為 `x`。
set [Array]	`set a n x` 就地修改陣列 `a`，將編號為 `n` 的元素替換為 `x`。
set_allowed_units [Dynlink]	設定未來動態載入的單元可以參考的編譯單元列表，使其與給定的值完全相同。
set_binary_mode [Out_channel]	`set_binary_mode oc true` 將通道 `oc` 設定為二進位模式：輸出期間不進行任何轉換。
set_binary_mode [In_channel]	`set_binary_mode ic true` 將通道 `ic` 設定為二進位模式：輸入期間不進行任何轉換。
set_binary_mode_in [Stdlib]	`set_binary_mode_in ic true` 將通道 `ic` 設定為二進位模式：輸入期間不進行任何轉換。
set_binary_mode_out [Stdlib]	`set_binary_mode_out oc true` 將通道 `oc` 設定為二進位模式：輸出期間不進行任何轉換。
set_buffered [Out_channel]	`set_buffered oc true` 將通道 `oc` 設定為緩衝模式。
set_capacity [Dynarray]	`set_capacity a n` 在必要時重新分配後備陣列，使產生的容量恰好為 `n`。
set_close_on_exec [UnixLabels]	在給定的描述符上設定 ``close-on-exec'' 標誌。
set_close_on_exec [Unix]	在給定的描述符上設定 ``close-on-exec'' 標誌。
set_data [Obj.Ephemeron]
set_double_field [Obj]
set_ellipsis_text [Format]	設定當過多美觀列印框打開時列印的省略號文字（預設為單點 `.`）。
set_field [Obj]	當使用 flambda 時
set_filename [Lexing]	將 `lexbuf` 中初始追蹤位置的檔名設定為 `file`。
set_formatter_out_channel [Format]	將標準美觀列印輸出重新導向至給定的通道。
set_formatter_out_functions [Format]	`pp_set_formatter_out_functions ppf out_funs` 將 `ppf` 的所有美觀列印輸出函數設定為參數 `out_funs` 的函數。
set_formatter_output_functions [Format]	`pp_set_formatter_output_functions ppf out flush` 將標準美觀列印輸出函數重新導向至函數 `out` 和 `flush`。
set_formatter_stag_functions [Format]	`pp_set_formatter_stag_functions ppf tag_funs` 變更打開和關閉語義標籤操作的含義，以便在 `ppf` 上列印時使用 `tag_funs` 中的函數。
set_geometry [Format]
set_int16_be [BytesLabels]	`set_int16_be b i v` 將 `b` 從位元組索引 `i` 開始的大端有符號 16 位元整數設定為 `v`。
set_int16_be [Bytes]	`set_int16_be b i v` 將 `b` 從位元組索引 `i` 開始的大端有符號 16 位元整數設定為 `v`。
set_int16_le [BytesLabels]	`set_int16_le b i v` 將 `b` 從位元組索引 `i` 開始的小端有符號 16 位元整數設定為 `v`。
set_int16_le [Bytes]	`set_int16_le b i v` 將 `b` 從位元組索引 `i` 開始的小端有符號 16 位元整數設定為 `v`。
set_int16_ne [BytesLabels]	`set_int16_ne b i v` 將 `b` 從位元組索引 `i` 開始的原生端有符號 16 位元整數設定為 `v`。
set_int16_ne [Bytes]	`set_int16_ne b i v` 將 `b` 從位元組索引 `i` 開始的原生端有符號 16 位元整數設定為 `v`。
set_int32_be [BytesLabels]	`set_int32_be b i v` 將 `b` 從位元組索引 `i` 開始的大端 32 位元整數設定為 `v`。
set_int32_be [Bytes]	`set_int32_be b i v` 將 `b` 從位元組索引 `i` 開始的大端 32 位元整數設定為 `v`。
set_int32_le [BytesLabels]	`set_int32_le b i v` 將 `b` 從位元組索引 `i` 開始的小端 32 位元整數設定為 `v`。
set_int32_le [Bytes]	`set_int32_le b i v` 將 `b` 從位元組索引 `i` 開始的小端 32 位元整數設定為 `v`。
set_int32_ne [BytesLabels]	`set_int32_ne b i v` 將 `b` 從位元組索引 `i` 開始的原生端 32 位元整數設定為 `v`。
set_int32_ne [Bytes]	`set_int32_ne b i v` 將 `b` 從位元組索引 `i` 開始的原生端 32 位元整數設定為 `v`。
set_int64_be [BytesLabels]	`set_int64_be b i v` 將 `b` 從位元組索引 `i` 開始的大端 64 位元整數設定為 `v`。
set_int64_be [Bytes]	`set_int64_be b i v` 將 `b` 從位元組索引 `i` 開始的大端 64 位元整數設定為 `v`。
set_int64_le [BytesLabels]	`set_int64_le b i v` 將 `b` 從位元組索引 `i` 開始的小端 64 位元整數設定為 `v`。
set_int64_le [Bytes]	`set_int64_le b i v` 將 `b` 從位元組索引 `i` 開始的小端 64 位元整數設定為 `v`。
set_int64_ne [BytesLabels]	`set_int64_ne b i v` 將 `b` 從位元組索引 `i` 開始的原生端 64 位元整數設定為 `v`。
set_int64_ne [Bytes]	`set_int64_ne b i v` 將 `b` 從位元組索引 `i` 開始的原生端 64 位元整數設定為 `v`。
set_int8 [BytesLabels]	`set_int8 b i v` 將 `b` 從位元組索引 `i` 開始的有符號 8 位元整數設定為 `v`。
set_int8 [Bytes]	`set_int8 b i v` 將 `b` 從位元組索引 `i` 開始的有符號 8 位元整數設定為 `v`。
set_key [Obj.Ephemeron]
set_margin [Format]	`pp_set_margin ppf d` 將右邊界設定為 `d` (以字元為單位)：美觀列印器會根據給定的斷行提示分割超出右邊界的行。
set_mark_tags [Format]	`pp_set_mark_tags ppf b` 開啟或關閉標籤標記操作。
set_max_boxes [Format]	`pp_set_max_boxes ppf max` 設定同時打開的美觀列印框的最大數量。
set_max_indent [Format]	`pp_set_max_indent ppf d` 將行的最大縮排限制設定為 `d` (以字元為單位)：一旦達到此限制，除非封閉框完全適合目前行，否則新的美觀列印框會被拒絕到左側。
set_method [CamlinternalOO]
set_methods [CamlinternalOO]
set_nonblock [UnixLabels]	在給定的描述符上設定 ``non-blocking'' 標誌。
set_nonblock [Unix]	在給定的描述符上設定 ``non-blocking'' 標誌。
set_position [Lexing]	將 `lexbuf` 的初始追蹤輸入位置設定為自訂值。
set_print_tags [Format]	`pp_set_print_tags ppf b` 開啟或關閉標籤列印操作。
set_raw_field [Obj]
set_signal [Sys]	與 `Sys.signal` 相同，但忽略傳回值。
set_state [Random]	`set_state s` 透過將狀態 `s` 複製到目前的網域本地產生器 (基本函數使用) 來更新其狀態。
set_tab [Format]	在目前的插入點設定跳格標記。
set_tags [Format]	`pp_set_tags ppf b` 開啟或關閉語義標籤的處理 (預設為關閉)。
set_temp_dir_name [Filename]	變更 `Filename.get_temp_dir_name` 所返回，以及 `Filename.temp_file` 和 `Filename.open_temp_file` 所使用的暫存目錄。
set_trace [Parsing]	控制 `ocamlyacc` 產生的剖析器的除錯支援。
set_uint16_be [BytesLabels]	`set_uint16_be b i v` 將 `b` 中從位元組索引 `i` 開始的大端序無號 16 位元整數設定為 `v`。
set_uint16_be [Bytes]	`set_uint16_be b i v` 將 `b` 中從位元組索引 `i` 開始的大端序無號 16 位元整數設定為 `v`。
set_uint16_le [BytesLabels]	`set_uint16_le b i v` 將 `b` 中從位元組索引 `i` 開始的小端序無號 16 位元整數設定為 `v`。
set_uint16_le [Bytes]	`set_uint16_le b i v` 將 `b` 中從位元組索引 `i` 開始的小端序無號 16 位元整數設定為 `v`。
set_uint16_ne [BytesLabels]	`set_uint16_ne b i v` 將 `b` 中從位元組索引 `i` 開始的原生端序無號 16 位元整數設定為 `v`。
set_uint16_ne [Bytes]	`set_uint16_ne b i v` 將 `b` 中從位元組索引 `i` 開始的原生端序無號 16 位元整數設定為 `v`。
set_uint8 [BytesLabels]	`set_uint8 b i v` 將 `b` 中從位元組索引 `i` 開始的無號 8 位元整數設定為 `v`。
set_uint8 [Bytes]	`set_uint8 b i v` 將 `b` 中從位元組索引 `i` 開始的無號 8 位元整數設定為 `v`。
set_uncaught_exception_handler [Thread]	`Thread.set_uncaught_exception_handler fn` 將 `fn` 註冊為未捕獲例外狀況的處理常式。
set_uncaught_exception_handler [Printexc]	`Printexc.set_uncaught_exception_handler fn` 將 `fn` 註冊為未捕獲例外狀況的處理常式。
set_utf_16be_uchar [BytesLabels]	`set_utf_16be_uchar b i u` 在 `b` 中索引 `i` 的位置進行 UTF-16BE 編碼 `u`，並返回從 `i` 開始寫入的位元組數 `n`。
set_utf_16be_uchar [Bytes]	`set_utf_16be_uchar b i u` 在 `b` 中索引 `i` 的位置進行 UTF-16BE 編碼 `u`，並返回從 `i` 開始寫入的位元組數 `n`。
set_utf_16le_uchar [BytesLabels]	`set_utf_16le_uchar b i u` 在 `b` 中索引 `i` 的位置進行 UTF-16LE 編碼 `u`，並返回從 `i` 開始寫入的位元組數 `n`。
set_utf_16le_uchar [Bytes]	`set_utf_16le_uchar b i u` 在 `b` 中索引 `i` 的位置進行 UTF-16LE 編碼 `u`，並返回從 `i` 開始寫入的位元組數 `n`。
set_utf_8_uchar [BytesLabels]	`set_utf_8_uchar b i u` 在 `b` 中索引 `i` 的位置進行 UTF-8 編碼 `u`，並返回從 `i` 開始寫入的位元組數 `n`。
set_utf_8_uchar [Bytes]	`set_utf_8_uchar b i u` 在 `b` 中索引 `i` 的位置進行 UTF-8 編碼 `u`，並返回從 `i` 開始寫入的位元組數 `n`。
setgid [UnixLabels]	設定程序的實際群組 ID 和有效群組 ID。
setgid [Unix]	設定程序的實際群組 ID 和有效群組 ID。
setgroups [UnixLabels]	`setgroups groups` 設定調用程序的補充群組 ID。
setgroups [Unix]	`setgroups groups` 設定調用程序的補充群組 ID。
setitimer [UnixLabels]	`setitimer t s` 設定間隔計時器 `t` 並返回其先前的狀態。
setitimer [Unix]	`setitimer t s` 設定間隔計時器 `t` 並返回其先前的狀態。
setsid [UnixLabels]	將調用程序放入新的會話中，並使其與其控制終端分離。
setsid [Unix]	將調用程序放入新的會話中，並使其與其控制終端分離。
setsockopt [UnixLabels]	設定或清除給定 socket 中的布林值選項。
setsockopt [Unix]	設定或清除給定 socket 中的布林值選項。
setsockopt_float [UnixLabels]	與 `UnixLabels.setsockopt` 相同，用於其值為浮點數的 socket 選項。
setsockopt_float [Unix]	與 `Unix.setsockopt` 相同，用於其值為浮點數的 socket 選項。
setsockopt_int [UnixLabels]	與 `UnixLabels.setsockopt` 相同，用於整數值的 socket 選項。
setsockopt_int [Unix]	與 `Unix.setsockopt` 相同，用於整數值的 socket 選項。
setsockopt_optint [UnixLabels]	與 `UnixLabels.setsockopt` 相同，用於其值為 `int option` 的 socket 選項。
setsockopt_optint [Unix]	與 `Unix.setsockopt` 相同，用於其值為 `int option` 的 socket 選項。
setuid [UnixLabels]	設定程序的實際使用者 ID 和有效使用者 ID。
setuid [Unix]	設定程序的實際使用者 ID 和有效使用者 ID。
shift_left [Nativeint]	`Nativeint.shift_left x y` 將 `x` 向左位移 `y` 位元。
shift_left [Int64]	`Int64.shift_left x y` 將 `x` 向左位移 `y` 位元。
shift_left [Int32]	`Int32.shift_left x y` 將 `x` 向左位移 `y` 位元。
shift_left [Int]	`shift_left x n` 將 `x` 向左位移 `n` 位元。
shift_right [Nativeint]	`Nativeint.shift_right x y` 將 `x` 向右位移 `y` 位元。
shift_right [Int64]	`Int64.shift_right x y` 將 `x` 向右位移 `y` 位元。
shift_right [Int32]	`Int32.shift_right x y` 將 `x` 向右位移 `y` 位元。
shift_right [Int]	`shift_right x n` 將 `x` 向右位移 `n` 位元。
shift_right_logical [Nativeint]	`Nativeint.shift_right_logical x y` 將 `x` 向右位移 `y` 位元。
shift_right_logical [Int64]	`Int64.shift_right_logical x y` 將 `x` 向右位移 `y` 位元。
shift_right_logical [Int32]	`Int32.shift_right_logical x y` 將 `x` 向右位移 `y` 位元。
shift_right_logical [Int]	`shift_right x n` 將 `x` 向右位移 `n` 位元。
shuffle [Float.ArrayLabels]	`shuffle ~rand a` 使用 `rand` 作為隨機性來源，隨機排列 `a` 的元素。
shuffle [Float.Array]	`shuffle rand a` 使用 `rand` 作為隨機性來源，隨機排列 `a` 的元素。
shuffle [ArrayLabels]	`shuffle ~rand a` 使用 `rand` 作為隨機性來源，隨機排列 `a` 的元素。
shuffle [Array]	`shuffle rand a` 使用 `rand` 作為隨機性來源，隨機排列 `a` 的元素。
shutdown [UnixLabels]	關閉 socket 連線。
shutdown [Unix]	關閉 socket 連線。
shutdown_connection [UnixLabels]	「關閉」使用 `UnixLabels.open_connection` 建立的連線；也就是說，向在連線另一端讀取的伺服器傳輸檔案結束狀況。
shutdown_connection [Unix]	「關閉」使用 `Unix.open_connection` 建立的連線；也就是說，向在連線另一端讀取的伺服器傳輸檔案結束狀況。
sigabrt [Sys]	異常終止
sigalrm [Sys]	逾時
sigbus [Sys]	匯流排錯誤
sigchld [Sys]	子程序終止
sigcont [Sys]	繼續
sigfpe [Sys]	算術例外
sighup [Sys]	掛斷控制終端
sigill [Sys]	無效的硬體指令
sigint [Sys]	互動式中斷 (ctrl-C)
sigkill [Sys]	終止 (無法忽略)
sigmask [Thread]	`sigmask cmd sigs` 變更呼叫執行緒的已封鎖訊號集。
sign_bit [Float]	`sign_bit x` 若且唯若 `x` 的符號位元已設定，則為 `true`。
signal [Sys]	設定系統在收到指定訊號時的行為。
signal [Condition]	`signal c` 喚醒等待在條件變數 `c` 上的其中一個執行緒（如果有的話）。
signaling_nan [Float]	發出訊號的 NaN。
sigpending [UnixLabels]	傳回目前處於擱置狀態的已封鎖訊號集。
sigpending [Unix]	傳回目前處於擱置狀態的已封鎖訊號集。
sigpipe [Sys]	管道破裂
sigpoll [Sys]	可輪詢事件
sigprocmask [UnixLabels]	`sigprocmask ~mode sigs` 變更已封鎖訊號的集合。
sigprocmask [Unix]	`sigprocmask mode sigs` 變更已封鎖訊號的集合。
sigprof [Sys]	效能分析中斷
sigquit [Sys]	互動式終止
sigsegv [Sys]	無效的記憶體參考
sigstop [Sys]	停止
sigsuspend [UnixLabels]	`sigsuspend sigs` 將已封鎖訊號原子性地設定為 `sigs`，並等待傳遞未忽略、未封鎖的訊號。
sigsuspend [Unix]	`sigsuspend sigs` 將已封鎖訊號原子性地設定為 `sigs`，並等待傳遞未忽略、未封鎖的訊號。
sigsys [Sys]	常式的錯誤引數
sigterm [Sys]	終止
sigtrap [Sys]	追蹤/中斷點陷阱
sigtstp [Sys]	互動式停止
sigttin [Sys]	背景處理序從終端讀取
sigttou [Sys]	背景處理序寫入終端
sigurg [Sys]	socket 上的緊急狀況
sigusr1 [Sys]	應用程式定義的訊號 1
sigusr2 [Sys]	應用程式定義的訊號 2
sigvtalrm [Sys]	虛擬時間逾時
sigxcpu [Sys]	CPU 時間逾時
sigxfsz [Sys]	超出檔案大小限制
sin [Stdlib]	正弦函數。
sin [Float]	正弦函數。
single_write [UnixLabels]	與 `UnixLabels.write` 相同，但嘗試只寫入一次。
single_write [Unix]	與 `Unix.write` 相同，但嘗試只寫入一次。
single_write_bigarray [UnixLabels]	與 `UnixLabels.single_write` 相同，但從 bigarray 取得資料。
single_write_bigarray [Unix]	與 `Unix.single_write` 相同，但從 bigarray 取得資料。
single_write_substring [UnixLabels]	與 `UnixLabels.single_write` 相同，但從字串而非位元組序列取得資料。
single_write_substring [Unix]	與 `Unix.single_write` 相同，但從字串而非位元組序列取得資料。
singleton [Set.S]	`singleton x` 傳回僅包含 `x` 的單元素集合。
singleton [MoreLabels.Set.S]	`singleton x` 傳回僅包含 `x` 的單元素集合。
singleton [MoreLabels.Map.S]	`singleton x y` 傳回包含 `x` 的繫結 `y` 的單元素映射。
singleton [Map.S]	`singleton x y` 傳回包含 `x` 的繫結 `y` 的單元素映射。
sinh [Stdlib]	雙曲正弦函數。
sinh [Float]	雙曲正弦函數。
size [Obj]
size [Nativeint]	原生整數的大小（以位元為單位）。
size_in_bytes [Bigarray.Array3]	`size_in_bytes a` 是 `a` 中元素數量乘以 `a` 的 `Bigarray.kind_size_in_bytes`。
size_in_bytes [Bigarray.Array2]	`size_in_bytes a` 是 `a` 中元素數量乘以 `a` 的 `Bigarray.kind_size_in_bytes`。
size_in_bytes [Bigarray.Array1]	`size_in_bytes a` 是 `a` 中元素數量乘以 `a` 的 `Bigarray.kind_size_in_bytes`。
size_in_bytes [Bigarray.Array0]	`size_in_bytes a` 是 `a` 的 `Bigarray.kind_size_in_bytes`。
size_in_bytes [Bigarray.Genarray]	`size_in_bytes a` 是 `a` 中元素數量乘以 `a` 的 `Bigarray.kind_size_in_bytes`。
sleep [UnixLabels]	停止執行指定秒數。
sleep [Unix]	停止執行指定秒數。
sleepf [UnixLabels]	停止執行指定秒數。
sleepf [Unix]	停止執行指定秒數。
slice [Bigarray.Array1]	從給定的一維 Bigarray 擷取純量（零維切片）。
slice_left [Bigarray.Array2]	從給定的二維 Bigarray 擷取一列（一維切片）。
slice_left [Bigarray.Genarray]	透過固定一個或數個最前（最左側）的座標，從給定的 Bigarray 擷取較低維度的子陣列。
slice_left_1 [Bigarray.Array3]	透過固定前兩個座標，從給定的三維 Bigarray 擷取一維切片。
slice_left_2 [Bigarray.Array3]	透過固定第一個座標，從給定的三維 Bigarray 擷取二維切片。
slice_right [Bigarray.Array2]	從給定的二維 Bigarray 擷取一欄（一維切片）。
slice_right [Bigarray.Genarray]	透過固定一個或數個最後（最右側）的座標，從給定的 Bigarray 擷取較低維度的子陣列。
slice_right_1 [Bigarray.Array3]	透過固定最後兩個座標，從給定的三維 Bigarray 擷取一維切片。
slice_right_2 [Bigarray.Array3]	透過固定最後一個座標，從給定的三維 Bigarray 擷取二維切片。
snd [Stdlib]	傳回配對的第二個元件。
socket [UnixLabels]	在給定的網域中，使用指定的類型建立新的 socket。
socket [Unix]	在給定的網域中，使用指定的類型建立新的 socket。
socketpair [UnixLabels]	建立一對未命名且連接在一起的 socket。
socketpair [Unix]	建立一對未命名且連接在一起的 socket。
some [Option]	`some v` 為 `Some v`。
sort [ListLabels]	根據比較函式，以遞增順序排序清單。
sort [List]	根據比較函式，以遞增順序排序清單。
sort [Float.ArrayLabels]	根據比較函式，以遞增順序排序 floatarray。
sort [Float.Array]	根據比較函式，以遞增順序排序 floatarray。
sort [ArrayLabels]	根據比較函式，以遞增順序排序陣列。
sort [Array]	根據比較函式，以遞增順序排序陣列。
sort_uniq [ListLabels]	與 `ListLabels.sort` 相同，但也會移除重複項目。
sort_uniq [List]	與 `List.sort` 相同，但也會移除重複項目。
sorted_merge [Seq]	如果序列 `xs` 和 `ys` 根據總預序 `cmp` 排序，則 `sorted_merge cmp xs ys` 是合併序列 `xs` 和 `ys` 所獲得的排序序列。
span [Runtime_events.Type]	具有開始和結束的事件。
spawn [Domain]	`spawn f` 建立與目前網域平行執行的新網域。
split [Str]	`split r s` 將 `s` 分割成子字串，以符合 `r` 的子字串作為分隔符號，並傳回子字串清單。
split [Set.S]	`split x s` 傳回一個三元組 `(l, present, r)`，其中 `l` 是 `s` 中嚴格小於 `x` 的元素集合；`r` 是 `s` 中嚴格大於 `x` 的元素集合；如果 `s` 沒有包含等於 `x` 的元素，則 `present` 為 `false`，如果 `s` 包含等於 `x` 的元素，則為 `true`。
split [Seq]	`split` 是 `unzip` 的別名。
split [Random.State]	從給定的 PRNG 狀態繪製新的 PRNG 狀態。
split [Random]	從預設函式使用的網域本機產生器的目前狀態繪製新的 PRNG 狀態。
split [MoreLabels.Set.S]	`split x s` 傳回一個三元組 `(l, present, r)`，其中 `l` 是 `s` 中嚴格小於 `x` 的元素集合；`r` 是 `s` 中嚴格大於 `x` 的元素集合；如果 `s` 沒有包含等於 `x` 的元素，則 `present` 為 `false`，如果 `s` 包含等於 `x` 的元素，則為 `true`。
split [MoreLabels.Map.S]	`split x m` 傳回一個三元組 `(l, data, r)`，其中 `l` 是一個 map，包含 `m` 中鍵值嚴格小於 `x` 的所有綁定；`r` 是一個 map，包含 `m` 中鍵值嚴格大於 `x` 的所有綁定；如果 `m` 沒有 `x` 的綁定，則 `data` 為 `None`，否則，若 `m` 將 `v` 綁定到 `x`，則 `data` 為 `Some v`。
split [Map.S]	`split x m` 傳回一個三元組 `(l, data, r)`，其中 `l` 是一個 map，包含 `m` 中鍵值嚴格小於 `x` 的所有綁定；`r` 是一個 map，包含 `m` 中鍵值嚴格大於 `x` 的所有綁定；如果 `m` 沒有 `x` 的綁定，則 `data` 為 `None`，否則，若 `m` 將 `v` 綁定到 `x`，則 `data` 為 `Some v`。
split [ListLabels]	將成對的列表轉換為成對的列表：`split [(a1,b1); ...; (an,bn)]` 為 `([a1; ...; an], [b1; ...; bn])`。
split [List]	將成對的列表轉換為成對的列表：`split [(a1,b1); ...; (an,bn)]` 為 `([a1; ...; an], [b1; ...; bn])`。
split [ArrayLabels]	`split [\|(a1,b1); ...; (an,bn)\|]` 為 `([\|a1; ...; an\|], [\|b1; ...; bn\|])`。
split [Array]	`split [\|(a1,b1); ...; (an,bn)\|]` 為 `([\|a1; ...; an\|], [\|b1; ...; bn\|])`。
split_delim [Str]	與 `Str.split` 相同，但會識別字串開頭和結尾的分隔符號，並將其作為空字串傳回結果中。
split_on_char [String]	`split_on_char sep s` 是 `s` 中所有（可能為空）子字串的列表，這些子字串以字元 `sep` 分隔。
split_on_char [StringLabels]	`split_on_char ~sep s` 是 `s` 中所有（可能為空）子字串的列表，這些子字串以字元 `sep` 分隔。
split_on_char [BytesLabels]	`split_on_char sep s` 傳回 `s` 中所有（可能為空）子序列的列表，這些子序列以 `sep` 字元分隔。
split_on_char [Bytes]	`split_on_char sep s` 傳回 `s` 中所有（可能為空）子序列的列表，這些子序列以 `sep` 字元分隔。
sprintf [Printf]	與 `Printf.fprintf` 相同，但不是列印到輸出通道，而是傳回一個字串，其中包含格式化參數的結果。
sprintf [Format]	與上面的 `printf` 相同，但不是列印在格式器上，而是傳回一個包含引數格式化結果的字串。
sqrt [Stdlib]	平方根。
sqrt [Float]	平方根。
sqrt [Complex]	平方根。
sscanf [Scanf]	與 `Scanf.bscanf` 相同，但是從給定的字串讀取。
sscanf_format [Scanf]	與 `Scanf.bscanf_format` 相同，但是從給定的字串讀取。
sscanf_opt [Scanf]	與 `Scanf.sscanf` 相同，但在掃描失敗的情況下傳回 `None`。
stable_sort [ListLabels]	與 `ListLabels.sort` 相同，但保證排序演算法是穩定的（即。
stable_sort [List]	與 `List.sort` 相同，但保證排序演算法是穩定的（即。
stable_sort [Float.ArrayLabels]	與 `Float.ArrayLabels.sort` 相同，但排序演算法是穩定的（即。
stable_sort [Float.Array]	與 `Float.Array.sort` 相同，但排序演算法是穩定的（即。
stable_sort [ArrayLabels]	與 `ArrayLabels.sort` 相同，但排序演算法是穩定的（即。
stable_sort [Array]	與 `Array.sort` 相同，但排序演算法是穩定的（即。
start [Runtime_events]	如果尚未開始，`start ()` 將啟動運行時的事件收集。
start [Gc.Memprof]	使用給定的參數開始分析。
starts_with [String]	當且僅當 `s` 以 `prefix` 開頭時，`starts_with` `~prefix s` 為 `true`。
starts_with [StringLabels]	當且僅當 `s` 以 `prefix` 開頭時，`starts_with` `~prefix s` 為 `true`。
starts_with [BytesLabels]	當且僅當 `s` 以 `prefix` 開頭時，`starts_with` `~prefix s` 為 `true`。
starts_with [Bytes]	當且僅當 `s` 以 `prefix` 開頭時，`starts_with` `~prefix s` 為 `true`。
stat [UnixLabels.LargeFile]
stat [UnixLabels]	傳回指定檔案的資訊。
stat [Unix.LargeFile]
stat [Unix]	傳回指定檔案的資訊。
stat [Gc]	在表示程式總記憶體統計的 `stat` 記錄中傳回記憶體管理計數器的當前值。
stats [CamlinternalOO]
stats [Weak.S]	傳回表格的統計資訊。
stats [MoreLabels.Hashtbl.SeededS]
stats [MoreLabels.Hashtbl.S]
stats [MoreLabels.Hashtbl]	`Hashtbl.stats tbl` 傳回有關表格 `tbl` 的統計資訊：桶的數量、最大桶的大小、按大小劃分的桶的分配。
stats [Hashtbl.SeededS]
stats [Hashtbl.S]
stats [Hashtbl]	`Hashtbl.stats tbl` 傳回有關表格 `tbl` 的統計資訊：桶的數量、最大桶的大小、按大小劃分的桶的分配。
stats [Ephemeron.SeededS]
stats [Ephemeron.S]
stats_alive [Ephemeron.SeededS]	與 `Hashtbl.SeededS.stats` 相同，但僅計算存活的綁定
stats_alive [Ephemeron.S]	與 `Hashtbl.SeededS.stats` 相同，但僅計算存活的綁定
std_formatter [Format]	初始網域的標準格式化程式，用於寫入標準輸出。
stdbuf [Format]	初始網域的字串緩衝區，`str_formatter` 將寫入此緩衝區。
stderr [UnixLabels]	標準錯誤的檔案描述符。
stderr [Unix]	標準錯誤的檔案描述符。
stderr [Stdlib]	程序的標準錯誤輸出。
stderr [Out_channel]	程序的標準錯誤輸出。
stdin [UnixLabels]	標準輸入的檔案描述符。
stdin [Unix]	標準輸入的檔案描述符。
stdin [Stdlib]	程序的標準輸入。
stdin [Scanf.Scanning]	`Scanf` 模組的標準輸入概念。
stdin [In_channel]	程序的標準輸入。
stdout [UnixLabels]	標準輸出的檔案描述符。
stdout [Unix]	標準輸出的檔案描述符。
stdout [Stdlib]	程序的標準輸出。
stdout [Out_channel]	程序的標準輸出。
stop [Gc.Memprof]	停止目前設定檔的取樣。
str_formatter [Format]	初始網域的格式化程式，用於輸出到 `Format.stdbuf` 字串緩衝區。
string [Digest.S]	傳回給定字串的摘要。
string [Digest]	傳回給定字串的摘要。
string_after [Str]	`string_after s n` 傳回 `s` 中位置 `n` 之後的所有字元的子字串（包括位置 `n` 上的字元）。
string_before [Str]	`string_before s n` 傳回 `s` 中位置 `n` 之前的所有字元的子字串（不包括位置 `n` 上的字元）。
string_match [Str]	`string_match r s start` 測試從位置 `start` 開始的 `s` 子字串是否與正規表示式 `r` 相符。
string_of_bool [Stdlib]	傳回布林值的字串表示形式。
string_of_float [Stdlib]	傳回浮點數的字串表示形式。
string_of_fmt [CamlinternalFormat]
string_of_fmtty [CamlinternalFormat]
string_of_format [Stdlib]	將格式字串轉換為字串。
string_of_formatting_lit [CamlinternalFormat]
string_of_inet_addr [UnixLabels]	傳回給定網際網路位址的可列印表示形式。
string_of_inet_addr [Unix]	傳回給定網際網路位址的可列印表示形式。
string_of_int [Stdlib]	傳回整數的字串表示形式（十進制）。
string_partial_match [Str]	與 `Str.string_match` 類似，但如果參數字串是符合比對的字串前綴，也會傳回 true。
string_tag [Obj]
strput_acc [CamlinternalFormat]
sub [String]	`sub s pos len` 是一個長度為 `len` 的字串，其中包含 `s` 的子字串，該子字串從位置 `pos` 開始，長度為 `len`。
sub [StringLabels]	`sub s ~pos ~len` 是一個長度為 `len` 的字串，其中包含 `s` 的子字串，該子字串從位置 `pos` 開始，長度為 `len`。
sub [Nativeint]	減法。
sub [Int64]	減法。
sub [Int32]	減法。
sub [Int]	`sub x y` 是減法 `x - y`。
sub [Float.ArrayLabels]	`sub a ~pos ~len` 返回一個長度為 `len` 的新浮點數陣列，其中包含浮點數陣列 `a` 中編號從 `pos` 到 `pos + len - 1` 的元素。
sub [Float.Array]	`sub a pos len` 返回一個長度為 `len` 的新浮點數陣列，其中包含浮點數陣列 `a` 中編號從 `pos` 到 `pos + len - 1` 的元素。
sub [Float]	浮點數減法。
sub [Complex]	減法
sub [BytesLabels]	`sub s ~pos ~len` 返回一個長度為 `len` 的新位元組序列，其中包含 `s` 中從位置 `pos` 開始、長度為 `len` 的子序列。
sub [Bytes]	`sub s pos len` 返回一個長度為 `len` 的新位元組序列，其中包含 `s` 中從位置 `pos` 開始、長度為 `len` 的子序列。
sub [Buffer]	`Buffer.sub b off len` 返回緩衝區 `b` 當前內容的 `len` 個位元組的副本，從偏移量 `off` 開始。
sub [Bigarray.Array1]	提取給定的一維 Bigarray 的子陣列。
sub [ArrayLabels]	`sub a ~pos ~len` 返回一個長度為 `len` 的新陣列，其中包含陣列 `a` 中編號從 `pos` 到 `pos + len - 1` 的元素。
sub [Array]	`sub a pos len` 返回一個長度為 `len` 的新陣列，其中包含陣列 `a` 中編號從 `pos` 到 `pos + len - 1` 的元素。
sub_left [Bigarray.Array3]	通過限制第一個維度，提取給定的三維 Bigarray 的三維子陣列。
sub_left [Bigarray.Array2]	通過限制第一個維度，提取給定的二維 Bigarray 的二維子陣列。
sub_left [Bigarray.Genarray]	通過限制第一個（最左邊的）維度，提取給定的 Bigarray 的子陣列。
sub_right [Bigarray.Array3]	通過限制第二個維度，提取給定的三維 Bigarray 的三維子陣列。
sub_right [Bigarray.Array2]	通過限制第二個維度，提取給定的二維 Bigarray 的二維子陣列。
sub_right [Bigarray.Genarray]	通過限制最後一個（最右邊的）維度，提取給定的 Bigarray 的子陣列。
sub_string [BytesLabels]	與 `BytesLabels.sub` 相同，但返回字串而不是位元組序列。
sub_string [Bytes]	與 `Bytes.sub` 相同，但返回字串而不是位元組序列。
subbytes [Digest.S]	`subbytes s ofs len` 返回 `s` 中從索引 `ofs` 開始、包含 `len` 個位元組的子序列的摘要。
subbytes [Digest]	`Digest.subbytes s ofs len` 返回 `s` 中從索引 `ofs` 開始、包含 `len` 個位元組的子序列的摘要。
subset [Set.S]	`subset s1 s2` 測試集合 `s1` 是否為集合 `s2` 的子集。
subset [MoreLabels.Set.S]	`subset s1 s2` 測試集合 `s1` 是否為集合 `s2` 的子集。
substitute_first [Str]	與 `Str.global_substitute` 相同，但只替換第一個與正則表達式匹配的子字串。
substring [Digest.S]	`substring s ofs len` 返回 `s` 中從索引 `ofs` 開始、包含 `len` 個字元的子字串的摘要。
substring [Digest]	`Digest.substring s ofs len` 返回 `s` 中從索引 `ofs` 開始、包含 `len` 個字元的子字串的摘要。
succ [Uchar]	`succ u` 是 Unicode 標量值集中 `u` 之後的標量值。
succ [Stdlib]	`succ x` 是 `x + 1`。
succ [Nativeint]	後繼值。
succ [Int64]	後繼值。
succ [Int32]	後繼值。
succ [Int]	`succ x` 是 `add x 1`。
succ [Float]	`succ x` 返回緊接在 `x` 之後的浮點數，即大於 `x` 的最小浮點數。
symbol_end [Parsing]	請參閱 `Parsing.symbol_start`。
symbol_end_pos [Parsing]	與 `symbol_end` 相同，但返回 `position` 而不是偏移量。
symbol_start [Parsing]	`symbol_start` 和 `Parsing.symbol_end` 只能在文法規則的動作部分中呼叫。
symbol_start_pos [Parsing]	與 `symbol_start` 相同，但返回 `position` 而不是偏移量。
symlink [UnixLabels]	`symlink ?to_dir ~src ~dst` 建立檔案 `dst` 作為指向檔案 `src` 的符號連結。
symlink [Unix]	`symlink ?to_dir src dst` 建立檔案 `dst` 作為指向檔案 `src` 的符號連結。
symm [CamlinternalFormat]
sync [Event]	在事件上「同步」：將事件中指定的所有通訊可能性提供給外部世界，並阻塞直到其中一個通訊成功。
synchronized_formatter_of_out_channel [Format]	`synchronized_formatter_of_out_channel oc` 返回網域本機狀態的索引鍵，該索引鍵保存用於寫入相應輸出通道 `oc` 的網域本機格式化程式。
system [UnixLabels]	執行給定的命令，等待其終止，並返回其終止狀態。
system [Unix]	執行給定的命令，等待其終止，並返回其終止狀態。
T
tag [Runtime_events.User]	`tag t` 是事件 `t` 的關聯標籤（如果已知）。
tag [Obj]
take [Seq]	`take n xs` 是 `xs` 的前 `n` 個元素的序列。
take [Queue]	`take q` 移除並返回佇列 `q` 中的第一個元素，如果佇列為空，則引發 `Queue.Empty` 異常。
take_opt [Queue]	`take_opt q` 移除並返回佇列 `q` 中的第一個元素，如果佇列為空，則返回 `None`。
take_while [Seq]	`take_while p xs` 是序列 `xs` 的最長前綴，其中每個元素 `x` 都滿足 `p x`。
tan [Stdlib]	正切。
tan [Float]	正切。
tanh [Stdlib]	雙曲正切。
tanh [Float]	雙曲正切。
tcdrain [UnixLabels]	等待直到在給定的檔案描述符上寫入的所有輸出都已傳輸。
tcdrain [Unix]	等待直到在給定的檔案描述符上寫入的所有輸出都已傳輸。
tcflow [UnixLabels]	根據第二個引數，暫停或重新啟動在給定檔案描述符上接收或傳輸資料：`TCOOFF` 暫停輸出，`TCOON` 重新啟動輸出，`TCIOFF` 傳輸 STOP 字元以暫停輸入，而 `TCION` 傳輸 START 字元以重新啟動輸入。
tcflow [Unix]	根據第二個引數，暫停或重新啟動在給定檔案描述符上接收或傳輸資料：`TCOOFF` 暫停輸出，`TCOON` 重新啟動輸出，`TCIOFF` 傳輸 STOP 字元以暫停輸入，而 `TCION` 傳輸 START 字元以重新啟動輸入。
tcflush [UnixLabels]	根據第二個引數，丟棄寫入到給定檔案描述符但尚未傳輸的資料，或接收但尚未讀取的資料：`TCIFLUSH` 清除接收但未讀取的資料，`TCOFLUSH` 清除寫入但未傳輸的資料，而 `TCIOFLUSH` 則清除兩者。
tcflush [Unix]	根據第二個引數，丟棄寫入到給定檔案描述符但尚未傳輸的資料，或接收但尚未讀取的資料：`TCIFLUSH` 清除接收但未讀取的資料，`TCOFLUSH` 清除寫入但未傳輸的資料，而 `TCIOFLUSH` 則清除兩者。
tcgetattr [UnixLabels]	返回給定檔案描述符所引用的終端機狀態。
tcgetattr [Unix]	返回給定檔案描述符所引用的終端機狀態。
tcsendbreak [UnixLabels]	在給定的檔案描述符上傳送中斷條件。
tcsendbreak [Unix]	在給定的檔案描述符上傳送中斷條件。
tcsetattr [UnixLabels]	設定給定檔案描述符所引用的終端機狀態。
tcsetattr [Unix]	設定給定檔案描述符所引用的終端機狀態。
temp_dir [Filename]	`temp_dir prefix suffix` 在 `temp_dir` 內部建立並返回具有權限 `perms` (預設為 0o700) 的新暫存目錄的名稱。
temp_file [Filename]	`temp_file prefix suffix` 返回暫存目錄中新暫存檔案的名稱。
time [UnixLabels]	返回自 GMT 1 月 1 日 00:00:00 以來的目前時間。
time [Unix]	返回自 GMT 1 月 1 日 00:00:00 以來的目前時間。
time [Sys]	返回程式自執行開始以來使用的處理器時間 (以秒為單位)。
times [UnixLabels]	返回程序的執行時間。
times [Unix]	返回程序的執行時間。
tl [ListLabels]	傳回不含第一個元素的指定列表。
tl [List]	傳回不含第一個元素的指定列表。
to_array [Dynarray]	`to_array a` 傳回對應於動態陣列 `a` 的固定大小陣列。
to_binary_string [Random.State]	將 PRNG 狀態序列化為不可變的位元組序列。
to_buffer [Marshal]	`Marshal.to_buffer buff ofs len v flags` 編列值 `v`，將其位元組表示形式儲存在序列 `buff` 中，從索引 `ofs` 開始，最多寫入 `len` 個位元組。
to_bytes [String]	回傳一個新的位元組序列，其中包含與給定字串相同的位元組。
to_bytes [StringLabels]	回傳一個新的位元組序列，其中包含與給定字串相同的位元組。
to_bytes [Marshal]	`Marshal.to_bytes v flags` 傳回包含 `v` 表示形式的位元組序列。
to_bytes [Buffer]	傳回緩衝區目前內容的副本。
to_channel [Marshal]	`Marshal.to_channel chan v flags` 將 `v` 的表示形式寫入通道 `chan`。
to_char [Uchar]	`to_char u` 是以 OCaml latin1 字元表示的 `u`。
to_dispenser [Seq]	`to_dispenser xs` 是序列 `xs` 上一個新的分配器。
to_float [Nativeint]	將指定的原生整數轉換為浮點數。
to_float [Int64]	將指定的 64 位元整數轉換為浮點數。
to_float [Int32]	將指定的 32 位元整數轉換為浮點數。
to_float [Int]	`to_float x` 是以浮點數表示的 `x`。
to_float [Bool]	`to_float b` 如果 `b` 為 `false`，則為 `0.`，如果 `b` 為 `true`，則為 `1.`。
to_hex [Digest.S]	傳回指定摘要的可列印十六進位表示形式。
to_hex [Digest]	傳回指定摘要的可列印十六進位表示形式。
to_int [Uchar]	`to_int u` 是以整數表示的 `u`。
to_int [Nativeint]	將指定的原生整數（類型 `nativeint`）轉換為整數（類型 `int`）。
to_int [Int64]	將指定的 64 位元整數（類型 `int64`）轉換為整數（類型 `int`）。
to_int [Int32]	將指定的 32 位元整數（類型 `int32`）轉換為整數（類型 `int`）。
to_int [Float]	將給定的浮點數截斷為整數。
to_int [Bool]	`to_int b` 如果 `b` 為 `false`，則為 `0`，如果 `b` 為 `true`，則為 `1`。
to_int32 [Nativeint]	將指定的原生整數轉換為 32 位元整數（類型 `int32`）。
to_int32 [Int64]	將指定的 64 位元整數（類型 `int64`）轉換為 32 位元整數（類型 `int32`）。
to_int64 [Runtime_events.Timestamp]
to_list [Set.S]	`to_list s` 為 `Set.S.elements` `s`。
to_list [Result]	`to_list r` 如果 `r` 為 `Ok v`，則為 `[v]`，否則為 `[]`。
to_list [Option]	`to_list o` 如果 `o` 為 `None`，則為 `[]`，如果 `o` 為 `Some v`，則為 `[v]`。
to_list [MoreLabels.Set.S]	`to_list s` 為 `MoreLabels.Set.S.elements` `s`。
to_list [MoreLabels.Map.S]	`to_list m` 為 `MoreLabels.Map.S.bindings` `m`。
to_list [Map.S]	`to_list m` 為 `Map.S.bindings` `m`。
to_list [Float.ArrayLabels]	`to_list a` 傳回 `a` 的所有元素所組成的列表。
to_list [Float.Array]	`to_list a` 傳回 `a` 的所有元素所組成的列表。
to_list [Dynarray]	`to_list a` 是一個包含陣列 `a` 中元素的列表。
to_list [ArrayLabels]	`to_list a` 傳回 `a` 的所有元素所組成的列表。
to_list [Array]	`to_list a` 傳回 `a` 的所有元素所組成的列表。
to_nativeint [Int64]	將指定的 64 位元整數（類型 `int64`）轉換為原生整數。
to_option [Result]	`to_option r` 是以選項形式表示的 `r`，將 `Ok v` 對應到 `Some v`，並將 `Error _` 對應到 `None`。
to_result [Option]	如果 `o` 為 `Some v`，則 `to_result ~none o` 為 `Ok v`，否則為 `Error none`。
to_rev_seq [Set.S]	以遞減順序逐一查看整個集合
to_rev_seq [MoreLabels.Set.S]	以遞減順序逐一查看整個集合
to_rev_seq [MoreLabels.Map.S]	以索引鍵的遞減順序逐一查看整個對應
to_rev_seq [Map.S]	以索引鍵的遞減順序逐一查看整個對應
to_seq [String]	`to_seq s` 是一個由字串字元依遞增順序組成的序列。
to_seq [StringLabels]	`to_seq s` 是一個由字串字元依遞增順序組成的序列。
to_seq [Stack]	由上到下逐一查看堆疊。
to_seq [Set.S]	以遞增順序逐一查看整個集合
to_seq [Result]	`to_seq r` 是以序列形式表示的 `r`。
to_seq [Queue]	以先後順序逐一查看佇列。
to_seq [Option]	`to_seq o` 是以序列形式表示的 `o`。
to_seq [MoreLabels.Set.S]	以遞增順序逐一查看整個集合
to_seq [MoreLabels.Map.S]	以索引鍵的遞增順序逐一查看整個對應
to_seq [MoreLabels.Hashtbl.SeededS]
to_seq [MoreLabels.Hashtbl.S]
to_seq [MoreLabels.Hashtbl]	逐一查看整個表格。
to_seq [Map.S]	以索引鍵的遞增順序逐一查看整個對應
to_seq [ListLabels]	逐一查看列表。
to_seq [List]	逐一查看列表。
to_seq [Hashtbl.SeededS]
to_seq [Hashtbl.S]
to_seq [Hashtbl]	逐一查看整個表格。
to_seq [Float.ArrayLabels]	以遞增順序逐一查看浮點數陣列。
to_seq [Float.Array]	以遞增順序逐一查看浮點數陣列。
to_seq [Dynarray]	`to_seq a` 是元素 `get a 0`、`get a 1`... 的序列。
to_seq [BytesLabels]	以遞增索引順序逐一查看字串。
to_seq [Bytes]	以遞增索引順序逐一查看字串。
to_seq [Buffer]	以遞增順序逐一查看緩衝區。
to_seq [ArrayLabels]	以遞增順序逐一查看陣列。
to_seq [Array]	以遞增順序逐一查看陣列。
to_seq_from [Set.S]	`to_seq_from x s` 以遞增順序，從 `x` 或以上逐一查看 `s` 的元素子集。
to_seq_from [MoreLabels.Set.S]	`to_seq_from x s` 以遞增順序，從 `x` 或以上逐一查看 `s` 的元素子集。
to_seq_from [MoreLabels.Map.S]	`to_seq_from k m` 以索引鍵的遞增順序，從索引鍵 `k` 或以上逐一查看 `m` 的繫結子集。
to_seq_from [Map.S]	`to_seq_from k m` 以索引鍵的遞增順序，從索引鍵 `k` 或以上逐一查看 `m` 的繫結子集。
to_seq_keys [MoreLabels.Hashtbl.SeededS]
to_seq_keys [MoreLabels.Hashtbl.S]
to_seq_keys [MoreLabels.Hashtbl]	與 `Seq.map fst (to_seq m)` 相同
to_seq_keys [Hashtbl.SeededS]
to_seq_keys [Hashtbl.S]
to_seq_keys [Hashtbl]	與 `Seq.map fst (to_seq m)` 相同
to_seq_reentrant [Dynarray]	`to_seq_reentrant a` 是 `Dynarray.to_seq` 的可重入變體，意即在 `a` 的長度變更後，仍然可以存取其元素。
to_seq_rev [Dynarray]	`to_seq_rev a` 是元素 `get a (l - 1)`、`get a (l - 2)`... 的序列。
to_seq_rev_reentrant [Dynarray]	`to_seq_rev_reentrant a` 是 `Dynarray.to_seq_rev` 的可重入變體，意即在 `a` 的長度變更後，仍然可以存取其元素。
to_seq_values [MoreLabels.Hashtbl.SeededS]
to_seq_values [MoreLabels.Hashtbl.S]
to_seq_values [MoreLabels.Hashtbl]	與 `Seq.map snd (to_seq m)` 相同
to_seq_values [Hashtbl.SeededS]
to_seq_values [Hashtbl.S]
to_seq_values [Hashtbl]	與 `Seq.map snd (to_seq m)` 相同
to_seqi [String]	`to_seqi s` 類似於 `String.to_seq`，但也包含對應的索引值。
to_seqi [StringLabels]	`to_seqi s` 類似於 `StringLabels.to_seq`，但也包含對應的索引值。
to_seqi [Float.ArrayLabels]	以遞增順序迭代浮點數組，同時產生元素及其索引。
to_seqi [Float.Array]	以遞增順序迭代浮點數組，同時產生元素及其索引。
to_seqi [BytesLabels]	以遞增順序迭代字串，同時產生字元及其索引。
to_seqi [Bytes]	以遞增順序迭代字串，同時產生字元及其索引。
to_seqi [Buffer]	以遞增順序迭代緩衝區，同時產生字元及其索引。
to_seqi [ArrayLabels]	以遞增順序迭代陣列，同時產生元素及其索引。
to_seqi [Array]	以遞增順序迭代陣列，同時產生元素及其索引。
to_string [Unit]	`to_string b` 為 `"()"`。
to_string [Printexc]	`Printexc.to_string e` 返回例外 `e` 的字串表示。
to_string [Nativeint]	以十進位返回其參數的字串表示。
to_string [Marshal]	與 `to_bytes` 相同，但返回字串而非位元組序列。
to_string [Int64]	以十進位返回其參數的字串表示。
to_string [Int32]	以有號十進位返回其參數的字串表示。
to_string [Int]	`to_string x` 是 `x` 的十進位寫入表示。
to_string [Float]	傳回浮點數的字串表示形式。
to_string [BytesLabels]	回傳一個新的字串，其中包含與給定的位元組序列相同的位元組。
to_string [Bytes]	回傳一個新的字串，其中包含與給定的位元組序列相同的位元組。
to_string [Bool]	如果 `b` 為 `true`，則 `to_string b` 為 `"true"`，如果 `b` 為 `false`，則為 `"false"`。
to_string_default [Printexc]	`Printexc.to_string_default e` 返回例外 `e` 的字串表示，忽略所有已註冊的例外印表機。
top [Stack]	`top s` 返回堆疊 `s` 的最頂層元素，如果堆疊為空則引發 `Stack.Empty` 例外。
top [Queue]	`top` 是 `peek` 的同義詞。
top_opt [Stack]	`top_opt s` 返回堆疊 `s` 的最頂層元素，如果堆疊為空則返回 `None`。
total_size [Marshal]	請參閱 `Marshal.header_size`。
trans [CamlinternalFormat]
transfer [Queue]	`transfer q1 q2` 將 `q1` 的所有元素加入到佇列 `q2` 的末尾，然後清空 `q1`。
transpose [Seq]	如果 `xss` 是一個矩陣（行的序列），則 `transpose xss` 是矩陣 `xss` 的列的序列。
trim [String]	`trim s` 是不帶開頭和結尾空白字元的 `s`。
trim [StringLabels]	`trim s` 是不帶開頭和結尾空白字元的 `s`。
trim [BytesLabels]	返回不帶開頭和結尾空白字元的參數副本。
trim [Bytes]	返回不帶開頭和結尾空白字元的參數副本。
trunc [Float]	`trunc x` 將 `x` 四捨五入到絕對值小於或等於 `x` 的最接近整數。
truncate [UnixLabels.LargeFile]	請參閱 `truncate`。
truncate [UnixLabels]	將指定檔案截斷至指定大小。
truncate [Unix.LargeFile]	請參閱 `truncate`。
truncate [Unix]	將指定檔案截斷至指定大小。
truncate [Stdlib]	與 `int_of_float` 相同。
truncate [Dynarray]	`truncate a n` 將 `a` 截斷為最多包含 `n` 個元素。
truncate [Buffer]	`truncate b len` 將 `b` 的長度截斷為 `len`。注意：內部的位元組序列不會縮短。
try_acquire [Semaphore.Binary]	如果號誌 `s` 的值為 0，則 `try_acquire s` 會立即返回 `false`。
try_acquire [Semaphore.Counting]	如果號誌 `s` 的值為零，則 `try_acquire s` 會立即返回 `false`。
try_lock [Mutex]	與 `Mutex.lock` 相同，但如果互斥鎖已鎖定，則不會暫停呼叫的執行緒：在這種情況下，會立即返回 `false`。
try_with [Effect.Deep]	`try_with f v h` 在處理器 `h` 下執行計算 `f v`。
type_format [CamlinternalFormat]
U
uid [Type.Id]	`uid id` 是 `id` 的執行階段唯一識別碼。
umask [UnixLabels]	設定進程的檔案模式建立遮罩，並返回先前的遮罩。
umask [Unix]	設定進程的檔案模式建立遮罩，並返回先前的遮罩。
unaligned_tag [Obj]
uncapitalize_ascii [String]	`uncapitalize_ascii s` 是 `s`，其中第一個字元設定為小寫，使用 US-ASCII 字元集。
uncapitalize_ascii [StringLabels]	`uncapitalize_ascii s` 是 `s`，其中第一個字元設定為小寫，使用 US-ASCII 字元集。
uncapitalize_ascii [BytesLabels]	返回參數的副本，其中第一個字元設定為小寫，使用 US-ASCII 字元集。
uncapitalize_ascii [Bytes]	返回參數的副本，其中第一個字元設定為小寫，使用 US-ASCII 字元集。
uncons [Seq]	如果 `xs` 為空，則 `uncons xs` 為 `None`。
unescaped [Scanf]	`unescaped s` 返回 `s` 的副本，其中跳脫序列（根據 OCaml 的詞彙約定）會被其對應的特殊字元取代。
unfold [Seq]	`unfold` 使用步驟函式和初始狀態來建構序列。
union [Set.S]	集合聯集。
union [MoreLabels.Set.S]	集合聯集。
union [MoreLabels.Map.S]	`union ~f m1 m2` 計算一個映射，其鍵是 `m1` 和 `m2` 的鍵的子集。
union [Map.S]	`union f m1 m2` 計算一個映射，其鍵是 `m1` 和 `m2` 的鍵的子集。
unit [Runtime_events.Type]	一個沒有關聯資料的事件。
unix [Sys]	如果 `Sys.os_type = "Unix"` 為真。
unlink [UnixLabels]	移除指定名稱的檔案。
unlink [Unix]	移除指定名稱的檔案。
unlock [Mutex]	解鎖給定的互斥鎖。
unsafe_environment [UnixLabels]	以 ``variable=value'' 格式的字串陣列形式傳回程序環境。
unsafe_environment [Unix]	以 ``variable=value'' 格式的字串陣列形式傳回程序環境。
unsafe_get [Bigarray.Array3]	類似 `Bigarray.Array3.get`，但不一定會執行邊界檢查。
unsafe_get [Bigarray.Array2]	類似 `Bigarray.Array2.get`，但不一定會執行邊界檢查。
unsafe_get [Bigarray.Array1]	類似 `Bigarray.Array1.get`，但不一定會執行邊界檢查。
unsafe_getenv [UnixLabels]	傳回程序環境中與變數關聯的值。
unsafe_getenv [Unix]	傳回程序環境中與變數關聯的值。
unsafe_of_string [BytesLabels]	不安全地將共享字串轉換為不應修改的位元組序列。
unsafe_of_string [Bytes]	不安全地將共享字串轉換為不應修改的位元組序列。
unsafe_set [Bigarray.Array3]	類似 `Bigarray.Array3.set`，但不一定會執行邊界檢查。
unsafe_set [Bigarray.Array2]	類似 `Bigarray.Array2.set`，但不一定會執行邊界檢查。
unsafe_set [Bigarray.Array1]	類似 `Bigarray.Array1.set`，但不一定會執行邊界檢查。
unsafe_to_string [BytesLabels]	不安全地將位元組序列轉換為字串。
unsafe_to_string [Bytes]	不安全地將位元組序列轉換為字串。
unset_data [Obj.Ephemeron]
unset_key [Obj.Ephemeron]
unsigned_compare [Nativeint]	與 `Nativeint.compare` 相同，但參數被解釋為無號原生整數。
unsigned_compare [Int64]	與 `Int64.compare` 相同，但參數被解釋為無號 64 位元整數。
unsigned_compare [Int32]	與 `Int32.compare` 相同，但參數被解釋為無號 32 位元整數。
unsigned_div [Nativeint]	與 `Nativeint.div` 相同，但參數和結果被解釋為無號原生整數。
unsigned_div [Int64]	與 `Int64.div` 相同，但參數和結果被解釋為無號 64 位元整數。
unsigned_div [Int32]	與 `Int32.div` 相同，但參數和結果被解釋為無號 32 位元整數。
unsigned_rem [Nativeint]	與 `Nativeint.rem` 相同，但參數和結果被解釋為無號原生整數。
unsigned_rem [Int64]	與 `Int64.rem` 相同，但參數和結果被解釋為無號 64 位元整數。
unsigned_rem [Int32]	與 `Int32.rem` 相同，但參數和結果被解釋為無號 32 位元整數。
unsigned_to_int [Nativeint]	與 `Nativeint.to_int` 相同，但將參數解釋為無號整數。
unsigned_to_int [Int64]	與 `Int64.to_int` 相同，但將參數解釋為無號整數。
unsigned_to_int [Int32]	與 `Int32.to_int` 相同，但將參數解釋為無號整數。
unzip [Seq]	`unzip` 將成對的序列轉換為成對的序列。
update [MoreLabels.Map.S]	`update ~key ~f m` 返回一個包含與 `m` 相同綁定的映射，除了 `key` 的綁定。
update [Map.S]	`update key f m` 返回一個包含與 `m` 相同綁定的映射，除了 `key` 的綁定。
update_geometry [Format]
update_mod [CamlinternalMod]
uppercase_ascii [String]	`uppercase_ascii s` 是 `s`，其中所有小寫字母都使用 US-ASCII 字元集轉換為大寫。
uppercase_ascii [StringLabels]	`uppercase_ascii s` 是 `s`，其中所有小寫字母都使用 US-ASCII 字元集轉換為大寫。
uppercase_ascii [Char]	使用 US-ASCII 字元集將給定的字元轉換為其等效的大寫字元。
uppercase_ascii [BytesLabels]	返回參數的副本，其中所有小寫字母都使用 US-ASCII 字元集轉換為大寫。
uppercase_ascii [Bytes]	返回參數的副本，其中所有小寫字母都使用 US-ASCII 字元集轉換為大寫。
usage [Arg]	`Arg.usage speclist usage_msg` 向標準錯誤輸出一個錯誤訊息，其中包含有效選項的列表。
usage_string [Arg]	返回如果使用相同參數提供給 `Arg.usage` 將列印的訊息。
use_printers [Printexc]	如果沒有註冊的列印器，則 `Printexc.use_printers e` 返回 `None`，否則返回帶有結果字串的 `Some s`。
utf_16_byte_length [Uchar]	`utf_16_byte_length u` 是以 UTF-16 編碼 `u` 所需的位元組數。
utf_8_byte_length [Uchar]	`utf_8_byte_length u` 是以 UTF-8 編碼 `u` 所需的位元組數。
utf_decode [Uchar]	`utf_decode n u` 是 `u` 的有效 UTF 解碼，它從來源中消耗了 `n` 個元素進行解碼。
utf_decode_invalid [Uchar]	`utf_decode_invalid n` 是一個無效的 UTF 解碼，它從來源中消耗了 `n` 個元素以產生錯誤。
utf_decode_is_valid [Uchar]	當且僅當 `d` 保存有效解碼時，`utf_decode_is_valid d` 為 `true`。
utf_decode_length [Uchar]	`utf_decode_length d` 是解碼 `d` 從來源消耗的元素數。
utf_decode_uchar [Uchar]	如果 `utf_decode_is_valid d` 為 `true`，則 `utf_decode_uchar d` 是 `d` 解碼的 Unicode 字元，否則為 `Uchar.rep`。
utimes [UnixLabels]	設定檔案的上次存取時間（第二個參數）和上次修改時間（第三個參數）。
utimes [Unix]	設定檔案的上次存取時間（第二個參數）和上次修改時間（第三個參數）。
V
value [Result]	如果 `r` 是 `Ok v`，則 `value r ~default` 為 `v`，否則為 `default`。
value [Option]	如果 `o` 是 `Some v`，則 `value o ~default` 為 `v`，否則為 `default`。
W
wait [UnixLabels]	等待直到其中一個子進程死亡，並返回其 pid 和終止狀態。
wait [Unix]	等待直到其中一個子進程死亡，並返回其 pid 和終止狀態。
wait [Condition]	只有當 `m` 是與條件變數 `c` 關聯的互斥鎖，且只有當 `m` 目前處於鎖定狀態時，才允許調用 `wait c m`。
wait_pid [Thread]	與 `Unix.waitpid` 相同的函式。
wait_signal [Thread]	`wait_signal sigs` 暫停呼叫執行緒的執行，直到進程收到列表 `sigs` 中指定的其中一個信號。
wait_timed_read [Thread]	請參閱 `Thread.wait_timed_write`。
wait_timed_write [Thread]	暫停呼叫執行緒的執行，直到至少有一個字元或 EOF 可用於在給定的 Unix 檔案描述符上讀取（`wait_timed_read`），或在沒有阻塞的情況下寫入一個字元（`wait_timed_write`）。
waitpid [UnixLabels]	與 `UnixLabels.wait` 相同，但等待給定 pid 的子進程。
waitpid [Unix]	與 `Unix.wait` 相同，但會等待指定的子進程 PID。
widen [CamlinternalOO]
win32 [Sys]	如果 `Sys.os_type = "Win32"`，則為 True。
with_open_bin [Out_channel]	`with_open_bin fn f` 會開啟檔案 `fn` 上的通道 `oc`，並回傳 `f oc`。
with_open_bin [In_channel]	`with_open_bin fn f` 會開啟檔案 `fn` 上的通道 `ic`，並回傳 `f ic`。
with_open_gen [Out_channel]	類似 `Out_channel.with_open_bin`，但在檔案必須被建立時，可以指定開啟模式和檔案權限（請參閱 `Out_channel.open_gen`）。
with_open_gen [In_channel]	類似 `In_channel.with_open_bin`，但在檔案必須被建立時，可以指定開啟模式和檔案權限（請參閱 `In_channel.open_gen`）。
with_open_text [Out_channel]	類似 `Out_channel.with_open_bin`，但通道會以文字模式開啟（請參閱 `Out_channel.open_text`）。
with_open_text [In_channel]	類似 `In_channel.with_open_bin`，但通道會以文字模式開啟（請參閱 `In_channel.open_text`）。
with_positions [Lexing]	告知詞法分析器緩衝區是否追蹤位置欄位 `lex_curr_p` / `lex_start_p`，由建立詞法分析器緩衝區的函數的對應可選參數決定（其預設值為 `true`）。
with_tag [Obj]
word_size [Sys]	目前執行 OCaml 程式的機器上一個字的大小（以位元為單位）：32 或 64。
wrap [Event]	`wrap ev fn` 回傳執行與 `ev` 相同的通訊的事件，然後對回傳值套用後處理函數 `fn`。
wrap_abort [Event]	`wrap_abort ev fn` 回傳執行與 `ev` 相同的通訊的事件，但如果未被選取，則會在同步化後呼叫函數 `fn`。
write [UnixLabels]	`write fd ~buf ~pos ~len` 將 `len` 個位元組寫入描述符 `fd`，從位元組序列 `buf` 中取得，從 `buff` 中的位置 `pos` 開始。
write [Unix]	`write fd buf pos len` 將 `len` 個位元組寫入描述符 `fd`，從位元組序列 `buf` 中取得，從 `buff` 中的位置 `pos` 開始。
write [Runtime_events.User]	`write t v` 發出事件 `t` 的值 `v`。
write_arg [Arg]	`Arg.write_arg file args` 將參數 `args` 以換行符號結尾寫入檔案 `file` 中。
write_arg0 [Arg]	與 `Arg.write_arg` 相同，但使用空字元作為終止符，而不是換行符號。
write_bigarray [UnixLabels]	與 `UnixLabels.write` 相同，但從大陣列中取得資料。
write_bigarray [Unix]	與 `Unix.write` 相同，但從大陣列中取得資料。
write_substring [UnixLabels]	與 `UnixLabels.write` 相同，但從字串中取得資料，而不是位元組序列。
write_substring [Unix]	與 `Unix.write` 相同，但從字串中取得資料，而不是位元組序列。
Y
yield [Thread]	重新排程呼叫的執行緒，而不暫停它。
Z
zero [Nativeint]	原生整數 0。
zero [Int64]	64 位元整數 0。
zero [Int32]	32 位元整數 0。
zero [Int]	`zero` 是整數 `0`。
zero [Float]	浮點數 0。
zero [Complex]	複數 `0`。
zip [Seq]	`zip xs ys` 是從序列 `xs` 和 `ys` 同步提取的成對 `(x, y)` 序列。