值索引


( * ) [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]	接受给定套接字上的连接。
accept [Unix]	接受给定套接字上的连接。
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` 的值减 1 并返回。
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` 在表 `tbl` 中添加将 `key` 绑定到 `data`。
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` 在表 `tbl` 中添加将 `key` 绑定到 `data`。
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`，使得 `l` 等于 `data :: Map.find key m`（如果 `key` 在 `m` 中被绑定）或 `[v]`（否则）。
add_to_list [Map.S]	`add_to_list key data m` 等效于 `m`，其中 `key` 映射到 `l`，使得 `l` 等于 `data :: Map.find key m`（如果 `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]	根据关键字的长度，通过在第一个对齐分隔符（制表符或，如果未找到制表符，则为空格）处插入空格来对齐文档字符串。
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` 中的所有元素追加到 `a` 的末尾，顺序与它们在 `b` 中出现的顺序相同。
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` 返回键 `a` 在键值对列表 `l` 中的关联值。
assoc [List]	`assoc a l` 返回键 `a` 在键值对列表 `l` 中的关联值。
assoc_opt [ListLabels]	`assoc_opt a l` 返回键 `a` 在键值对列表 `l` 中的关联值。
assoc_opt [List]	`assoc_opt a l` 返回键 `a` 在键值对列表 `l` 中的关联值。
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]	将套接字绑定到地址。
bind [Unix]	将套接字绑定到地址。
bind [Result]	`bind r f` 如果 `r` 是 `Ok v` 则为 `f v`，如果 `r` 是 `Error _` 则为 `r`。
bind [Option]	`bind o f` 如果 `o` 是 `Some v` 则为 `f v`，如果 `o` 是 `None` 则为 `None`。
bindings [MoreLabels.Map.S]	返回给定映射的所有绑定的列表。
bindings [Map.S]	返回给定映射的所有绑定的列表。
bits [Random.State]
bits [Random]	返回一个非负整数中的 30 个随机位。
bits32 [Random.State]
bits32 [Random]	`Random.bits32 ()` 返回一个介于 `Int32.min_int` 和 `Int32.max_int` 之间的 32 个随机位。
bits64 [Random.State]
bits64 [Random]	`Random.bits64 ()` 返回一个介于 `Int64.min_int` 和 `Int64.max_int` 之间的 64 个随机位。
bits_of_float [Int64]	根据 IEEE 754 浮点 '双精度格式' 位布局返回给定浮点数的内部表示。
bits_of_float [Int32]	根据 IEEE 754 浮点 '单精度格式' 位布局返回给定浮点数的内部表示。
blit [Weak]	`Weak.blit ar1 off1 ar2 off2 len` 将 `len` 个弱指针从 `ar1`（从 `off1` 开始）复制到 `ar2`（从 `off2` 开始）。
blit [String]	与 `Bytes.blit_string` 相同，建议优先使用 `Bytes.blit_string`。
blit [StringLabels]	与 `Bytes.blit_string` 相同，建议优先使用 `Bytes.blit_string`。
blit [Float.ArrayLabels]	`blit ~src ~src_pos ~dst ~dst_pos ~len` 将 `len` 个元素从浮点数组 `src`（从元素编号 `src_pos` 开始）复制到浮点数组 `dst`（从元素编号 `dst_pos` 开始）。
blit [Float.Array]	`blit src src_pos dst dst_pos len` 将 `len` 个元素从浮点数组 `src`（从元素编号 `src_pos` 开始）复制到浮点数组 `dst`（从元素编号 `dst_pos` 开始）。
blit [BytesLabels]	`blit ~src ~src_pos ~dst ~dst_pos ~len` 将 `len` 个字节从字节序列 `src`（从索引 `src_pos` 开始）复制到字节序列 `dst`（从索引 `dst_pos` 开始）。
blit [Bytes]	`blit src src_pos dst dst_pos len` 将 `len` 个字节从字节序列 `src`（从索引 `src_pos` 开始）复制到字节序列 `dst`（从索引 `dst_pos` 开始）。
blit [Buffer]	`Buffer.blit src srcoff dst dstoff len` 将 `len` 个字符从缓冲区 `src` 的当前内容（从偏移量 `srcoff` 开始）复制到 `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` 将 `len` 个元素从数组 `src`（从元素编号 `src_pos` 开始）复制到数组 `dst`（从元素编号 `dst_pos` 开始）。
blit [Array]	`blit src src_pos dst dst_pos len` 将 `len` 个元素从数组 `src`（从元素编号 `src_pos` 开始）复制到数组 `dst`（从元素编号 `dst_pos` 开始）。
blit_data [Obj.Ephemeron]
blit_key [Obj.Ephemeron]
blit_string [BytesLabels]	`blit_string ~src ~src_pos ~dst ~dst_pos ~len` 将 `len` 个字节从字符串 `src`（从索引 `src_pos` 开始）复制到字节序列 `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` 从格式化的输入通道 `ic` 中读取格式字符串标记，根据给定的格式字符串 `fmt`，并将 `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]	如上所示值类型， `float16_elt`、`float32_elt` 和 `float64_elt` 类型的 Bigarray 使用 OCaml 类型 `float` 进行访问。
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]	`check_suffix name suff` 如果文件名 `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]	`compare x y` 如果 `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]	`compare x y` 如果 `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]	`compare_and_set r seen v` 仅当 `r` 的当前值与 `seen` 物理相等时，才会将 `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]	将套接字连接到地址。
connect [Unix]	将套接字连接到地址。
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]	`contains_from s start c` 当且仅当 `c` 在位置 `start` 之后出现在 `s` 中时为 `true`。
contains_from [StringLabels]	`contains_from s start c` 当且仅当 `c` 在位置 `start` 之后出现在 `s` 中时为 `true`。
contains_from [BytesLabels]	`contains_from s start c` 测试字节 `c` 是否在位置 `start` 之后出现在 `s` 中。
contains_from [Bytes]	`contains_from s start c` 测试字节 `c` 是否在位置 `start` 之后出现在 `s` 中。
contents [Buffer]	返回缓冲区的当前内容的副本。
continue [Effect.Deep]	`continue k x` 通过将 `x` 传递给 `k` 来恢复延续 `k`。
continue_with [Effect.Shallow]	`continue_with k v h` 使用处理程序 `h` 恢复延续 `k`，并使用值 `v`。
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` 创建一个游标以从运行时事件读取。
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"`，则为真。
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` 包含不在 `s2` 中的 `s1` 的元素。
diff [MoreLabels.Set.S]	集合差：`diff s1 s2` 包含不在 `s2` 中的 `s1` 的元素。
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` 返回 Bigarray `a` 的所有维度，作为一个长度为 `Genarray.num_dims a` 的整数数组。
dir_sep [Filename]	目录分隔符（例如
dirname [Filename]	参见 `Filename.basename`。
discard [Gc.Memprof]	丢弃所有已停止配置文件的分析状态，这将阻止为其进行任何进一步的回调。
discontinue [Effect.Deep]	`discontinue k e` 通过在 `k` 中抛出异常 `e` 来恢复延续 `k`。
discontinue_with [Effect.Shallow]	`discontinue_with k e h` 通过使用处理程序 `h` 抛出异常 `e` 来恢复延续 `k`。
discontinue_with_backtrace [Effect.Shallow]	`discontinue_with k e bt h` 通过使用原始回溯 `bt` 作为异常的来源，使用处理程序 `h` 抛出异常 `e` 来恢复延续 `k`。
discontinue_with_backtrace [Effect.Deep]	`discontinue_with_backtrace k e bt` 通过使用 `bt` 作为异常的来源，在 `k` 中抛出异常 `e` 来恢复延续 `k`。
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]	返回适合给定套接字地址的套接字域。
domain_of_sockaddr [Unix]	返回适合给定套接字地址的套接字域。
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` 已经打开，则关闭 `dst`。
dup2 [Unix]	`dup2 src dst` 将 `src` 复制到 `dst`，如果 `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]	`ends_with` `~suffix s` 当且仅当 `s` 以 `suffix` 结尾时为 `true`。
ends_with [StringLabels]	`ends_with` `~suffix s` 当且仅当 `s` 以 `suffix` 结尾时为 `true`。
ends_with [BytesLabels]	`ends_with` `~suffix s` 当且仅当 `s` 以 `suffix` 结尾时为 `true`。
ends_with [Bytes]	`ends_with` `~suffix s` 当且仅当 `s` 以 `suffix` 结尾时为 `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]	返回进程环境，作为格式为“变量=值”的字符串数组。
environment [Unix]	返回进程环境，作为格式为“变量=值”的字符串数组。
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]	`equal s0 s1` 当且仅当 `s0` 和 `s1` 在字符上相等时为 `true`。
equal [StringLabels]	`equal s0 s1` 当且仅当 `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]	用于 64 位整数的相等函数。
equal [Int32]	用于 32 位整数的相等函数。
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`，将 `len` 个字符替换为 `c`，从 `pos` 开始。
fill [Bytes]	`fill s pos len c` 在原地修改 `s`，将 `len` 个字符替换为 `c`，从 `pos` 开始。
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` 是一个新数组，包含所有满足 `f` 的 `a` 的元素。
filter_map [Set.S]	`filter_map f s` 返回所有 `v` 的集合，其中 `f x = Some v` 对集合 `s` 中的某些元素 `x` 成立。
filter_map [Seq]	`filter_map f xs` 是元素 `y` 的序列，其中 `f x = Some y`，其中 `x` 在 `xs` 中变化。
filter_map [MoreLabels.Set.S]	`filter_map ~f s` 返回所有 `v` 的集合，其中 `f x = Some v` 对集合 `s` 中的某些元素 `x` 成立。
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` 为 `Some y`，对于 `a` 中的元素 `x`。
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` 返回与 `x` 相等的 `s` 的元素（根据 `Ord.compare`），或者如果不存在这样的元素，则引发 `Not_found`。
find [Seq]	`find p xs` 返回 `Some x`，其中 `x` 是序列 `xs` 中第一个满足 `p x` 的元素（如果存在这样的元素）。
find [MoreLabels.Set.S]	`find x s` 返回与 `x` 相等的 `s` 的元素（根据 `Ord.compare`），或者如果不存在这样的元素，则引发 `Not_found`。
find [MoreLabels.Map.S]	`find x m` 返回 `x` 在 `m` 中的当前值，或者如果不存在 `x` 的绑定，则引发 `Not_found`。
find [MoreLabels.Hashtbl.SeededS]
find [MoreLabels.Hashtbl.S]
find [MoreLabels.Hashtbl]	`Hashtbl.find tbl x` 返回 `x` 在 `tbl` 中的当前绑定，或者如果不存在这样的绑定，则引发 `Not_found`。
find [Map.S]	`find x m` 返回 `x` 在 `m` 中的当前值，或者如果不存在 `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` 返回 `x` 在 `tbl` 中的当前绑定，或者如果不存在这样的绑定，则引发 `Not_found`。
find [Ephemeron.Kn.Bucket]	返回具有给定键的最最近添加的 ephemeron 的数据，或者如果不存在这样的 ephemeron，则返回 `None`。
find [Ephemeron.K2.Bucket]	返回具有给定键的最最近添加的 ephemeron 的数据，或者如果不存在这样的 ephemeron，则返回 `None`。
find [Ephemeron.K1.Bucket]	返回具有给定键的最最近添加的 ephemeron 的数据，或者如果不存在这样的 ephemeron，则返回 `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` 返回与 `x` 关联的所有数据，这些数据与 `tbl` 中的关联有关。
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` 返回与 `x` 关联的所有数据，这些数据与 `tbl` 中的关联有关。
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]	`fold ~ok ~error r` 是 `ok v` 如果 `r` 是 `Ok v` 且 `error e` 如果 `r` 是 `Error e`。
fold [Queue]	`fold f accu q` 等效于 `List.fold_left f accu l`，其中 `l` 是 `q` 的元素列表。
fold [Option]	`fold ~none ~some o` 是 `none` 如果 `o` 是 `None` 且 `some v` 如果 `o` 是 `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]	`get o` 如果 `o` 是 `Some v`，则为 `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]	`get k` 如果在调用域的域本地状态上，键 `k` 与值 `v` 相关联，则返回 `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]	`get_error r` 如果 `r` 是 `Error e`，则为 `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` 是 `b` 从字符索引 `i` 开始的本地端序有符号 16 位整数。
get_int16_ne [StringLabels]	`get_int16_ne b i` 是 `b` 从字符索引 `i` 开始的本地端序有符号 16 位整数。
get_int16_ne [BytesLabels]	`get_int16_ne b i` 是 `b` 从字节索引 `i` 开始的本地端序有符号 16 位整数。
get_int16_ne [Bytes]	`get_int16_ne b i` 是 `b` 从字节索引 `i` 开始的本地端序有符号 16 位整数。
get_int32_be [String]	`get_int32_be b i` 是 `b` 从字符索引 `i` 开始的大端序 32 位整数。
get_int32_be [StringLabels]	`get_int32_be b i` 是 `b` 从字符索引 `i` 开始的大端序 32 位整数。
get_int32_be [BytesLabels]	`get_int32_be b i` 是 `b` 从字节索引 `i` 开始的大端序 32 位整数。
get_int32_be [Bytes]	`get_int32_be b i` 是 `b` 从字节索引 `i` 开始的大端序 32 位整数。
get_int32_le [String]	`get_int32_le b i` 是 `b` 从字符索引 `i` 开始的小端序 32 位整数。
get_int32_le [StringLabels]	`get_int32_le b i` 是 `b` 从字符索引 `i` 开始的小端序 32 位整数。
get_int32_le [BytesLabels]	`get_int32_le b i` 是 `b` 从字节索引 `i` 开始的小端序 32 位整数。
get_int32_le [Bytes]	`get_int32_le b i` 是 `b` 从字节索引 `i` 开始的小端序 32 位整数。
get_int32_ne [String]	`get_int32_ne b i` 是 `b` 的以本地字节序排列的 32 位整数，从字符索引 `i` 开始。
get_int32_ne [StringLabels]	`get_int32_ne b i` 是 `b` 的以本地字节序排列的 32 位整数，从字符索引 `i` 开始。
get_int32_ne [BytesLabels]	`get_int32_ne b i` 是 `b` 的以本地字节序排列的 32 位整数，从字节索引 `i` 开始。
get_int32_ne [Bytes]	`get_int32_ne b i` 是 `b` 的以本地字节序排列的 32 位整数，从字节索引 `i` 开始。
get_int64_be [String]	`get_int64_be b i` 是 `b` 的以大端字节序排列的 64 位整数，从字符索引 `i` 开始。
get_int64_be [StringLabels]	`get_int64_be b i` 是 `b` 的以大端字节序排列的 64 位整数，从字符索引 `i` 开始。
get_int64_be [BytesLabels]	`get_int64_be b i` 是 `b` 的以大端字节序排列的 64 位整数，从字节索引 `i` 开始。
get_int64_be [Bytes]	`get_int64_be b i` 是 `b` 的以大端字节序排列的 64 位整数，从字节索引 `i` 开始。
get_int64_le [String]	`get_int64_le b i` 是 `b` 的以小端字节序排列的 64 位整数，从字符索引 `i` 开始。
get_int64_le [StringLabels]	`get_int64_le b i` 是 `b` 的以小端字节序排列的 64 位整数，从字符索引 `i` 开始。
get_int64_le [BytesLabels]	`get_int64_le b i` 是 `b` 的以小端字节序排列的 64 位整数，从字节索引 `i` 开始。
get_int64_le [Bytes]	`get_int64_le b i` 是 `b` 的以小端字节序排列的 64 位整数，从字节索引 `i` 开始。
get_int64_ne [String]	`get_int64_ne b i` 是 `b` 的以本地字节序排列的 64 位整数，从字符索引 `i` 开始。
get_int64_ne [StringLabels]	`get_int64_ne b i` 是 `b` 的以本地字节序排列的 64 位整数，从字符索引 `i` 开始。
get_int64_ne [BytesLabels]	`get_int64_ne b i` 是 `b` 的以本地字节序排列的 64 位整数，从字节索引 `i` 开始。
get_int64_ne [Bytes]	`get_int64_ne b i` 是 `b` 的以本地字节序排列的 64 位整数，从字节索引 `i` 开始。
get_int8 [String]	`get_int8 b i` 是 `b` 的有符号 8 位整数，从字符索引 `i` 开始。
get_int8 [StringLabels]	`get_int8 b i` 是 `b` 的有符号 8 位整数，从字符索引 `i` 开始。
get_int8 [BytesLabels]	`get_int8 b i` 是 `b` 的有符号 8 位整数，从字节索引 `i` 开始。
get_int8 [Bytes]	`get_int8 b i` 是 `b` 的有符号 8 位整数，从字节索引 `i` 开始。
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` 返回下一个内联的槽位（如果有）。
get_raw_backtrace_slot [Printexc]	`get_raw_backtrace_slot bckt pos` 返回回溯 `bckt` 中位置 `pos` 的槽位。
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` 是 `b` 的以大端字节序排列的无符号 16 位整数，从字符索引 `i` 开始。
get_uint16_be [StringLabels]	`get_uint16_be b i` 是 `b` 的以大端字节序排列的无符号 16 位整数，从字符索引 `i` 开始。
get_uint16_be [BytesLabels]	`get_uint16_be b i` 是 `b` 的以大端字节序排列的无符号 16 位整数，从字节索引 `i` 开始。
get_uint16_be [Bytes]	`get_uint16_be b i` 是 `b` 的以大端字节序排列的无符号 16 位整数，从字节索引 `i` 开始。
get_uint16_le [String]	`get_uint16_le b i` 是 `b` 的以小端字节序排列的无符号 16 位整数，从字符索引 `i` 开始。
get_uint16_le [StringLabels]	`get_uint16_le b i` 是 `b` 的以小端字节序排列的无符号 16 位整数，从字符索引 `i` 开始。
get_uint16_le [BytesLabels]	`get_uint16_le b i` 是 `b` 的以小端字节序排列的无符号 16 位整数，从字节索引 `i` 开始。
get_uint16_le [Bytes]	`get_uint16_le b i` 是 `b` 的以小端字节序排列的无符号 16 位整数，从字节索引 `i` 开始。
get_uint16_ne [String]	`get_uint16_ne b i` 是 `b` 的以本地字节序排列的无符号 16 位整数，从字符索引 `i` 开始。
get_uint16_ne [StringLabels]	`get_uint16_ne b i` 是 `b` 的以本地字节序排列的无符号 16 位整数，从字符索引 `i` 开始。
get_uint16_ne [BytesLabels]	`get_uint16_ne b i` 是 `b` 的以本地字节序排列的无符号 16 位整数，从字节索引 `i` 开始。
get_uint16_ne [Bytes]	`get_uint16_ne b i` 是 `b` 的以本地字节序排列的无符号 16 位整数，从字节索引 `i` 开始。
get_uint8 [String]	`get_uint8 b i` 是 `b` 的无符号 8 位整数，从字符索引 `i` 开始。
get_uint8 [StringLabels]	`get_uint8 b i` 是 `b` 的无符号 8 位整数，从字符索引 `i` 开始。
get_uint8 [BytesLabels]	`get_uint8 b i` 是 `b` 的无符号 8 位整数，从字节索引 `i` 开始。
get_uint8 [Bytes]	`get_uint8 b i` 是 `b` 的无符号 8 位整数，从字节索引 `i` 开始。
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` 记录列表，这些参数和地址适合与给定的主机和服务通信。
getaddrinfo [Unix]	`getaddrinfo host service opts` 返回描述套接字参数和地址的 `Unix.addr_info` 记录列表，这些参数和地址适合与给定的主机和服务通信。
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]	在 `group` 中查找具有给定组 ID 的条目。
getgrgid [Unix]	在 `group` 中查找具有给定组 ID 的条目。
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]	在 `passwd` 中查找具有给定用户 ID 的条目。
getpwuid [Unix]	在 `passwd` 中查找具有给定用户 ID 的条目。
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` 相同的字符串，只是将与 `regexp` 匹配的所有 `s` 的子字符串替换为 `templ`。
global_substitute [Str]	`global_substitute regexp subst s` 返回一个与 `s` 相同的字符串，只是将与 `regexp` 匹配的所有 `s` 的子字符串替换为函数 `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]	表示一个序列化值的字节由一个固定大小的头部和一个可变大小的数据部分组成，其大小可以从头部确定。
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 [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` 返回字节 `c` 在 `s` 中第一次出现的索引。
index [Bytes]	`index s c` 返回字节 `c` 在 `s` 中第一次出现的索引。
index_from [String]	`index_from s i c` 是 `c` 在 `s` 中位置 `i` 之后第一次出现的索引。
index_from [StringLabels]	`index_from s i c` 是 `c` 在 `s` 中位置 `i` 之后第一次出现的索引。
index_from [BytesLabels]	`index_from s i c` 返回字节 `c` 在 `s` 中位置 `i` 之后第一次出现的索引。
index_from [Bytes]	`index_from s i c` 返回字节 `c` 在 `s` 中位置 `i` 之后第一次出现的索引。
index_from_opt [String]	`index_from_opt s i c` 是 `c` 在 `s` 中位置 `i` 之后第一次出现的索引（如果有）。
index_from_opt [StringLabels]	`index_from_opt s i c` 是 `c` 在 `s` 中位置 `i` 之后第一次出现的索引（如果有）。
index_from_opt [BytesLabels]	`index_from_opt s i c` 返回字节 `c` 在 `s` 中位置 `i` 之后第一次出现的索引，或者如果 `c` 在位置 `i` 之后没有出现在 `s` 中，则返回 `None`。
index_from_opt [Bytes]	`index_from_opt s i c` 返回字节 `c` 在 `s` 中位置 `i` 之后第一次出现的索引，或者如果 `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` 返回字节 `c` 在 `s` 中第一次出现的索引，或者如果 `c` 没有出现在 `s` 中，则返回 `None`。
index_opt [Bytes]	`index_opt s c` 返回字节 `c` 在 `s` 中第一次出现的索引，或者如果 `c` 没有出现在 `s` 中，则返回 `None`。
inet6_addr_any [UnixLabels]	一个特殊的 IPv6 地址，仅用于 `bind`，表示主机拥有所有 Internet 地址。
inet6_addr_any [Unix]	一个特殊的 IPv6 地址，仅用于 `bind`，表示主机拥有所有 Internet 地址。
inet6_addr_loopback [UnixLabels]	一个特殊的 IPv6 地址，表示主机 (`::1`)。
inet6_addr_loopback [Unix]	一个特殊的 IPv6 地址，表示主机 (`::1`)。
inet_addr_any [UnixLabels]	一个特殊的 IPv4 地址，仅用于 `bind`，表示主机拥有所有 Internet 地址。
inet_addr_any [Unix]	一个特殊的 IPv4 地址，仅用于 `bind`，表示主机拥有所有 Internet 地址。
inet_addr_loopback [UnixLabels]	一个特殊的 IPv4 地址，表示主机 (`127.0.0.1`)。
inet_addr_loopback [Unix]	一个特殊的 IPv4 地址，表示主机 (`127.0.0.1`)。
inet_addr_of_string [UnixLabels]	从 Internet 地址的可打印表示形式转换为其内部表示形式。
inet_addr_of_string [Unix]	从 Internet 地址的可打印表示形式转换为其内部表示形式。
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` 的新浮点数组，其元素编号为 `i`，初始化为 `f i` 的结果。
init [Float.Array]	`init n f` 返回一个长度为 `n` 的新浮点数数组，其中元素编号为 `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` 返回一个新的三维大数组 `b`，其在第一维的大小为 `dim1`，在第二维的大小为 `dim2`，在第三维的大小为 `dim3`。
init [Bigarray.Array2]	`Array2.init kind layout dim1 dim2 f` 返回一个新的二维大数组 `b`，其在第一维的大小为 `dim2`，在第二维的大小为 `dim2`。
init [Bigarray.Array1]	`Array1.init kind layout dim f` 返回一个新的只有一维的大数组 `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` 相同，但将数据读入大数组。
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]	`is_char u` 当且仅当 `u` 是 latin1 OCaml 字符时为 `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]	`is_empty l` 当且仅当 `l` 没有元素时为真。
is_empty [List]	`is_empty l` 当且仅当 `l` 没有元素时为真。
is_empty [Dynarray]	`is_empty a` 如果 `a` 为空，即 `length a = 0`，则为 `true`。
is_error [Result]	`is_error r` 当且仅当 `r` 为 `Error _` 时为 `true`。
is_finite [Float]	`is_finite x` 当且仅当 `x` 为有限时为 `true`，即不为无限也不为 `Float.nan`。
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]	`is_infinite x` 当且仅当 `x` 为 `Float.infinity` 或 `Float.neg_infinity` 时为 `true`。
is_inline [Printexc.Slot]	`is_inline slot` 当 `slot` 指向由编译器内联的调用时为 `true`，当它来自任何其他上下文时为 `false`。
is_int [Obj]
is_integer [Float]	`is_integer x` 当且仅当 `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]	`is_nan x` 当且仅当 `x` 不是数字（参见 `Float.nan`）时为 `true`。
is_native [Dynlink]	如果程序是本机的，则为 `true`，如果程序是字节码，则为 `false`。
is_none [Option]	`is_none o` 当且仅当 `o` 为 `None` 时为 `true`。
is_ok [Result]	`is_ok r` 当且仅当 `r` 为 `Ok _` 时为 `true`。
is_raise [Printexc.Slot]	`is_raise slot` 当 `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]	`is_some o` 当且仅当 `o` 为 `Some o` 时为 `true`。
is_val [Lazy]	`is_val x` 如果 `x` 已经强制并且没有引发异常，则返回 `true`。
is_valid [Uchar]	`is_valid n` 当且仅当 `n` 为 Unicode 标量值（即。
is_valid_utf_16be [String]	`is_valid_utf_16be b` 当且仅当 `b` 包含有效的 UTF-16BE 数据时为 `true`。
is_valid_utf_16be [StringLabels]	`is_valid_utf_16be b` 当且仅当 `b` 包含有效的 UTF-16BE 数据时为 `true`。
is_valid_utf_16be [BytesLabels]	`is_valid_utf_16be b` 当且仅当 `b` 包含有效的 UTF-16BE 数据时为 `true`。
is_valid_utf_16be [Bytes]	`is_valid_utf_16be b` 当且仅当 `b` 包含有效的 UTF-16BE 数据时为 `true`。
is_valid_utf_16le [String]	`is_valid_utf_16le b` 当且仅当 `b` 包含有效的 UTF-16LE 数据时为 `true`。
is_valid_utf_16le [StringLabels]	`is_valid_utf_16le b` 当且仅当 `b` 包含有效的 UTF-16LE 数据时为 `true`。
is_valid_utf_16le [BytesLabels]	`is_valid_utf_16le b` 当且仅当 `b` 包含有效的 UTF-16LE 数据时为 `true`。
is_valid_utf_16le [Bytes]	`is_valid_utf_16le b` 当且仅当 `b` 包含有效的 UTF-16LE 数据时为 `true`。
is_valid_utf_8 [String]	`is_valid_utf_8 b` 当且仅当 `b` 包含有效的 UTF-8 数据时为 `true`。
is_valid_utf_8 [StringLabels]	`is_valid_utf_8 b` 当且仅当 `b` 包含有效的 UTF-8 数据时为 `true`。
is_valid_utf_8 [BytesLabels]	`is_valid_utf_8 b` 当且仅当 `b` 包含有效的 UTF-8 数据时为 `true`。
is_valid_utf_8 [Bytes]	`is_valid_utf_8 b` 当且仅当 `b` 包含有效的 UTF-8 数据时为 `true`。
isatty [UnixLabels]	如果给定的文件描述符是指终端或控制台窗口，则返回 `true`，否则返回 `false`。
isatty [Unix]	如果给定的文件描述符是指终端或控制台窗口，则返回 `true`，否则返回 `false`。
isatty [Out_channel]	`isatty oc` 如果 `oc` 指向终端或控制台窗口，则为 `true`，否则为 `false`。
isatty [In_channel]	`isatty ic` 如果 `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]	`iter f r` 如果 `r` 为 `Ok v`，则为 `f v`，否则为 `()`。
iter [Queue]	`iter f q` 依次将 `f` 应用于 `q` 的所有元素，从最不最近进入的元素到最最近进入的元素。
iter [Option]	`iter f o` 如果 `o` 为 `Some v`，则为 `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]	返回桶长度的上限。
length [Ephemeron.K2.Bucket]	返回桶长度的上限。
length [Ephemeron.K1.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]	设置一个套接字以接收连接请求。
listen [Unix]	设置一个套接字以接收连接请求。
lnot [Stdlib]	按位逻辑非。
loadfile [Dynlink]	在字节码中：加载给定的字节码对象文件（`.cmo` 文件）或字节码库文件（`.cma` 文件），并将其与正在运行的程序链接。
loadfile_private [Dynlink]	与 `loadfile` 相同，不同之处在于，刚刚加载的编译单元对之后动态加载的其他模块是隐藏的（不能被引用）。
localtime [UnixLabels]	将 `UnixLabels.time` 返回的以秒为单位的时间转换为日期和时间。
localtime [Unix]	将 `Unix.time` 返回的以秒为单位的时间转换为日期和时间。
location [Printexc.Slot]	`location 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` 的按位逻辑与。
lognot [Nativeint]	按位逻辑非。
lognot [Int64]	按位逻辑非。
lognot [Int32]	按位逻辑非。
lognot [Int]	`lognot x` 是 `x` 的按位逻辑非。
logor [Nativeint]	按位逻辑或。
logor [Int64]	按位逻辑或。
logor [Int32]	按位逻辑或。
logor [Int]	`logor x y` 是 `x` 和 `y` 的按位逻辑或。
logxor [Nativeint]	按位逻辑异或。
logxor [Int64]	按位逻辑异或。
logxor [Int32]	按位逻辑异或。
logxor [Int]	`logxor x y` 是 `x` 和 `y` 的按位逻辑异或。
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` 是通过对 `s` 中所有字符（按升序）应用 `f` 而生成的字符串。
map [StringLabels]	`map f s` 是通过对 `s` 中所有字符（按升序）应用 `f` 而生成的字符串。
map [Set.S]	`map f s` 是一个集合，其元素为 `f a0`,`f a1`...
map [Seq]	`map f xs` 是序列 `xs` 通过变换 `f` 的图像。
map [Result]	`map f r` 是 `Ok (f v)`（如果 `r` 是 `Ok v`）以及 `r`（如果 `r` 是 `Error _`）。
map [Option]	`map f o` 是 `None`（如果 `o` 是 `None`）以及 `Some (f v)`（如果 `o` 是 `Some 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 a1; ...; f an]`，其中包含 `f` 返回的结果。
map [List]	`map f [a1; ...; an]` 将函数 `f` 应用于 `a1, ..., an`，并构建一个列表 `[f a1; ...; f an]`，其中包含 `f` 返回的结果。
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]	`map_error f r` 是 `Error (f e)` 如果 `r` 是 `Error e` 并且是 `r` 如果 `r` 是 `Ok _`。
map_file [UnixLabels]	将文件作为大数组进行内存映射。
map_file [Unix]	将文件作为大数组进行内存映射。
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]	`map_left f e` 是 `Left (f v)` 如果 `e` 是 `Left v` 并且是 `e` 如果 `e` 是 `Right _`。
map_product [Seq]	序列 `map_product f xs ys` 是序列 `xs` 和 `ys` 的笛卡尔积通过 `f` 的映像。
map_right [Either]	`map_right f e` 是 `Right (f v)` 如果 `e` 是 `Right v` 并且是 `e` 如果 `e` 是 `Left _`。
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]	`map_val f x` 如果 `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` 相同，但该函数接收作为参数的键和与映射的每个绑定相关的 value。
mapi [Map.S]	与 `Map.S.map` 相同，但该函数接收作为参数的键和与映射的每个绑定相关的 value。
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` 的形式，对于 `a` 的每个元素 `x` 位于索引 `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` 返回与最后一次匹配或搜索函数调用匹配的正则表达式的第 `n` 个组 `\(...\)` 匹配的 `s` 的子字符串（有关详细信息，请参阅 `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` 的情况下，仅在 `subst` 参数中调用 `matched_string` 才是有效的，而不是在 `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]	Ephemeron 的最大长度，即 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]	`mem t x` 如果 `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]	`mem x m` 如果 `m` 包含 `x` 的绑定，则返回 `true`，否则返回 `false`。
mem [MoreLabels.Hashtbl.SeededS]
mem [MoreLabels.Hashtbl.S]
mem [MoreLabels.Hashtbl]	`Hashtbl.mem tbl x` 检查 `x` 是否在 `tbl` 中绑定。
mem [Map.S]	`mem x m` 如果 `m` 包含 `x` 的绑定，则返回 `true`，否则返回 `false`。
mem [ListLabels]	`mem a ~set` 当且仅当 `a` 等于 `set` 的一个元素时为真。
mem [List]	`mem a set` 当且仅当 `a` 等于 `set` 的一个元素时为真。
mem [Hashtbl.SeededS]
mem [Hashtbl.S]
mem [Hashtbl]	`Hashtbl.mem tbl x` 检查 `x` 是否在 `tbl` 中绑定。
mem [Float.ArrayLabels]	`mem a ~set` 当且仅当 `set` 中存在一个与 `a` 结构上相等的元素时为真，即
mem [Float.Array]	`mem a set` 当且仅当 `set` 中存在一个与 `a` 结构上相等的元素时为真，即
mem [Ephemeron.SeededS]
mem [Ephemeron.S]
mem [ArrayLabels]	`mem a ~set` 当且仅当 `a` 与 `set` 中的一个元素结构上相等（即
mem [Array]	`mem a set` 当且仅当 `a` 与 `set` 中的一个元素结构上相等（即
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]	`merge t x` 返回在 `t` 中找到的 `x` 的实例，如果没有找到，则将 `x` 添加到 `t` 中并返回 `x`。
merge [MoreLabels.Map.S]	`merge ~f m1 m2` 计算一个映射，其键是 `m1` 和 `m2` 的键的子集。
merge [Map.S]	`merge f m1 m2` 计算一个映射，其键是 `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]	返回给定映射中具有最小键的绑定（根据 `Ord.compare` 排序），或者如果映射为空则引发 `Not_found`。
min_binding [Map.S]	返回给定映射中具有最小键的绑定（根据 `Ord.compare` 排序），或者如果映射为空则引发 `Not_found`。
min_binding_opt [MoreLabels.Map.S]	返回给定映射中具有最小键的绑定（根据 `Ord.compare` 排序），或者如果映射为空则返回 `None`。
min_binding_opt [Map.S]	返回给定映射中具有最小键的绑定（根据 `Ord.compare` 排序），或者如果映射为空则返回 `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` 返回由插槽引用的位置所包含的函数或定义的名称。
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` 返回 `x` 方向上 `y` 之后的下一个可表示浮点数。
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` 是 `c` 作为 Unicode 字符。
of_dispenser [Seq]	`of_dispenser it` 是分配器 `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` 是 `i` 作为 Unicode 字符。
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` 运行程序 `prog`，参数为 `args`。
open_process_args [Unix]	`open_process_args prog args` 运行程序 `prog`，参数为 `args`。
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`
output [Out_channel]	`output oc buf pos len` 将字节序列 `buf`
output [Digest.S]	将摘要写入给定的输出通道。
output [Digest]	将摘要写入给定的输出通道。
output_acc [CamlinternalFormat]
output_bigarray [Out_channel]	与 `Out_channel.output` 相同，但从大数组
output_binary_int [Stdlib]	以二进制格式（4 字节，大端序）将一个整数写入给定的输出通道。
output_buffer [Buffer]	`output_buffer oc b` 将缓冲区 `b` 的当前内容写入输出
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` 相同，
parse_argv [Arg]	`Arg.parse_argv ~current args speclist anon_fun usage_msg`
parse_argv_dynamic [Arg]	与 `Arg.parse_argv` 相同，
parse_dynamic [Arg]	与 `Arg.parse` 相同，
parse_expand [Arg]	与 `Arg.parse` 相同，
partition [Set.S]	`partition f s` 返回一对集合 `(s1, s2)`，其中
partition [Seq]	`partition p xs` 返回满足 `p` 的 `xs` 的元素
partition [MoreLabels.Set.S]	`partition ~f s` 返回一对集合 `(s1, s2)`，其中
partition [MoreLabels.Map.S]	`partition ~f m` 返回一对映射 `(m1, m2)`，其中
partition [Map.S]	`partition f m` 返回一对映射 `(m1, m2)`，其中
partition [ListLabels]	`partition ~f l` 返回一对列表 `(l1, l2)`，其中
partition [List]	`partition f l` 返回一对列表 `(l1, l2)`，其中
partition_map [Seq]	`partition_map f xs` 返回一对序列 `(ys, zs)`，其中
partition_map [ListLabels]	`partition_map f l` 返回一对列表 `(l1, l2)`，使得对于
partition_map [List]	`partition_map f l` 返回一对列表 `(l1, l2)`，使得对于
pause [UnixLabels]	等待直到传递一个非忽略、非阻塞信号。
pause [Unix]	等待直到传递一个非忽略、非阻塞信号。
pause [Runtime_events]	`pause ()` 将暂停运行时中的事件收集。
peek [Queue]	`peek q` 返回队列 `q` 中的第一个元素，但不将其从队列中
peek_opt [Queue]	`peek_opt q` 返回队列 `q` 中的第一个元素，但不将其从队列中
perform [Effect]	`perform e` 执行一个副作用 `e`。
pi [Float]	常数 pi。
pipe [UnixLabels]	创建一个管道。
pipe [Unix]	创建一个管道。
polar [Complex]	`polar norm arg` 返回具有模数 `norm` 和辐角
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` 使用 `left` 在 `ppf` 上打印 `e`，如果 `e` 是 `Either.Left _`，则使用 `right` 打印，如果 `e` 是 `Either.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` 在 `ppf` 上格式化 `iter` 对集合 `v` 中值的迭代，使用 `pp_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` 使用 `pp_v` 在 `ppf` 上打印 `o`，如果 `o` 是 `Some v`，则使用 `none` 打印，如果它为 `None`。
pp_print_result [Format]	`pp_print_result ~ok ~error ppf r` 使用 `ok` 在 `ppf` 上打印 `r`，如果 `r` 是 `Ok _`，则使用 `error` 打印，如果 `r` 是 `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` 使用 `Format.pp_print_space` 和 `Format.pp_force_newline` 分别打印空格和换行符打印 `s`。
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]	`provably_equal i0 i1` 如果标识符 `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]	`Ephemeron.K1.query eph key` 如果 `key` 与 `eph` 的键在物理上相等，则返回 `Some x`（其中 `x` 是瞬态的值），如果 `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]	使用给定的原始回溯重新引发异常，作为异常的来源。
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` 中的插槽数量。
raw_backtrace_to_string [Printexc]	从原始回溯返回一个字符串，格式与 `Printexc.get_backtrace` 使用的格式相同。
raw_field [Obj]
rcontains_from [String]	`rcontains_from s stop c` 当且仅当 `c` 出现在 `s` 中的位置 `stop+1` 之前时为 `true`。
rcontains_from [StringLabels]	`rcontains_from s stop c` 当且仅当 `c` 出现在 `s` 中的位置 `stop+1` 之前时为 `true`。
rcontains_from [BytesLabels]	`rcontains_from s stop c` 测试字节 `c` 是否出现在 `s` 中的位置 `stop+1` 之前。
rcontains_from [Bytes]	`rcontains_from s stop c` 测试字节 `c` 是否出现在 `s` 中的位置 `stop+1` 之前。
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` 相同，但将数据读入大数组中。
read_bigarray [Unix]	与 `Unix.read` 相同，但将数据读入大数组中。
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` 相同，但将数据读入大数组中。
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]	从连接的套接字接收数据。
recv [Unix]	从连接的套接字接收数据。
recvfrom [UnixLabels]	从未连接的套接字接收数据。
recvfrom [Unix]	从未连接的套接字接收数据。
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` 在名称 `n` 下注册值 `v`。
register_exception [Callback]	`Callback.register_exception n exn` 在名称 `n` 下注册异常值 `exn` 中的异常。
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` 的短暂对象，如果不存在这样的短暂对象，则不执行任何操作。
remove [Ephemeron.K2.Bucket]	`remove b k1 k2` 从 `b` 中移除最近添加的具有键 `k1` 和 `k2` 的短暂对象，如果不存在这样的短暂对象，则不执行任何操作。
remove [Ephemeron.K1.Bucket]	`remove b k` 从 `b` 中移除最近添加的具有键 `k` 的短暂对象，如果不存在这样的短暂对象，则不执行任何操作。
remove [Ephemeron.SeededS]
remove [Ephemeron.S]
remove_assoc [ListLabels]	`remove_assoc a l` 返回对列表 `l`，其中不包含第一个键为 `a` 的对（如果有）。
remove_assoc [List]	`remove_assoc a l` 返回对列表 `l`，其中不包含第一个键为 `a` 的对（如果有）。
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` 用 `key` 到 `data` 的绑定替换 `tbl` 中 `key` 的当前绑定。
replace [Hashtbl.SeededS]
replace [Hashtbl.S]
replace [Hashtbl]	`Hashtbl.replace tbl key data` 用 `key` 到 `data` 的绑定替换 `tbl` 中 `key` 的当前绑定。
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 重塑为零维数组的 `Bigarray.reshape` 的版本。
reshape_1 [Bigarray]	专门用于将 Bigarray 重塑为一维数组的 `Bigarray.reshape` 的版本。
reshape_2 [Bigarray]	专门用于将 Bigarray 重塑为二维数组的 `Bigarray.reshape` 的版本。
reshape_3 [Bigarray]	专门用于将 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` 返回字节 `c` 在 `s` 中最后出现的位置。
rindex [Bytes]	`rindex s c` 返回字节 `c` 在 `s` 中最后出现的位置。
rindex_from [String]	`rindex_from s i c` 是 `c` 在位置 `i+1` 之前在 `s` 中最后出现的位置。
rindex_from [StringLabels]	`rindex_from s i c` 是 `c` 在位置 `i+1` 之前在 `s` 中最后出现的位置。
rindex_from [BytesLabels]	`rindex_from s i c` 返回字节 `c` 在位置 `i+1` 之前在 `s` 中最后出现的位置。
rindex_from [Bytes]	`rindex_from s i c` 返回字节 `c` 在位置 `i+1` 之前在 `s` 中最后出现的位置。
rindex_from_opt [String]	`rindex_from_opt s i c` 是 `c` 在位置 `i+1` 之前在 `s` 中最后出现的位置（如果有）。
rindex_from_opt [StringLabels]	`rindex_from_opt s i c` 是 `c` 在位置 `i+1` 之前在 `s` 中最后出现的位置（如果有）。
rindex_from_opt [BytesLabels]	`rindex_from_opt s i c` 返回字节 `c` 在位置 `i+1` 之前在 `s` 中最后出现的位置，或者如果 `c` 在位置 `i+1` 之前未出现在 `s` 中，则返回 `None`。
rindex_from_opt [Bytes]	`rindex_from_opt s i c` 返回字节 `c` 在位置 `i+1` 之前在 `s` 中最后出现的位置，或者如果 `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` 返回发送值 `v` 到通道 `ch` 的事件。
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` 更改 GC 参数，以符合 `control` 记录 `r`。
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]	设置给定描述符上的“非阻塞”标志。
set_nonblock [Unix]	设置给定描述符上的“非阻塞”标志。
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` 的大端无符号 16 位整数（从字节索引 `i` 开始）设置为 `v`。
set_uint16_be [Bytes]	`set_uint16_be b i v` 将 `b` 的大端无符号 16 位整数（从字节索引 `i` 开始）设置为 `v`。
set_uint16_le [BytesLabels]	`set_uint16_le b i v` 将 `b` 的小端无符号 16 位整数（从字节索引 `i` 开始）设置为 `v`。
set_uint16_le [Bytes]	`set_uint16_le b i v` 将 `b` 的小端无符号 16 位整数（从字节索引 `i` 开始）设置为 `v`。
set_uint16_ne [BytesLabels]	`set_uint16_ne b i v` 将 `b` 的本机端无符号 16 位整数（从字节索引 `i` 开始）设置为 `v`。
set_uint16_ne [Bytes]	`set_uint16_ne b i v` 将 `b` 的本机端无符号 16 位整数（从字节索引 `i` 开始）设置为 `v`。
set_uint8 [BytesLabels]	`set_uint8 b i v` 将 `b` 的无符号 8 位整数（从字节索引 `i` 开始）设置为 `v`。
set_uint8 [Bytes]	`set_uint8 b i v` 将 `b` 的无符号 8 位整数（从字节索引 `i` 开始）设置为 `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]	设置或清除给定套接字中的布尔值选项。
setsockopt [Unix]	设置或清除给定套接字中的布尔值选项。
setsockopt_float [UnixLabels]	与 `UnixLabels.setsockopt` 相同，用于套接字选项，其值为浮点数。
setsockopt_float [Unix]	与 `Unix.setsockopt` 相同，用于套接字选项，其值为浮点数。
setsockopt_int [UnixLabels]	与 `UnixLabels.setsockopt` 相同，用于整数值套接字选项。
setsockopt_int [Unix]	与 `Unix.setsockopt` 相同，用于整数值套接字选项。
setsockopt_optint [UnixLabels]	与 `UnixLabels.setsockopt` 相同，用于套接字选项，其值为 `int option`。
setsockopt_optint [Unix]	与 `Unix.setsockopt` 相同，用于套接字选项，其值为 `int option`。
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]	关闭套接字连接。
shutdown [Unix]	关闭套接字连接。
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]	套接字上的紧急情况
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 [Unix]	在给定的域中，以及使用给定的类型，创建一个新的套接字。
socketpair [UnixLabels]	创建一个相互连接的无名套接字对。
socketpair [Unix]	创建一个相互连接的无名套接字对。
some [Option]	`some v` 是 `Some v`。
sort [ListLabels]	根据比较函数，按升序对列表进行排序。
sort [List]	根据比较函数，按升序对列表进行排序。
sort [Float.ArrayLabels]	根据比较函数，按升序对浮点数数组进行排序。
sort [Float.Array]	根据比较函数，按升序对浮点数数组进行排序。
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` 的元素集合；`present` 如果 `s` 不包含等于 `x` 的元素，则为 `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` 的元素集合；`present` 如果 `s` 不包含等于 `x` 的元素，则为 `false`，或者如果 `s` 包含等于 `x` 的元素，则为 `true`。
split [MoreLabels.Map.S]	`split x m` 返回一个三元组 `(l, data, r)`，其中 `l` 是所有键值对 `m` 的映射，其键值严格小于 `x`；`r` 是所有键值对 `m` 的映射，其键值严格大于 `x`；`data` 如果 `m` 不包含绑定到 `x` 的键值对，则为 `None`，或者如果 `m` 将 `v` 绑定到 `x`，则为 `Some v`。
split [Map.S]	`split x m` 返回一个三元组 `(l, data, r)`，其中 `l` 是所有键值对 `m` 的映射，其键值严格小于 `x`；`r` 是所有键值对 `m` 的映射，其键值严格大于 `x`；`data` 如果 `m` 不包含绑定到 `x` 的键值对，则为 `None`，或者如果 `m` 将 `v` 绑定到 `x`，则为 `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]	`starts_with` `~prefix s` 当且仅当 `s` 以 `prefix` 开头时为 `true`。
starts_with [StringLabels]	`starts_with` `~prefix s` 当且仅当 `s` 以 `prefix` 开头时为 `true`。
starts_with [BytesLabels]	`starts_with` `~prefix s` 当且仅当 `s` 以 `prefix` 开头时为 `true`。
starts_with [Bytes]	`starts_with` `~prefix s` 当且仅当 `s` 以 `prefix` 开头时为 `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` 测试 `s` 中从位置 `start` 开始的子字符串是否与正则表达式 `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`，但如果参数字符串是匹配字符串的前缀，也返回真值。
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` 当前内容中从偏移量 `off` 开始的 `len` 个字节的副本。
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` 传输一个停止字符来暂停输入，以及 `TCION` 传输一个开始字符来重启输入。
tcflow [Unix]	根据第二个参数，暂停或重启给定文件描述符上的数据接收或传输：`TCOOFF` 暂停输出，`TCOON` 重启输出，`TCIOFF` 传输一个停止字符来暂停输入，以及 `TCION` 传输一个开始字符来重启输入。
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]	返回自 00:00:00 GMT，1 月以来的当前时间。
time [Unix]	返回自 00:00:00 GMT，1 月以来的当前时间。
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` 是 `u` 作为 OCaml 拉丁1 字符。
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` 是 `0.` 如果 `b` 是 `false` 并且是 `1.` 如果 `b` 是 `true`。
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` 是 `0` 如果 `b` 是 `false` 并且是 `1` 如果 `b` 是 `true`。
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` 是 `[v]` 如果 `r` 是 `Ok v` 并且是 `[]` 否则。
to_list [Option]	`to_list o` 是 `[]` 如果 `o` 是 `None` 并且是 `[v]` 如果 `o` 是 `Some 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]	`to_result ~none o` 是 `Ok v` 如果 `o` 是 `Some 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` 遍历 `s` 的元素子集，按升序排列，从 `x` 或更高开始。
to_seq_from [MoreLabels.Set.S]	`to_seq_from x s` 遍历 `s` 的元素子集，按升序排列，从 `x` 或更高开始。
to_seq_from [MoreLabels.Map.S]	`to_seq_from k m` 遍历 `m` 的绑定子集，按键的升序排列，从键 `k` 或更高开始。
to_seq_from [Map.S]	`to_seq_from k m` 遍历 `m` 的绑定子集，按键的升序排列，从键 `k` 或更高开始。
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]	`to_string b` 如果 `b` 为 `true`，则为 `"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]	`try_acquire s` 如果信号量 `s` 的值为 0，则立即返回 `false`。
try_acquire [Semaphore.Counting]	`try_acquire s` 如果信号量 `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]	返回进程环境，作为格式为“变量=值”的字符串数组。
unsafe_environment [Unix]	返回进程环境，作为格式为“变量=值”的字符串数组。
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`，其中 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]	`utf_decode_is_valid d` 当且仅当 `d` 包含有效的解码时为 `true`。
utf_decode_length [Uchar]	`utf_decode_length d` 表示解码 `d` 时从源数据中消耗的元素数量。
utf_decode_uchar [Uchar]	`utf_decode_uchar d` 表示由 `d` 解码的 Unicode 字符，如果 `utf_decode_is_valid d` 为 `true`，否则为 `Uchar.rep`。
utimes [UnixLabels]	设置文件的最后访问时间（第二个参数）和最后修改时间（第三个参数）。
utimes [Unix]	设置文件的最后访问时间（第二个参数）和最后修改时间（第三个参数）。
V
value [Result]	`value r ~default` 如果 `r` 为 `Ok v`，则为 `v`，否则为 `default`。
value [Option]	`value o ~default` 如果 `o` 为 `Some v`，则为 `v`，否则为 `default`。
W
wait [UnixLabels]	等待直到子进程之一死亡，并返回其进程 ID 和终止状态。
wait [Unix]	等待直到子进程之一死亡，并返回其进程 ID 和终止状态。
wait [Condition]	调用 `wait c m` 仅当 `m` 是与条件变量 `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]	挂起调用线程的执行，直到在给定的 Unix 文件描述符上至少有一个字符或 EOF 可用于读取（`wait_timed_read`）或可以写入一个字符而不阻塞（`wait_timed_write`）。
waitpid [UnixLabels]	与 `UnixLabels.wait` 相同，但会等待指定进程 ID 的子进程。
waitpid [Unix]	与 `Unix.wait` 相同，但会等待指定进程 ID 的子进程。
widen [CamlinternalOO]
win32 [Sys]	如果 `Sys.os_type = "Win32"`，则为真。
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)` 对的序列。