函子、适用函子、单子：揭秘函数式编程中令人费解的概念

2023-09-12 05:41:53

函数式编程中，函子（Functor）、适用函子（Applicative）、单子（Monad）是三个非常重要的概念，然而很多人对它们理解起来比较困难。其实，这三个概念并不复杂，只是由于数学和编程背景的不同，导致人们在理解上存在一定的障碍。因此，本文将使用尽量直白易懂的语言，结合简单的例子，来解释这三个概念。

什么是函子？

函子本质上是一个容器，它可以用来包装不同的类型的数据。举个例子，我们可以创建一个函子来包装一个数字，也可以创建一个函子来包装一个字符串。

class Functor<T> {
  private value: T;

  constructor(value: T) {
    this.value = value;
  }

  map<U>(f: (value: T) => U): Functor<U> {
    return new Functor(f(this.value));
  }
}

函子的核心方法是map方法。这个方法允许我们对函子中的数据进行转换，而无需更改函子本身。例如，我们可以使用map方法将一个数字转换成一个字符串：

const numberFunctor = new Functor(10);
const stringFunctor = numberFunctor.map((value) => value.toString());
console.log(stringFunctor.value); // "10"

什么是适用函子？

适用函子是函子的一个子类。它不仅可以包装数据，还可以包装函数。这使得我们可以将多个函数组合起来，并以一种链式的方式执行它们。

class Applicative<T> extends Functor<T> {
  static of<T>(value: T): Applicative<T> {
    return new Applicative(value);
  }

  ap<U>(f: Applicative<(value: T) => U>): Applicative<U> {
    return f.map((g) => (value) => g(value)).ap(this);
  }
}

适用函子的核心方法是ap方法。这个方法允许我们将一个函数应用到另一个函子中的数据上。例如，我们可以使用ap方法将一个函数应用到一个数字函子上，从而得到一个字符串函子：

const numberFunctor = new Applicative(10);
const add10Function = new Applicative((value: number) => value + 10);
const resultFunctor = add10Function.ap(numberFunctor);
console.log(resultFunctor.value); // 20

什么是单子？

单子是函子的一个子类。它不仅可以包装数据，还可以包装副作用。这使得我们可以将多个副作用组合起来，并以一种控制流的方式执行它们。

class Monad<T> extends Applicative<T> {
  static of<T>(value: T): Monad<T> {
    return new Monad(value);
  }

  flatMap<U>(f: (value: T) => Monad<U>): Monad<U> {
    return f(this.value).ap(this);
  }
}

单子的核心方法是flatMap方法。这个方法允许我们将一个函数应用到一个单子中的数据上，并得到一个新的单子。例如，我们可以使用flatMap方法将一个函数应用到一个数字单子上，从而得到一个字符串单子：

const numberMonad = new Monad(10);
const add10Function = new Monad((value: number) => value + 10);
const resultMonad = numberMonad.flatMap((value) => add10Function.map((f) => f(value)));
console.log(resultMonad.value); // 20