Question

FreeT / ProgramT创建的monad变换器可以有类似mtl的机制吗？

我对历史的理解如下。曾几何时，monad变压器被发明了。然后人们开始在另一个上堆叠monad变换器，然后发现在任何地方插入lift都很烦人。然后有几个人发明了monad类，所以我们可以例如任何monad ask :: m r m MonadReader r m (Monoid w, MonadState s m) => MonadState s (WriterT w m) MonadWriter w m => MonadWriter w (StateT s m)。这可以通过使每个monad类穿透每个monad变换器来实现，例如

data

你需要为每对monad变换器提供这样的实例声明对，所以当有 n monad变换器时， n ^ 2成本。然而，这不是一个大问题，因为人们将主要使用预定义的monad并且很少创建自己的monad。到目前为止我理解的故事，也是详细的，例如：在以下Q＆amp; A中：

Avoiding lift with Monad Transformers

然后我的问题在于新的免费单子http://hackage.haskell.org/package/free和操作单子http://hackage.haskell.org/package/operational。它们允许我们编写自己的DSL并将其用作monad，只需将语言定义为某些代数Functor类型（Operational甚至不需要ProgramT个实例）。好消息是我们可以免费获得monad和monad变换器;那么monad课怎么样？坏消息是“我们很少定义我们自己的monad变换器”的假设不再成立。

为了解这个问题，我做了两个operational并使它们相互渗透;

https://github.com/nushio3/practice/blob/master/operational/exe-src/test-05.hs

minioperational包不支持monad类，所以我采用了另一个实现instance (Monad m, Operational ILang m) => Operational ILang (ProgramT SLang m) where并将其修改为我需要的工作; https://github.com/nushio3/minioperational

仍然，我需要专门的实例声明

instance (Monad m, Operational f m) => Operational f (ProgramT g m) where

因为以下表格的一般声明会导致不可判定的实例。

{{1}}

我的问题是，我们怎样才能让我们的操作单子更容易相互渗透。或者，我是否希望能够对任何可操作的Monad进行渗透。

我也想知道渗透的正确技术术语：）

Answer 1

我尝试了一种不同的方法，至少给出了部分答案。由于堆叠monad有时会出现问题，并且我们知道所有monad都是从某种数据类型构造的，所以我尝试组合数据类型。

我对MonadFree感觉更舒服，所以我使用了它，但我想同样的方法也可以用于Operational。

让我们从数据类型的定义开始：

{-# LANGUAGE DeriveFunctor, FlexibleContexts,
             FlexibleInstances, FunctionalDependencies #-}
import Control.Monad
import Control.Monad.Free

data SLang x = ReadStr (String -> x) | WriteStr String x
  deriving Functor
data ILang x = ReadInt (Int -> x) | WriteInt Int x
  deriving Functor

为了将两个仿函数组合在一起以便在免费monad中使用它们，让我们定义它们的副产品：

data EitherF f g a = LeftF (f a) | RightF (g a)
  deriving Functor

如果我们在EitherF f g上创建一个免费的monad，我们可以调用它们的命令。为了使此过程透明，我们可以使用MPTC来允许从每个仿函数转换为目标仿函数：

class Lift f g where
    lift :: f a -> g a
instance Lift f f where
    lift = id

instance Lift f (EitherF f g) where
    lift = LeftF
instance Lift g (EitherF f g) where
    lift = RightF

现在我们可以致电lift并将其中任何一部分转换为副产品。

使用辅助功能

wrapLift :: (Functor g, Lift g f, MonadFree f m) => g a -> m a
wrapLift = wrap . lift . fmap return

我们最终可以创建通用函数，允许我们从任何可以提升到仿函数的函数中调用命令：

readStr :: (Lift SLang f, MonadFree f m) => m String
readStr = wrapLift $ ReadStr id

writeStr :: (Lift SLang f, MonadFree f m) => String -> m ()
writeStr x = wrapLift $ WriteStr x ()

readInt :: (Lift ILang f, MonadFree f m) => m Int
readInt = wrapLift $ ReadInt id

writeInt :: (Lift ILang f, MonadFree f m) => Int -> m ()
writeInt x = wrapLift $ WriteInt x ()

然后，程序可以表示为

myProgram :: (Lift ILang f, Lift SLang f, MonadFree f m) => m ()
myProgram = do
  str <- readStr
  writeStr "Length of that str is"
  writeInt $ length str
  n <- readInt
  writeStr "you wanna have it n times; here we go:"
  writeStr $ replicate n 'H'

没有定义任何进一步的实例。

虽然上述所有方法都很好用，但问题是如何一般地运行这样的组合免费monad。我不知道是否有可能拥有一个完全通用的，可组合的解决方案。

如果我们只有一个基本仿函数，我们可以将其作为

运行

runSLang :: Free SLang x -> String -> (String, x)
runSLang = f
  where
    f (Pure x)              s  = (s, x)
    f (Free (ReadStr g))    s  = f (g s) s
    f (Free (WriteStr s' x)) _ = f x s'

如果我们有两个，我们需要线程化它们的状态：

runBoth :: Free (EitherF SLang ILang) a -> String -> Int -> ((String, Int), a)
runBoth = f
  where
    f (Pure x)                       s i  = ((s, i), x)
    f (Free (LeftF  (ReadStr g)))     s i = f (g s) s i
    f (Free (LeftF  (WriteStr s' x))) _ i = f x s' i
    f (Free (RightF (ReadInt g)))     s i = f (g i) s i
    f (Free (RightF (WriteInt i' x))) s _ = f x s i'

我想一种可能性就是使用free中的iter :: Functor f => (f a -> a) -> Free f a -> a来表达运行仿函数，然后创建一个类似的组合函数

iter2 :: (Functor f, Functor g)
      => (f a -> a) -> (g a -> a) -> Free (EitherF f g) a -> a

但我没有时间尝试。

Monad Stack Penetration Classes with Free / Operational Monad Transformers？

1 个答案: