Question

我想阅读STDIN中换行符分隔的字符串列表，直到看到新行并且我想要IO [String]类型的操作。以下是我将如何使用递归：

myReadList :: IO String
myReadList = go []
where 
    go :: [String] -> IO [String]   
    go l = do {
                 inp <- getLine;
                 if (inp == "") then 
                     return l;
                 else go (inp:l);
                }

然而，这种使用方法模糊了可读性，并且是一种非常常见的模式，理想情况下想要将其抽象出来。

所以，这是我的尝试：

whileM :: (Monad m) => (a -> Bool) -> [m a] -> m [a]
whileM p []     = return []
whileM p (x:xs) = do
    s <- x
    if p s
    then do
        l <- whileM p xs
        return (s:l)
    else
        return []

myReadList :: IO [String]
myReadList = whileM (/= "") (repeat getLine)

我猜这个whileM或类似的东西有一些默认实现。但是我找不到它。

有人能指出解决这个问题最自然，最优雅的方法吗？

Answer 1

unfoldWhileM与您的whileM相同，只是它将操作（不是列表）作为第二个参数。

myReadList = unfoldWhileM (/= "") getLine

Answer 2

是的，为了抽象出前面答案中提到的显式递归，有Control.Monad.Loop库是有用的。对于那些感兴趣的人here is a nice tutorial on Monad Loops。

然而还有另一种方式。以前，在努力完成这项工作并且知道Haskell是默认的Lazy我首先尝试过;

(sequence . repeat $ getLine) >>= return . takeWhile (/="q")

我希望上面的内容能够将输入的行收集到IO [String]类型中。不......它无限期地运行，IOactişons一点也不懒。此时System IO Lazy也可能派上用场。它只是一个2功能的简单库。

run        :: T a -> IO a
interleave :: IO a -> T a

因此run采用Lazy IO操作并将其转换为IO操作，interleave执行相反的操作。因此，如果我们将上述函数改写为;

import qualified System.IO.Lazy as LIO

gls = LIO.run (sequence . repeat $ LIO.interleave getLine) >>= return . takeWhile (/="q")

Prelude> gls >>= return . sum . fmap (read :: String -> Int)
1
2
3
4
q
10

Answer 3

使用streaming包的有效流的解决方案：

import Streaming
import qualified Streaming.Prelude as S

main :: IO ()
main = do
    result <- S.toList_ . S.takeWhile (/="") . S.repeatM $ getLine
    print result

显示提示的解决方案，使其与阅读操作分开：

main :: IO ()
main = do
    result <- S.toList_
            $ S.zipWith (\_ s -> s)
                        (S.repeatM $ putStrLn "Write something: ")
                        (S.takeWhile (/="") . S.repeatM $ getLine)
    print result

Haskell做IO循环的方式（没有显式递归）？

3 个答案: