FP，全称为函数式编程（Functional Programming）。函数式编程是一种编程范式，强调将计算过程视为数学函数的计算。
Function Composition
在函数式编程中，函数被视为第一类公民，可以作为参数传递、返回值返回，从而支持高度的抽象和组合。
函数组合(Function Composition)，即将简单的函数组合成更复杂的函数。每个函数的结果作为下一个函数的参数传递，最后一个函数的结果是整个操作的结果。
例如：
const clear = (s:string): string => s.trim();
const length = (s: string): number => s.length;
const cal = (n: number): number => n+1;
const result = cal(length(clear("hello, fp-ts")));
这里虽然将多个函数组合在了一起，但从写法上可以看出，嵌套很深，可读性非常差，不符合人脑思维。这里还只是列举了三个函数，可想而知如果在工程代码中大量使用这种方式来组合庞大的函数，将是巨大的灾难。因此，如何将众多函数优雅合理且具有较好可读性的组合连接在一起就尤为重要。（记住这个例子，后面我们将使用两种fp-ts中常用的方式对其进行改进）
flow
根据官网定义，flow是执行从左到右的函数组合。截取一部分flow的定义：
export declare function flow<A extends ReadonlyArray<unknown>, B>(ab: (...a: A) => B): (...a: A) => B
export declare function flow<A extends ReadonlyArray<unknown>, B, C>(
ab: (...a: A) => B,
bc: (b: B) => C
): (...a: A) => C
...
由此可得：
-
flow将每个函数的输出作为下一个函数的参数传递; -
flow的第一个函数可以有任意数量的参数，其余函数必须只接受一个参数；
对上述例子进行改进：
const clear = (s:string): string => s.trim();
const length = (s: string): number => s.length;
const cal = (n: number): number => n+1;
const bestFlow = flow(clear, length, cal);
const result = bestFlow("hello, fp-ts");
pipe
根据官网定义，pipe会将表达式的值传送到函数管道中。截取一部分pipe的定义：
export declare function pipe<A>(a: A): A
export declare function pipe<A, B>(a: A, ab: (a: A) => B): B
export declare function pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C
...
由此可得：
-
pipe的初始值作为第一个函数的参数传递，然后该函数的输出作为下一个函数的参数传递，依此类推； -
pipe的第一个参数是一个值（或一个表达式，因为每个表达式都会返回一个值）；
对上述例子进行改进：
const clear = (s:string): string => s.trim();
const length = (s: string): number => s.length;
const cal = (n: number): number => n+1;
const result = pipe("hello, fp-ts", clear, length, cal);
在 fp-ts 这个函数式编程库中，flow 和 pipe 都是用来组合函数的工具，只是在使用方式和用途上有一些区别：
- pipe 和 flow 都是用来组合函数的，按顺序执行一系列函数；
- pipe 的参数是按顺序传递的，函数直接调用，增加了可读性；
- flow 的参数是一个函数数组，更适合在代码中动态地组合一组函数；
无论选择使用哪个，都取决于你的个人偏好和具体的使用场景。它们都有助于编写更具有可读性和组合性的函数式代码。
常用 fp-ts Monad
fp-ts 提供了许多不同的 Monad 类型，用于在函数式编程中处理容器、副作用、异步操作等场景。这里根据处理问题的类型不同，介绍常见的Monad：
- 同步可失败 - Option，Either
- 同步不可失败 - IO
- 异步不可失败 - Task
- 异步可失败 - TaskEither
同步可失败: Option
null 和 undefined 是运行时错误的主要原因。TypeScript 在的检查只能在一定程度上保护我们进行识别，但我们必须自己做这些检查，且null 的使用也不够清晰，是表示“无值”还是“空值”的含义呢？
fp-ts 提供的Option能够对null和undefined进行表示。首先来看其定义：
type Option<A> = None | Some<A>;
interface None {
readonly _tag: "None";
}
interface Some<A> {
readonly _tag: "Some";
readonly value: A;
}
Option 是一个包含可选类型 A 的“容器”，如果有值，它是 Some<A> 的实例。如果没有值，它是 None 的实例。另一种对Option的理解是，它可以被视为一个集合或可折叠的结构，要么包含一个元素，要么不包含任何元素。且由于其定义中None的定义，它表示可能失败的计算的效果。
同步可失败：Either
在 TypeScript 程序中处理错误条件最常见的方法是抛出错误，然后由调用者使用 try/catch 块来处理。在FP的代码世界中，我们不能这样直接throw error出去，即使有try/catch包裹也不行，因为这本身就是存在side effect的方式。
在函数式编程中处理可能失败的方式是使用 "Either" 。首先来看其定义：
type Either<E, A> = Left<E> | Right<A>;
interface Left<E> {
readonly _tag: "Left";
readonly left: E;
}
interface Right<A> {
readonly _tag: "Right";
readonly right: A;
}
Either代表两种可能类型中的一个值 E 和 A。这里Left 和 Right 没有固有的含义。只是在常见的用法中，Left 用于表示失败或错误，而 Right 用于表示成功的结果。在 fp-ts 中，Either 仅用于处理可能失败的同步操作。
同步不可失败：IO
针对有side effect的计算，fp-ts可以使用IO进行表示。
export interface IO<A> {
(): A
}
IO<A> 表示一种非确定性的同步计算，它可能引发副作用，生成类型为 A 的值，并且永远不会失败。
异步不可失败：Task
根据官方文档，Task 表示一个将执行异步计算的函数，该计算会生成类型为 A 的值。需要执行该 Task 才能获取其值。执行 Task 永远不会失败，它会始终返回一个 Promise，该 Promise 将始终解析并永远不会拒绝。
interface Task<A> {
(): Promise<A>
}
异步可失败：TaskEither
Node.js 是一个异步事件驱动的系统。异步代码可能很难编写，也很难理解。多年来，Node.js 提供了一些方法来改善这种体验，比如callback，Promises，async/await。直接使用 Promises 可能会令人困惑, async 和 await 可以帮助我们将异步代码转换为同步代码，这样更容易理解，但它们无法帮助我们知道“这段代码可能会抛出错误”。
TaskEither可以帮助处理这种场景。
interface TaskEither<E, A> extends Task<Either<E, A>> {}
TaskEither<E, A> 表示一个异步计算，它可以生成类型为 A 的值，也可能在发生错误时生成类型为 E 的错误。
还是不好理解？根据上述 Task 的定义，我们可以对 TaskEither 进行如下等价变形
TaskEither<E, A> <=> Task<Either<E, A>> <=> () => Promise<Either<E, A>>
即TaskEither是一个 Task，它在执行时返回一个 Promise，该 Promise 在成功时解析为 Right<A> 实例，或在发生错误时解析为 Left<E> 实例。
以上解释并列举了fp-ts中常见Monad，具体使用场景要根据需求进行选择。例如对网络请求的实现，由于网络请求是异步的，且在请求处理过程中可能出错，则选择使用异步可失败的 TaskEither ；对于打日志，生成UUID等存在副作用的函数，且通常使用第三方库生成，则选择同步不可失败的IO；对于代码库中常见的业务逻辑，如果是同步且可能产生错误的处理，根据是否需要识别不同的错误类型，选择使用Option或Either。
