处理一个monad调用另一个monad的干净方法是什么？

Question

这是将monad粘合在一起的问题.不是堆栈形式,而是需要打开一个monad以在另一个内部运行操作的形式.

两个领域:Weblog和App.但是,请记住,App域将以与当前调用Weblog相同的方式调用其他域.两者都有自己的monad堆栈.两者都记录着自己的状态.

newtype WeblogM a = WeblogM (ReaderT Weblog (ErrorT WeblogError IO) a)
    deriving (Monad, MonadIO, Reader.MonadReader Weblog, Error.MonadError WeblogError)

newtype AppM a = AppM (ReaderT App (EitherT AppError IO) a)
    deriving ( Functor, Applicative, Monad
             , MonadReader App, MonadError AppError)

为了WeblogM在AppM函数内部运行一个操作,我发现我必须WeblogM使用这样的函数解包并重新包装它:

runWeblogHere :: forall a. Weblog.Weblog -> Weblog.WeblogM a -> AppM a
runWeblogHere weblog action =
    runIO (left . WeblogError) (Weblog.runWeblog weblog action)

runIO :: (e -> EitherT AppError IO a) -> IO (Either e a) -> AppM a
runIO handler = AppM . lift . handleT handler . EitherT

但是,这确实使我的实际直通操作变得非常简单:

getPage :: Weblog.PageId -> AppM Weblog.WikiPage
getPage pageid = do
    App{weblog} <- ask
    runWeblogHere weblog $ Weblog.getWikiPage pageid

这困扰我已经因为我有我已经知道我要去插上其他单子库AppM架构,我担心写一个runXHere方法,它是真正的样板,对于他们中的每一个.

我有一个建议,以创建一个MonadWeblog类来对应WeblogM,在多,以同样的方式MonadReader对应ReaderT.这更吸引我,因为我可以开始将monad胶水隔离到我的MonadWeblog(或者,真的MonadX)实例中.

Answer 1

如果我们忽略新类型，并将两个错误转换器转换为ExceptT，则两个 monad 堆栈共享相似的结构：

import Control.Monad
import Control.Monad.Trans.Except (ExceptT, catchE)
import Control.Monad.Trans.Reader

type M env err r = ReaderT env (ExceptT err IO) r

使用withReaderT和mapReaderT函数，我们可以定义：

changeMonad :: (env' -> env) 
            -> (err -> ExceptT err' IO r) 
            -> M env err r 
            -> M env' err' r 
changeMonad envLens handler = withReaderT envLens . mapReaderT (flip catchE handler)  

编辑：为了简化新类型的包装和展开，我们可以将它们作为库的实例Wrapped，lens并定义一个更通用的转换函数：

{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE TemplateHaskell #-}

newtype N1 r = N1 { getN1 :: M (Int,Int) String r }

$(makeWrapped ''N1)

--instance Wrapped (N1 r) where
--  type Unwrapped (N1 r) = M (Int,Int) String r 
--  _Wrapped' = iso getN1 N1

newtype N2 r = N2 { getN2 :: M Int Char r }

$(makeWrapped ''N2)

changeMonad' :: (Wrapped (n1 r), 
                 Unwrapped (n1 r) ~ M env' err' r, 
                 Wrapped (n2 r), 
                 Unwrapped (n2 r) ~ M env err r) 
             => (env' -> env)
             -> (err -> ExceptT err' IO r) 
             -> n2 r 
             -> n1 r  
changeMonad' envLens handler = 
     view _Unwrapped' . changeMonad envLens handler . view _Wrapped'

changeN2N1 :: N2 r -> N1 r
changeN2N1 = changeMonad' fst (\c -> throwE [c]) 

Wrapped是一个类型类，它说：“我实际上是一个新类型，这是添加/删除新类型构造函数的通用方法”。

如果lens依赖性太重，该newtype包会提供类似的功能。