monad

在 Haskell 中，Functor、Applicative 和 Monad 是三种重要的类型类，它们各自提供了不同层次的抽象来操作容器类型。下面我们将介绍 Functor 和 Applicative 的局限性，解释为什么需要 Monad，并对 Monad 的类型类进行详细介绍。

1. Functor 的局限性

Functor 类型类定义了一个基本的映射（map）操作，使我们可以对容器中的每个元素应用一个函数。其核心方法是 fmap 或中缀形式 <$>：

class Functor f where
    fmap :: (a -> b) -> f a -> f b

局限性：Functor 只能对容器内的每个元素应用单一的函数，无法处理两个或多个容器内的值之间的关系。
示例：假设我们有两个列表 xs 和 ys，希望得到所有可能的组合。Functor 无法直接处理这种需要多容器联合的场景，只能分别对每个容器内的元素操作。

2. Applicative 的局限性

Applicative 类型类提升了 Functor 的功能，可以将多个容器内的值进行组合。其核心方法是 pure 和 <*>：

class Functor f => Applicative f where
    pure :: a -> f a
    (<*>) :: f (a -> b) -> f a -> f b

局限性：虽然 Applicative 支持对两个容器内的值进行组合，但它的组合方式是静态的，无法在一个容器的计算结果基础上决定下一个容器的计算方式。
示例：例如，假设我们要从一个列表中取值，然后基于该值从另一个列表中取出特定的值。Applicative 无法实现这种依赖于上一步计算结果的操作。

3. Monad 类型类：解决依赖关系的灵活组合

为了解决 Functor 和 Applicative 的局限性，Haskell 引入了 Monad 类型类，它允许我们在计算中根据上一步的结果动态决定下一步的计算方式。Monad 的核心方法是 >>=（称为 bind）：

class Applicative m => Monad m where
    (>>=) :: m a -> (a -> m b) -> m b
    return :: a -> m a  -- 'return' 是 'pure' 的别名

>>=（bind）：该方法接受一个容器 m a 和一个函数 (a -> m b)，将容器内的值解出，并将其传递给函数，再将结果重新包裹为一个容器。
return：与 pure 类似，将一个普通值提升为容器内的值。

Monad 的优势

Monad 允许我们对容器内的值逐步进行计算，每一步可以动态依赖上一步的结果。这种特性使得 Monad 可以解决 Functor 和 Applicative 无法处理的依赖关系问题。

4. 使用 Monad 进行非确定性计算

以列表 [] 为例，[] 是 Monad 的一个实例。通过 Monad，我们可以实现基于上一步计算结果的非确定性计算：

-- 从两个列表中选择元素，并要求第一个选择的元素小于第二个
choose :: [Int] -> [Int] -> [(Int, Int)]
choose xs ys = do
    x <- xs
    y <- ys
    guard (x < y)  -- 依赖于上一步的结果
    return (x, y)

-- 示例调用
result = choose [1, 2, 3] [2, 3, 4]
-- 结果：[(1,2),(1,3),(1,4),(2,3),(2,4),(3,4)]

在这里，choose 使用 do 表达式和 guard 进行条件筛选，每一步的计算依赖于前一步的结果，这是 Applicative 无法做到的。

monad

>> 允许你执行一个 IO 操作并将其与下一个操作链接起来，但会忽略第一个操作的返回值。
>>= 允许你执行一个 IO 操作，然后将这个操作的返回值传递给另一个等待这个值的操作。
(\\x -> return (func x)) 让你可以将一个普通的函数放入 IO 的上下文中执行，从而让它能够在 IO 环境中工作。

5. Monad 的一些常见应用场景

非确定性计算：如前述，列表 Monad 能够方便地处理多种可能的结果。
错误处理：Maybe 和 Either 类型可以处理可能失败的计算，通过 Monad 的特性，可以依赖上一步的结果逐步处理错误。
状态管理：State Monad 允许我们在纯函数式编程中处理状态变化。
IO 操作：IO Monad 用于处理副作用，保证 I/O 操作的顺序性。

总结

Functor：支持单容器的映射操作。
Applicative：支持静态组合多个容器。
Monad：支持动态组合，能根据上一步的结果决定下一步的计算。

通过 Monad，Haskell 提供了更灵活的容器操作方式，适合处理依赖关系复杂的计算场景。