模块化程序设计 - 在 Monad 不可知函数中组合 Monad Transformers

Question

我正在尝试进行模块化程序设计，我再次请求您的帮助。

作为这些后续帖子Monad Transformers vs passing Parameters 和Large Scale Design in Haskell 的后续工作，我正在尝试构建两个独立的模块，它们使用 Monad Transformers 但公开与 Monad 无关的函数，然后将其中每个模块中的一个与 Monad 无关的函数组合起来模块到一个新的 Monad-agnostic 函数中。

我一直无法运行组合功能，例如如何在下面的示例中使用runReaderT 调用mainProgram？。

次要问题是：有没有更好的方法来实现相同的模块化设计目标？

---

该示例有两个模拟模块（但可以编译），一个执行日志记录，一个读取用户输入并对其进行操作。组合函数读取用户输入，记录并打印。

{-# LANGUAGE FlexibleContexts #-}

module *2 where

import Control.Monad.Reader

----
---- From Log Module - Writes the passed message in the log
---- 

data LogConfig = LC { logFile :: FilePath }

doLog :: (MonadIO m, MonadReader LogConfig m) => String -> m ()
doLog _ = undefined


----
---- From UserProcessing Module - Reads the user Input and changes it to the configured case
----

data  MessageCase = LowerCase | UpperCase deriving (Show, Read)

getUserInput :: (MonadReader MessageCase m, MonadIO m) => m String
getUserInput = undefined

----
---- Main program that combines the two
----                  

mainProgram :: (MonadReader MessageCase m, MonadReader LogConfig m, MonadIO m) => m ()
mainProgram = do input <- getUserInput
                 doLog input
                 liftIO $ putStrLn $ "Entry logged: " ++ input

Answer 1

有一种方法可以编写程序的完全模块化版本。解决问题所需的方法是将阅读器配置捆绑到一个数据结构中，然后定义类型类来描述特定功能对该数据结构所需的部分接口。例如：

class LogConfiguration c where
  logFile :: c -> FilePath

doLog :: (MonadIO m, LogConfiguration c, MonadReader c m) => String -> m ()
doLog = do
  file <- asks logFile
  -- ...

class MessageCaseConfiguration c where
  isLowerCase :: c -> Bool

getUserInput :: (MonadIO m, MessageCaseConfiguration c, MonadReader c m) => m String
getUserInput = do
  lc <- asks isLowerCase
  -- ...

data LogConfig = LC { logConfigFile :: FilePath }
data MessageCase = LowerCase | UpperCase

data Configuration = Configuration { logging :: LogConfig, casing :: MessageCase }

instance LogConfiguration Configuration where
  logFile = logConfigFile . logging

instance MessageCaseConfiguration Configuration where
  isLowerCase c = case casing c of
    LowerCase -> True
    UpperCase -> False

mainProgram :: (MonadIO m, MessageCaseConfiguration c, LogConfiguration c, MonadReader c m) => m ()
mainProgram = do
  input <- getUserInput
  doLog input
  liftIO . putStrLn $ "Entry logged: " ++ input

现在您可以在ReaderT monad 中使用Configuration 调用mainProgram，它会按您的预期工作。

Answer 2

您的mainProgram 签名有问题，因为MonadReader 类型类包含函数依赖MonadReader r m | m -> r。这实质上意味着单个具体类型不能有多个不同类型的MonadReader 实例。因此，当您说 m 类型同时具有 MonadReader MessageCase 和 MonadReader LogConfig 实例时，它违反了依赖声明。

最简单的解决方案是将mainProgram 更改为非泛型类型：

mainProgram :: ReaderT MessageCase (ReaderT LogConfig IO) ()
mainProgram = do input <- getUserInput
                 lift $ doLog input
                 liftIO $ putStrLn $ "Entry logged: " ++ input

这也需要为doLog 显式lift。

现在您可以通过分别运行每个ReaderT 来运行mainProgram，如下所示：

main :: IO ()
main = do
    let messageCase = undefined :: MessageCase
        logConfig   = undefined :: LogConfig
    runReaderT (runReaderT mainProgram messageCase) logConfig

如果您想要一个使用两个不同 MonadReader 实例的通用函数，您需要在签名中明确说明一个阅读器是另一个阅读器之上的单子转换器。

mainProgram :: (MonadTrans mt, MonadReader MessageCase (mt m), MonadReader LogConfig m, MonadIO (mt m), MonadIO m) => mt m ()
mainProgram = do input <- getUserInput
                 lift $ doLog input
                 liftIO $ putStrLn $ "Entry logged: " ++ input

但是，不幸的是，函数不再是完全通用的，因为两个读取器出现在 monad 堆栈中的顺序是锁定的。也许有一种更简洁的方法来实现这一点，但我无法在不牺牲（甚至更多）通用性的情况下从头顶想出一个。