书接上回，Maybe已经可以正确处理数据了。但是Maybe遇到意外分支时只返回了null，开发者不清楚是哪个环节出现了问题。 所以需要一个函子来保留意外分支的上下文信息.
🍐 Either 函子
在上一篇关于MayBe函子的讨论中，我们了解了如何使用函子处理可能为null或undefined的情况。Maybe函子帮助我们避免了重复的空值检查，但它的缺点在于遇到错误或意外分支时，无法保留出错的上下文信息。此时，我们需要引入Either函子，来帮助我们在处理错误时保留详细的错误信息。
🌰 Either 核心实现
Either函子由两个主要的子类构成：Left和Right。Left代表错误分支，Right代表成功分支。通过Either函子，我们不仅能够处理错误，还能保留出错的位置和上下文。
为了实现这一点，我们首先需要一个Nothing类，它不对持有的值进行任何处理，始终返回自身。这为Either提供了一个空的错误容器。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
class Nothing {
constructor(value) {
this.value = value
}
map(fn) {
return this
}
static of(value) {
return new this(value)
}
}
const val = new Nothing('hello').map((str) => `say: ${str}`)
|
Nothing函子可以很方便地捕获错误或意外分支，作为Left的一种表现形式。下面是一个简单的使用示例，展示了如何处理Maybe函数执行中的错误。
🌰 Either 使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
class Some {
constructor(value) {
this.value = value
}
map(fn) {
return Some.of(fn(this.value))
}
static of(value) {
return new this(value)
}
}
const capitalCase = (val) => {
try {
return new Some(val).map((str) => `${str[0].toUpperCase()}${str.substring(1)}`)
} catch (err) {
return new Nothing(err)
}
}
console.log(capitalCase('hello').map((str) => `result: ${str}`))
console.log(capitalCase(undefined).map((str) => `result: ${str}`))
|
在上述代码中，Nothing能够准确捕获错误，并将错误信息作为返回值。如果我们传入一个undefined值，capitalCase函数会抛出错误，Nothing函子捕获并返回错误信息，而不会导致程序崩溃。
🍐 Either 简单实现
以下是一个简化版的Either实现。它使用map方法来处理数据，同时在捕获到错误时返回Nothing，从而使开发者能够继续追踪错误。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| class Either {
constructor(value) {
this.value = value
}
map(fn) {
try {
return Either.of(fn(this.value))
} catch (err) {
return new Nothing(err)
}
}
static of(value) {
return new this(value)
}
}
const capitalCase2 = (val) => {
return new Either(val).map((str) => `${str[0].toUpperCase()}${str.substring(1)}`)
}
console.log(capitalCase2('hello').map((str) => `result: ${str}`))
console.log(capitalCase2(undefined).map((str) => `result: ${str}`))
|
在这个例子中，Either函子能够在发生错误时返回Nothing，让开发者明确地看到哪里发生了问题。
🍐 Monad 函子
在Maybe函子的应用中，我们通常会遇到值的嵌套问题。例如，当一个map调用返回的是另一个函子时，我们就会遇到类似MayBe { value: MayBe { value: "HELLO" } }的嵌套结构。为了避免这种情况的复杂性，我们引入了Monad函子，它通过chain方法（或join方法）来平铺嵌套结构，从而简化链式调用的操作。
！ 多重map调用
在以下示例中，第一个MayBe函子的map调用返回了一个新的函子对象。为了访问嵌套的值，我们需要不断调用value属性，这会使代码变得不够优雅。
1
2
3
4
5
6
| const val = new MayBe('hello').map((str) => new MayBe(str).map((str) => str.toUpperCase()))
console.log(val)
console.log(val.value.value)
|
💡 使用 join 解套嵌套
join方法帮助我们解决了单一函子嵌套的问题，它会将一个MayBe中的MayBe值解开，返回内部的值。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| class MayBe {
static of(value) {
return new this(value)
}
constructor(value) {
this.value = value
}
map(fn) {
return MayBe.of(this.isNothing() ? null : fn(this.value))
}
isNothing() {
return this.value === null || this.value === undefined
}
join() {
return this.isNothing() ? MayBe.of(null) : this.value
}
}
const val = new MayBe('hello').map((str) => new MayBe(str).map((str) => str.toUpperCase()).join())
console.log(val)
const num = new MayBe(new MayBe(30).map((n) => n + 3))
console.log(num.join().map((n) => n + 200))
|
通过join，我们将MayBe中的嵌套函子解开，简化了代码并避免了嵌套值的访问。
💡 使用 chain 进一步优化
尽管join可以解决单层嵌套，但多个嵌套的函子依然需要调用join进行解套。为了更加简洁，我们引入了chain方法，它会在调用时自动执行一次join，从而避免手动处理嵌套。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
| class MayBe {
static of(value) {
return new this(value)
}
constructor(value) {
this.value = value
}
map(fn) {
return MayBe.of(this.isNothing() ? null : fn(this.value))
}
isNothing() {
return this.value === null || this.value === undefined
}
join() {
return this.isNothing() ? MayBe.of(null) : this.value
}
chain(fn) {
return this.map(fn).join()
}
}
const num = new MayBe(30).chain((n) => new MayBe(n + 3).map((n) => n + 200))
console.log(num)
|
通过chain方法，我们简化了多重map调用的逻辑，使代码更清晰、简洁。
