Question

我正在努力想出一个模块化的程序设计，我再次请求你的帮助。

作为以下帖子Monad Transformers vs passing Parameters和Large Scale Design in Haskell的后续内容，我正在尝试构建两个独立的模块，这些模块使用Monad变形金刚但暴露出与Monad无关的功能，然后结合Monad不可知的功能从这些模块中的每一个进入一个新的Monad无关功能。

我无法运行合并功能，例如如何在下面的示例中使用mainProgram来呼叫runReaderT？

附属问题是：是否有更好的方法来实现相同的模块化设计目标？

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

{-# LANGUAGE FlexibleContexts #-}

module Stackoverflow2 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

现在，您可以在mainProgram monad中使用Configuration拨打ReaderT，这样就可以正常工作了。

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

这还需要明确lift doLog。

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

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

如果你想拥有一个使用两个不同MonadReader实例的泛型函数，你需要在签名中明确指出一个读者是另一个读者之上的monad变换器。

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堆栈中的顺序是锁定的。也许有一种更清洁的方法来实现这一目标，但是如果不牺牲（甚至更多）通用性，我无法从头脑中找到一个。

模块化程序设计 - 将Monad变压器与Monad不可知功能相结合

2 个答案: