如何在 Haskell 中初始化 monad 然后在函数中多次使用

Question

其中大部分直接来自提示示例。我想做的是用模块和导入等初始化解释器，并以某种方式保留它。稍后（用户事件或其他），我希望能够调用具有该初始化状态的函数并多次解释表达式。因此，在代码中的 --split here 位置，我希望将上面的代码放在 init 中，将下面的代码放在一个接受表达式并解释它的新函数中。

module Main where
import Language.Haskell.Interpreter
import Test.SomeModule

main :: IO ()
main = do r <- runInterpreter testHint
          case r of
            Left err -> printInterpreterError err
            Right () -> putStrLn "Done."
          -- Right here I want to do something like the following
          -- but how do I do testInterpret thing so it uses the
          -- pre-initialized interpreter?
          case (testInterpret "expression one")
            Left err -> printInterpreterError err
            Right () -> putStrLn "Done."
          case (testInterpret "expression two")
            Left err -> printInterpreterError err
            Right () -> putStrLn "Done."

testHint :: Interpreter ()
testHint =
    do
      loadModules ["src/Test/SomeModule.hs"]
      setImportsQ [("Prelude", Nothing), ("Test.SomeModule", Just "SM")]
      say "loaded"
      -- Split here, so what I want is something like this though I know
      -- this doesn't make sense as is:
      -- testExpr = Interpreter () -> String -> Interpreter ()
      -- testExpr hintmonad expr = interpret expr
      let expr1 = "let p1o1 = SM.exported undefined; p1o2 = SM.exported undefined; in p1o1"
      say $ "e.g. typeOf " ++ expr1
      say =<< typeOf expr1


say :: String -> Interpreter ()
say = liftIO . putStrLn

printInterpreterError :: InterpreterError -> IO ()
printInterpreterError e = putStrLn $ "Ups... " ++ (show e)

Answer 1

我无法理解你的问题。另外我对提示也不是很熟悉。但我会尝试一下。

据我所知，Interpreter monad 只是一个围绕 IO 的简单状态包装器——它的存在只是为了让你可以说例如。 setImportsQ [...] 并让后续计算取决于该函数修改的“设置”。所以基本上你想共享多个计算的单子上下文。做到这一点的唯一方法是留在 monad 中——在 Interpreter 中构建单个计算并运行一次。您不能拥有转义并重用 runInterpreter 的“全局变量”。

幸运的是，Interpreter 是 MonadIO 的一个实例，这意味着您可以使用 交错 IO 计算和 Interpreter 计算>liftIO::IO a->解释器a。基本上你是从内到外思考（对于 Haskell 学习者来说这是一个极其常见的错误）。不要使用 IO 中在解释器中运行代码的函数，而是使用 Interpreter 中在 IO 中运行代码的函数（即 liftIO ）。所以例如。

main = runInterpreter $ do
    testHint
    expr1 <- liftIO getLine
    r1 <- interpret "" expr1 
    case r1 of
        ...
    expr2 <- liftIO getLine
    r2 <- interpret "" expr2
    case r2 of
        ...

如果需要的话，您可以轻松地将后面的代码提取到函数中，利用引用透明性的优点！直接拉出来就可以了

runSession :: Interpreter ()
runSession = do
    expr1 <- liftIO getLine
    r1 <- interpret "" expr1
    case interpret expr1 of
        ...

main = runInterpreter $ do
    testHint
    runSession

这有道理吗？您的整个程序是一个解释器计算，只有在最后一刻才将其拉出到IO。

（这并不意味着您编写的每个函数都应该在 Interpreter monad 中。远非如此！像往常一样，在边缘使用 Interpreter您的程序并保持核心纯粹的功能。解释器是新的IO）。

Answer 2

如果我理解正确，您希望初始化编译器一次，然后运行多个查询（可能是交互式的）。

有两种主要方法：

• 将 IO 操作提升到 Interpreter 上下文中（请参阅 luqui 的答案）。
• 使用惰性 IO 将数据流偷偷地进出程序。

我将描述第二个选项。

---

借助惰性 IO 的魔力，您可以向 testHint 传递一个惰性输入流，然后在 testHint 的主体中循环，以交互方式解释许多查询：

main = do
      ls <- getContents   -- a stream of future input
      r <- runInterpreter (testHint (lines input))
      case r of
         Left err -> printInterpreterError err
         Right () -> putStrLn "Done."

testHint input = do
      loadModules ["src/Test/SomeModule.hs"]
      setImportsQ [("Prelude", Nothing), ("Test.SomeModule", Just "SM")]
      say "loaded"

      -- loop over the stream of input, interpreting commands
      let go (":quit":es) = return ()
             (e:es)       = do say =<< typeOf e
                               go es
      go

go< /code> 函数可以访问初始化解释器的封闭环境，因此向其提供事件显然将在该一次初始化解释器的范围内运行。

另一种方法是从 monad 中提取解释器状态，但我不确定这在 GHC 中是否可行（它从根本上要求 GHC 不在 IO monad 中）。