我想知道在 IO monad 还没有发明的时候，Haskell 是如何完成 I/O 的。任何人都知道一个例子。
编辑：可以在没有现代 Haskell 中的 IO Monad 的情况下完成 I/O 吗？我更喜欢一个适用于现代 GHC 的示例。
问问题
5570 次
3 回答
65
在引入 IO monad 之前，main它是 type 的函数[Response] -> [Request]。ARequest将代表一个 I/O 操作，例如写入通道或文件，或读取输入，或读取环境变量等。AResponse将是此类操作的结果。例如，如果您执行了ReadChanorReadFile请求，则对应的Response将是包含读取输入的 aStr str所在的位置。执行, or请求时，响应将只是. （当然，假设在所有情况下，给定的操作实际上是成功的）。strStringAppendChanAppendFileWriteFileSuccess
因此，Haskell 程序将通过建立一个Request值列表并从给定的列表中读取相应的响应来工作main。例如，从用户那里读取数字的程序可能如下所示（为简单起见，省略了任何错误处理）：
main :: [Response] -> [Request]
main responses =
[
AppendChan "stdout" "Please enter a Number\n",
ReadChan "stdin",
AppendChan "stdout" . show $ enteredNumber * 2
]
where (Str input) = responses !! 1
firstLine = head . lines $ input
enteredNumber = read firstLine
正如 Stephen Tetley 已经在评论中指出的那样，该模型的详细规格在1.2 Haskell 报告的第 7 章中给出。
可以在没有现代 Haskell 中的 IO Monad 的情况下完成 I/O 吗？
不，Haskell 不再支持Response/Request直接做 IO 的方式，类型main是 now IO ()，所以你不能写一个不涉及的 Haskell 程序，IO即使你可以，你仍然没有替代的方式做任何 I/O。
但是，您可以做的是编写一个函数，该函数采用旧式主函数并将其转换为 IO 操作。然后，您可以使用旧样式编写所有内容，然后仅main在您只需在真正的主函数上调用转换函数的地方使用 IO。这样做几乎肯定会比使用IOmonad 更麻烦（并且会让任何现代 Haskeller 阅读您的代码感到困惑），所以我绝对不会推荐它。然而这是可能的。这样的转换函数可能如下所示：
import System.IO.Unsafe
-- Since the Request and Response types no longer exist, we have to redefine
-- them here ourselves. To support more I/O operations, we'd need to expand
-- these types
data Request =
ReadChan String
| AppendChan String String
data Response =
Success
| Str String
deriving Show
-- Execute a request using the IO monad and return the corresponding Response.
executeRequest :: Request -> IO Response
executeRequest (AppendChan "stdout" message) = do
putStr message
return Success
executeRequest (AppendChan chan _) =
error ("Output channel " ++ chan ++ " not supported")
executeRequest (ReadChan "stdin") = do
input <- getContents
return $ Str input
executeRequest (ReadChan chan) =
error ("Input channel " ++ chan ++ " not supported")
-- Take an old style main function and turn it into an IO action
executeOldStyleMain :: ([Response] -> [Request]) -> IO ()
executeOldStyleMain oldStyleMain = do
-- I'm really sorry for this.
-- I don't think it is possible to write this function without unsafePerformIO
let responses = map (unsafePerformIO . executeRequest) . oldStyleMain $ responses
-- Make sure that all responses are evaluated (so that the I/O actually takes
-- place) and then return ()
foldr seq (return ()) responses
然后你可以像这样使用这个函数：
-- In an old-style Haskell application to double a number, this would be the
-- main function
doubleUserInput :: [Response] -> [Request]
doubleUserInput responses =
[
AppendChan "stdout" "Please enter a Number\n",
ReadChan "stdin",
AppendChan "stdout" . show $ enteredNumber * 2
]
where (Str input) = responses !! 1
firstLine = head . lines $ input
enteredNumber = read firstLine
main :: IO ()
main = executeOldStyleMain doubleUserInput
于 2013-06-08T22:21:31.053 回答
1
我更喜欢一个适用于现代 GHC 的示例。
对于 GHC 8.6.5：
import Control.Concurrent.Chan(newChan, getChanContents, writeChan)
import Control.Monad((<=<))
type Dialogue = [Response] -> [Request]
data Request = Getq | Putq Char
data Response = Getp Char | Putp
runDialogue :: Dialogue -> IO ()
runDialogue d =
do ch <- newChan
l <- getChanContents ch
mapM_ (writeChan ch <=< respond) (d l)
respond :: Request -> IO Response
respond Getq = fmap Getp getChar
respond (Putq c) = putChar c >> return Putp
其中类型声明来自Philip Wadler的How to Declare an Imperative的第 14 页。测试程序留给好奇的读者作为练习:-)
如果有人想知道：
-- from ghc-8.6.5/libraries/base/Control/Concurrent/Chan.hs, lines 132-139
getChanContents :: Chan a -> IO [a]
getChanContents ch
= unsafeInterleaveIO (do
x <- readChan ch
xs <- getChanContents ch
return (x:xs)
)
是的 -unsafeInterleaveIO确实出现了。
于 2020-06-04T12:24:18.953 回答
0
@sepp2k已经阐明了这是如何工作的，但我想补充几句
我真的很抱歉。我认为没有 unsafePerformIO 就不可能编写这个函数
当然可以，你几乎不应该使用 unsafePerformIO http://chrisdone.com/posts/haskellers
我正在使用稍微不同的Request类型构造函数，因此它不需要通道版本（stdin/stdout就像在@sepp2k 的代码中一样）。这是我的解决方案：
（注意：getFirstReq不适用于空列表，您必须为此添加一个案例，但这应该是微不足道的）
data Request = Readline
| PutStrLn String
data Response = Success
| Str String
type Dialog = [Response] -> [Request]
execRequest :: Request -> IO Response
execRequest Readline = getLine >>= \s -> return (Str s)
execRequest (PutStrLn s) = putStrLn s >> return Success
dialogToIOMonad :: Dialog -> IO ()
dialogToIOMonad dialog =
let getFirstReq :: Dialog -> Request
getFirstReq dialog = let (req:_) = dialog [] in req
getTailReqs :: Dialog -> Response -> Dialog
getTailReqs dialog resp =
\resps -> let (_:reqs) = dialog (resp:resps) in reqs
in do
let req = getFirstReq dialog
resp <- execRequest req
dialogToIOMonad (getTailReqs dialog resp)
于 2017-06-06T18:32:14.377 回答