理解 Haskell 中的绑定函数

Question

我熟悉范畴论中的单子（事实上，它们是一个非常简单的概念），但 Haskell 中的 >>= 函数完全让我困惑。好的，所以将绑定应用于 M a 的值和函数 a ->; M u 与首先将 monad 应用于此函数，然后在指定值处对其求值并将结果相乘相同： a >>= f 与 相同>加入$(fmap f)$a。但这如何是计算的自然描述呢？是否有一些有用的看待它的方式可以帮助我理解它？

是否有一些不错的文章不适合刚从 C++ 丛林中出来的人？

Answer 1

从计算的角度来看，也许 =<< 更容易理解（它只是 flip (>>=)）。它有输入 (=<<) :: (Monad m) =>; (a→mb)→妈-> m b，对应函数应用的类型，cf ($) :: (a -> b) ->一个-> b。所以 >>= 只是单子层面上翻转的函数应用。

此外，(>>=) 用于对 do 表示法进行脱糖，并且 do 在语法上与命令式代码非常对应（以合适的形式）单子）。

Answer 2

下面是它如何作为计算模型工作的粗略想法：带有 Monad 实例的类型构造函数 M 表示参数数据结构，非参数部分该结构可以包含其他信息。 return 和 join 对应于结构中这些部分的某种幺半群。一个函数 a -> M b 基于类型 a 的输入在该结构中引入信息。因此，通过提升函数 a -> M b 至 M a -> M b 我们使用 M 的参数信息来创建一些非参数信息，然后将其与 M a 类型值中已存在的信息相结合代码>.

类型a -> 的不对称性质M b 为非参数信息流提供了固有的方向，而关联性要求意味着整体顺序是唯一重要的。

最终结果是使用某种具有内置因果概念的上下文来增强函数。

Answer 3

考虑一元函数复合运算符 <=<。这类似于 .，只不过它适用于一元函数。它可以简单地用 >>= 来定义，因此了解一个可以让我们了解另一个。

(<=<) :: (b -> m c) -> (a -> m b) -> a -> m c
(f <=< g) x =  g x >>= f

(.) :: (b -> c) -> (a -> b) -> a -> c
(f . g) x = g x |> f
  where z |> h = h z

对于.，首先“执行”g，然后对g的输出执行f >。在<=<的情况下，g及其效果首先“执行”，然后f 并执行其效果。实际上，说一个发生在另一个“之前”有点用词不当，因为并非所有单子都这样工作。

也许更准确的说法是 f 可以利用 g 提供的附加上下文信息。但这并不完全正确，因为g可能夺走上下文信息。如果你想 100% 正确地描述单子，你真的必须如履薄冰。

但在几乎所有重要情况下，f <=< g 表示一元函数 g 的效果（以及结果）随后将影响一元函数的行为函数f。

---

要解决有关 v >>= f = join (fmap fv) 的问题，

请考虑 f :: a -> m b 和 v :: m a 。 fmap f v 是什么意思？那么 fmap :: (c -> d) -> MC-> m d，在本例中 c = a 和 d = m b，因此 fmap f :: ma ->米（mb）。当然，现在我们可以将 v :: m a 应用于此函数，从而得到 m (mb)。但是结果类型 m (mb) 到底意味着什么？

内部 m 表示从 f 生成的上下文。 outer m 表示源自 v 的上下文（注意 fmap 不应干扰此原始上下文）。

然后您加入那个m (mb)，将这两个上下文粉碎在一起形成m a。这是 Monad 定义的核心：您必须提供一种将上下文粉碎在一起的方法。您可以检查各种 Monad 实例的实现细节，以尝试了解它们如何将上下文“粉碎”在一起。不过，这里的要点是，在将“内部上下文”与“外部上下文”合并之前，“内部上下文”是不可观察的。如果您使用 v >>= f，则不存在函数 f 接收纯值 a 的实际概念 并产生一个简单的单子结果m b。相反，我们知道 f 在 v 的原始上下文中起作用。

Answer 4

唔。我认为一个很好的思考方式是 >>= 让您可以组合计算；计算本身的形式为 a ->; m b。所以 m b 只是代表计算的结果。

因此，计算只需要一些值并产生一些结果。列表类型就是一个很好的例子：a -> [b] 表示非确定性计算。它需要一个输入，但可以产生多个结果。就其本身而言，a ->; [b] 作为计算是有意义的。但你会如何结合这些呢？自然的答案是，您将对之前的所有结果执行每个连续的“计算”。这正是 >>= 对列表所做的事情。

真正帮助我了解其实际价值的一件事是思考 DFA 和 NFA。您可以想象在 Haskell 中简单地编写一个 DFA，如下所示：

data State = S1 | S2 | S3 | S4 | Q
data Input = A | B
transition :: State -> Input -> State
transition S1 A = S2
transition S1 B = S3
-- and so on...

然后我们可以折叠输入：

 foldl transition S1 [A, A, B, B]

现在，我们如何获取此代码并将其推广到 NFA？嗯，NFA 的转换“函数”可以被认为是一种非确定性计算。所以我们定义如下：

transition S1 A = [S1, S2]
transition S1 B = []

但是现在我们必须做一些奇怪的体操才能使用foldl！幸运的是，我们可以用 foldM 来代替。所以这里单子建模的“计算”就是非确定性转移函数。