高阶类型和其他
函子：函子是执行映射操作的函数的推广。对于任何泛型类型，以Box<T>为例，如果map()操作接受一个Box<T>和一个从 T 到 U 的函数作为实参，并得到一个Box<U>，那么该map()就是一个函子
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| class Box<T> {
value: T;
constructor(value: T) {
this.value = value;
}
}
namespace Box {
export function map<T, U>(
value: Box<T> | undefined,
func: (value: T) => U
): Box<U> | undefined {
if (value === undefined) {
return undefined;
} else {
return new Box<U>(func(value.value));
}
}
}
|
高阶类型：泛型类型是具有类型参数的类型，如泛型类型 T，或者有一个类型参数 T 的类型，如Box<T>。高阶类型与高阶函数类似，代表具有另外一个类型参数的类型参数。例如，T<U>或Box<T<U>>有一个类型参数 T，后者又有一个类型参数 U。
单子模式：单子是一个泛型类型H<T>。对于该类型，我们有一个函数（如 unit()）可接受类型 T 的一个值并返回类型H<T>的一个值。还有一个函数（如 bind()）可接受类型H<T>的一个值和一个从 T 到H<U>的函数，并返回类型H<U>的一个值
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
32
33
| class Optional<T> {
private value: T | undefined;
private assigned: boolean;
constructor(value?: T) {
if (value) {
this.value = value;
this.assigned = true;
} else {
this.value = undefined;
this.assigned = false;
}
}
hasValue(): boolean {
return this.assigned;
}
getValue(): T {
if (!this.assigned) throw new Error("value is undefined");
return <T>this.value;
}
}
namespace Optional {
export function unit<T>(val: T): Optional<T> {
return new Optional(val);
}
export function bind<T, U>(
optional: Optional<T>,
func: (value: T) => Optional<U>
): Optional<U> {
if (!optional.hasValue()) return new Optional();
return func(optional.getValue());
}
}
|
