Applicative 函子如何与 Monad 函子进行比较和区分？

Applicative 和 Monad 都是函数式编程中的重要抽象，它们都用于处理带有上下文的计算，但它们的能力和使用方式有所不同。

Applicative

Applicative 是一种比 Functor 更强大的抽象，它允许你在上下文中应用函数。Applicative 提供了两个主要操作：

1. pure：将一个值提升到一个上下文中。

2. ap：将一个在上下文中的函数应用到一个在上下文中的值。

在 TypeScript 中，使用 fp-ts 库可以实现 Applicative：

import { option, some, none } from 'fp-ts';

import { pipe } from 'fp-ts/function';

const A = option.Applicative;

// 将一个值提升到一个上下文中

const pureValue = A.of(5);

// 定义一个在上下文中的函数

const add = (a: number) => (b: number) => a + b;

const addInContext = A.of(add);

// 将在上下文中的函数应用到在上下文中的值

const result = pipe(

  addInContext,

  A.ap(some(2)),

  A.ap(some(3))

);

console.log(result); // 输出: some(5)

Monad

Monad 是一种比 Applicative 更强大的抽象，它不仅允许你在上下文中应用函数，还允许你在上下文中进行链式计算。Monad 提供了两个主要操作：

1. of：将一个值提升到一个上下文中（与 Applicative 的 pure 类似）。

2. chain：将一个返回带有上下文的函数应用到一个带有上下文的值，并将结果展平。

在 TypeScript 中，使用 fp-ts 库可以实现 Monad：

import { option, some, none } from 'fp-ts';

import { pipe } from 'fp-ts/function';

const M = option.Monad;

// 将一个值提升到一个上下文中

const pureValue = M.of(5);

// 定义一个返回带有上下文的函数

const add = (a: number) => (b: number) => some(a + b);

// 将返回带有上下文的函数应用到一个带有上下文的值

const result = pipe(

  some(2),

  M.chain(add(3))

);

console.log(result); // 输出: some(5)

Applicative 与 Monad 的比较和区分

1. 能力：

   • Applicative 允许你在上下文中应用函数。

   • Monad 允许你在上下文中进行链式计算，并将结果展平。

2. 操作：

   • Applicative 提供 pure 和 ap 操作。

   • Monad 提供 of 和 chain 操作。

3. 组合计算：

   • Applicative 适用于独立的上下文计算。

   • Monad 适用于依赖于前一个计算结果的链式计算。

示例对比

以下是一个对比 Applicative 和 Monad 的示例：

Applicative 示例

import { option, some, none } from 'fp-ts';

import { pipe } from 'fp-ts/function';

const A = option.Applicative;

const add = (a: number) => (b: number) => a + b;

const addInContext = A.of(add);

const result = pipe(

  addInContext,

  A.ap(some(2)),

  A.ap(some(3))

);

console.log(result); // 输出: some(5)

Monad 示例

import { option, some, none } from 'fp-ts';

import { pipe } from 'fp-ts/function';

const M = option.Monad;

const add = (a: number) => (b: number) => some(a + b);

const result = pipe(

  some(2),

  M.chain(add(3))

);

console.log(result); // 输出: some(5)

总结

• Applicative 适用于独立的上下文计算，提供 pure 和 ap 操作。

• Monad 适用于依赖于前一个计算结果的链式计算，提供 of 和 chain 操作。

• Monad 是 Applicative 的超集，所有的 Monad 都是 Applicative，但并非所有的 Applicative 都是 Monad。