|
另请参阅以下语言扩展：一等模块，在 open 语句中覆盖，Bigarray 访问语法，属性，扩展节点 和 扩展索引操作符。
下表显示了运算符和非闭合构造的优先级和结合性。优先级较高的构造排在最前面。对于中缀和前缀符号，我们写“*…” 表示“任何以 * 开头的符号”。
| 构造或运算符 | 结合性 |
| 前缀符号 | – |
| . .( .[ .{ （见第 12.11 节） | – |
| #… | 左结合 |
| 函数应用、构造函数应用、标签应用、assert、lazy | 左结合 |
| - -. (前缀) | – |
| **… lsl lsr asr | 右结合 |
| *… /… %… mod land lor lxor | 左结合 |
| +… -… | 左结合 |
| :: | 右结合 |
| @… ^… | 右结合 |
| =… <… >… |… &… $… != | 左结合 |
| & && | 右结合 |
| or || | 右结合 |
| , | – |
| <- := | 右结合 |
| if | – |
| ; | 右结合 |
| let match fun function try | – |
测试或刷新一下你的理解很容易
由常量组成的表达式计算结果为该常量。例如，3.14 或 [||]。
由访问路径组成的表达式计算结果为当前评估环境中绑定到该路径的值。该路径可以是值名称，也可以是访问模块值组件的访问路径。
表达式 ( 表达式 ) 和 begin 表达式 end 的值与 表达式 相同。这两个构造在语义上等效，但建议在控制结构中使用 begin … end
if … then begin … ; … end else begin … ; … end
而在其他分组情况中使用 ( … )。
带括号的表达式可以包含类型约束，例如 ( 表达式 : 类型表达式 )。此约束强制 表达式 的类型与 类型表达式 兼容。
带括号的表达式还可以包含强制转换 ( 表达式 [: 类型表达式] :> 类型表达式) （见下文第 11.7.7 小节）。
函数应用用（可能带标签的）表达式的并置表示。表达式 表达式 参数1 … 参数n 计算 表达式 及其出现在 参数1 到 参数n 中的表达式。表达式 表达式 必须计算为一个函数值 f，然后将其应用于 参数1、…、参数n 的值。
参数和参数根据各自的标签匹配。参数顺序无关紧要，除非参数具有相同的标签，或者没有标签。
如果在 表达式 的类型中，某个参数被指定为可选参数（标签以 ? 为前缀），则相应的参数将被自动包装在构造函数 Some 中，除非参数本身也以 ? 为前缀，在这种情况下，参数将按原样传递。
如果传递了一个没有标签的参数，并且它对应的参数之前有一个或多个可选参数，那么这些参数将被默认，即将为它们传递值 None。所有其他缺少参数（没有对应参数），包括可选参数和非可选参数，都将保留，并且函数的结果将仍然是这些缺少参数对 f 体的函数。
在所有情况下，除了顺序和标签完全匹配，并且没有可选参数之外，函数类型都应该在应用点已知。这可以通过添加类型约束来确保。在 -principal 模式下可以检查推导的原则性。
作为一个特殊情况，OCaml 支持labels-omitted 全应用：如果函数具有已知的元数，所有参数都是未标记的，并且它们的数量与非可选参数的数量匹配，则会忽略标签，并且非可选参数会按照其定义顺序匹配。可选参数将被赋予默认值。不建议省略标签，并且会导致警告，请参见 13.5.1。
提供了两种语法形式来定义函数。第一种形式由关键字 function 引入：
|
此表达式计算为具有一个参数的函数值。当此函数应用于值 v 时，此值将与每个模式 模式1 到 模式n 匹配。如果其中一项匹配成功，也就是说，如果值 v 与模式 模式i 匹配，则与所选模式关联的表达式 表达式i 将被计算，并且它的值将成为函数应用的值。在匹配期间执行的绑定所丰富环境中，将进行 表达式i 的计算。
如果多个模式与参数 v 匹配，则选择函数定义中第一个出现的模式。如果没有任何模式与参数匹配，则会引发异常 Match_failure。
此表达式等效于
可以在 -> 之前添加一个可选的类型约束 类型表达式，以强制结果的类型与约束 类型表达式 兼容
等效于
注意最后参数的类型约束
和结果的类型约束
参数模式 ~标签名 和 ~(标签名 [: 类型]) 分别是 ~标签名:标签名 和 ~标签名:(标签名 [: 类型]) 的简写，其可选对应项也是如此。
形式为 fun ? 标签名 :( 模式 = 表达式0 ) -> 表达式 的函数等效于
其中 标识符 是一个新的变量，除了在计算 表达式0 时没有指定它。
经过这两个转换之后，表达式将具有以下形式
如果我们忽略标签（在函数应用时才有意义），则它等效于
也就是说，上面的 fun 表达式计算为具有 n 个参数的柯里化函数：在将此函数应用于值 v1 … vn n 次之后，这些值将与模式 模式1 … 模式n 平行匹配。如果匹配成功，则函数将在匹配期间执行的绑定所丰富环境中返回 表达式 的值。如果匹配失败，则会引发异常 Match_failure。
模式匹配的 case（在 function、match 和 try 结构中）可以包含 guard 表达式，它们是任意布尔表达式，必须计算为 true 才能选择匹配的 case。Guard 位于 -> 标记之前，由 when 关键字引入。
|
匹配过程如前所述，除了如果值匹配某个模式 patterni 并且该模式具有 guard condi，那么表达式 condi 将被评估（在由匹配过程中执行的绑定扩展的环境中）。如果 condi 评估为 true，那么 expri 将被评估，其值将作为匹配结果返回，如常。但如果 condi 评估为 false，匹配将继续对 patterni 之后的模式进行。
let 和 let rec 结构在本地绑定值名称。结构
以某种未指定顺序评估 expr1 … exprn，并将它们的值与模式 pattern1 … patternn 进行匹配。如果匹配成功，expr 在由匹配过程中执行的绑定扩展的环境中进行评估，expr 的值将作为整个 let 表达式的值返回。如果其中一个匹配失败，将引发异常 Match_failure。
提供了一种替代语法来将变量绑定到函数值：而不是编写
在 let 表达式中，可以改写为
递归定义名称由 let rec 引入
与上面描述的 let 结构唯一的区别是，模式匹配执行的名称到值的绑定在评估表达式 expr1 到 exprn 时被认为已经执行。也就是说，表达式 expr1 到 exprn 可以引用由模式 pattern1，…，patternn 中的其中一个绑定的标识符，并期望它们与 expr（let rec 结构的主体）中的值相同。
如果表达式 expr1 到 exprn 是函数定义（fun … 或 function …），并且模式 pattern1 … patternn 只是值名称，如
这将 name1 … namen 定义为对 expr 局部的相互递归函数。
其他形式的 let rec 定义的行为取决于实现。当前实现还支持一定范围的非函数值的递归定义，如第 12.1 节所述。
(在 OCaml 4.04 中引入)
可以在表达式中定义局部异常：let exception constr-decl in expr 。
异常构造函数的语法范围是内部表达式，但没有任何东西可以阻止使用此构造函数创建的异常值逃逸此范围。上面定义的两个执行将导致两个不兼容的异常构造函数（与任何异常定义一样）。例如
(在 OCaml 3.12 中引入)
let 定义中的多态类型注解的行为与多态方法类似
这些注解明确要求定义的值是多态的，并且允许在递归出现时使用这种多态性（在使用 let rec 时）。但请注意，这是一个普通的多态类型，可以与自身的任何实例进行统一。
表达式 expr1 ; expr2 首先计算 expr1 的值，然后计算 expr2 的值，并返回 expr2 的值。
表达式 if expr1 then expr2 else expr3 的值，如果 expr1 的值为布尔值 true，则为 expr2 的值；如果 expr1 的值为布尔值 false，则为 expr3 的值。
else expr3 部分可以省略，在这种情况下，它默认为 else ()。
表达式
|
将 expr 的值与模式 pattern1 到 patternn 匹配。如果与 patterni 的匹配成功，则计算关联的表达式 expri，其值将成为整个 match 表达式的值。 expri 的计算在通过匹配进行绑定的环境中进行。如果多个模式与 expr 的值匹配，则选择在 match 表达式中首先出现的模式。
如果没有任何模式与 expr 的值匹配，则会引发 Match_failure 异常。
表达式 expr1 && expr2 的值为 true，当且仅当 expr1 和 expr2 的值都为 true；否则，其值为 false。第一个分量 expr1 首先计算。如果第一个分量的值为 false，则不会计算第二个分量 expr2。因此，表达式 expr1 && expr2 的行为与以下表达式完全相同：
表达式 expr1 || expr2 的值为 true，如果 expr1 和 expr2 中至少有一个表达式的值为 true；否则，其值为 false。第一个分量 expr1 首先计算。如果第一个分量的值为 true，则不会计算第二个分量 expr2。因此，表达式 expr1 || expr2 的行为与以下表达式完全相同：
布尔运算符 & 和 or 是 (分别) && 和 || 的过时同义词。
表达式 while expr1 do expr2 done 在 expr1 的值为 true 时，重复计算 expr2。循环条件 expr1 在每次迭代开始时计算并测试。整个 while … done 表达式的值为单元值 ()。
作为一种特殊情况，while true do expr done 被赋予一个多态类型，使其可以用于任何表达式（例如作为任何模式匹配的分支）。
表达式 for name = expr1 to expr2 do expr3 done 首先计算表达式 expr1 和 expr2 （边界）为整数值 n 和 p。然后，循环体 expr3 在环境中重复计算，其中 name 依次绑定到值 n、n+1、…、p−1、p。如果 n > p，则循环体永远不会计算。
表达式 for name = expr1 downto expr2 do expr3 done 的计算类似，只是 name 依次绑定到值 n、n−1、…、p+1、p。如果 n < p，则循环体永远不会计算。
在这两种情况下，整个 for 表达式的值为单元值 ()。
表达式
|
对表达式 expr 进行求值，如果求值过程中没有抛出异常，则返回其值。如果对 expr 的求值抛出异常，则将异常值与模式 pattern1 到 patternn 进行匹配。如果与 patterni 的匹配成功，则对关联的表达式 expri 进行求值，其结果成为整个 try 表达式的值。对 expri 的求值是在通过匹配进行绑定后，在扩展的环境中进行的。如果多个模式与 expr 的值匹配，则选择在 try 表达式中首先出现的那个。如果没有任何模式与 expr 的值匹配，则会再次抛出异常值，从而透明地“通过” try 结构。
表达式 expr1 , … , exprn 求值为表达式 expr1 到 exprn 的值的 n 元组。子表达式的求值顺序未指定。
表达式 constr expr 求值为构造函数为 constr，参数为 expr 值的一元变体值。类似地，表达式 constr ( expr1 , … , exprn ) 求值为构造函数为 constr，参数为 expr1, …, exprn 的值的 n 元变体值。
表达式 constr (expr1, …, exprn) 求值为构造函数为 constr，参数为 expr1 … exprn 值的变体值。
对于列表，提供了一些语法糖。表达式 expr1 :: expr2 代表将构造函数 ( :: ) 应用于参数 ( expr1 , expr2 )，因此求值为一个列表，其头部是 expr1 的值，尾部是 expr2 的值。表达式 [ expr1 ; … ; exprn ] 等效于 expr1 :: … :: exprn :: []，因此求值为一个列表，其元素是 expr1 到 exprn 的值。
表达式 `tag-name expr 求值为一个多态变体值，其标签为 tag-name，参数为 expr 的值。
表达式 { field1 [= expr1] ; … ; fieldn [= exprn ]} 求值为记录值 { field1 = v1; …; fieldn = vn }，其中 vi 是 expri 的值，对于 i = 1,… , n。单个标识符 fieldk 代表 fieldk = fieldk，限定标识符 module-path . fieldk 代表 module-path . fieldk = fieldk。字段 field1 到 fieldn 必须都属于同一个记录类型；该记录类型的每个字段都必须在记录表达式中出现一次，但可以以任何顺序出现。求值 expr1 到 exprn 的顺序未指定。可以在每个字段之后添加可选的类型约束 { field1 : typexpr1 = expr1 ;… ; fieldn : typexprn = exprn }，以强制 fieldk 的类型与 typexprk 兼容。
表达式 { expr with field1 [= expr1] ; … ; fieldn [= exprn] } 用于构建一个新的记录，其中字段 field1 … fieldn 等于 expr1 … exprn，而所有其他字段的值与记录 expr 中的值相同。换句话说，它返回记录 expr 的浅拷贝，除了字段 field1 … fieldn，这些字段被初始化为 expr1 … exprn。如前所述，单个标识符 fieldk 代表 fieldk = fieldk，限定标识符 module-path . fieldk 代表 module-path . fieldk = fieldk，并且可以为每个正在更新的字段添加一个可选的类型约束，如 { expr with field1 : typexpr1 = expr1 ; … ; fieldn : typexprn = exprn }。
表达式 expr1 . field 将 expr1 评估为一个记录值，并返回该记录值中与 field 关联的值。
表达式 expr1 . field <- expr2 将 expr1 评估为一个记录值，然后通过用 expr2 的值替换该记录中与 field 关联的值，原地修改该记录。仅当 field 在记录类型定义中被声明为 mutable 时，此操作才允许。整个表达式 expr1 . field <- expr2 评估为单元值 ()。
表达式 [| expr1 ; … ; exprn |] 评估为一个 n 元素数组，其元素分别用 expr1 到 exprn 的值初始化。这些表达式评估的顺序是不确定的。
表达式 expr1 .( expr2 ) 返回 expr1 所表示的数组中元素编号为 expr2 的值。第一个元素的编号为 0；最后一个元素的编号为 n−1，其中 n 是数组的大小。如果访问超出范围，则会引发异常 Invalid_argument。
表达式 expr1 .( expr2 ) <- expr3 会原地修改 expr1 所表示的数组，用 expr3 的值替换元素编号为 expr2 的元素。如果访问超出范围，则会引发异常 Invalid_argument。整个表达式的值为 ()。
表达式 expr1 .[ expr2 ] 返回 expr1 所表示的字符串中字符编号为 expr2 的值。第一个字符的编号为 0；最后一个字符的编号为 n−1，其中 n 是字符串的长度。如果访问超出范围，则会引发异常 Invalid_argument。
表达式 expr1 .[ expr2 ] <- expr3 会原地修改 expr1 所表示的字符串，用 expr3 的值替换字符编号为 expr2 的字符。如果访问超出范围，则会引发异常 Invalid_argument。整个表达式的值为 ()。 注意： 此功能仅为了向后兼容 OCaml 的旧版本而提供，将在未来的版本中移除。新代码应使用字节序列和 Bytes.set 函数。
来自类 infix-symbol 的符号，以及关键字 *、+、-、-.、=、!=、<、>、or、||、&、&&、:=、mod、land、lor、lxor、lsl、lsr 和 asr 可以出现在中缀位置（两个表达式之间）。来自类 prefix-symbol 的符号，以及关键字 - 和 -. 可以出现在前缀位置（表达式前面）。
中缀和前缀符号没有固定的含义：它们只是被解释为绑定到与符号相对应的名称的函数的应用。表达式 prefix-symbol expr 被解释为应用 ( prefix-symbol ) expr。类似地，表达式 expr1 infix-symbol expr2 被解释为应用 ( infix-symbol ) expr1 expr2。
下表列出了初始环境中定义的符号及其初始含义。（有关更多详细信息，请参阅第 28 章中对核心库模块 Stdlib 的描述）。它们的含义可以使用 let ( infix-op ) name1 name2 = … 在任何时候更改。
注意：运算符 &&、|| 和 ~- 的处理方式有所不同，不建议更改它们的含义。
关键字 - 和 -. 可以同时用作中缀运算符和前缀运算符。当它们用作前缀运算符时，它们分别被解释为函数 (~-) 和 (~-.)。
| 运算符 | 初始含义 |
| + | 整数加法。 |
| - (中缀) | 整数减法。 |
| ~- - (前缀) | 整数取反。 |
| * | 整数乘法。 |
| / | 整数除法。如果第二个参数为零，则引发 Division_by_zero。 |
| mod | 整数取模。如果第二个参数为零，则引发 Division_by_zero。 |
| land | 整数的按位逻辑“与”。 |
| lor | 整数的按位逻辑“或”。 |
| lxor | 整数的按位逻辑“异或”。 |
| lsl | 整数的按位逻辑左移。 |
| lsr | 整数的按位逻辑右移。 |
| asr | 整数的按位算术右移。 |
| +. | 浮点数加法。 |
| -. (中缀) | 浮点数减法。 |
| ~-. -. (前缀) | 浮点数取反。 |
| *. | 浮点数乘法。 |
| /. | 浮点数除法。 |
| ** | 浮点数求幂。 |
| @ | 列表连接。 |
| ^ | 字符串连接。 |
| ! | 解除引用（返回引用的当前内容）。 |
| := | 引用赋值（使用第二个参数的值更新作为第一个参数给出的引用）。 |
| = | 结构相等性测试。 |
| <> | 结构不等性测试。 |
| == | 物理相等性测试。 |
| != | 物理不等性测试。 |
| < | 测试“小于”。 |
| <= | 测试“小于或等于”。 |
| > | 测试“大于”。 |
| >= | 测试“大于或等于”。 |
| && & | 布尔合取。 |
| || or | 布尔析取。 |
当 class-path 评估为类体时，new class-path 评估为一个新对象，包含该类的实例变量和方法。
当 class-path 评估为类函数时，new class-path 评估为一个函数，该函数期望相同数量的参数并返回该类的新的对象。
直接通过 object class-body end 结构创建对象在操作上等同于在本地定义一个 class class-name = object class-body end——参见第 11.9.2 节及以下部分，了解 class-body 的语法——并立即通过 new class-name 从中创建一个单个对象。
立即对象的类型与显式定义类的类型略有不同，主要体现在两个方面。首先，推断出的对象类型可能包含自由类型变量。其次，由于立即对象的类体永远不会扩展，因此它的自我类型可以与封闭的对象类型统一。
表达式 expr # method-name 调用由 expr 表示的对象的方法 method-name。
如果 method-name 是一个多态方法，则它的类型应该在调用位置已知。例如，如果 expr 是一个新对象的名称（let ident = new class-path … ）或如果存在类型约束。可以在 -principal 模式下检查推导的原理性。
类的实例变量只在定义在同一类或继承自定义实例变量的类的类的方法体中可见。表达式 inst-var-name 评估为给定实例变量的值。表达式 inst-var-name <- expr 将 expr 的值赋值给实例变量 inst-var-name，该实例变量必须是可变的。整个表达式 inst-var-name <- expr 评估为 ()。
可以使用库函数 Oo.copy（参见模块 Oo）复制对象。在方法内部，表达式 {< [inst-var-name [= expr] { ; inst-var-name [= expr] }] >} 返回 self 的副本，其中给定的实例变量被关联表达式的值替换。单个实例变量名 id 代表 id = id。其他实例变量在返回对象中与 self 中具有相同的值。
类型包含对象或多态变体类型的表达式可以显式强制转换为（弱化为）超类型。表达式 (expr :> typexpr) 将表达式 expr 强制转换为类型 typexpr。表达式 (expr : typexpr1 :> typexpr2) 将表达式 expr 从类型 typexpr1 强制转换为类型 typexpr2。
前一个运算符有时无法将表达式 expr 从类型 typ1 强制转换为类型 typ2，即使类型 typ1 是类型 typ2 的子类型：在当前实现中，它只扩展包含对象和/或多态变体的类型缩写两个级别，仅保留类类型（对于对象）中显式递归。作为上述算法的例外，如果 expr 的推断类型和 typ 都是地面类型（即 不包含类型变量），则前一个运算符的行为与后一个运算符相同，将 expr 的推断类型作为 typ1。如果前一个运算符失败，则应使用后一个运算符。
只有当 expr 的类型是 typ1 的实例（如类型注释）时，才能将表达式 expr 从类型 typ1 强制转换为类型 typ2，并且 typ1 是 typ2 的子类型。强制转换表达式的类型是 typ2 的实例。如果类型包含变量，则它们可能会被子类型算法实例化，但这只有在确定 typ1 是否是 typ2 的潜在子类型之后才会进行。这意味着在后一个统一步骤期间，类型可能失败，即使 typ1 的某些实例是 typ2 的某些实例的子类型。在以下段落中，我们将描述所使用的子类型关系。
固定对象类型承认任何包含其所有方法的对象类型作为子类型。方法的类型应是超类型中方法的子类型。也就是说，
是
的超类型，如果每个 typi 都是对应 typ′i 的超类型，则该超类型可能包含省略号 ..。
单态方法类型可以是多态方法类型的超类型。也就是说，如果 typ 是 typ′ 的实例，则 'a1 … 'an . typ′ 是 typ 的子类型。
在类定义内部，新定义的类型不可用于子类型化，因为类型缩写尚未完全定义。有一个例外是将 self 强制转换为其类的（精确）类型：如果 self 的类型没有出现在类类型中，则允许这样做。 ，即 如果没有二元方法。
如果 typ 的上限（即 可能出现在 typ 的实例中的构造函数的最大集合）包含在 typ′ 的下限中，则多态变体类型 typ 是另一个多态变体类型 typ′ 的子类型，并且 typ 的构造函数的参数类型是 typ′ 中的子类型。也就是说，
可能是可缩减类型，是
如果每个 typi 都是 typ′i 的子类型，那么它可能是一个可扩展类型。
其他类型不会引入新的子类型，但它们可能会传播其参数的子类型关系。例如，typ1 * typ2 是 typ′1 * typ′2 的子类型，当 typ1 和 typ2 分别是 typ′1 和 typ′2 的子类型时。对于函数类型，关系更加微妙：typ1 -> typ2 是 typ′1 -> typ′2 的子类型，如果 typ1 是 typ′1 的超类型，而 typ2 是 typ′2 的子类型。因此，函数类型在其第二个参数（如元组）中是协变的，但在其第一个参数中是逆变的。可变类型，例如 array 或 ref 既不是协变也不是逆变，它们是非变的，也就是说它们不会传播子类型关系。
对于用户定义的类型，方差会自动推断：如果参数只有协变出现，则它是协变的；如果参数只有逆变出现，则它是逆变的；如果参数没有出现，则它是无方差的；否则它是逆变的。无方差参数可以通过子类型自由更改，它不必是子类型或超类型。对于抽象和私有类型，必须显式指定方差（参见第 11.8.1 节），否则默认值为非变的。这对于类型定义中的约束参数也是如此。
OCaml 支持 assert 结构来检查调试断言。表达式 assert expr 会评估表达式 expr，如果 expr 评估为 true，则返回 ()。如果它评估为 false，则会抛出异常 Assert_failure，并以源文件名和 expr 的位置作为参数。可以使用 -noassert 编译器选项关闭断言检查。在这种情况下，expr 根本不会被评估。
作为一种特殊情况，assert false 会被简化为 raise (Assert_failure ...)，这会给它一个多态类型。这意味着它可以用于任何表达式的替代（例如作为任何模式匹配的分支）。这也意味着 assert false “断言” 不能通过 -noassert 选项关闭。
表达式 lazy expr 返回一个类型为 Lazy.t 的值 v，它封装了 expr 的计算。参数 expr 在程序的此时不会被评估。相反，它的评估将在第一次将函数 Lazy.force 应用于值 v 时执行，并返回 expr 的实际值。后续对 v 的 Lazy.force 应用不会再次评估 expr。通过模式匹配可以隐式应用 Lazy.force（参见 11.6）。
表达式 let module module-name = module-expr in expr 在表达式 expr 的评估过程中，将模块表达式 module-expr 局部绑定到标识符 module-name。然后它返回 expr 的值。例如
表达式 let open module-path in expr 和 module-path.(expr) 严格等价。这些结构在表达式 expr 的各自范围内局部打开模块路径 module-path 所引用的模块。
当本地打开表达式的正文由 [ ]、[| |] 或 { } 分隔时，可以省略括号。对于表达式，对于 {< >} 也可以省略括号。例如，module-path.[expr] 等价于 module-path.([expr])，而 module-path.[| expr |] 等价于 module-path.([| expr |])。