基础Monad入门指南

### 基础 Monad 入门指南 #### 1. Id Monad 介绍 在编程中，Monad 是一种强大的抽象概念，而 Id Monad 是其中较为特别的存在。与 `Option` 用于表示可选性不同，Id Monad 本身没有什么特别的含义，它只是简单地包装一个值，不做任何额外处理。 以下是 Id Monad 的定义方式： ```scala type Id[A] = A implicit val idMonad = new Monad[Id] { override def unit[A](a: => A): Id[A] = a override def flatMap[A, B](a: Id[A])(f: A => Id[B]): Id[B] = f(a) } ``` 这里通过类型别名 `type Id[A] = A` 让编译器认为 `Id[A]` 和 `A` 是相同的。`unit(a)` 直接返回 `a`，`flatMap` 则是将函数 `f` 应用到 `a` 上。 为了验证其符合 Monad 定律，我们可以编写如下属性检查： ```scala property("Monad[Id] and Int => String, String => Long") = { monad[Int, String, Long, Id] } property("Monad[Id] and String => Int, Int => Boolean") = { monad[String, Int, Boolean, Id] } ``` 测试结果表明，Id Monad 通过了 100 次测试，符合 Monad 定律。 那么，我们为什么需要 Id Monad 呢？从抽象角度看，Id Monad 在 Monad 空间中扮演着单位元的角色，就像数字空间中加法的零和乘法的一。它可以作为 Monad 变换器的占位符，也适用于现有代码期望使用 Monad，但实际并不需要的情况。 #### 2. State Monad 引入 在命令式编程中，全局变量是一个常见的概念，它可以在程序的任何地方访问。然而，这种做法被认为是不良实践，但仍经常被使用。全局状态的概念进一步扩展了全局变量，包括系统资源，如文件系统或系统时钟。在 JVM 中，一些全局资源可以通过 `java.lang.System` 类访问。 但全局状态存在一个问题，它破坏了代码的引用透明性。引用透明性意味着在程序中，任何部分的代码（如函数调用）都可以被其计算结果替换，而不会导致程序行为的可观察变化。与之密切相关的概念是纯函数，即对于所有引用透明的参数，函数都是引用透明的。 以下是一个示例，展示了全局状态如何破坏引用透明性： ```scala var globalState = 0 def incGlobal(count: Int): Int = { globalState += count globalState } val g1 = incGlobal(10) // g1 == 10 val g2 = incGlobal(10) // g1 == 20 ``` 在这个例子中，`incGlobal` 函数不是纯函数，因为每次调用的结果不同，无法用其计算结果替换函数调用。 相比之下，以下函数是引用透明且纯的： ```scala def incLocal(count: Int, global: Int): Int = global + count val l1 = incLocal(10, 0) // l1 = 10 val l2 = incLocal(10, 0) // l2 = 10 ``` 在函数式编程中，我们通常期望只使用纯函数，因此全局状态不适合函数式编程。但在很多情况下，我们又需要累积和修改状态，这时 State Monad 就派上用场了。 #### 3. State Monad 定义 State Monad 围绕一个函数构建，该函数接受全局状态的相关部分作为参数，并返回一个结果和修改后的状态（当然，不会在全局层面改变任何东西）。其函数签名如下： ```scala type StatefulFunction[S, A] = S => (A, S) ``` 为了简化辅助方法的定义，我们可以将其封装到一个 `case class` 中： ```scala final case class State[S, A](run: S => (A, S)) ``` 同时，在伴生对象中定义几个构造函数： ```scala object State { def apply[S, A](a: => A): State[S, A] = State(s => (a, s)) def get[S]: State[S, S] = State(s => (s, s)) def set[S](s: => S): State[S, Unit] = State(_ => ((), s)) } ``` - `apply` 方法：将值 `a` 提升到 `State` 上下文中，返回给定参数作为结果，并传播现有状态而不做改变。 - `get` 方法：创建一个 `State`，返回当前状态作为结果。 - `set` 方法：设置状态，不返回结果。 #### 4. State Monad 组合 现在，我们希望能够将这些状态计算组合起来。我们可以在 `State` 类上定义一个 `compose` 方法来实现这一点： ```scala final case class State[S, A](run: S => (A, S)) { def compose[B](f: A => State[S, B]): State[S, B] = { val composedRuns = (s: S) => { val (a, nextState) = run(s) f(a).run(nextState) } State(composedRuns) } } ``` 这个 `compose` 方法将两个 `run` 函数组合起来，先执行第一个 `State` 的 `run` 方法，得到结果和下一个状态，然后将结果应用到函数 `f` 上，并使用下一个状态执行 `f` 返回的 `State` 的 `run` 方法。 #### 5. State Monad 实现 由于 `compose` 方法的签名与 Monad 的 `flatMap` 相同，我们可以将 Monad 行为委托给 `State` 已有的逻辑： ```scala import ch09._ implicit def stateMonad[S] = new Monad[State[S, ?]] { override def unit[A](a: => A): State[S, A] = State(a) override def flatMap[A, B](a: State[S, A])(f: A => State[S, B]): State[S, B] = a.compose(f) } ``` 这里，`unit` 方法委托给 `State` 的默认构造函数，`flatMap` 方法委托给 `compose` 方法。 由于 `State` 包含函数作为值，直接测试其是否符合 Monad 定律比较困难，因为比较两个函数是否相等是一个活跃的学术研究课题。我们可以使用替换模型来证明其实现的正确性。 以下是一个证明引理的过程： 假设 `as: M[A]`，`f: A => M[B]` 且 `M = State`，`as.run = s => (a, s1)`，`f(b) = (b: A) => State(s1 => (b, s2))`，则 `M.flatMap(as)(f)` 总是返回 `State(s => (b, s2))