Question

我正在开展一个项目，除其他外，涉及数据库访问层。非常正常，真的。在之前的项目中，合作者鼓励我将Free Monads概念用于数据库层，所以我做到了。现在我正在尝试在我的新项目中决定我获得了什么。

在上一个项目中，我有一个看似相似的API。

saveDocument :: RawDocument -> DBAction ()
getDocuments :: DocumentFilter -> DBAction [RawDocument]
getDocumentStats :: DBAction [(DocId, DocumentStats)]

等。大约20个这样的公共职能。为了支持它们，我有DBAction数据结构：

data DBAction a =
      SaveDocument          RawDocument         (DBAction a)
    | GetDocuments          DocumentFilter      ([RawDocument] -> DBAction a)
    | GetDocumentStats                          ([(DocId, DocumentStats)] -> DBAction a)
    | Return a

然后是monad实现：

instance Monad DBAction where
    return = Return
    SaveDocument doc k >>= f = SaveDocument doc (k >>= f)
    GetDocuments df k >>= f = GetDocuments df (k >=> f)

然后翻译。然后是实现每个不同查询的原始函数。基本上，我觉得我有大量的胶水代码。

在我目前的项目中（在一个完全不同的领域），我已经为我的数据库添加了一个非常普通的monad：

newtype DBM err a = DBM (ReaderT DB (EitherT err IO) a)
    deriving (Monad, MonadIO, MonadReader DB)

indexImage :: (ImageId, UTCTime) -> Exif -> Thumbnail -> DBM SaveError ()
removeImage :: DB -> ImageId -> DBM DeleteError ()

等等。我认为，最终，我将拥有代表高级概念的“公共”函数，这些函数都在DBM上下文中运行，然后我将拥有执行SQL / Haskell粘合剂的所有函数。总的来说，这比免费的monad系统感觉要好得多，因为我没有写大量的样板代码来获得除了替换翻译器的能力。

或者...

我实际上是通过Free Monad + Interpreter模式获得其他东西吗？如果是这样，是什么？

Answer 1

正如评论中所提到的，通常需要在代码和数据库实现之间进行一些抽象。你可以通过为你的DB Monad定义一个类来获得与免费monad相同的抽象（我在这里采取了一些自由）：

class (Monad m) => MonadImageDB m where
    indexImage  :: (ImageId, UTCTime) -> Exif -> Thumbnail -> m SaveResult
    removeImage :: ImageId                                 -> m DeleteResult

如果您的代码是针对MonadImageDB m =>编写的，而不是与DBM紧密耦合，那么您将能够在不修改代码的情况下交换数据库和错误处理。

你为什么要免费使用？因为它"frees the interpreter as much as possible"，意味着解释器只承诺提供monad，而不是其他任何东西。这意味着您尽可能不受限制地编写monad实例以使用您的代码。请注意，对于免费monad，您不会为Monad编写自己的实例，get it for free。你会写类似

的东西

data DBActionF next =
      SaveDocument     RawDocument    (                            next)
    | GetDocuments     DocumentFilter ([RawDocument]            -> next)
    | GetDocumentStats                ([(DocId, DocumentStats)] -> next)

派生Functor DBActionF，并从Free DBActionF的现有实例中获取Functor f => Monad (Free f)的monad实例。

对于您的示例，它反而是：

data ImageActionF next =
      IndexImage  (ImageId, UTCTime) Exif Thumbnail (SaveResult   -> next)
    | RemoveImage ImageId                           (DeleteResult -> next)

您还可以为类型类获取属性“尽可能释放解释器”。如果m上没有其他约束类型MonadImageDB，MonadImageDB的所有方法都可以是Functor的构造函数，那么你会得到相同的属性。您可以通过实施instance MonadImageDB (Free ImageActionF)来了解这一点。

如果你要将代码与其他monad的交互混合，你可以从free而不是monad获得monad变换器。

选择

您无需选择。您可以在表示之间来回转换。此示例显示了如何对具有零个，一个或两个参数的操作执行此操作，从而返回零个，一个或两个结果。首先，一点样板

{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE FlexibleInstances #-}

import Control.Monad.Free

我们有一个类型

class Monad m => MonadAddDel m where
    add  :: String           -> m Int
    del  :: Int              -> m ()
    set  :: Int    -> String -> m ()
    add2 :: String -> String -> m (Int, Int)
    nop ::                      m ()

和等效的函子表示

data AddDelF next
    = Add  String        (       Int -> next)
    | Del  Int           (              next)
    | Set  Int    String (              next)
    | Add2 String String (Int -> Int -> next)
    | Nop                (              next)
  deriving (Functor)

从自由表示转换为类型类会将Pure替换为return，Free替换为>>=，Add替换为add等

run :: MonadAddDel m => Free AddDelF a -> m a
run (Pure a) = return a
run (Free (Add  x    next)) = add  x    >>= run . next
run (Free (Del  id   next)) = del  id   >>  run next
run (Free (Set  id x next)) = set  id x >>  run next
run (Free (Add2 x  y next)) = add2 x  y >>= \ids -> run (next (fst ids) (snd ids))
run (Free (Nop       next)) = nop       >>  run next

表示的MonadAddDel实例使用next为构造函数的Pure参数构建函数。

instance MonadAddDel (Free AddDelF) where
    add  x    = Free . (Add  x   ) $ Pure
    del  id   = Free . (Del  id  ) $ Pure ()
    set  id x = Free . (Set  id x) $ Pure ()
    add2 x  y = Free . (Add2 x  y) $ \id1 id2 -> Pure (id1, id2)
    nop       = Free .  Nop        $ Pure ()

（这些都有我们可以为生产代码提取的模式，一般来说编写这些模块的难点在于处理不同数量的输入和结果参数）

针对类型类的编码仅使用MonadAddDel m =>约束，例如：

example1 :: MonadAddDel m => m ()
example1 = do
    id <- add "Hi"
    del id
    nop
    (id3, id4) <- add2 "Hello" "World"
    set id4 "Again"

除了我从免费获得的那个之外，我太懒了为MonadAddDel编写另一个实例，除了使用MonadAddDel类型类之外我懒得做一个例子。

如果你喜欢运行示例代码，这里足以看到解释一次的示例（将类型类表示转换为自由表示），并再次将自由表示转换回类型类表示。再说一遍，我懒得两次写代码。

debugInterpreter :: Free AddDelF a -> IO a
debugInterpreter = go 0
    where
        go n (Pure a) = return a
        go n (Free (Add x next)) =
            do
                print $ "Adding " ++ x ++ " with id " ++ show n
                go (n+1) (next n)
        go n (Free (Del id next)) =
            do
                print $ "Deleting " ++ show id
                go n next
        go n (Free (Set id x next)) =
            do
                print $ "Setting " ++ show id ++ " to " ++ show x
                go n next
        go n (Free (Add2 x y next)) =
            do
                print $ "Adding " ++ x ++ " with id " ++ show n ++ " and " ++ y ++ " with id " ++ show (n+1)
                go (n+2) (next n (n+1))
        go n (Free (Nop      next)) =
            do
                print "Nop"
                go n next

main =
    do
        debugInterpreter example1
        debugInterpreter . run $ example1

我什么时候想使用Free Monad + Interpreter模式？

1 个答案:

选择