这个 State monad 代码是如何工作的？

Question

此代码来自article

在这部分之前我一直能够关注它。

module Test where

type State = Int

data ST a = S (State -> (a, State))

apply        :: ST a -> State -> (a,State)
apply (S f) x = f x

fresh =  S (\n -> (n, n+1))

instance Monad ST where
    -- return :: a -> ST a
    return x   = S (\s -> (x,s))

    -- (>>=)  :: ST a -> (a -> ST b) -> ST b
    st >>= f   = S (\s -> let (x,s') = apply st s in apply (f x) s')

data Tree a = Leaf a | Node (Tree a) (Tree a) deriving (Show)


mlabel  :: Tree a -> ST (Tree (a,Int))
-- THIS IS THE PART I DON'T UNDERSTAND:
mlabel (Leaf x) = do n <- fresh
                     return (Leaf (x,n))
mlabel (Node l r) =  do l' <- mlabel l
                        r' <- mlabel r
                        return (Node l' r')

label t = fst (apply (mlabel t) 0)

tree = Node (Node (Leaf 'a') (Leaf 'b')) (Leaf 'c')

而label tree 产生：

Node (Node (Leaf ('a',0)) (Leaf ('b',1))) (Leaf ('c',2))

我可以看到 >>= 运算符是“链接”返回 monad（或类似的东西）的函数的工具。

虽然我认为我理解这段代码，但我不明白这段特定代码的工作原理。

特别是do n <- fresh。我们还没有向fresh传递任何论据，对吧？在这种情况下，n <- fresh 会产生什么？完全不明白这一点。也许它与咖喱有关？

Answer 1

专门做n

没错。例如，当我们执行apply (mlabel someTree) 5 之类的操作时，我们正在编写一个将 传递给fresh 的论点。一个很好的练习可以帮助您更清楚地看到正在发生的事情，首先使用显式 (>>=) 而不是 do-notation 编写 mlabel，然后将 (>>=) 和 return 替换为 Monad 实例所说的内容他们是。

Answer 2

要实现的关键是do 符号被翻译成Monad 函数，所以

do n <- fresh
   return (Leaf (x,n))

简称

fresh >>= (\n -> 
           return (Leaf (x,n))  )

和

do l' <- mlabel l
   r' <- mlabel r
   return (Node l' r')

是

的缩写

mlabel l >>= (\l' -> 
              mlabel r >>= (\r' ->
                            return (Node l' r') ))

这有望让您继续弄清代码的含义，但要获得更多帮助，您应该阅读 Monads 的 do 表示法。

Answer 3

通过内联单子“流水线”，您的代码变为

fresh state = (state, state + 1)

mlabel (Leaf x) state =                   --  do
  let (n, state') = fresh state           --    n <- fresh
  in  (Leaf (x,n), state')                --    return (Leaf (x,n))

mlabel (Node l r) state =                 -- do
  let (l', state') = mlabel l state       --    l' <- mlabel l
  in let (r', state'') = mlabel r state'  --    r' <- mlabel r
     in  (Node l' r', state'')            --    return (Node l' r') 

main = let (result, state') = mlabel tree 0  
       in  print result                         

{- Or with arrows,

mlabel (Leaf x)   = Leaf . (x ,)  &&&  (+ 1)
mlabel (Node l r) = mlabel l >>> second (mlabel r)
                              >>> (\(a,(b,c)) -> (Node a b,c))
main              = mlabel tree >>> fst >>> print  $ 0
-}

或者在命令式伪代码中：

def state = unassigned

def fresh ():
    tmp = state 
    state := state + 1     -- `fresh` alters the global var `state`
    return tmp             -- each time it is called

def mlabel (Leaf x):       -- a language with pattern matching
    n = fresh ()           -- global `state` is altered!
    return (Leaf (x,n))  

def mlabel (Node l r):
    l' = mlabel l          -- affects the global
    r' = mlabel r          --    assignable variable
    return (Node l' r')    --    `state`

def main:
    state := 0             -- set to 0 before the calculation!
    result = mlabel tree
    print result

计算result 会改变state 可赋值；它对应于 Haskell 的 (a, State) 元组中的 snd 字段。元组的fst 字段是新构建的树，在其叶子中的数据旁边带有编号。

这些变体在功能上是等效的。

也许您听说过关于单子绑定是“可编程分号”的流行语。这里意思就很明确了：可以说是定义了“函数调用协议”，我们将第一个返回值作为计算结果，第二个返回值作为更新状态，传递给下一次计算，所以它可以看到 updated 状态。

这是 state-passing 编程风格（例如 Prolog 必不可少），使状态更改显式但必须手动处理正确的传递，更新状态。 Monads 允许我们抽象这种从一个计算传递到下一个计算的状态“接线”，所以它是自动为我们完成的，代价是必须以命令式的方式思考，并且让这个状态再次变得隐藏、隐含（就像状态变化隐含在命令式编程中，我们希望在切换到函数式编程时首先避免这种情况......）。

所以 State monad 所做的就是为我们维护这个隐藏状态，并在连续计算之间更新它。所以这毕竟不是什么主要。