w3ctech

[ReasonML] - Lists and arrays - 列表与数组


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

翻译:ppp

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


在这篇文章中,11选511选5我 们 看看ReasonML的两个数据结构 - 列表和数组:

  • 列表是一种不可修改的数据结构,用于存放一个数据的序列,每个元素都是相同类型。它特别适合通过模式匹配进行处理。
  • 数组是一中可修改的数据类型,同于存放可随机访问的数据,每个元素都是相同的类型。它特别适合大数据或需要随机访问。

下表比较了两种数据结构。 | | Lists | Arrays | |------------|-------------| -------| | Size | small–medium | small–large | | Resizable? | flexible | fixed | | Mutability | immutable | mutable | | Elem types | same | same | | Access via | destructuring | index | | Fastest | prepend/remove first | read/write elems |

1. 快速探索:类型签名(类型)

在这篇文章中,11选5你 会看到许多类型签名,例如:

let map: ('a => 'b, list('a)) => list('b);

这个类型签名对11选5你 来说似乎仍然很神秘。但是通过学习如何读懂它们,11选5你 将会有不少收获。让11选511选5我 们 来看看map的类型签名告诉了11选511选5我 们 什么 - 当11选511选5我 们 还不知道map是什么,也不知道它有什么功能时(这将在后面解释)。一步一步理解:

  • let map: («parameters») => «result»; map 是一个函数。
  • 'a => 'b map第一个参数是一个函数,传入类型'a并返回类型'b。撇号表示'a并且'b是类型变量:它们接受任何类型。但是一旦接受了一个特定的类型,它就只能接受这种类型了。
  • list('a) map第二个参数是一个元素类型为'a的列表。
  • list('b) map返回值是一个元素类型是'b的列表。

2. 用于列表和数组的标准库功能

ReasonML目前有两个用于列表和数组的标准模块:

  • List模块的函数,例如: let map: ('a => 'b, list('a)) => list('b);
  • Array模块的函数,例如: let map: ('a => 'b, array('a)) => array('b);

这两个模块里的每个功能都有参数别名的版本,对应下面的这两个模块:

  • ListLabels模块对应的函数: let map: (~f: 'a => 'b, list('a)) => list('b);
  • ArrayLabels模块对应的函数: let map: (~f: 'a => 'b, array('a)) => array('b);

有个小11选5技巧 ,11选5你 可以通过open StdLabels来将标准模块替换为标准模块的参数别名版本:

open StdLabels;

该模块还有全局ArrayLabels的别名:Array,Bytes,List和String等等。因此,如果11选5你 open了这个模块,11选5你 会覆盖当前的Array等的实现。

3. 列表

ReasonML中的列表是一种典型的功能性数据结构,因为它们的类型是递归定义的,并且列表不可变。让11选511选5我 们 看看这是什么意思。

3.1 列表的结构

通过自递归参数化实现的列表

list是一个自递归参数化变体。如果11选5你 要自己定义它,这就是它的样子:

type mylist('a) =
  | Nil;
  | Cons('a, mylist('a))

取名Nil和Cons(“构造”)是有历史渊源的,它源于Lisp这种编程语言。通过嵌套Cons创建列表:

# let abc = Cons("a", Cons("b", Cons("c", Nil)));
let abc: mylist(string) = Cons("a", Cons("b", Cons("c", Nil)));

mylist有一个类型的参数'a。它将和mylist递归的传递给Cons。这意味着两件事:首先,mylist的元素可以是任意类型。其次,它们都必须具有相同的类型。通过之前的学习,11选5你 可以看到ReasonML自动推断出abc的类型,'a是string。

abc的是实现是一个单向链表。在内存中,它可能看起来像这样:

singly-linked-list.jpg

一个cons对的两部分被称为:

  • 头(或第一个):这是当前链表的第一个值。
  • 尾(或剩下的):它指向链表剩下的部分。

ReasonML列表的创建和模式匹配

ReasonML的列表有特殊的语法。有两种构造方式:

  • 空列表[]
  • cons对[head, ...tail]

因此,模式匹配就像这样:

switch myList {
| [] => ···
| [head, ...tail] => ···
}

这是用另一种方式重新创建上一节中abc的11选5方法 :

# let abc = ["a", ...["b", ...["c", ...[]]]];
let abc: list(string) = ["a", "b", "c"];

11选5你 可以看到rtop给出了一个等价的,但更紧凑的语法:

# let abc = ["a", "b", "c"];
let abc: list(string) = ["a", "b", "c"];

11选511选5我 们 用模式匹配来计算任何列表的长度myList:

let rec len = (myList: list('a)) =>
  switch myList {
  | [] => 0
  | [_, ...tail] => 1 + len(tail)
  };

11选511选5我 们 回顾这两个构造函数:

  • 一个空列表的长度为0。
  • 非空列表的长度为:尾部的长度 + 1。

类型参数'a使函数len变得通用。但是在列表这种数据结构中,11选511选5我 们 从来不关心这些元素的类型。下面是各种类型的列表使用len函数的示例:

# len([]);
- : int = 0
# len(["a", "b"]);
- : int = 2
# len([1, 2, 3, 4]);
- : int = 4

打印列表

ReasonML内置不支持打印复杂数据结构。但是BuckleScript可以让11选5你 使用JavaScript的console.log()。最好像这样调用:

Js.log(Array.of_list(myList));

在11选511选5我 们 打印列表myList之前,11选511选5我 们 将它转​​换为一个数组。但为什么要这样做呢?因为这可以让输出的效果更好。ReasonML列表在JavaScript中表示为嵌套的有两个元素的数组。

创建列表的其他方式

三点构造函数也被称为展开运算符。该运算符允许11选5你 在现有列表之前添加零个或多个元素:

# [...["a", "b"]];
- : list(string) = ["a", "b"]
# ["a", ...["b", "c"]];
- : list(string) = ["a", "b", "c"]
# ["a", "b", ...["c", "d"]];
- : list(string) = ["a", "b", "c", "d"]

可惜的是,在ReasonML中,11选5你 只能用在表达式的最后使用,不像JavaScript中,可以在任何地方使用。

# [...["a", "b"], ...["c", "d"]];
Error: Syntax error

ReasonML有自己的连接列表的运算符:

# ["a", "b"] @ ["c", "d"];
- : list(string) = ["a", "b", "c", "d"]

请注意,连接列表操作相对较慢,因为11选5你 必须将第一个列表的每个元素添加到第二个列表中:

let rec append = (l1: list('a), l2: list('a)) =>
  switch l1 {
  | [] => l2
  | [head, ...tail] => [head, ...append(tail, l2)]
  };

(这个实现可以被改进,11选511选5我 们 将在即将发布的博客文章中看到。)

这是11选5你 如何使用append:

# append([1,2,3], [4,5]);
- : list(int) = [1, 2, 3, 4, 5]

这是再次用到了类型推断:

  • 首先,ReasonML推断1这些值的类型int。
  • 然后它推断出第一个输入列表的类型为list(int):
    # [1,2,3];
    - : list(int) = [1, 2, 3]
    
  • 然后它检查l1、l2具有相同的类型参数值'a。
  • 最后,最后根据l1和l2的类型推断出了append的结果的类型list(int)。

3.2 示例:创建列表

range() 创建一个int列表

/**
 * Compute a list of integers starting with `start`,
 * up to and excluding `end_`.
 */
let rec range = (start: int, end_: int) =>
  if (start >= end_) {
    [];
  } else {
    [start, ...range(start + 1, end_)];
  };

在ReasonML中end是一个11选5关键词 ,因此不是一个合法的变量名。所以给end_加了一个下划线。让11选511选5我 们 试试执行range():

# range(0, 0);
- : list(int) = []
# range(0, 1);
- : list(int) = [0]
# range(0, 5);
- : list(int) = [0, 1, 2, 3, 4]

fill()创建一个填充值为~element的列表:

/**
 * Create a list of length `~length` where each
 * element is `~element`.
 */
let rec fill = (~element: 'a, ~length: int) =>
  if (length <= 0) {
    [];
  } else {
    [element, ...fill(~element, ~length=length-1)];
  };

ReasonML使用~element的类型来推断出结果的类型:

# fill("x", 4);
- : list(string) = ["x", "x", "x", "x"]
# fill(0, 3);
- : list(int) = [0, 0, 0]

3.3 示例:遍历列表

计算一个列表的总和

summarize() 计算列表中所有整数的总和:

/**
 * Compute the sum of all the ints in the list `l`.
 */
let rec summarize = (l: list(int)) =>
  switch l {
  | [] => 0
  | [head, ...tail] => head + summarize(tail)
  };

summarize([]); /* 0 */
summarize([3]); /* 3 */
summarize([1, 2, 3]); /* 6 */

访问第n个列表元素

getElementAt() 通过索引检索列表元素:

/**
 * Get the list element at index `~index`.
 * The head of a list has the index 0,
 * the head of its tail the index 1, etc.
 */
let rec getElementAt = (~index: int, l: list('a)) =>
  switch l {
  | [] => None
  | [head, ...tail] =>
    if (index <= 0) {
      Some(head);
    } else {
      getElementAt(~index=index-1, tail);
    }
  };

11选511选5我 们 可以用when字句和一个额外的case来取代switch中的if-else,下面的实现更扁平,更易读:

let rec getElementAt = (~index: int, l: list('a)) =>
  switch l {
  | [] => None
  | [head, ..._] when index <= 0 => Some(head)
  | [head, ...tail] => getElementAt(~index=index-1, tail)
  };

代码中有一些值得注意的:

  • 失败的处理是通过变体类型实现的:
    • None 意味着检索失败。
    • Some(x)意味着检索成功,结果为x。
  • 索引0指当前的头(第二种情况)。
  • 当访问到list的结尾[]时,将返回None。l为空或者~index比l的长度还要大时都会触发switch的第一个条件。

标准库中ListLabels.nth()的功能和getElementAt()类似,但它有可能会抛出非法索引的异常,因为它没有使用option。

3.4 示例:更改列表

由于列表是不可修改的 - 11选5你 如何改变它们?为了找到答案,11选511选5我 们 看看目前为止11选511选5我 们 已经看到了两类算法:

  • 递归的遍历列表。例如:len(),summarize(),等。
  • 递归的创建列表。例如:range(),fill(),等。

要更改列表,11选511选5我 们 需要将两种11选5方法 结合起来:根据需要,11选511选5我 们 创建一个全新的列表,并且把数据从已有的列表或数据源中导入。

removeAll()

以下是更改现有列表的函数的第一个示例。

/**
 * Remove all elements from the list `l` that are
 * equal to `~value`.
 */
let rec removeAll = (~value: 'a, l: list('a)) =>
  switch l {
  | [] => []
  | [head, ...tail] when head == value => removeAll(~value, tail)
  | [head, ...tail] => [head, ...removeAll(~value, tail)]
  };

第一种情况意味着11选511选5我 们 完成了操作。第三种情况是复制现有列表。第二种情况则是11选5删除 等于~value的元素。

这是removeAll()在实际中的使用:

# removeAll(~value=9, [1,9,2,9,3]);
- : list(int) = [1, 2, 3]

replaceAll()

replaceAll() 用于替换值:

/**
 * Inside the list `l`, remove all occurrences of the value `~value`
 * with the value `~with_`.
 */
let rec replaceAll = (~value: 'a, ~with_: 'a, l: list('a)) =>
  switch l {
  | [] => []
  | [head, ...tail] when head == value =>
    [with_, ...replaceAll(~value, ~with_, tail)]
  | [head, ...tail] =>
    [head, ...replaceAll(~value, ~with_, tail)]
  };

第一种情况意味着11选511选5我 们 完成了操作。第三种情况是复制现有列表。第二种情况则是执行替换。

11选511选5我 们 可以通过一个内联辅助函数replaceOne(),让replaceAll()变得更加紧凑:

let rec replaceAll = (~value: 'a, ~with_: 'a, l: list('a)) => {
  let replaceOne = (x) => if (x == value) with_ else x;
  switch l {
  | [] => []
  | [head, ...tail] =>
    [replaceOne(head), ...replaceAll(~value, ~with_, tail)]
  };
};

replaceAll()实际场景中的使用:

# replaceAll(~value=1, ~with_=11, [1, 2, 1, 3]);
- : list(int) = [11, 2, 11, 3]

drop()

drop() 功能是11选5删除 列表元素

/**
 * Remove the first `~count` elements of `theList`.
 */
let rec drop = (~count, theList: list('a)) =>
  switch theList {
  | [] => []
  | l when count <= 0 => l
  | [_, ...tail] => drop(~count=count-1, tail)
  };

让11选511选5我 们 来调用drop():

# drop(~count=0, ["a", "b", "c", "d"]);
- : list(string) = ["a", "b", "c", "d"]
# drop(~count=2, ["a", "b", "c", "d"]);
- : list(string) = ["c", "d"]
# drop(~count=2, ["a", "b"]);
- : list(string) = []
# drop(~count=2, ["a"]);
- : list(string) = []
# drop(~count=2, []);
- : list('a) = []

对于最后一个drop()调用的结果,ReasonML无法推断出元素的类型,因此给出一个未对类型绑定的'a类型。

4. 列表的标准库函数

ReasonML的标准库仍在不断变化。因此,11选511选5我 们 只在这里看一些重要的。11选5你 可以阅读ListLabels的文档来了解其他的功能(如当前存在的内容)。

4.1 ListLabels.map()

类型签名:

let map: (~f: 'a => 'b, list('a)) => list('b);

map()接收类型元素为'a的列表,将函数~f应用于列表的每个元素,并将结果保存在另一个列表中返回。

# ListLabels.map(~f=x => int_of_string(x), ["7", "15", "6"]);
- : list(int) = [7, 15, 6]

该功能是处理数据列表的常用11选5方法 。

mapi()是一个map()的另一个版本,它会把元素值和索引都传递给~f,11选511选5我 们 可以用mapi()来实现对列表的非破坏性更新:

/**
 * Create a copy of `theList` whose element at index `~index`
 * is `~value`.
 */
let setElementAt = (~index: int, ~value: 'a, theList: list('a)) =>
  ListLabels.mapi(
    ~f=(i,x) => if (i==index) value else x,
    theList
  );

~f函数只对索引为~index的元素做了修改。

setElementAt()的实际使用:

# setElementAt(~index=1, ~value="|", ["a", "b", "c"]);
- : list(string) = ["a", "|", "c"]

4.2 ListLabels.filter()

这是该函数的类型签名:

let filter: (~f: 'a => bool, list('a)) => list('a);

filter()把列表的每个元素传递给~f。如果~f返回true,该元素被将包含在返回结果中,如果是false,则不包含。用法如下:

# ListLabels.filter(~f=x=>x>5, [8, 4, 9, 7, 2]);
- : list(int) = [8, 9, 7]

4.3 ListLabels.for_all()

类型签名:

let for_all: (~f: 'a => bool, list('a)) => bool;

如果列表中的每个元素在函数~f都返回true,for_all()返回就true。例如:

# ListLabels.for_all(~f=x=>x>3, [4,5,6]);
- : bool = true
# ListLabels.for_all(~f=x=>x>3, [3,4,5,6]);
- : bool = false

如果~f返回false,for_all就回立刻返回。而且结果一定为false。for_all是以数学运算符∀来命名的。

ListLabels.exists()和for_all()类似:只要列表中有一个元素使回调函数的返回值为true,则返回true。exists以数学运算符∃命名。

4.4 ListLabels.flatten()

类型签名:

let flatten: list(list('a)) => list('a);

flatten()通过连接元素的方式把多个列表转化为一个列表。也就是说,以下三个表达式是等价的:

flatten([l1, l2, l3])
ListLabels.append(l1, ListLabels.append(l2, l3))
l1 @ l2 @ l3

这是flatten()的用法:

# ListLabels.flatten([[1,2], [], [3,4,5]]);
- : list(int) = [1, 2, 3, 4, 5]

如果11选5你 想使用任意嵌套的列表,请回想一下,在ReasonML中,所有元素必须具有相同的类型。因此,如果一个列表元素本身就是一个列表,那么所有元素都必须是列表:

# ListLabels.flatten([[1,[2]], [], [3]]);
Error: This expression has type list('a)
but an expression was expected of type int
# ListLabels.flatten([[[1],[2]], [], [[3]]]);
- : list(list(int)) = [[1], [2], [3]]

让11选511选5我 们 继续查看flatten()的用例。

用例:同时过滤和映射

flatten()让11选5你 可以同时过滤和映射。例子,考虑这种情况:尝试提取存储在一个列表中的多个列表的第一个元素。11选5你 可以:

  • 首先通过ListLabels.filter()过滤出空列表(没有第一个元素)。
  • 然后通过ListLabels.map()将每个非空列表映射到其头部。

或者11选5你 可以使用flatten同时执行这两种操作:

module L = ListLabels;
let listFromHead = (l: list('a)) =>
  switch (l) {
  | [] => []
  | [head, ..._] => [head]
  };
let heads = (l: list(list('a))) =>
  L.flatten(L.map(~f=listFromHead, l));

首先,11选511选5我 们 将每个非空列表通过它的头映射到另一个列表中,每个空列表映射到一个空列表。然后11选511选5我 们 把结果扁平化。看起来像这样:

# let l0 = [[1, 2], [], [3,4,5]];
let l0: list(list(int)) = [[1, 2], [], [3, 4, 5]];
# L.map(~f=listFromHead, l0);
- : list(list(int)) = [[1], [], [3]]
# let l1 = L.map(~f=listFromHead, l0);
let l1: list(list(int)) = [[1], [], [3]];
# L.flatten(l1);
- : list(int) = [1, 3]

这些步骤等价于:

# heads([[1, 2], [], [3,4,5]]);
- : list(int) = [1, 3]

把listFromHead和getHead做一个对比,这对11选511选5我 们 有11选5帮助 。

let getHead = (l: list('a)) =>
  switch (l) {
  | [] => None
  | [head, ..._] => Some(head)
  };

也就是说,None表示“l没有头”:

# getHead(["a", "b"]);
- : option(string) = Some("a")
# getHead([1, 2, 3]);
- : option(int) = Some(1)
# getHead([]);
- : option('a) = None

listFromHead中,11选511选5我 们 使用空列表而不是None,以及用只有一个元素的列表取代Some。

用例:映射到多个值

假设11选511选5我 们 已经创建了一个person的列表和节点:

type person = Person(string, list(string));
let persons = [
  Person("Daisy", []),
  Person("Della", ["Huey", "Dewey", "Louie"]),
  Person("Marcus", ["Minnie"])
];

如果11选511选5我 们 想获取列表的节点,ListLabels.map()几乎满足了11选511选5我 们 的需求,但不是很完美:

# ListLabels.map(~f=(Person(_, ch)) => ch, persons);
- : list(list(string)) = [[], ["Huey", "Dewey", "Louie"], ["Minnie"]]

可惜的是,这是字符串列表的列表,而不是字符串列表。11选511选5我 们 可以通过ListLabels.flatten()来解决这个嵌套列表的问题:

let collectChildren = (persons: list(person)) =>
  ListLabels.flatten(
    ListLabels.map(
        ~f=(Person(_, children)) => children,
        persons));

collectChildren(persons);
  /* ["Huey", "Dewey", "Louie", "Minnie"] */

现在11选511选5我 们 得到了期望的结果:

# collectChildren(persons);
- : list(string) = ["Huey", "Dewey", "Louie", "Minnie"]

用例:有条件地插入值

有时,11选5你 会根据条件创建列表,其中添加或省略了一些元素(下示例中的cond):

let func = (cond: bool) => ListLabels.flatten([
  if (cond) ["a"] else [],
  [
    "b",
    "c"
  ]
]);

这是如何使用func():

# func(true);
- : list(string) = ["a", "b", "c"]
# func(false);
- : list(string) = ["b", "c"]

4.5 ListLabels.fold_left()

类型签名:

let fold_left: (~f: ('a, 'b) => 'a, ~init: 'a, list('b)) => 'a;

fold_left() 工作如下:

  • 输入:类型为list('b)的列表(最后一个参数)
  • 结果:类型的值'a

fold_left()的计算结果取决于它的参数:函数~f。输入参数的每个元素都会传入~f:

let nextIntermediateResult = f(intermediateResult, elem);

intermediateResult是求得值。第一个中间结果是~init。最后的nextIntermediateResult就是fold_left()的结果。

11选511选5我 们 来看一个具体的例子。

fold_left()通过例子:summarize()

11选511选5我 们 已经见过summarize()函数,用于计算整数列表的和。让11选511选5我 们 通过fold_left()实现该功能:

let rec summarize = (l: list(int)) =>
  ListLabels.fold_left(~f=(r, elem) => r + elem, ~init=0, l);

要理解summarize()是如何工作的,请先看看以下表达式:

summarize([1,2,3]) /* 6 */

为了得到结果6,将采取以下步骤:

/* Parameter */
let f = (r, elem) => r + elem;
let init = 0;

/* Steps */
let result0 = f(init, 1); /* 1 */
let result1 = f(result0, 2); /* 3 */
let result2 = f(result1, 3); /* 6 */

result2就是fold_left()的结果。

fold_left()的另一种理解

fold_left()的另一种理解是采用二元运算符~f并将其变为列表的n元运算符。在数学中也有从二元运算到n元运算的一个例子:二元运算符+的n元版本是运算符Σ。summarize()就相当于从+变成了Σ。它也可以这样写:

# ListLabels.fold_left(~f=(+), ~init=0, [1, 2, 3]);
- : int = 6

11选5我 发现fold_left最容易理解的是它是工作在这种模式下 - ~f参数是一个和位置无关的参数(参数顺序无关紧要)。11选5你 可以用它做很多事情 - 继续看下个例子。

一个更复杂的例子:查找值

该函数contains()使用它在列表中查找值:

let contains = (~value: 'a, theList: list('a)) => {
  let f = (found, elem) => found || elem == value;
  fold_left(~f, ~init=false, theList);
};

4.6 通过iteri()将列表转换为数组

类型签名:

let iteri: (~f: (int, 'a) => unit, list('a)) => unit;

iteri()将遍历列表的每个元素,并传给~f,参数是元素的值和索引,它的返回为unit。这意味着iteri并没有实际的功能,具体的操作都是通过函数~f来实现的。

以下函数使用iteri()来填充一个数组。通过逐个写入数组的元素来实现:

let arrayFromList = (~init: 'a, l: list('a)) => {
  let arr = ArrayLabels.make(ListLabels.length(l), init);
  ListLabels.iteri(~f=(i, x) => arr[i]=x, l);
  arr;
};

~init是必选参数,因为make()需要它(为什么稍后解释)。

arrayFromList()的实际用例:

# arrayFromList(~init=0, [1,2,3]);
- : array(int) = [|1, 2, 3|]

5. 数组

数组很像列表:它们的所有元素都具有相同的类型,并且可以按位置访问它们。但他们也不尽相同:

  • 数组是可变的。列表是不可变的。
  • 数组不能调整大小。但用列表,11选5你 可以有效地添加元素并检索列表尾部。(BuckleScript可以让11选5你 调整数组的大小,但如果11选5你 这样做的话,11选5你 将失去跨平台兼容性。)
  • 数组提供快速索引访问。列表通过递归和模式匹配进行处理。

5.1 创建数组

以下小节介绍创建数组的三种常用11选5方法 。

数组字面量

# [| "a", "b", "c" |];
- : array(string) = [|"a", "b", "c"|]

ArrayLabels.make()

类型签名:

let make: (int, 'a) => array('a);

第一个参数指定数组的长度。第二个参数指定了要填充的值。为什么第二个参数是必选的的?因为make()返回的数组必须只包含类型'a的值。ReasonML没有null,所以11选5你 必须手动的为'a指定一个类型。

这是make()如何工作的:

# ArrayLabels.make(3, "x");
- : array(string) = [|"x", "x", "x"|]
# ArrayLabels.make(3, true);
- : array(bool) = [|true, true, true|]

ArrayLabels.init()

类型签名:

let init: (int, ~f: int => 'a) => array('a);

第一个参数指定数组的长度。函数~f将根据索引映射出对应的初始值。例如:

# ArrayLabels.init(~f=i=>i, 3);
- : array(int) = [|0, 1, 2|]
# ArrayLabels.init(~f=i=>"abc".[i], 3);
- : array(char) = [|'a', 'b', 'c'|]

5.2 获取数组的长度

ListLabels.length()返回数组的长度:

# ArrayLabels.length([| "a", "b", "c" |]);
- : int = 3

5.3 读取和写入数组元素

这就是读取和写入数组元素的方式:

# let arr = [| "a", "b", "c" |];
let arr: array(string) = [|"a", "b", "c"|];
# arr[1]; /* read */
- : string = "b"
# arr[1] = "x"; /* write */
- : unit = ()
# arr;
- : array(string) = [|"a", "x", "c"|]

5.4 模式匹配和数组

模式匹配数组类似于匹配元组,而不是匹配列表。让11选511选5我 们 从元组和列表开始(11选511选5我 们 可以忽略exhaustiveness警告,因为11选511选5我 们 正在处理固定数据):

# let (a, b) = (1, 2);
let a: int = 1;
let b: int = 2;
# let [a, ...b] = [1, 2, 3];
Warning: this pattern-matching is not exhaustive.
let a: int = 1;
let b: list(int) = [2, 3];

接下来11选511选5我 们 将解构一个数组:

# let [| a, b |] = [| 1, 2 |];
Warning: this pattern-matching is not exhaustive.
let a: int = 1;
let b: int = 2;

与元组类似,模式必须与数据具有相同的长度(这是例外情况):

# let [| a, b |] = [| 1, 2, 3 |];
Warning: this pattern-matching is not exhaustive.
Exception: Match_failure

5.5 列表和数组之间的转换

这就是如何在列表和数组之间进行转换:

  • 从数组到列表(ArrayLabels 模块): let to_list: array('a) => list('a);
  • 从列表到数组(ArrayLabels 模块): let of_list: list('a) => array('a);

有时候使用数组处理数据会比列表更方便,然后11选5你 又可以再把它转换为列表(如果需要的话,再转换回数组)。

5.6 处理数组

标准库仍处于不断变化之中。因此,这里只会演示一些重要的11选5方法 。

ArrayLabels.map()

map()对于数组的处理和列表是类似的:

# ArrayLabels.map(s => s ++ "x", [| "a", "b" |]);
- : array(string) = [|"ax", "bx"|]

ArrayLabels.fold_left()

fold_left()也与列表的类似:

let maxOfArray = (arr) =>
  ArrayLabels.fold_left(~f=max, ~init=min_int, arr);

这是maxOfArray()的用法:

# maxOfArray([||]);
- : int = -4611686018427387904
# maxOfArray([|3, -1, 5|]);
- : int = 5

这里11选5我 又一次见到了从二元到n元的变化 max() -> maxOfArray()。对max()而言,11选511选5我 们 还使用了整数常量min_int。两者都属于Pervasives模块。

max 是一个适用于大多数类型的二元函数:

# max(1.0, 1.1);
- : float = 1.1
# max(None, Some(1));
- : option(int) = Some(1)
# max("a", "b");
- : string = "b"
# max(4, -3);
- : int = 4

min_int 是int的最小取值(它的确切值和当前的平台有关):

# min_int;
- : int = -4611686018427387904

通过fold_right()将数组转换为列表

fold_right()的原理和fold_left()类似,但它是从最后一个元素开始的。它的类型签名是:

let fold_right: (~f: ('b, 'a) => 'a, array('b), ~init: 'a) => 'a;

此功能的一个使用场景是将数组转换为列表。该列表必须按照以下方式构建(即,11选5你 必须从最后一个数组元素开始):

[··· [x_2nd_last, ...[x_last, ...[]]]]

像这样:

let listFromArray = (arr: array('a)) =>
  ArrayLabels.fold_right(~f=(ele, l) => [ele, ...l], arr, ~init=[]);

这是listFromArray()的实际用例:

# listFromArray([||]);
- : list('a) = []
# listFromArray([| 1, 2, 3 |]);
- : list(int) = [1, 2, 3]
# listFromArray([| "a", "b", "c" |]);
- : list(string) = ["a", "b", "c"]

过滤数组

所有数组的处理函数都会返回与输入数组长度相同的数组。因此,如果11选5你 想11选5删除 数组的元素,11选5你 必须借助列表:

let filterArray = (~f, arr) =>
  arr
  |> ArrayLabels.to_list
  |> ListLabels.filter(~f)
  |> ArrayLabels.of_list;

filterArray() 实例:

# filterArray(~f=x=>x>0, [|-2, 3, -4, 1|]);
- : array(int) = [|3, 1|]
w3ctech微信

扫码关注w3ctech微信11选5公众号

共收到0条回复