Haskell的WriterMonad解构

ゝ一世哀愁。 2022-08-10 05:46 92阅读 0赞

**问题导出**

move i = do
        x <- left i
        tell "Go"
        y <- left x
        return y

其中

left i = writer ( x -1,"move left\t')
    :t tell "G0" :: MonadWriter [Char] m => m ()

问题

tell "Go"的上下文到底在哪里

我们一步步的解开

move  :: Int -> Writer String Int
    move i = do
        x <- left' i
        _ <- tell "GO\t"
        return x

我们把do展开

move i = let
                ok p = do
                        tell "go"
                        return p
                ok _ = fail ".."
               in writer ((i-1),"Move Left\t") >>= ok

展开**tell**

move' i = let
                ok p = do
                        writer ((),"Go\t")
                        return p
                ok _ = fail ".."
               in writer ((i-1),"Move Left\t") >>= ok

将**let**解构转换为**where**解构,暂时消除掉i

move i = writer ((i-1),"Move Left\t") >>= ok where
                ok p = do
                        writer ((),"Go\t")
                        return p

消除掉第二个**do**

move i = writer ((i-1),"Move Left\t") >>= ok where
                ok p = writer ((),"Go\t") >>  return p

增加辅助函数，做最终转换

instance (Monoid w) => Monad (Writer w) where
        return x = Writer (x,mempty)
        (Writer (x,v)) >>= f = let (Writer ( y,v')) = fx
            in Writer (y, v `mappend` v')

temp ::Int -> Writer String Int
    temp i = writer ((),"GO\t") >> return (i-1)
    
    move i =  case runWriter(temp i) of
               (y,v') -> writer (y, "Move Left\t" `mappend` v') _ -> writer(0,mempty)

对于`temp`的模拟，可以参看[monad][]这里的对于`>>`的实现，确实是使用了`>>=`。这样既满足了需要串行运算上下文，又能保证丢弃了上文的M a的a，但是仍然可以把M传递给下文。而恰好，`Writer`的声明形式是`Writer String a`,这样可以把a丢弃掉，而把String传递给下文，达到了`tell`要求的仅保留String内容，而忽略`a`的内容.  
结论：  
可以看出，上下文首先是因为做了内部的do运算，得到的关键的`Writer((),"Go")`，  
之后把(i-1) 附属到了tell的结果上，然后再做外部运算，结束掉`x <- left i`。

[monad]: http://hackage.haskell.org/package/base-4.8.0.0/docs/src/GHC-Base.html#%3E%3E