haskell - 创建我自己的状态 monad 转换器模块，隐藏底层状态 monad

Question

我正在学习 mtl，我希望学习创建新 monad 作为模块(而不是典型的应用程序用法)的正确方法。

作为一个简单的例子，我编写了一个 ZipperT monad ( complete code here ):

{-# LANGUAGE FlexibleInstances, FunctionalDependencies, MultiParamTypeClasses, GeneralizedNewtypeDeriving #-}
module ZipperT (
  MonadZipper (..)
, ZipperT
, runZipperT
) where

import Control.Applicative
import Control.Monad.State

class Monad m => MonadZipper a m | m -> a where
    pushL :: a -> m ()
    pushR :: a -> m ()
    ...

data ZipperState s = ZipperState { left :: [s], right :: [s] }

newtype ZipperT s m a = ZipperT_ { runZipperT_ :: StateT (ZipperState s) m a }
                        deriving ( Functor, Applicative
                                 , Monad, MonadIO, MonadTrans
                                 , MonadState (ZipperState s))

instance (Monad m) => MonadZipper s (ZipperT s m) where
    pushL x = modify $ \(ZipperState left right) -> ZipperState (x:left) right
    pushR x = modify $ \(ZipperState left right) -> ZipperState left (x:right)
    ...

runZipperT :: (Monad m) => ZipperT s m a -> ([s], [s]) -> m (a, ([s], [s]))
runZipperT computation (left, right) = do
    (x, ZipperState left' right') <- runStateT (runZipperT_ computation) (ZipperState left right)
    return (x, (left', right'))

它可以工作，我可以与其他 monad 组合

import Control.Monad.Identity
import Control.Monad.State
import ZipperT

length' :: [a] -> Int
length' xs = runIdentity (execStateT (runZipperT contar ([], xs)) 0)
    where contar = headR >>= \x -> case x of
                     Nothing -> return ()
                     Just  _ -> do
                                    right2left
                                    (lift . modify) (+1)
                                 -- ^^^^^^^
                                    contar

但我希望避免显式的提升。

• 创建这样的模块的正确方法是什么？
• 我可以避免显式提升吗？ (我希望隐藏 ZipperT 的内部 StateT 结构)

谢谢!

Answer 1

我认为如果你可以写一个 MonadState 的实例对于你的变压器，你可以使用modify而不使用lift:

instance Monad m => MonadState (ZipperT s m a) where
   ...

我必须承认，我不确定 modify 应该影响状态的哪一部分。

<小时/>

我已经查看了完整的代码。看来你已经定义了

MonadState (ZipperState s) (ZipperT s m)

这已经提供了一个修改，但是它修改了错误的底层状态。您真正想要的是公开封装在 m 中的状态，前提是它本身是一个 MonadState 。理论上这可以通过

instance MonadState s m => MonadState s (ZipperT s m) where
   ...

但是现在我们有同一个 monad 的两个 MonadState 实例，导致了冲突。

<小时/>

我想我以某种方式解决了这个问题。

这就是我所做的:

首先，我删除了原始的派生 MonadState 实例。我改为写

getZ :: Monad m => ZipperT s m (ZipperState s)
getZ = ZipperT_ get

putZ :: Monad m => ZipperState s -> ZipperT s m ()
putZ = ZipperT_ . put

modifyZ :: Monad m => (ZipperState s -> ZipperState s) -> ZipperT s m ()
modifyZ = ZipperT_ . modify

并用上述自定义函数替换了 ZipperT 库中以前出现的 get,put,modify。

然后我添加了新实例:

-- This requires UndecidableInstances
instance MonadState s m => MonadState s (ZipperT a m) where
   get = lift get
   put = lift . put

现在，客户端代码无需提升即可运行:

length' :: [a] -> Int
length' xs = runIdentity (execStateT (runZipperT contar ([], xs)) 0)
    where contar :: ZipperT a (StateT Int Identity) ()
          contar = headR >>= \x -> case x of
                     Nothing -> return ()
                     Just  _ -> do
                                    right2left
                                    modify (+ (1::Int))
                                 -- ^^^^^^^
                                    contar