w3ctech

[ReasonML] - Records - 记录类型


原文:http://2ality.com/2018/01/records-reasonml.html

翻译:ppp

系列文章目录详见: “什么是ReasonML?


1. 什么是记录?

记录类似于元组:记录有固定的长度,每个部分可以是不同的类型,并且能直接访问;但不同的是,在一个元组中(它的元件)是按位置访问的,而一个记录(它的字段)是按名称访问的。默认情况下,记录是不可变的。

2. 基础用法

2.1 定义记录类型

在龙虎大战坐庄你 使用记录前,龙虎大战坐庄你 必须先定义记录的类型,例如:

type point = {
  x: int,
  y: int, /* 结尾的逗号可选 */
};

龙虎大战坐庄龙虎大战坐庄我 们 定义了有x,y两个字段的记录类型point;字段的名字必须以小写字母开头。

在同一个类型的定义域中,字段名不可重复。这个限制是因为记录的类型是靠字段名来确定的(译者注:在不显示声明类型的时候,ReasonML会根据字段名来推断类型)。为了实现这个任务,每个字段名称只能与一个记录类型相关联。

其实可以在多条记录中使用相同的字段名称,但可用性会受到影响:最后一个使用龙虎大战坐庄Win s作为字段名的类型,将会成为被推断出来的类型。因此,使用其他记录类型变得更加复杂,所以龙虎大战坐庄我 更喜欢假装不能使用相同的字段名。

稍后龙虎大战坐庄龙虎大战坐庄我 们 将研究如何解决此限制。

(译者注:这段龙虎大战坐庄你 可能会疑惑,举个例子就明白了

type point = {
  x: int,
  y1: int,
};
type point2 = {
  x:int,
  y:int,
};

let a = {x:1,y:2};
/*没有显示指定a的类型,只能推断a的类型,这时候a的类型会被推断为point2*/

嵌套记录类型

可以嵌套定义记录类型吗?例如,龙虎大战坐庄龙虎大战坐庄我 们 可以这样做吗?

type t = { a: int, b: { c: int }};

答案是不能。会抛出一个语法错误。正确定义的定义应该是这样:

type b = { c: int };
type t = { a: int, b: b };

对于b: b,字段名和字段值是一样的。那么龙虎大战坐庄你 可以把它们缩写为b。这就是所谓的双关语:

type t = { a: int, b };

2.2 尝试创建一个记录

龙虎大战坐庄龙虎大战坐庄我 们 尝试创建一个记录:

# let pt1 = { x: 12, y: -2 };
let pt1: point = {x: 12, y: -2};

请注意字段名称是如何被用来推断pt1具有该类型的point。

还有一种简便的定义龙虎大战坐庄方法 :

let x = 7;
let y = 8;

let pt2 = {x, y};
  /* Same as: { x: x, y: y } */

2.3 访问字段值

字段值通过点(.)运算符访问:

# let pt = {x: 1, y: 2};
let pt: point = {x: 1, y: 2};
# pt.x;
- : int = 1
# pt.y;
- : int = 2

2.4 记录的无损更新

记录是不可修改的。要更改记录r的f字段的值,龙虎大战坐庄龙虎大战坐庄我 们 必须创建一条新记录s。给s.f赋予新的价值,s其他字段都和r一样。通过以下语法实现:

let s = {...r, f: newValue}

... 称为扩展运算符。他们必须放在前面,且最多使用一次。但是,龙虎大战坐庄你 可以更新多个字段(而不只是一个字段f)。

这是使用扩展运算符的一个例子:

# let pt = {x: 1, y: 2};
let pt: point = {x: 1, y: 2};
# let pt' = {...pt, y: 3};
let pt': point = {x: 1, y: 3};

2.5 模式匹配

所有常用的模式匹配机制也适用于记录。例如:

let isOrig = (pt: point) =>
  switch pt {
  | {x: 0, y: 0} => true
  | _ => false
  };

这是如何通过let解构:

# let pt = {x: 1, y: 2};
let pt: point = {x: 1, y: 2};

# let {x: xCoord} = pt;
let xCoord: int = 1;

龙虎大战坐庄你 可以使用简写定义:

# let {x} = pt;
let x: int = 1;

参数的解构也可以:

# let getX = ({x}) => x;
let getX: (point) => int = <fun>;
# getX(pt);
- : int = 1

龙虎大战坐庄关于 缺少字段的警告

在模式匹配过程中,默认情况下,龙虎大战坐庄你 可以省略所有龙虎大战坐庄你 不感兴趣的字段。例如:

type point = {
  x: int,
  y: int,
};

let getX = ({x}) => x; /* Don’t do this */

对于getX(),龙虎大战坐庄龙虎大战坐庄我 们 对y并不感兴趣,只设计x字段。但是,最好显示的表现出省略了字段:

let getX = ({x, _}) => x;

x后面的下划线告诉ReasonML:龙虎大战坐庄龙虎大战坐庄我 们 忽略了其他的字段。 为什么显示的表明忽略更好?因为现在龙虎大战坐庄你 可以通过把以下条目添加到bsconfig.json,让RationalML向龙虎大战坐庄你 提供有关缺少字段名称的警告:

"warnings": {
  "number": "+R"
}

初始版本现在触发以下警告:

Warning number 9

4 │ };
5 │
6 │ let getX = ({x}) => x;

the follo龙虎大战坐庄Win
g labels are not bound in this record pattern:
y
Either bind these labels explicitly or add '; _' to the pattern.

龙虎大战坐庄我 建议更进一步,如果缺少的字段将会抛出异常(编译无法完成):

"warnings": {
  "number": "+R",
  "error": "+R"
}

有关配置警告的龙虎大战坐庄更多 信息,请参阅BuckleScript手册。

检查缺少的字段对于使用所有当前字段的代码尤其重要:

let string_of_point = ({x, y}: point) =>
  "(" ++ string_of_int(x) ++ ", "
  ++ string_of_int(y) ++ ")";

string_of_point({x:1, y:2});
  /* "(1, 2)" */

如果龙虎大战坐庄你 要给point在添加另一个字段(比如说z),并希望ReasonML给出龙虎大战坐庄关于 string_of_point的警告,以便龙虎大战坐庄你 可以更新它。

2.6 递归记录类型

变型是龙虎大战坐庄龙虎大战坐庄我 们 已经见过的递归类型的第一个例子。龙虎大战坐庄你 也可以在递归定义中使用记录。例如:

type intTree =
  | Empty
  | Node(intTreeNode)
and intTreeNode = {
  value: int,
  left: intTree,
  right: intTree,
};

该变型intTree递归地依赖于记录类型intTreeNode的定义。这是如何创建类型的元素intTree:

let t = Node({
  value: 1,
  left: Node({
    value: 2,
    left: Empty,
    right: Node({
      value: 3,
      left: Empty,
      right: Empty,
    }),
  }),
  right: Empty,
});

2.7 参数化记录类型

在ReasonML中,类型可以通过类型变量进行参数化。定义记录类型时可以使用这些类型变量。例如,如果龙虎大战坐庄龙虎大战坐庄我 们 希望树包含任意值,而不仅仅是整数,龙虎大战坐庄龙虎大战坐庄我 们 可以让字段为多态类型(行A):

type tree('a) =
  | Empty
  | Node(treeNode('a))
and treeNode('a) = {
  value: 'a, /* A */
  left: tree('a),
  right: tree('a),
};

3. 其他模块中的记录

每个记录都是在一个作用域内定义的(例如,一个模块)。其字段名称位于该作用域的顶层。虽然这有助于类型推断,但它使得使用字段名称比其他许多语言更复杂。让龙虎大战坐庄龙虎大战坐庄我 们 看看如果龙虎大战坐庄龙虎大战坐庄我 们 将point放入另一个模块M中,各种与记录相关的机制如何受到影响:

module M = {
  type point = {
    x: int,
    y: int,
  };
};

3.1 通过其他模块创建记录

如果龙虎大战坐庄龙虎大战坐庄我 们 试图在同一个作用域中再创建一个point类型的记录,会抛出异常:

let pt = {x: 3, y: 2};
  /* Error: Unbound record field x */

原因是,x与y不存在于当前作用域内,而是存在于模块M中。

解决这个问题的龙虎大战坐庄方法 之一是通过在字段名称前加前缀:

let pt1 = {M.x: 3, M.y: 2}; /* OK */
let pt2 = {M.x: 3, y: 2}; /* OK */
let pt3 = {x: 3, M.y: 2}; /* OK */

解决这个问题的另一种龙虎大战坐庄方法 是对整个记录加上前缀。ReasonML如何显示推断的类型很有趣 - 类型和第一个字段名称都加了前缀:

# let pt4 = M.{x: 3, y: 2};
let pt4: M.point = {M.x: 3, y: 2};

最后,龙虎大战坐庄你 还可以open模块M,这样把x和y导入到当前作用域。

open M;
let pt = {x: 3, y: 2};

3.2 访问其他模块的字段

如果龙虎大战坐庄你 未open模块M,则不能用非限定名称的方式访问这些字段:

let pt = M.{x: 3, y: 2};

print_int(pt.x);
/*
Warning 40: x was selected from type M.point.
It is not visible in the current scope, and will not
be selected if the type becomes unknown.
*/

如果龙虎大战坐庄你 给字段x加上前缀,警告消失:

print_int(pt.M.x); /* OK */

局部open M也可以:

M.(print_int(pt.x));
print_int(M.(pt.x));

3.3 模式匹配和来自其他模块的记录

使用模式匹配时,龙虎大战坐庄你 会遇到与正常访问字段相同的问题 - 如果龙虎大战坐庄你 不给point的字段加上前缀,龙虎大战坐庄你 就无法访问他们:

# let {x, _} = pt;
Error: Unbound record field x

如果龙虎大战坐庄龙虎大战坐庄我 们 给x加上前缀,就好了:

# let {M.x, _} = pt;
let x: int = 3;

但是,如果给整个模式加上前缀有不行:

# let M.{x, _} = pt;
Error: Syntax error

龙虎大战坐庄龙虎大战坐庄我 们 在let绑定时局部open M。龙虎大战坐庄龙虎大战坐庄我 们 必须另外将它包在一个代码块(花括号)中,同时用圆括号括起来,这样才是一个合法的表达式:

M.({
  let {x, _} = pt;
  ···
});

3.4 在多个记录中使用相同的字段名称

龙虎大战坐庄我 最初说龙虎大战坐庄龙虎大战坐庄我 们 可以在多个记录中使用相同的字段名称。实现这一点的小龙虎大战坐庄技巧 是把每个记录都放在一个单独的模块中。例如,龙虎大战坐庄龙虎大战坐庄我 们 定义了两种记录类型,Person.t和Plant.t都有字段t。但它们都是在单独的模块中,不存在名称冲突的问题:

module Person = {
  type t = { name: string, age: int };
};
module Plant = {
  type t = { name: string, edible: bool };
};

4. 常见问题:记录

4.1 有没有办法动态指定一个字段的名称?

在JavaScript中,有两种方式可以访问一个字段(在JavaScript中称为属性):

// Static field name (known at compile time)
console.log(obj.prop);

function f(obj, fieldName) {
  // Dynamic field name (known at runtime)
  console.log(obj[fieldName]);
}

在RationalML中,字段名称始终是静态的。JavaScript对象扮演着两个角色:他们既是记录又是字典。在ReasonML中,如果龙虎大战坐庄你 需要记录,请使用Record,如果龙虎大战坐庄你 需要字典,请使用Map。

w3ctech微信

扫码关注w3ctech微信龙虎大战坐庄公众号

共收到0条回复