Question

这是将monad粘合在一起的问题。不是堆栈形式，而是需要打开一个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

这让我很困扰，因为我已经知道其他monadic库我将要插入AppM架构，我担心编写runXHere方法，对于每一个来说都是样板。

我建议创建一个与MonadWeblog对应的WeblogM类，与MonadReader对应ReaderT的方式非常相似。这更吸引我，因为我可以开始将monad胶水隔离到我的MonadWeblog（或者，真的，MonadX）的实例中。

Answer 1

如果我们忽略newtypes，并将两个错误转换器转换为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)

编辑：为了简化新类型的换行和展开，我们可以从lens库中创建Wrapped的实例，并定义更通用的转换函数：

{-# 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是一个类型类，它说：＆＃34;我实际上是一个新类型，这里是添加/删除newtype构造函数的通用方法＆＃34;。

如果lens依赖关系太重，newtype包提供了类似的功能。

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

1 个答案: