From 04a640bd49b6e8ab4c7a49224dfab89eec400456 Mon Sep 17 00:00:00 2001 From: Cigui Date: Wed, 9 Jun 2021 09:13:46 +0800 Subject: [PATCH 1/5] add ch12 --- ch12.md | 296 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 296 insertions(+) create mode 100644 ch12.md diff --git a/ch12.md b/ch12.md new file mode 100644 index 0000000..7cc4c3c --- /dev/null +++ b/ch12.md @@ -0,0 +1,296 @@ +# 第 12 章：遍历 + +迄今为止，在我们的集装箱马戏团中，你曾看到我们驯服了凶猛的 [functor](ch8.md)，让它听从我们的意志，执行任何让我们心动的操作；你曾被同时使用[函数应用](ch10.md)来收集结果的许多危险效果的杂耍弄得晕头转向；你曾在看到容器通过 [join](ch9.md) 凭空消失时惊讶地坐倒。在副作用杂耍中，我们看到它们经过 compose 合为一体。而最近，我们大胆地超越了自然，在你的眼前将一种类型转化为另一种 ([natural transformations](ch11.md))。 + +至于我们的下一个表演，我们要看一下遍历。我们将看着类型在彼此之间翱翔，就像空中飞人一样保持着我们的值不变。我们将像倾斜旋转中的手推车一样重新排列效果 (effects)。当我们的容器像变形金刚的四肢一样交织在一起时，我们可以用这个接口来进行整理。我们将见证不同的效果与不同的顺序。拿上我的长裤和滑动口哨，让我们开始吧。 + +## 类型与类型 + +让我们整点怪活： + +```js +// readFile :: FileName -> Task Error String + +// firstWords :: String -> String +const firstWords = compose(intercalate(' '), take(3), split(' ')); + +// tldr :: FileName -> Task Error String +const tldr = compose(map(firstWords), readFile); + +map(tldr, ['file1', 'file2']); +// [Task('hail the monarchy'), Task('smash the patriarchy')] +``` + +在这里，我们读了一堆文件然后形成一个无用的 tasks 数组。我们要怎么样对其中的每一个进行 fork 操作呢？如果我们能够把类型做一些变化，得到 `Task Error [String]` 而不是 `[Task Error String]` 的话，想必是极好的。那样的话，我们将会有一个带有所有结果的 future 的值，这比起有多个 future 在它们闲暇之时到达要有用得多。 + +这里有最后一个例子，展示一种棘手的情况： + +```js +// getAttribute :: String -> Node -> Maybe String +// $ :: Selector -> IO Node + +// getControlNode :: Selector -> IO (Maybe (IO Node)) +const getControlNode = compose( + map(map($)), + map(getAttribute('aria-controls')), + $ +); +``` + +看看那些渴望在一起的 `IO` 们。如果能把他们 `join` 起来，让他们面对面地跳舞，那真是太可爱了。可惜的是，一个 `Maybe` 站在他们之间，就像舞会上的陪练。我们最好的办法是把它们的位置移到彼此旁边，这样每种类型最后都可以在一起，我们的签名可以简化为 `IO (Maybe Node)`。 + +## 类型风水 + +`Traversable`接口由两个值得称道的函数组成：`sequence` 和 `traverse` + +让我们用 `sequence` 重新编排我们的类型： + +```js +sequence(List.of, Maybe.of(['the facts'])); // [Just('the facts')] +sequence(Task.of, new Map({ a: Task.of(1), b: Task.of(2) })); // Task(Map({ a: 1, b: 2 })) +sequence(IO.of, Either.of(IO.of('buckle my shoe'))); // IO(Right('buckle my shoe')) +sequence(Either.of, [Either.of('wing')]); // Right(['wing']) +sequence(Task.of, left('wing')); // Task(Left('wing')) +``` + +让我们看看发生了什么？我们的嵌套类型里外翻转了过来，就像潮湿的夏夜中的皮革裤子。内部的 functor 被转移到了外部，而外部的被转移到了内部。需要知道的是，`sequence` 对于它的参数有一点挑剔。它看起来像这样子： + +```js +// sequence :: (Traversable t, Applicative f) => (a -> f a) -> t (f a) -> f (t a) +const sequence = curry((of, x) => x.sequence(of)); +``` + +让我们从第二个参数看起。它必须是一个持有 _Applicative_ 的 _Traversable_。这听起来很严格，但是事实往往如此。这就是把 `t (f a)` 转换成了 `f (t a)`。还不够有表现力吗？两种类型互相发生的操作已经是一清二楚了。而第一个参数仅仅是一个拐杖，它只在无类型的语言中是必要的。它提供了一个类型构造器（我们的 _of_）使得我们可以将那些不情愿被 map 的类型（就像 `Left`）倒置过来——稍后会有更多的介绍。 + +使用 `sequence`，我们可以像在人行道上变戏法一样精确地转移类型。但它是如何工作的呢？让我们看看一个类型，比如说 `Either`，会如何实现它： + +```js +class Right extends Either { + // ... + sequence(of) { + return this.$value.map(Either.of); + } +} +``` + +没错，如果我们的 `$value` 是一个 functor （事实上它必须是一个 applicative functor），我们就可以简单地 `map` 我们的构造器来实现类型的跃迁。 + +你可能注意到，我们把 `of` 完全忽略掉了。它仅仅是为了在 `map` 不可用的情况下而被传入的，比如在 `Left` 中： + +```js +class Left extends Either { + // ... + sequence(of) { + return of(this); + } +} +``` + +我们希望这些类型总是以相同的排列结束，所以对于像 `Left` 这样的实际上并不持有 applicative functor 的类型来说，我们有必要这么做来让它们获得一点小小的帮助。 _Applicative_ 接口要求我们首先有一个 _Pointed Functor_，使得我们总是有一个 `of` 来传入。在具有类型系统的语言中，外部的类型可以通过签名被推断而不需要显式地给出。 + +## 效果组合 + +就我们的容器而言，不同的顺序会带来不同的结果，如果我有一个 `[Maybe a]`，它是一个包含可能的值的集合 (a collection of possible values)；而如果我有一个 `Maybe [a]`，那是一个可能的包含值的集合 (a possible collection of values)。前者表示我们会宽容的保留那些"好"的值，而后者则意味着这是一个 "all or nothing" 的情况。类似地，`Either Error (Task Error a)` 可以表示一个客户端的验证，而 `Task Error (Either Error a)` 则会是一个服务端的验证。类型可以互换，为我们带来不同的效果。 + +```js +// fromPredicate :: (a -> Bool) -> a -> Either e a + +// partition :: (a -> Bool) -> [a] -> [Either e a] +const partition = (f) => map(fromPredicate(f)); + +// validate :: (a -> Bool) -> [a] -> Either e [a] +const validate = (f) => traverse(Either.of, fromPredicate(f)); +``` + +这里，根据我们使用 `map` 还是 `traverse`，我们有两个不同的函数。第一个， `partition` 将会根据谓词函数给我们一个包含 `Left` 和 `Right` 的数组。这能够把宝贵的数据保留起来以供未来使用，而不是将它和洗澡水一同过滤掉。相反，`validate` 将会给我们一个包含第一个不符合谓词函数的项目的 `Left`，或者如果一切顺利的话给我们所有的包含对应元素的 `Right`。通过选择不同的类型顺序，我们得到不同的行为。 + +让我们看看 `List` 的 `traverse` 函数，来了解 `validate` 是如何形成的。 + +```js +traverse(of, fn) { + return this.$value.reduce( + (f, a) => fn(a).map(b => bs => bs.concat(b)).ap(f), + of(new List([])), + ); +} +``` + +它仅仅是对这个列表运行了一次 `reduce`。 传入的 reduce 函数是 `(f, a) => fn(a).map(b => bs => bs.concat(b)).ap(f)`，这看起来有点儿吓人，让我们一步步看。 + +1. `reduce(..., ...)` + + 它的签名是 `reduce :: [a] -> (f -> a -> f) -> f -> f`。第一个参数事实上是由 `$value` 的点标记提供的，它是一个数组。然后我们需要一个函数，以一个 `f` (一个累计器) 和一个 a (迭代器，代表当前值) 为输入参数，返回一个新的累计器。 + +2. `of(new List([]))` + + reduce 函数的初始值是 `of(new List([]))`，在我们的例子当中则是 `Right([]) :: Either e [a]`。注意 `Either e [a]` 同时也是我们的最终返回类型。 + +3. `fn::Applicative f => a -> f a` + + 如果我们把它应用到上面的例子， `fn` 实际上是 `fromPredicate(f) :: a -> Either e a` + + > fn(a) :: Either e a + +4. `.map(b => bs => bs.concat(b))` + + 当 `fn(a)` 是一个 `Right` 的时候，`Either.map` 将正确的值传入函数中并且返回一个包含结果的新的 `Right`。在这个例子中，函数有一个参数 (`b`)，并且返回了另一个函数 (`bs => bs.concat(b)`，其中 `b` 由于闭包的存在是在作用域内的。)。当它是一个 `Left` 时，Left 对应的值会被返回。 + + > fn(a).map(b => bs => bs.concat(b)) :: Either e ([a] -> [a]) + +5. `ap(f)` + + `f` 在这里是一个 Applicative，所以我们可以把函数 `bs => bs.concat(b)` 应用到 `f` 中任意的值 `bs :: [a]`。幸运的是，`f` 是从我们的初始种子得到的，它有这样的类型：`f :: Either e [a]`，这也会在我们应用 `bs => bs.concat(b)` 的时候保留下来。当 `f` 是 `Right` 的时候，它将会调用 `bs => bs.concat(b)`，返回一个将元素添加到列表中的 `Right`；当它是个 `Left` 的时候，Left 对应的值会被返回。 + + > fn(a).map(b => bs => bs.concat(b)).ap(f) :: Either e [a] + +这个神奇的转换仅仅通过 `List.traverse` 中的 6 行简短的代码实现，并且通过 `of`, `map` 和 `ap` 完成，所以它将在任意的 Applicative Functor 中正常工作。这是一个很棒的例子，展示了那些抽象能够如何帮助我们写出高度通用的代码，仅仅依赖于一点点假设（并且这些假设可以，顺便地，从类型级别被声明和检查！）。 + +## 类型的华尔兹 + +是时候重新回顾并且清理我们最开始的例子了。 + +```js +// readFile :: FileName -> Task Error String + +// firstWords :: String -> String +const firstWords = compose(intercalate(' '), take(3), split(' ')); + +// tldr :: FileName -> Task Error String +const tldr = compose(map(firstWords), readFile); + +traverse(Task.of, tldr, ['file1', 'file2']); +// Task(['hail the monarchy', 'smash the patriarchy']); +``` + +使用 `traverse` 而不是 `map`，我们成功地将那些不守规矩的 `Task` 感到了一个漂亮的、协调的结果数组中。这有点像 `Promise.all()`，如果你熟悉的话，只不过它不只是一个一次性的自定义函数，它适用于任何可遍历的类型。这些数学上的 api 倾向于以一种互操作、可重用的方式捕获我们想做的大部分事情，而不是每个库都要为单一类型重新发明这些函数。 + +让我们清理最后一个例子来收尾。 + +```js +// getAttribute :: String -> Node -> Maybe String +// $ :: Selector -> IO Node + +// getControlNode :: Selector -> IO (Maybe Node) +const getControlNode = compose( + chain(traverse(IO.of, $)), + map(getAttribute('aria-controls')), + $ +); +``` + +我们用 `chain(traverse(IO.of, $))`代替 `map(map($))`，它在映射时反转我们的类型，然后通过 chain 将两个 IO 扁平化。 + +## 定律 + +OK 现在，在你开始评头论足，像敲槌子一样敲打退格键，从这一章中撤退之前，花点时间认识一下，这些定律是有用的代码保证。我觉得大多数程序架构的目标是试图对我们的代码进行有用的限制，以缩小可能性，引导我们作为设计师和读者找到答案。 + +一个没有定律的接口是迂回的。像其他的数学结构一样，为了我们自己的理智，我们必须暴露出属性。这和封装有类似的效果，因为它保护了数据，使我们能够用另一个遵守定律的公民来交换接口。 + +来吧，我们有一些定律要研究。 + +### 同一律 (identity) + +```js +const identity1 = compose(sequence(Identity.of), map(Identity.of)); +const identity2 = Identity.of; + +// test it out with Right +identity1(Either.of('stuff')); +// Identity(Right('stuff')) + +identity2(Either.of('stuff')); +// Identity(Right('stuff')) +``` + +这应该是很直接的。如果我们把一个 Identity 放在我们的 functor 中，然后用 `sequence` 把它翻出来，这就和一开始就把它放在外面是一样的。我们选择 `Right` 作为我们的小白鼠，因为它很容易尝试定律和检查。一个任意的 functor 在这里是正常的，然而，在这里使用一个具体的 functor，即定律本身中的 `Identity`，可能会引起一些人的注意。请记住，一个[范畴](ch5.md#范畴学)是由其对象之间的变形来定义的，这些变形具有关联构成和同一性。当处理 functor 的范畴时，自然变换就是形态，而 `Identity` 就是，嗯，自身。在证明定律方面，`Identity` functor 和我们的 `compose` 函数一样基本。事实上，我们应该放弃鬼魂，跟随我们的 [Compose](ch8.md#一点理论) 类型： + +### 组合 (Composition) + +```js +const comp1 = compose(sequence(Compose.of), map(Compose.of)); +const comp2 = (Fof, Gof) => + compose(Compose.of, map(sequence(Gof)), sequence(Fof)); + +// Test it out with some types we have lying around +comp1(Identity(Right([true]))); +// Compose(Right([Identity(true)])) + +comp2(Either.of, Array)(Identity(Right([true]))); +// Compose(Right([Identity(true)])) +``` + +这个定律如人们所期望的那样保留了组合：如果我们交换 functor 的组合，我们不应该看到任何意外，因为组合本身就是一个 functor。我们任意地选择了 `true`、`Right`、`Identity` 和 `Array` 来测试它。像 [quickcheck](https://hackage.haskell.org/package/QuickCheck) 或 [jsverify](http://jsverify.github.io/) 这样的库可以通过模糊测试输入来帮助我们测试这个规律。 + +作为上述定律的自然结果，我们能够获得[融合遍历](https://www.cs.ox.ac.uk/jeremy.gibbons/publications/iterator.pdf)的能力，这从性能的角度来看很不错。 + +### 自然 (Naturality) + +```js +const natLaw1 = (of, nt) => compose(nt, sequence(of)); +const natLaw2 = (of, nt) => compose(sequence(of), map(nt)); + +// test with a random natural transformation and our friendly Identity/Right functors. + +// maybeToEither :: Maybe a -> Either () a +const maybeToEither = (x) => (x.$value ? new Right(x.$value) : new Left()); + +natLaw1(Maybe.of, maybeToEither)(Identity.of(Maybe.of('barlow one'))); +// Right(Identity('barlow one')) + +natLaw2(Either.of, maybeToEither)(Identity.of(Maybe.of('barlow one'))); +// Right(Identity('barlow one')) +``` + +这和我们的同一律有点像。如果我们先把类型翻转出来，在外部做一次 natural transformation，那将会和 map 一下 natural transformation 然后再翻转类型得到同样的结果。 + +这个定律的一个自然的结果就是： + +```js +traverse(A.of, A.of) === A.of; +``` + +从性能的角度看，这也是极好的。 + +## 总结 + +_Traversable_ 是一个有力的接口，能够让我们像具有心灵感应能力的室内装饰师一样轻松地重新编排我们的类型。我们可以通过不同的顺序达到不同的效果，也可以熨平那些让我们无法 `join` 的讨厌的类型皱纹。接下来，我们将绕道看看函数式编程甚至可能是代数本身中最强大的接口之一：[Monoids](ch13.md)。 + +## 练习 + +考虑下列元素： + +```js +// httpGet :: Route -> Task Error JSON + +// routes :: Map Route Route +const routes = new Map({ '/': '/', '/about': '/about' }); +``` + +使用 traversable 接口把 `getJsons` 的类型签名改成 `Map Route Route -> Task Error (Map Route JSON)` + +```js +// getJsons :: Map Route Route -> Map Route (Task Error JSON) +const getJsons = map(httpGet); +``` + +我们现在定义下列校验函数： + +```js +// validate :: Player -> Either String Player +const validate = (player) => + player.name ? Either.of(player) : left('must have name'); +``` + +使用 traversable 和 `validate` 函数，更新 `startGame` （和它的类型签名），使得只有在所有玩家是有效时才开始游戏。 + +```js +// startGame :: [Player] -> [Either Error String] +const startGame = compose(map(map(always('game started!'))), map(validate)); +``` + +最终，我们考虑一些文件系统相关的帮助函数： + +```js +// readfile :: String -> String -> Task Error String +// readdir :: String -> Task Error [String] +``` From eadae2407f03d07051af787a1c3e4ba80ac0fa84 Mon Sep 17 00:00:00 2001 From: Cigui Date: Wed, 9 Jun 2021 13:16:49 +0800 Subject: [PATCH 2/5] update ch12 --- ch12.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/ch12.md b/ch12.md index 7cc4c3c..4138d4a 100644 --- a/ch12.md +++ b/ch12.md @@ -1,8 +1,8 @@ # 第 12 章：遍历 -迄今为止，在我们的集装箱马戏团中，你曾看到我们驯服了凶猛的 [functor](ch8.md)，让它听从我们的意志，执行任何让我们心动的操作；你曾被同时使用[函数应用](ch10.md)来收集结果的许多危险效果的杂耍弄得晕头转向；你曾在看到容器通过 [join](ch9.md) 凭空消失时惊讶地坐倒。在副作用杂耍中，我们看到它们经过 compose 合为一体。而最近，我们大胆地超越了自然，在你的眼前将一种类型转化为另一种 ([natural transformations](ch11.md))。 +迄今为止，在我们的容器马戏团中，你曾看到我们驯服了凶猛的 [functor](ch8.md)，让它听从我们的意志，执行任何让我们心动的操作；你曾被同时使用[函数应用](ch10.md)来收集结果的许多危险作用的杂耍弄得晕头转向；你曾在看到容器通过 [join](ch9.md) 凭空消失时惊讶地坐倒。在副作用杂耍中，我们看到它们经过 compose 合为一体。而最近，我们大胆地超越了自然，在你的眼前将一种类型转化为另一种 ([natural transformations](ch11.md))。 -至于我们的下一个表演，我们要看一下遍历。我们将看着类型在彼此之间翱翔，就像空中飞人一样保持着我们的值不变。我们将像倾斜旋转中的手推车一样重新排列效果 (effects)。当我们的容器像变形金刚的四肢一样交织在一起时，我们可以用这个接口来进行整理。我们将见证不同的效果与不同的顺序。拿上我的长裤和滑动口哨，让我们开始吧。 +至于我们的下一个表演，我们要看一下遍历。我们将看着类型在彼此之间翱翔，就像空中飞人一样保持着我们的值不变。我们将像倾斜旋转中的手推车一样重新排列作用 (effects)。当我们的容器像变形金刚的四肢一样交织在一起时，我们可以用这个接口来进行整理。我们将见证不同的作用与不同的顺序。拿上我的长裤和滑动口哨，让我们开始吧。 ## 类型与类型 @@ -88,9 +88,9 @@ class Left extends Either { 我们希望这些类型总是以相同的排列结束，所以对于像 `Left` 这样的实际上并不持有 applicative functor 的类型来说，我们有必要这么做来让它们获得一点小小的帮助。 _Applicative_ 接口要求我们首先有一个 _Pointed Functor_，使得我们总是有一个 `of` 来传入。在具有类型系统的语言中，外部的类型可以通过签名被推断而不需要显式地给出。 -## 效果组合 +## 作用组合 -就我们的容器而言，不同的顺序会带来不同的结果，如果我有一个 `[Maybe a]`，它是一个包含可能的值的集合 (a collection of possible values)；而如果我有一个 `Maybe [a]`，那是一个可能的包含值的集合 (a possible collection of values)。前者表示我们会宽容的保留那些"好"的值，而后者则意味着这是一个 "all or nothing" 的情况。类似地，`Either Error (Task Error a)` 可以表示一个客户端的验证，而 `Task Error (Either Error a)` 则会是一个服务端的验证。类型可以互换，为我们带来不同的效果。 +就我们的容器而言，不同的顺序会带来不同的结果，如果我有一个 `[Maybe a]`，它是一个包含可能的值的集合 (a collection of possible values)；而如果我有一个 `Maybe [a]`，那是一个可能的包含值的集合 (a possible collection of values)。前者表示我们会宽容的保留那些"好"的值，而后者则意味着这是一个 "all or nothing" 的情况。类似地，`Either Error (Task Error a)` 可以表示一个客户端的验证，而 `Task Error (Either Error a)` 则会是一个服务端的验证。类型可以互换，为我们带来不同的作用。 ```js // fromPredicate :: (a -> Bool) -> a -> Either e a @@ -184,7 +184,7 @@ const getControlNode = compose( OK 现在，在你开始评头论足，像敲槌子一样敲打退格键，从这一章中撤退之前，花点时间认识一下，这些定律是有用的代码保证。我觉得大多数程序架构的目标是试图对我们的代码进行有用的限制，以缩小可能性，引导我们作为设计师和读者找到答案。 -一个没有定律的接口是迂回的。像其他的数学结构一样，为了我们自己的理智，我们必须暴露出属性。这和封装有类似的效果，因为它保护了数据，使我们能够用另一个遵守定律的公民来交换接口。 +一个没有定律的接口是迂回的。像其他的数学结构一样，为了我们自己的理智，我们必须暴露出属性。这和封装有类似的作用，因为它保护了数据，使我们能够用另一个遵守定律的公民来交换接口。 来吧，我们有一些定律要研究。 @@ -253,7 +253,7 @@ traverse(A.of, A.of) === A.of; ## 总结 -_Traversable_ 是一个有力的接口，能够让我们像具有心灵感应能力的室内装饰师一样轻松地重新编排我们的类型。我们可以通过不同的顺序达到不同的效果，也可以熨平那些让我们无法 `join` 的讨厌的类型皱纹。接下来，我们将绕道看看函数式编程甚至可能是代数本身中最强大的接口之一：[Monoids](ch13.md)。 +_Traversable_ 是一个有力的接口，能够让我们像具有心灵感应能力的室内装饰师一样轻松地重新编排我们的类型。我们可以通过不同的顺序达到不同的作用，也可以熨平那些让我们无法 `join` 的讨厌的类型皱纹。接下来，我们将绕道看看函数式编程甚至可能是代数本身中最强大的接口之一：[Monoids](ch13.md)。 ## 练习 From 503ed1d43c4f8bef72c48b5cd6645dcdf7ad2e72 Mon Sep 17 00:00:00 2001 From: Cigui Date: Wed, 9 Jun 2021 13:25:33 +0800 Subject: [PATCH 3/5] update ch12 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 统一使用空格缩进代码 --- ch12.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ch12.md b/ch12.md index 4138d4a..8202ab1 100644 --- a/ch12.md +++ b/ch12.md @@ -108,9 +108,9 @@ const validate = (f) => traverse(Either.of, fromPredicate(f)); ```js traverse(of, fn) { - return this.$value.reduce( - (f, a) => fn(a).map(b => bs => bs.concat(b)).ap(f), - of(new List([])), + return this.$value.reduce( + (f, a) => fn(a).map(b => bs => bs.concat(b)).ap(f), + of(new List([])), ); } ``` From 5cd69fbeed0b4fbe31823bac15cde82ed2e195c7 Mon Sep 17 00:00:00 2001 From: cigui Date: Wed, 9 Jun 2021 18:38:20 +0800 Subject: [PATCH 4/5] Apply suggestions from code review Co-authored-by: Linghao Li --- ch12.md | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/ch12.md b/ch12.md index 8202ab1..fdbc135 100644 --- a/ch12.md +++ b/ch12.md @@ -21,7 +21,7 @@ map(tldr, ['file1', 'file2']); // [Task('hail the monarchy'), Task('smash the patriarchy')] ``` -在这里，我们读了一堆文件然后形成一个无用的 tasks 数组。我们要怎么样对其中的每一个进行 fork 操作呢？如果我们能够把类型做一些变化，得到 `Task Error [String]` 而不是 `[Task Error String]` 的话，想必是极好的。那样的话，我们将会有一个带有所有结果的 future 的值，这比起有多个 future 在它们闲暇之时到达要有用得多。 +在这里，我们读了一堆文件然后形成一个无用的 task 数组。要怎么样对其中的每一个进行 fork 操作呢？如果我们能够把类型做一些变化，得到 `Task Error [String]` 而不是 `[Task Error String]` 的话，想必是极好的。这样，我们将得到一个包含所有结果的 future value（译注：即异步任务完成后返回的值）；从异步的需求来说，这要比多个 future value （分别在各自空闲时间完成任务后再返回）要好操作得多。 这里有最后一个例子，展示一种棘手的情况： @@ -41,9 +41,9 @@ const getControlNode = compose( ## 类型风水 -`Traversable`接口由两个值得称道的函数组成：`sequence` 和 `traverse` +`Traversable` 接口由两个值得称道的函数组成：`sequence` 和 `traverse`。 -让我们用 `sequence` 重新编排我们的类型： +我们用 `sequence` 重新编排编排类型： ```js sequence(List.of, Maybe.of(['the facts'])); // [Just('the facts')] @@ -53,14 +53,14 @@ sequence(Either.of, [Either.of('wing')]); // Right(['wing']) sequence(Task.of, left('wing')); // Task(Left('wing')) ``` -让我们看看发生了什么？我们的嵌套类型里外翻转了过来，就像潮湿的夏夜中的皮革裤子。内部的 functor 被转移到了外部，而外部的被转移到了内部。需要知道的是，`sequence` 对于它的参数有一点挑剔。它看起来像这样子： +看清楚这里发生了什么吗？嵌套类型里外翻转了过来，就像潮湿夏夜里的皮裤翻过来了一样。内部的 functor 转移到了外部，而外部的转移到了内部。不过要注意，`sequence` 对它的参数有一点挑剔。它看起来像这样子： ```js // sequence :: (Traversable t, Applicative f) => (a -> f a) -> t (f a) -> f (t a) const sequence = curry((of, x) => x.sequence(of)); ``` -让我们从第二个参数看起。它必须是一个持有 _Applicative_ 的 _Traversable_。这听起来很严格，但是事实往往如此。这就是把 `t (f a)` 转换成了 `f (t a)`。还不够有表现力吗？两种类型互相发生的操作已经是一清二楚了。而第一个参数仅仅是一个拐杖，它只在无类型的语言中是必要的。它提供了一个类型构造器（我们的 _of_）使得我们可以将那些不情愿被 map 的类型（就像 `Left`）倒置过来——稍后会有更多的介绍。 +我们先看第二个参数。它必须是一个持有 _Applicative_ 的 _Traversable_。这听起来很严格，但是事实往往如此。这就是把 `t (f a)` 转换成了 `f (t a)`。还不够明显吗？这两种类型简直就是在背靠背。而第一个参数，它仅仅是一个拐杖，只在无类型的语言中是必要的。它提供了一个类型构造器（即 _of_）用来倒置那些不情愿被 map 的类型（比如 `Left`）——稍后会有更多介绍。 使用 `sequence`，我们可以像在人行道上变戏法一样精确地转移类型。但它是如何工作的呢？让我们看看一个类型，比如说 `Either`，会如何实现它： @@ -143,7 +143,7 @@ traverse(of, fn) { > fn(a).map(b => bs => bs.concat(b)).ap(f) :: Either e [a] -这个神奇的转换仅仅通过 `List.traverse` 中的 6 行简短的代码实现，并且通过 `of`, `map` 和 `ap` 完成，所以它将在任意的 Applicative Functor 中正常工作。这是一个很棒的例子，展示了那些抽象能够如何帮助我们写出高度通用的代码，仅仅依赖于一点点假设（并且这些假设可以，顺便地，从类型级别被声明和检查！）。 +这个神奇的转换仅仅通过 `List.traverse` 中的 6 行简短的代码实现，并且通过 `of`, `map` 和 `ap` 完成，所以它将在任意的 Applicative Functor 中正常工作。这是一个很棒的例子，展示了那些抽象能够如何帮助我们写出高度通用的代码，仅仅依赖于一点点假设（而且这些假设可以通过类型系统声明和检查！）。 ## 类型的华尔兹 @@ -162,7 +162,7 @@ traverse(Task.of, tldr, ['file1', 'file2']); // Task(['hail the monarchy', 'smash the patriarchy']); ``` -使用 `traverse` 而不是 `map`，我们成功地将那些不守规矩的 `Task` 感到了一个漂亮的、协调的结果数组中。这有点像 `Promise.all()`，如果你熟悉的话，只不过它不只是一个一次性的自定义函数，它适用于任何可遍历的类型。这些数学上的 api 倾向于以一种互操作、可重用的方式捕获我们想做的大部分事情，而不是每个库都要为单一类型重新发明这些函数。 +使用 `traverse` 而不是 `map`，我们成功地将那些不守规矩的 `Task` 赶到了一个漂亮的、协调的结果数组中。如果你熟悉 `Promise.all()`，你会发现它们很像；只不过 `traverse` 并不是个一次性的自定义函数，它适用于任何可遍历的类型。这些数学上的 API 倾向于以一种互操作、可重用的方式捕获我们想做的大部分事情，而不必像单个类库那样为某一类型重新发明这些函数。 让我们清理最后一个例子来收尾。 @@ -182,7 +182,7 @@ const getControlNode = compose( ## 定律 -OK 现在，在你开始评头论足，像敲槌子一样敲打退格键，从这一章中撤退之前，花点时间认识一下，这些定律是有用的代码保证。我觉得大多数程序架构的目标是试图对我们的代码进行有用的限制，以缩小可能性，引导我们作为设计师和读者找到答案。 +好了，在你要像法官像敲槌子一样下结论关闭本章之前，还是要认识到，这些定律是很受用的法规保证。在我看来，大多数程序架构的目地是对代码加以限制来缩小可能性，最终引导我们找到正确答案。 一个没有定律的接口是迂回的。像其他的数学结构一样，为了我们自己的理智，我们必须暴露出属性。这和封装有类似的作用，因为它保护了数据，使我们能够用另一个遵守定律的公民来交换接口。 @@ -202,7 +202,7 @@ identity2(Either.of('stuff')); // Identity(Right('stuff')) ``` -这应该是很直接的。如果我们把一个 Identity 放在我们的 functor 中，然后用 `sequence` 把它翻出来，这就和一开始就把它放在外面是一样的。我们选择 `Right` 作为我们的小白鼠，因为它很容易尝试定律和检查。一个任意的 functor 在这里是正常的，然而，在这里使用一个具体的 functor，即定律本身中的 `Identity`，可能会引起一些人的注意。请记住，一个[范畴](ch5.md#范畴学)是由其对象之间的变形来定义的，这些变形具有关联构成和同一性。当处理 functor 的范畴时，自然变换就是形态，而 `Identity` 就是，嗯，自身。在证明定律方面，`Identity` functor 和我们的 `compose` 函数一样基本。事实上，我们应该放弃鬼魂，跟随我们的 [Compose](ch8.md#一点理论) 类型： +这应该是很直接的。如果我们把一个 Identity 放在 functor 中，然后用 `sequence` 把它翻出来，这就和一开始就把它放在外面是一样的。我们选择 `Right` 作为小白鼠，因为它很容易验证和检查定律。一个任意的 functor 在这里是正常的，然而，在这里使用一个具体的 functor，即定律本身中的 `Identity`，可能会引起一些人的注意。请记住，一个[范畴](ch5.md#范畴学)是由其对象之间的变形来定义的，这些变形具有关联构成和同一性。当处理 functor 的范畴时，自然变换就是形态，而 `Identity` 就是，嗯，自身。`Identity` functor 和 `compose` 函数一样，都是很基本的定律。好了，关于 `Identity` 就先到这里，接下来我们看看 [Compose](ch8.md#一点理论) 类型： ### 组合 (Composition) @@ -241,7 +241,7 @@ natLaw2(Either.of, maybeToEither)(Identity.of(Maybe.of('barlow one'))); // Right(Identity('barlow one')) ``` -这和我们的同一律有点像。如果我们先把类型翻转出来，在外部做一次 natural transformation，那将会和 map 一下 natural transformation 然后再翻转类型得到同样的结果。 +这和同一律有点像。如果我们先把类型翻转出来，在外部做一次 natural transformation，那将会和 map 一下 natural transformation 然后再翻转类型得到同样的结果。 这个定律的一个自然的结果就是： @@ -253,7 +253,7 @@ traverse(A.of, A.of) === A.of; ## 总结 -_Traversable_ 是一个有力的接口，能够让我们像具有心灵感应能力的室内装饰师一样轻松地重新编排我们的类型。我们可以通过不同的顺序达到不同的作用，也可以熨平那些让我们无法 `join` 的讨厌的类型皱纹。接下来，我们将绕道看看函数式编程甚至可能是代数本身中最强大的接口之一：[Monoids](ch13.md)。 +_Traversable_ 是一个强大的接口，能够让你像有心灵感应的室内设计师一样轻松重新编排类型。我们可以通过不同的顺序达到不同的作用，也可以熨平那些令人讨厌的无法 `join` 的类型皱纹。接下来，我们将一起欣赏函数式编程乃至于代数学本身最强大的接口之一：[Monoids](ch13.md)。 ## 练习 From 8e41558d1f4cefa6d53a3dd48e5b533d2a4855d6 Mon Sep 17 00:00:00 2001 From: Cigui Date: Wed, 9 Jun 2021 18:41:21 +0800 Subject: [PATCH 5/5] update ch12 --- ch12.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ch12.md b/ch12.md index fdbc135..fafb47d 100644 --- a/ch12.md +++ b/ch12.md @@ -90,7 +90,7 @@ class Left extends Either { ## 作用组合 -就我们的容器而言，不同的顺序会带来不同的结果，如果我有一个 `[Maybe a]`，它是一个包含可能的值的集合 (a collection of possible values)；而如果我有一个 `Maybe [a]`，那是一个可能的包含值的集合 (a possible collection of values)。前者表示我们会宽容的保留那些"好"的值，而后者则意味着这是一个 "all or nothing" 的情况。类似地，`Either Error (Task Error a)` 可以表示一个客户端的验证，而 `Task Error (Either Error a)` 则会是一个服务端的验证。类型可以互换，为我们带来不同的作用。 +就我们的容器而言，不同的顺序会带来不同的结果，如果我有一个 `[Maybe a]`，它是一个包含可能的值的集合 (a collection of possible values)；而如果我有一个 `Maybe [a]`，那是一个可能的包含值的集合 (a possible collection of values)。前者表示我们会宽容地保留那些"好"的值，而后者则意味着这是一个 "all or nothing" 的情况。类似地，`Either Error (Task Error a)` 可以表示一个客户端的验证，而 `Task Error (Either Error a)` 则会是一个服务端的验证。类型可以互换，为我们带来不同的作用。 ```js // fromPredicate :: (a -> Bool) -> a -> Either e a