模块 Stdlib

module Stdlib: sig .. end

OCaml 标准库。

此模块在每次编译开始时自动打开。因此，此模块的所有组件都可以通过其简短名称引用，无需使用 Stdlib 作为前缀。

特别是，它提供了对内置类型（数字、布尔值、字节序列、字符串、异常、引用、列表、数组、输入/输出通道等）的基本操作以及标准库模块。

异常

val raise : exn -> 'a

引发给定的异常值

val raise_notrace : exn -> 'a

一个更快的版本 raise，它不记录回溯。

自从 4.02

val invalid_arg : string -> 'a

引发异常 Invalid_argument，并带有给定的字符串。

val failwith : string -> 'a

引发异常 Failure，并带有给定的字符串。

exception Exit

异常 Exit 不会由任何库函数引发。它提供用于程序中的使用。

exception Match_failure of (string * int * int)

当模式匹配的任何情况都不适用时引发的异常。参数是源代码中匹配关键字的位置（文件名、行号、列号）。

exception Assert_failure of (string * int * int)

当断言失败时引发的异常。参数是源代码中 assert 关键字的位置（文件名、行号、列号）。

exception Invalid_argument of string

由库函数引发的异常，以表示给定的参数没有意义。字符串提供一些信息给程序员。一般来说，此异常不应该被捕获，它表示编程错误，代码应该修改，不要触发它。

exception Failure of string

由库函数引发的异常，以表示它们在给定的参数上未定义。字符串旨在提供一些信息给程序员；您不应将字符串文字进行模式匹配，因为它可能会在将来的版本中更改（改为使用 Failure _）。

exception Not_found

搜索函数在找不到所需对象时引发的异常。

exception Out_of_memory

当垃圾回收器没有足够的内存来完成计算时引发的异常。（对于次要堆上的分配不可靠。）

exception Stack_overflow

当字节码解释器达到其最大堆栈大小时引发的异常。这通常表明用户程序中存在无限或过度深度的递归。

在 4.10 之前，它没有被原生代码编译器完全实现。

exception Sys_error of string

由输入/输出函数引发的异常，以报告操作系统错误。字符串旨在提供一些信息给程序员；您不应将字符串文字进行模式匹配，因为它可能会在将来的版本中更改（改为使用 Sys_error _）。

exception End_of_file

由输入函数引发的异常，以表示已到达文件末尾。

exception Division_by_zero

当它们的第二个参数为零时，由整数除法和余数运算引发的异常。

exception Sys_blocked_io

当在非阻塞 I/O 通道上无法执行 I/O 时引发的 Sys_error 的特殊情况。

exception Undefined_recursive_module of (string * int * int)

当评估无基础的递归模块定义时引发的异常。参数是源代码中定义的位置（文件名、行号、列号）。

比较

val (=) : 'a -> 'a -> bool

e1 = e2 测试 e1 和 e2 的结构相等性。可变结构（例如引用和数组）当且仅当它们当前的内容结构相等时才相等，即使两个可变对象不是同一个物理对象也是如此。函数值之间的相等性会引发 Invalid_argument。循环数据结构之间的相等性可能无法终止。左结合运算符，有关更多信息，请参见 Ocaml_operators。

val (<>) : 'a -> 'a -> bool

(=) 的否定。左结合运算符，有关更多信息，请参见 Ocaml_operators。

val (<) : 'a -> 'a -> bool

参见 (>=)。左结合运算符，有关更多信息，请参见 Ocaml_operators。

val (>) : 'a -> 'a -> bool

参见 (>=)。左结合运算符，有关更多信息，请参见 Ocaml_operators。

val (<=) : 'a -> 'a -> bool

参见 (>=)。左结合运算符，有关更多信息，请参见 Ocaml_operators。

val (>=) : 'a -> 'a -> bool

结构排序函数。这些函数与整数、字符、字符串、字节序列和浮点数上的常用排序一致，并将它们扩展到所有类型上的全排序。排序与 ( = ) 兼容。与 ( = ) 一样，可变结构按内容进行比较。函数值之间的比较会引发 Invalid_argument。循环结构之间的比较可能无法终止。左结合运算符，有关更多信息，请参见 Ocaml_operators。

val compare : 'a -> 'a -> int

compare x y 如果 x 等于 y，则返回 0；如果 x 小于 y，则返回负整数；如果 x 大于 y，则返回正整数。由 compare 实现的排序与上面定义的比较谓词 =、< 和 > 兼容，在处理浮点值 nan 方面存在一个区别。也就是说，比较谓词将 nan 视为与任何其他浮点值（包括它自身）不同；而 compare 将 nan 视为等于它自身并且小于任何其他浮点值。这种对 nan 的处理确保 compare 定义了一个全排序关系。

compare 应用于函数值可能会引发 Invalid_argument。 compare 应用于循环结构可能无法终止。

compare 函数可以用作 Set.Make 和 Map.Make 函子以及 List.sort 和 Array.sort 函数所需的比较函数。

val min : 'a -> 'a -> 'a

返回两个参数中较小的那个。如果其中一个参数包含浮点值 nan，则结果未定义。

val max : 'a -> 'a -> 'a

返回两个参数中较大的那个。如果其中一个参数包含浮点值 nan，则结果未定义。

val (==) : 'a -> 'a -> bool

e1 == e2 测试 e1 和 e2 的物理相等性。在可变类型（如引用、数组、字节序列、具有可变字段的记录和具有可变实例变量的对象）上，e1 == e2 当且仅当 e1 的物理修改也会影响 e2 时为真。在不可变类型上，( == ) 的行为依赖于实现；但是，保证 e1 == e2 意味着 compare e1 e2 = 0。左结合运算符，有关更多信息，请参见 Ocaml_operators。

val (!=) : 'a -> 'a -> bool

(==) 的否定。左结合运算符，有关更多信息，请参见 Ocaml_operators。

布尔运算

val not : bool -> bool

布尔否定。

val (&&) : bool -> bool -> bool

布尔“与”。评估是顺序的，从左到右：在 e1 && e2 中，e1 首先被评估，如果它返回 false，则 e2 根本不会被评估。右结合运算符，有关更多信息，请参见 Ocaml_operators。

val (||) : bool -> bool -> bool

布尔“或”。评估是顺序的，从左到右：在 e1 || e2 中，e1 首先被评估，如果它返回 true，则 e2 根本不会被评估。右结合运算符，有关更多信息，请参见 Ocaml_operators。

调试

val __LOC__ : string

__LOC__ 返回此表达式在当前被编译器解析的文件中出现的位置，使用 OCaml 的标准错误格式："File %S, line %d, characters %d-%d"。

自从 4.02

val __FILE__ : string

__FILE__ 返回当前被编译器解析的文件的名称。

自从 4.02

val __LINE__ : int

__LINE__ 返回此表达式在当前被编译器解析的文件中出现的位置的行号。

自从 4.02

val __MODULE__ : string

__MODULE__ 返回当前被编译器解析的文件的模块名称。

自从 4.02

val __POS__ : string * int * int * int

__POS__ 返回一个元组 (file,lnum,cnum,enum)，对应于此表达式在当前被编译器解析的文件中出现的位置。 file 是当前文件名，lnum 是行号，cnum 是行中的字符位置，enum 是行中的最后一个字符位置。

自从 4.02

val __FUNCTION__ : string

__FUNCTION__ 返回当前函数或方法的名称，包括任何封闭的模块或类。

自从 4.12

val __LOC_OF__ : 'a -> string * 'a

__LOC_OF__ expr 返回一对 (loc, expr)，其中 loc 是 expr 在当前被编译器解析的文件中出现的位置，使用 OCaml 的标准错误格式："File %S, line %d, characters %d-%d"。

自从 4.02

val __LINE_OF__ : 'a -> int * 'a

__LINE_OF__ expr 返回一对 (line, expr)，其中 line 是表达式 expr 在当前被编译器解析的文件中出现的位置的行号。

自从 4.02

val __POS_OF__ : 'a -> (string * int * int * int) * 'a

__POS_OF__ expr 返回一对 (loc,expr)，其中 loc 是一个元组 (file,lnum,cnum,enum)，对应于表达式 expr 在当前被编译器解析的文件中出现的位置。 file 是当前文件名，lnum 是行号，cnum 是行中的字符位置，enum 是行中的最后一个字符位置。

自从 4.02

组合运算符

val (|>) : 'a -> ('a -> 'b) -> 'b

反向应用运算符：x |> f |> g 等效于 g (f (x))。左结合运算符，有关更多信息，请参见 Ocaml_operators。

自从 4.01

val (@@) : ('a -> 'b) -> 'a -> 'b

应用运算符：g @@ f @@ x 等效于 g (f (x))。右结合运算符，有关更多信息，请参见 Ocaml_operators。

自从 4.01

整数运算

整数的宽度为 Sys.int_size 位。所有运算都以 2 的 Sys.int_size 次幂为模进行。它们不会在溢出时失败。

val (~-) : int -> int

一元否定。你也可以写 - e 代替 ~- e。一元运算符，更多信息请参见 Ocaml_operators。

val (~+) : int -> int

一元加法。你也可以写 + e 代替 ~+ e。一元运算符，更多信息请参见 Ocaml_operators。

自从 3.12

val succ : int -> int

succ x 等于 x + 1。

val pred : int -> int

pred x 等于 x - 1。

val (+) : int -> int -> int

整数加法。左结合运算符，更多信息请参见 Ocaml_operators。

val (-) : int -> int -> int

整数减法。左结合运算符，更多信息请参见 Ocaml_operators。

val ( * ) : int -> int -> int

整数乘法。左结合运算符，更多信息请参见 Ocaml_operators。

val (/) : int -> int -> int

整数除法。整数除法将实数商四舍五入到零。更准确地说，如果 x >= 0 且 y > 0，则 x / y 是小于或等于 x 除以 y 的实数商的最大整数。此外，(- x) / y = x / (- y) = - (x / y)。左结合运算符，更多信息请参见 Ocaml_operators。

抛出 Division_by_zero 如果第二个参数为 0。

val (mod) : int -> int -> int

整数余数。如果 y 不为零，则 x mod y 的结果满足以下属性：x = (x / y) * y + x mod y 且 abs(x mod y) <= abs(y) - 1。如果 y = 0，则 x mod y 抛出 Division_by_zero。请注意，x mod y 仅当 x < 0 时为负数。左结合运算符，更多信息请参见 Ocaml_operators。

抛出 Division_by_zero 如果 y 为零。

val abs : int -> int

abs x 是 x 的绝对值。在 min_int 上，它本身就是 min_int，因此仍然是负数。

val max_int : int

最大的可表示整数。

val min_int : int

最小的可表示整数。

位运算

val (land) : int -> int -> int

按位逻辑与。左结合运算符，更多信息请参见 Ocaml_operators。

val (lor) : int -> int -> int

按位逻辑或。左结合运算符，更多信息请参见 Ocaml_operators。

val (lxor) : int -> int -> int

按位逻辑异或。左结合运算符，更多信息请参见 Ocaml_operators。

val lnot : int -> int

按位逻辑非。

val (lsl) : int -> int -> int

n lsl m 将 n 左移 m 位。如果 m < 0 或 m > Sys.int_size，则结果未定义。右结合运算符，更多信息请参见 Ocaml_operators。

val (lsr) : int -> int -> int

n lsr m 将 n 右移 m 位。这是一个逻辑移位：无论 n 的符号如何，都会插入零。如果 m < 0 或 m > Sys.int_size，则结果未定义。右结合运算符，更多信息请参见 Ocaml_operators。

val (asr) : int -> int -> int

n asr m 将 n 右移 m 位。这是一个算术移位：复制 n 的符号位。如果 m < 0 或 m > Sys.int_size，则结果未定义。右结合运算符，更多信息请参见 Ocaml_operators。

浮点运算

OCaml 的浮点数遵循 IEEE 754 标准，使用双精度 (64 位) 数。浮点运算在溢出、下溢、除以零等情况下永远不会抛出异常。相反，将返回相应的特殊 IEEE 数，例如 infinity 用于 1.0 /. 0.0，neg_infinity 用于 -1.0 /. 0.0，以及 nan（'非数字'）用于 0.0 /. 0.0。这些特殊数字将按预期在浮点计算中传播：例如，1.0 /. infinity 是 0.0，nan 作为参数的基本算术运算（+.、-.、*.、/.）返回 nan，...

val (~-.) : float -> float

一元否定。你也可以写 -. e 代替 ~-. e。一元运算符，更多信息请参见 Ocaml_operators。

val (~+.) : float -> float

一元加法。你也可以写 +. e 代替 ~+. e。一元运算符，更多信息请参见 Ocaml_operators。

自从 3.12

val (+.) : float -> float -> float

浮点加法。左结合运算符，更多信息请参见 Ocaml_operators。

val (-.) : float -> float -> float

浮点减法。左结合运算符，更多信息请参见 Ocaml_operators。

val ( *. ) : float -> float -> float

浮点乘法。左结合运算符，更多信息请参见 Ocaml_operators。

val (/.) : float -> float -> float

浮点除法。左结合运算符，更多信息请参见 Ocaml_operators。

val ( ** ) : float -> float -> float

求幂。右结合运算符，更多信息请参见 Ocaml_operators。

val sqrt : float -> float

平方根。

val exp : float -> float

指数。

val log : float -> float

自然对数。

val log10 : float -> float

以 10 为底的对数。

val expm1 : float -> float

expm1 x 计算 exp x -. 1.0，即使 x 接近 0.0 也能给出数值精确的结果。

自从 3.12

val log1p : float -> float

log1p x 计算 log(1.0 +. x)（自然对数），即使 x 接近 0.0 也能给出数值精确的结果。

自从 3.12

val cos : float -> float

余弦。参数以弧度为单位。

val sin : float -> float

正弦。参数以弧度为单位。

val tan : float -> float

正切。参数以弧度为单位。

val acos : float -> float

反余弦。参数必须在 [-1.0, 1.0] 范围内。结果以弧度为单位，介于 0.0 和 pi 之间。

val asin : float -> float

反正弦。参数必须在 [-1.0, 1.0] 范围内。结果以弧度为单位，介于 -pi/2 和 pi/2 之间。

val atan : float -> float

反正切。结果以弧度为单位，介于 -pi/2 和 pi/2 之间。

val atan2 : float -> float -> float

atan2 y x 返回 y /. x 的反正切。x 和 y 的符号用于确定结果的象限。结果以弧度为单位，介于 -pi 和 pi 之间。

val hypot : float -> float -> float

hypot x y 返回 sqrt(x *. x + y *. y)，即两条边长度分别为 x 和 y 的直角三角形的斜边长度，或等效地，点 (x,y) 到原点的距离。如果 x 或 y 之一是无穷大，则返回 infinity，即使另一个是 nan。

自从 4.00

val cosh : float -> float

双曲余弦。参数以弧度为单位。

val sinh : float -> float

双曲正弦。参数以弧度为单位。

val tanh : float -> float

双曲正切。参数以弧度为单位。

val acosh : float -> float

双曲反余弦。参数必须在 [1.0, inf] 范围内。结果以弧度为单位，介于 0.0 和 inf 之间。

自从 4.13

val asinh : float -> float

双曲反正弦。参数和结果范围在整个实数线上。结果以弧度为单位。

自从 4.13

val atanh : float -> float

双曲反正切。参数必须在 [-1.0, 1.0] 范围内。结果以弧度为单位，范围在整个实数线上。

自从 4.13

val ceil : float -> float

向上舍入到整数。ceil f 返回大于或等于 f 的最小整数。结果以浮点数形式返回。

val floor : float -> float

向下舍入到整数。floor f 返回小于或等于 f 的最大整数。结果以浮点数形式返回。

val abs_float : float -> float

abs_float f 返回 f 的绝对值。

val copysign : float -> float -> float

copysign x y 返回一个浮点数，其绝对值为 x 的绝对值，其符号为 y 的符号。如果 x 是 nan，则返回 nan。如果 y 是 nan，则返回 x 或 -. x，但没有指定哪一个。

自从 4.00

val mod_float : float -> float -> float

mod_float a b 返回 a 对 b 的余数。返回值为 a -. n *. b，其中 n 是商 a /. b 向零舍入到整数。

val frexp : float -> float * int

frexp f 返回 f 的有效数字和指数的对。当 f 为零时，有效数字 x 和 f 的指数 n 等于零。当 f 不为零时，它们由 f = x *. 2 ** n 和 0.5 <= x < 1.0 定义。

val ldexp : float -> int -> float

ldexp x n 返回 x *. 2 ** n。

val modf : float -> float * float

modf f 返回 f 的小数部分和整数部分的对。

val float : int -> float

与 float_of_int 相同。

val float_of_int : int -> float

将整数转换为浮点数。

val truncate : float -> int

与 int_of_float 相同。

val int_of_float : float -> int

将给定的浮点数截断为整数。如果参数是 nan 或超出可表示整数的范围，则结果未定义。

val infinity : float

正无穷大。

val neg_infinity : float

负无穷大。

val nan : float

一个特殊的浮点数，表示未定义运算的结果，例如0.0 /. 0.0。代表“非数字”。任何以nan作为参数的浮点运算都返回nan作为结果，除非 IEEE 754 标准另有规定。对于浮点比较，=、<、<=、> 和 >= 返回 false，而 <> 返回 true，如果其一个或两个参数是 nan。

nan 从 5.1 开始是安静的 NaN；之前它是信号 NaN。

val max_float : float

类型 float 的最大正有限值。

val min_float : float

类型 float 的最小正非零非规格化值。

val epsilon_float : float

1.0 与大于 1.0 的最小精确可表示浮点数之间的差值。

type fpclass =

`\|`	`FP_normal`	`(*`	普通数字，不属于以下任何类型。	`*)`
`\|`	`FP_subnormal`	`(*`	非常接近 0.0 的数字，精度降低。	`*)`
`\|`	`FP_zero`	`(*`	数字为 0.0 或 -0.0。	`*)`
`\|`	`FP_infinite`	`(*`	数字为正无穷或负无穷。	`*)`
`\|`	`FP_nan`	`(*`	非数字：未定义运算的结果。	`*)`

五类浮点数，由 classify_float 函数确定。

val classify_float : float -> fpclass

返回给定浮点数的类别：普通、次正规、零、无穷或非数字。

字符串操作

模块 String 中提供了更多字符串操作。

val (^) : string -> string -> string

字符串连接。右结合运算符，有关更多信息，请参见 Ocaml_operators。

引发如果结果长度超过 Sys.max_string_length 字节，则引发 Invalid_argument。

字符操作

模块 Char 中提供了更多字符操作。

val int_of_char : char -> int

返回参数的 ASCII 码。

val char_of_int : int -> char

返回具有给定 ASCII 码的字符。

引发如果参数超出范围 0--255，则引发 Invalid_argument。

单元操作

val ignore : 'a -> unit

丢弃其参数的值并返回 ()。例如，ignore(f x) 丢弃副作用函数 f 的结果。它等效于 f x; ()，但后者可能会生成编译器警告；编写 ignore(f x) 可以避免警告。

字符串转换函数

val string_of_bool : bool -> string

返回布尔值的字符串表示形式。由于返回的值可能是共享的，因此用户不应直接修改它们。

val bool_of_string_opt : string -> bool option

将给定字符串转换为布尔值。

如果字符串不是 "true" 或 "false"，则返回 None。

自从 4.05

val bool_of_string : string -> bool

与 bool_of_string_opt 相同，但引发 Invalid_argument "bool_of_string" 而不是返回 None。

val string_of_int : int -> string

返回整数的字符串表示形式（十进制）。

val int_of_string_opt : string -> int option

将给定字符串转换为整数。字符串以十进制（默认或如果字符串以 0u 开头）、十六进制（如果字符串以 0x 或 0X 开头）、八进制（如果字符串以 0o 或 0O 开头）或二进制（如果字符串以 0b 或 0B 开头）形式读取。

0u 前缀将输入读取为范围 [0, 2*max_int+1] 内的无符号整数。如果输入超过 max_int，则将其转换为有符号整数 min_int + input - max_int - 1。

字符 _（下划线）可以出现在字符串中的任何位置，并将被忽略。

如果给定字符串不是整数的有效表示形式，或者表示的整数超出类型 int 可表示的整数范围，则返回 None。

自从 4.05

val int_of_string : string -> int

与 int_of_string_opt 相同，但引发 Failure "int_of_string" 而不是返回 None。

val string_of_float : float -> string

返回浮点数的字符串表示形式。

此转换可能会导致精度损失。有关对数字打印方式的更多控制，请参见 Printf。

val float_of_string_opt : string -> float option

将给定字符串转换为浮点数。字符串以十进制（默认）或十六进制（以 0x 或 0X 标记）形式读取。

十进制浮点数的格式为 [-] dd.ddd (e|E) [+|-] dd ，其中 d 代表十进制数字。

十六进制浮点数的格式为 [-] 0(x|X) hh.hhh (p|P) [+|-] dd ，其中 h 代表十六进制数字，d 代表十进制数字。

在这两种情况下，必须给出整数部分和分数部分中的至少一个；指数部分是可选的。

字符 _（下划线）可以出现在字符串中的任何位置，并将被忽略。

根据执行平台，可以接受其他浮点数表示形式，但不要依赖它们。

如果给定字符串不是浮点数的有效表示形式，则返回 None。

自从 4.05

val float_of_string : string -> float

与 float_of_string_opt 相同，但引发 Failure "float_of_string" 而不是返回 None。

对操作

val fst : 'a * 'b -> 'a

返回对的第一个组件。

val snd : 'a * 'b -> 'b

返回对的第二个组件。

列表操作

模块 List 中提供了更多列表操作。

val (@) : 'a list -> 'a list -> 'a list

l0 @ l1 将 l1 附加到 l0。与 List.append 相同的函数。右结合运算符，有关更多信息，请参见 Ocaml_operators。

自 5.1 开始，此函数是尾递归的。

输入/输出

注意：所有输入/输出函数在系统调用失败时都可能引发 Sys_error。

type in_channel

输入通道的类型。

type out_channel

输出通道的类型。

val stdin : in_channel

进程的标准输入。

val stdout : out_channel

进程的标准输出。

val stderr : out_channel

进程的标准错误输出。

标准输出的输出函数

val print_char : char -> unit

在标准输出上打印字符。

val print_string : string -> unit

在标准输出上打印字符串。

val print_bytes : bytes -> unit

在标准输出上打印字节序列。

自从 4.02

val print_int : int -> unit

在标准输出上打印整数（十进制）。

val print_float : float -> unit

在标准输出上打印浮点数（十进制）。

数字到字符串的转换使用 string_of_float，可能会导致精度损失。

val print_endline : string -> unit

在标准输出上打印字符串，后跟换行符，并刷新标准输出。

val print_newline : unit -> unit

在标准输出上打印换行符，并刷新标准输出。这可用于模拟标准输出的行缓冲。

标准错误的输出函数

val prerr_char : char -> unit

在标准错误上打印字符。

val prerr_string : string -> unit

在标准错误上打印字符串。

val prerr_bytes : bytes -> unit

在标准错误上打印字节序列。

自从 4.02

val prerr_int : int -> unit

在标准错误上打印整数（十进制）。

val prerr_float : float -> unit

在标准错误上打印浮点数（十进制）。

数字到字符串的转换使用 string_of_float，可能会导致精度损失。

val prerr_endline : string -> unit

在标准错误上打印字符串，后跟换行符，并刷新标准错误。

val prerr_newline : unit -> unit

在标准错误上打印换行符，并刷新标准错误。

标准输入的输入函数

val read_line : unit -> string

刷新标准输出，然后从标准输入读取字符，直到遇到换行符。

返回读取的所有字符的字符串，不包括末尾的换行符。

引发如果在行首到达文件末尾，则引发 End_of_file。

val read_int_opt : unit -> int option

刷新标准输出，然后从标准输入读取一行并将其转换为整数。

如果读取的行不是整数的有效表示形式，则返回 None。

自从 4.05

val read_int : unit -> int

与 read_int_opt 相同，但引发 Failure "int_of_string" 而不是返回 None。

val read_float_opt : unit -> float option

刷新标准输出，然后从标准输入读取一行并将其转换为浮点数。

如果读取的行不是浮点数的有效表示形式，则返回 None。

自从 4.05

val read_float : unit -> float

与 read_float_opt 相同，但引发 Failure "float_of_string" 而不是返回 None。

通用输出函数

type open_flag =

`\|`	`Open_rdonly`	`(*`	以只读方式打开。	`*)`
`\|`	`Open_wronly`	`(*`	以只写方式打开。	`*)`
`\|`	`Open_append`	`(*`	以追加方式打开：始终写入文件末尾。	`*)`
`\|`	`Open_creat`	`(*`	如果文件不存在，则创建文件。	`*)`
`\|`	`Open_trunc`	`(*`	如果文件已存在，则清空文件。	`*)`
`\|`	`Open_excl`	`(*`	如果 Open_creat 并且文件已存在，则失败。	`*)`
`\|`	`Open_binary`	`(*`	以二进制模式打开（无转换）。	`*)`
`\|`	`Open_text`	`(*`	以文本模式打开（可能执行转换）。	`*)`
`\|`	`Open_nonblock`	`(*`	以非阻塞模式打开。	`*)`

用于 open_out_gen 和 open_in_gen 的打开模式。

val open_out : string -> out_channel

以写入方式打开指定名称的文件，并返回该文件上的一个新输出通道，该通道定位在文件的开头。如果文件已存在，则将其截断为零长度。如果文件不存在，则创建它。

val open_out_bin : string -> out_channel

与 open_out 相同，但文件以二进制模式打开，因此在写入过程中不会进行任何转换。在不区分文本模式和二进制模式的操作系统上，此函数的行为类似于 open_out。

val open_out_gen : open_flag list -> int -> string -> out_channel

open_out_gen mode perm filename 以写入方式打开指定名称的文件，如上所述。额外的参数 mode 指定打开模式。额外的参数 perm 指定文件权限，以防必须创建文件。 open_out 和 open_out_bin 是此函数的特例。

val flush : out_channel -> unit

刷新与给定输出通道关联的缓冲区，执行该通道上所有挂起的写入操作。交互式程序必须注意在适当的时候刷新标准输出和标准错误。

val flush_all : unit -> unit

刷新所有打开的输出通道；忽略错误。

val output_char : out_channel -> char -> unit

将字符写入给定的输出通道。

val output_string : out_channel -> string -> unit

将字符串写入给定的输出通道。

val output_bytes : out_channel -> bytes -> unit

将字节序列写入给定的输出通道。

自从 4.02

val output : out_channel -> bytes -> int -> int -> unit

output oc buf pos len 从字节序列 buf 中写入 len 个字符，从偏移量 pos 开始，写入给定的输出通道 oc。

抛出 Invalid_argument，如果 pos 和 len 不指定 buf 的有效范围。

val output_substring : out_channel -> string -> int -> int -> unit

与 output 相同，但接受字符串作为参数，而不是字节序列。

自从 4.02

val output_byte : out_channel -> int -> unit

在给定的输出通道上写入一个 8 位整数（作为具有该代码的单个字符）。给定的整数取模 256。

val output_binary_int : out_channel -> int -> unit

在给定的输出通道上以二进制格式（4 字节，大端）写入一个整数。给定的整数取模 2³²。唯一可靠的读取方式是通过 input_binary_int 函数。该格式在给定 OCaml 版本的所有机器上都是兼容的。

val output_value : out_channel -> 'a -> unit

将任何类型的结构化值的表示写入通道。循环和值内部的共享会被检测并保留。可以使用 input_value 函数读取回该对象。有关更多信息，请参阅模块 Marshal 的说明。 output_value 等效于 Marshal.to_channel，带有空标志列表。

val seek_out : out_channel -> int -> unit

seek_out chan pos 将通道 chan 的当前写入位置设置为 pos。这仅适用于常规文件。对于其他类型的文件（例如终端、管道和套接字），行为未定义。

val pos_out : out_channel -> int

返回给定通道的当前写入位置。不适用于使用 Open_append 标志打开的通道（返回未定义的结果）。对于在 Windows 下以文本模式打开的文件，返回的位置是近似值（由于换行符转换）；特别是，使用 pos_out 保存当前位置，然后使用 seek_out 返回此位置将不起作用。为了使此编程习惯用法可靠且可移植，文件必须以二进制模式打开。

val out_channel_length : out_channel -> int

返回打开给定通道的常规文件的大小（字符数）。如果通道在非常规文件上打开，则结果毫无意义。

val close_out : out_channel -> unit

关闭给定的通道，刷新所有缓冲的写入操作。输出函数在应用于关闭的输出通道时会抛出 Sys_error 异常，除了 close_out 和 flush，它们在应用于已关闭的通道时不会执行任何操作。请注意，如果操作系统在刷新或关闭时发出错误信号，则 close_out 可能会抛出 Sys_error。

val close_out_noerr : out_channel -> unit

与 close_out 相同，但忽略所有错误。

val set_binary_mode_out : out_channel -> bool -> unit

set_binary_mode_out oc true 将通道 oc 设置为二进制模式：在输出期间不会进行任何转换。 set_binary_mode_out oc false 将通道 oc 设置为文本模式：根据操作系统，在输出期间可能会进行一些转换。例如，在 Windows 下，换行符将从 \n 转换为 \r\n。此函数在不区分文本模式和二进制模式的操作系统上没有影响。

通用输入函数

val open_in : string -> in_channel

打开命名文件以供读取，并在该文件上返回一个新的输入通道，位于文件开头。

val open_in_bin : string -> in_channel

与 open_in 相同，但文件以二进制模式打开，因此在读取期间不会进行任何转换。在不区分文本模式和二进制模式的操作系统上，此函数的行为与 open_in 相同。

val open_in_gen : open_flag list -> int -> string -> in_channel

open_in_gen mode perm filename 打开命名文件以供读取，如上所述。额外的参数 mode 和 perm 指定打开模式和文件权限。 open_in 和 open_in_bin 是此函数的特殊情况。

val input_char : in_channel -> char

从给定的输入通道读取一个字符。

抛出 End_of_file，如果不再有字符可读取。

val input_line : in_channel -> string

从给定的输入通道读取字符，直到遇到换行符。返回所有已读取字符的字符串，没有末尾的换行符。

引发如果在行首到达文件末尾，则引发 End_of_file。

val input : in_channel -> bytes -> int -> int -> int

input ic buf pos len 从给定的通道 ic 中读取最多 len 个字符，将它们存储在字节序列 buf 中，从字符编号 pos 开始。它返回实际读取的字符数，介于 0 和 len 之间（含）。返回值 0 表示已到达文件末尾。返回值介于 0 和 len 之间（不含）表示未读取所有请求的 len 个字符，要么是因为此时没有更多字符可用，要么是因为实现发现进行部分读取很方便；如果需要，必须再次调用 input 以读取剩余的字符。（另请参阅 really_input 以准确读取 len 个字符。）如果 pos 和 len 不指定 buf 的有效范围，则会抛出异常 Invalid_argument "input"。

val really_input : in_channel -> bytes -> int -> int -> unit

really_input ic buf pos len 从通道 ic 中读取 len 个字符，将它们存储在字节序列 buf 中，从字符编号 pos 开始。

抛出
- End_of_file，如果在读取 len 个字符之前已到达文件末尾。
- Invalid_argument，如果 pos 和 len 不指定 buf 的有效范围。

val really_input_string : in_channel -> int -> string

really_input_string ic len 从通道 ic 中读取 len 个字符，并将它们返回到一个新字符串中。

自从 4.02
抛出 End_of_file，如果在读取 len 个字符之前已到达文件末尾。

val input_byte : in_channel -> int

与 input_char 相同，但返回表示字符的 8 位整数。

抛出 End_of_file，如果已到达文件末尾。

val input_binary_int : in_channel -> int

从给定的输入通道读取以二进制格式编码的整数（4 字节，大端）。见 output_binary_int.

抛出 End_of_file，如果在读取整数时已到达文件末尾。

val input_value : in_channel -> 'a

读取由 output_value 生成的结构化值的表示，并返回相应的值。此函数与 Marshal.from_channel 相同；有关更多信息，请参阅模块 Marshal 的说明，特别是关于类型安全性的缺乏。

val seek_in : in_channel -> int -> unit

seek_in chan pos 将通道 chan 的当前读取位置设置为 pos。这仅适用于常规文件。对于其他类型的文件，行为未定义。

val pos_in : in_channel -> int

返回给定通道的当前读取位置。对于在 Windows 下以文本模式打开的文件，返回的位置是近似值（由于换行符转换）；特别是，使用 pos_in 保存当前位置，然后使用 seek_in 返回此位置将不起作用。为了使此编程习惯用法可靠且可移植，文件必须以二进制模式打开。

val in_channel_length : in_channel -> int

返回打开给定通道的常规文件的大小（字符数）。如果通道在非常规文件上打开，则结果毫无意义。返回的大小不考虑在从以文本模式打开的通道读取时可能执行的换行符转换。

val close_in : in_channel -> unit

关闭给定的通道。输入函数在应用于关闭的输入通道时会抛出 Sys_error 异常，除了 close_in，它在应用于已关闭的通道时不会执行任何操作。

val close_in_noerr : in_channel -> unit

与 close_in 相同，但忽略所有错误。

val set_binary_mode_in : in_channel -> bool -> unit

set_binary_mode_in ic true 将通道 ic 设置为二进制模式：在输入期间不会进行任何转换。 set_binary_mode_out ic false 将通道 ic 设置为文本模式：根据操作系统，在输入期间可能会进行一些转换。例如，在 Windows 下，换行符将从 \r\n 转换为 \n。此函数在不区分文本模式和二进制模式的操作系统上没有影响。

大型文件操作

module LargeFile: sig .. end

对大型文件的操作。

引用

type 'a ref = {

mutable contents : 'a;

}

包含类型为 'a 的值的引用（可变间接单元）的类型。

val ref : 'a -> 'a ref

返回包含给定值的新的引用。

val (!) : 'a ref -> 'a

!r 返回引用 r 的当前内容。等效于 fun r -> r.contents。一元运算符，有关更多信息，请参阅 Ocaml_operators。

val (:=) : 'a ref -> 'a -> unit

r := a 将 a 的值存储在引用 r 中。等效于 fun r v -> r.contents <- v。右结合运算符，有关更多信息，请参阅 Ocaml_operators。

val incr : int ref -> unit

递增给定引用中包含的整数。等效于 fun r -> r := succ !r。

val decr : int ref -> unit

递减给定引用中包含的整数。等效于 fun r -> r := pred !r。

结果类型

type ('a, 'b) result =

`\|`	`Ok of 'a`
`\|`	`Error of 'b`

自从 4.03

格式字符串操作

格式字符串是包含特殊语法规则的字符序列，用于定义格式化输入/输出函数的功能。格式字符串用于从 Scanf 模块的格式化输入函数读取数据，以及使用 Printf 和 Format 模块的格式化输出函数打印数据。

格式字符串由三种类型的实体组成：

转换说明符，以特殊字符 '%' 开头，后跟一个或多个字符，用于指定要读取或打印的 аргумент类型。
格式化指示符，以特殊字符 '@' 开头，后跟一个或多个字符，用于指定如何读取或打印 аргумент。
普通字符，即具有常规语法规则的字符。普通字符指定在输入中读取或在输出中打印的字符串字面量。

在格式字符串中，存在一个额外的语法规则来转义特殊字符 '%' 和 '@'：如果特殊字符紧跟在 '%' 字符之后，则将其视为普通字符。换句话说，"%%" 被视为一个普通的 '%'，而 "%@" 被视为一个普通的 '@'。

有关可用转换说明符和格式化指示符的更多信息，请阅读 Scanf、Printf 和 Format 模块的文档。

格式字符串具有一个通用且高度多态的类型 ('a, 'b, 'c, 'd, 'e, 'f) format6。为了向后兼容 OCaml 的早期版本，包括了两个简化的类型：format 和 format4。

格式字符串类型参数的含义如下：

'a 是格式化输出函数（printf 风格的函数）格式参数的类型；'a 是格式化输入函数（scanf 风格的函数）读取的值的类型。

'b 是格式化输入函数的输入源类型以及格式化输出函数的输出目标类型。对于来自 Printf 模块的 printf 风格的函数，'b 通常是 out_channel；对于来自 Format 模块的 printf 风格的函数，'b 通常是 Format.formatter；对于来自 Scanf 模块的 scanf 风格的函数，'b 通常是 Scanf.Scanning.in_channel。

类型参数 'b 也是用户定义的打印函数（用于 %a 和 %t 转换）以及用户定义的读取函数（用于 %r 转换）的第一个参数的类型。

'c 是 %a 和 %t 打印函数的结果类型，也是传递给 kprintf 风格的函数的第一个参数或传递给 kscanf 风格的函数的参数的类型。

'd 是 scanf 风格的函数的参数类型。

'e 是 scanf 风格的函数的接收器函数的类型。

'f 是格式化输入/输出函数调用的最终结果类型：对于 printf 风格的函数，它通常是 unit；对于 scanf 风格的函数，它通常是接收器函数的结果类型。

type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6

type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6

type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4

val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string

将格式字符串转换为字符串。

val format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 ->
       ('a, 'b, 'c, 'd, 'e, 'f) format6

format_of_string s 返回从字符串字面量 s 读取的格式字符串。注意：format_of_string 不能转换不是字面量的字符串参数。如果你需要此功能，请使用更通用的 Scanf.format_from_string 函数。

val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 ->
       ('f, 'b, 'c, 'e, 'g, 'h) format6 ->
       ('a, 'b, 'c, 'd, 'g, 'h) format6

f1 ^^ f2 连接格式字符串 f1 和 f2。结果是一个格式字符串，其行为等同于格式字符串 f1 和 f2 的连接：在格式化输出的情况下，它接受来自 f1 的参数，然后接受来自 f2 的参数；在格式化输入的情况下，它返回来自 f1 的结果，然后返回来自 f2 的结果。右结合运算符，有关更多信息，请参见 Ocaml_operators。

程序终止

val exit : int -> 'a

终止进程，向操作系统返回给定的状态码：通常为 0 表示没有错误，小正整数表示失败。所有打开的输出通道将使用 flush_all 刷新。使用 Domain.at_exit 注册的回调函数将被调用，随后是使用 at_exit 注册的回调函数。

每次程序正常终止时，都会隐式执行 exit 0。如果程序因未捕获的异常而过早终止，则会隐式执行 exit 2。

val at_exit : (unit -> unit) -> unit

注册给定的函数，以便在程序终止时调用。使用 at_exit 注册的函数将在程序执行以下操作时被调用：

执行 exit
终止，无论是正常终止还是因未捕获的异常而终止
执行 C 函数 caml_shutdown。这些函数将按“后进先出”的顺序调用：使用 at_exit 最近添加的函数将首先调用。

标准库模块

module Arg: Arg

module Array: Array

module ArrayLabels: ArrayLabels

module Atomic: Atomic

module Bigarray: Bigarray

module Bool: Bool

module Buffer: Buffer

module Bytes: Bytes

module BytesLabels: BytesLabels

module Callback: Callback

module Char: Char

module Complex: Complex

module Condition: Condition

module Digest: Digest

module Domain: Domain

module Dynarray: Dynarray

module Effect: Effect

module Either: Either

module Ephemeron: Ephemeron

module Filename: Filename

module Float: Float

module Format: Format

module Fun: Fun

module Gc: Gc

module Hashtbl: Hashtbl

module In_channel: In_channel

module Int: Int

module Int32: Int32

module Int64: Int64

module Lazy: Lazy

module Lexing: Lexing

module List: List

module ListLabels: ListLabels

module Map: Map

module Marshal: Marshal

module MoreLabels: MoreLabels

module Mutex: Mutex

module Nativeint: Nativeint

module Obj: Obj

module Oo: Oo

module Option: Option

module Out_channel: Out_channel

module Parsing: Parsing

module Printexc: Printexc

module Printf: Printf

module Queue: Queue

module Random: Random

module Result: Result

module Scanf: Scanf

module Semaphore: Semaphore

module Seq: Seq

module Set: Set

module Stack: Stack

module StdLabels: StdLabels

module String: String

module StringLabels: StringLabels

module Sys: Sys

module Type: Type

module Uchar: Uchar

module Unit: Unit

module Weak: Weak