结合免费类型

这是一个基于纸张数据类型单点的答案,除了没有类型类.我建议阅读那篇论文.

诀窍在于,不是为Bells和编写解释器,而是Whistles为他们的单个函子步骤定义解释器,BellsF并且WhistlesF像这样:

playBellsF :: BellsF (IO a) -> IO a
playBellsF (Ring  io) = putStrLn "RingRing!"  >> io
playBellsF (Chime io) = putStr   "Ding-dong!" >> io

playWhistlesF :: WhistelsF (IO a) -> IO a
playWhistlesF (PeaWhistle   io) = putStrLn "Preeeet!"   >> io
playWhistlesF (SteamWhistle io) = putStrLn "choo-choo!" >> io

如果您选择不将它们组合在一起,您可以将它们传递给Control.Monad.Free.iterM原来的播放功能:

playBells    :: Bells a    -> IO a
playBells    = iterM playBell

playWhistles :: Whistles a -> IO a
playWhistles = iterM playWhistlesF

...但是因为他们处理单个步骤,所以可以更容易地组合.您可以像这样定义一个新的组合免费monad:

data BellsAndWhistlesF a = L (BellsF a) | R (WhistlesF a)

然后把它变成一个免费的monad:

type BellsAndWhistles = Free BellsAndWhistlesF

然后你BellsAndWhistlesF就两个子解释器的一个步骤编写一个解释器:

playBellsAndWhistlesF :: BellsAndWhistlesF (IO a) -> IO a
playBellsAndWhistlesF (L bs) = playBellsF    bs
playBellsAndWhistlesF (R ws) = playWhistlesF ws

...然后你通过传递到以下内容获得免费monad的解释器iterM:

playBellsAndWhistles :: BellsAndWhistles a -> IO a
playBellsAndWhistles = iterM playBellsAndWhistlesF

因此,您的问题的答案是,组合免费monad的技巧是通过为各个函子步骤("代数")定义中间解释器来保留更多信息.这些"代数"比免费monad的解释器更适合组合.

加布里埃尔的回答很明显,但我认为有必要更多地强调让它全部发挥作用的事情,即两个Functors 的总和也是Functor:

-- | Data type to encode the sum of two 'Functor's @f@ and @g@.
data Sum f g a = InL (f a) | InR (g a)

-- | The 'Sum' of two 'Functor's is also a 'Functor'.
instance (Functor f, Functor g) => Functor (Sum f g) where
    fmap f (InL fa) = InL (fmap f fa)
    fmap f (InR ga) = InR (fmap f ga)

-- | Elimination rule for the 'Sum' type.
elimSum :: (f a -> r) -> (g a -> r) -> Sum f g a -> r
elimSum f _ (InL fa) = f fa
elimSum _ g (InR ga) = g ga

(Edward Kmett的图书馆有这个Data.Functor.Coproduct.)

因此,如果Functors是Freemonad 的"指令集" ,那么:

求和函数子给你的工会这样的指令集,因而相应的组合的自由单子

该elimSum函数是一个基本规则,允许您Sum f g从解释器f和一个解释器构建一个解释器g.

在"数据类型点菜 "技术,当你发展这个你正是洞察,这是非常值得的,同时只工作了手.

这种Functor代数是值得学习的东西.例如:

data Product f g a = Product (f a) (g a)

-- | The 'Product' of two 'Functor's is also a 'Functor'.
instance (Functor f, Functor g) => Functor (Product f g) where
   fmap f (Product fa ga) = Product (fmap f fa) (fmap f ga)

-- | The 'Product' of two 'Applicative's is also an 'Applicative'.
instance (Applicative f, Applicative g) => Applicative (Product f g) where
   pure x = Product (pure x) (pure x)
   Product ff gf <*> Product fa ga = Product (ff <*> fa) (gf <*> ga)


-- | 'Compose' is to 'Applicative' what monad transformers are to 'Monad'.
-- If your problem domain doesn't need the full power of the 'Monad' class, 
-- then applicative composition might be a good alternative on how to combine
-- effects.
data Compose f g a = Compose (f (g a))

-- | The composition of two 'Functor's is also a 'Functor'.
instance (Functor f, Functor g) => Functor (Compose f g) where
   fmap f (Compose fga) = Compose (fmap (fmap f) fga)

-- | The composition of two 'Applicative's is also an 'Applicative'.
instance (Applicative f, Applicative g) => Applicative (Compose f g) where
   pure = Compose . pure . pure
   Compose fgf <*> Compose fga = Compose ((<*>) <$> fgf <*> fga)

Gershom Bazerman的博客文章"Abstracting with Applicatives"扩展了关于Applicatives的这些观点,非常值得一读.

编辑:最后我要注意的是,当人们Functor为他们的免费monad 设计他们的自定义时,事实上,隐含地他们正在使用这些技术.我将从Gabriel的"为什么免费monad重要"中拿两个例子:

data Toy b next =
    Output b next
  | Bell next
  | Done

data Interaction next =
    Look Direction (Image -> next)
  | Fire Direction next
  | ReadLine (String -> next)
  | WriteLine String (Bool -> next)

所有这些都可以分析到的一些组合Product,Sum,Compose,(->)仿函数和以下三种:

-- | Provided by "Control.Applicative"
newtype Const b a = Const b

instance Functor (Const b) where
    fmap _ (Const b) = Const b


-- | Provided by "Data.Functor.Identity"
newtype Identity a = Identity a

instance Functor Identity where
    fmap f (Identity a) = Identity (f a)


-- | Near-isomorphic to @Const ()@
data VoidF a = VoidF

instance Functor VoidF where
    fmap _ VoidF = VoidF

因此,为简洁起见,使用以下类型的同义词:

{-# LANGUAGE TypeOperators #-}

type f :+: g = Sum f g
type f :*: g = Product f g
type f :.: g = Compose f g

infixr 6 :+:
infixr 7 :*:
infixr 9 :.:

...我们可以像这样重写那些仿函数:

type Toy b = Const b :*: Identity :+: Identity :+: VoidF

type Interaction = Const Direction :*: ((->) Image :.: Identity)
               :+: Const Direction :*: Identity
               :+: (->) String :.: Identity
               :+: Const String :*: ((->) Bool :.: Identity)