如何将IO中的数据读取到数据结构中，然后对数据结构进行处理？

Question

首先，我很抱歉做了“我从哪里开始”的典型事情，但我完全迷失了。

我已经读了“为伟大的利益而学习哈斯克尔”网站了，感觉已经有一个时代了（差不多半个学期了。我即将完成“输入和输出”一章，但我仍然没有知道如何编写多行程序

我已经看到了 do 语句，并且只能使用它将 IO 操作连接到单个函数中，但我不知道如何编写一个实际的应用程序。 我

有人能给我指出正确的方向吗？

有 C 背景，基本上我在大学的一个模块中使用了 Haskell，我想将 C++ 与 Haskell 进行比较（在很多方面）。我希望创建一系列搜索和排序程序，以便我可以评论它们在各自语言中的易用性及其速度。

但是，我真的开始失去使用 Haskell 的信心，因为已经六周了，并且。我仍然不知道如何编写一个完整的应用程序，而且我正在阅读的网站中的章节似乎越来越长。

我基本上需要创建一个将存储在结构中的基本对象（我知道该怎么做），更多我正在努力解决的是，如何创建一个从某些文本文件读取数据并填充的程序首先包含该数据的结构，然后继续处理它。由于 haskell 似乎分割了 IO 和其他操作，它不仅仅让我在程序中编写多行，我正在寻找这样的东西：

main = data <- getContent
       let allLines = lines data
       let myStructure = generateStruct allLines
       sort/search/etc
       print myStructure

我该怎么做？有什么好的教程可以帮助我开始实际的程序吗？

-一个

Answer 1

您提到看到 do 表示法，现在是时候学习如何使用 do 了。考虑您的示例 main 是一个 IO，您应该使用 do 语法或绑定：

main = do
  dat <- getContent
  let allLines = lines dat
      myStructure = generateStruct allLines
      sorted = mySort myStructure
      searchResult = mySearch myStructure
  print myStructure
  print sorted
  print searchResult

所以现在您有一个获取 stdin 的 main，将其打开通过 lines 转换为 [String]，大概将其解析为一个结构，并对该结构运行排序和搜索。请注意，有趣的代码都是纯的 - mySort、mySearch 和 generateStruct 不需要是 IO（也不可能是，因为在 let 绑定中），因此您实际上正确地一起使用了纯粹且有效的代码。

我建议你看看bind是如何工作的(>>=)以及如何将符号脱糖到bind中。 这个问题应该有帮助。

Answer 2

另请参阅 Neil Mitchell 的解释没有 Monad 的 Haskell IO。

Answer 3

我将尝试从一个简化的示例开始。假设这就是我们想要做的：

1. 打开一个包含整数列表的文件并返回它。
2. 对此列表进行排序
3. 让我们也反转列表
4. 在屏幕上打印结果

让我们也说我们有这些可以使用的函数：

getContent :: IO [Int]
sort :: [Int] -> [Int]
reverse :: [Int] -> [Int]
show :: a -> String
putStrLn :: String -> IO ()

为了让我们清楚，我将介绍一下这些函数：

• getContent：我编写了这个函数，但是如果有这样的函数，将是它的签名（您可以使用getContent = return [3,7,2,1]测试目的）。我确信您以前见过这样的签名，并且至少模糊地理解，由于它确实进行 IO，因此它的签名不能只是 getContent :: [Int]。
• sort：它是Data.List模块中定义的函数，用法很简单：sort [3,1,2]返回[1,2,3]< /code>
• reverse：也在 Data.List 模块中定义： reverse [1,3,2] 返回 [2,3,1]
• show：不需要导入任何东西，直接使用即可：show 11 返回字符串"11"； show [1,2,3] 返回字符串 "[1,2,3]" 等
• putStrLn：获取一个字符串，将其放在屏幕上并返回IO ()，现在再说一次，因为它执行 IO，所以它的签名不能只是 putStrLn :: Stiring -> ()。

好的，现在我们已经拥有了创建程序所需的一切，现在的问题是将这些函数连接在一起。让我们从连接函数开始：

getContent :: IO [Int] 和 sort :: [Int] -> [Int]

我认为如果你得到了这一部分，你也将很容易得到其余的。因此，问题在于，由于 getContent 返回 IO [Int] 而不仅仅是 [Int]，因此您不能忽略或摆脱IO 部分并将其推入 sort 中。也就是说，您不能执行以下操作来连接这些函数：


排序（getRidOfIO getContent）


这里是 >>= :: ma -> (a→mb)→ m b 操作可以解决这个问题。现在请注意，m、a 和 b 是类型变量，因此如果我们替换 m > 表示 IO，a 表示 [Int]，b 表示 [Int] ，我们得到签名：

>>= :: IO [Int] -> ([Int] -> IO [Int]) -> IO [Int]

再次查看这些 getContent 和 sort 函数及其签名，并尝试考虑它们如何适合 >>=。我相信您会注意到，您可以直接使用 getContent 作为 >>= 的第一个参数。到目前为止， >>= 要做的就是将 [Int] 取出 getContent 并将其推入作为第二个参数提供的函数中。但是第二个参数中的函数是什么？我们不能使用 sort :: [Int] ->直接 [Int]，我们可以尝试的下一个最好的方法是

\listOfInts ->对 listOfInts 进行排序，

但仍然具有签名 [Int] -> [Int] 所以这没有多大帮助。这是另一个英雄登场的地方，

return :: a ->; m a..

同样，a 和 m 是类型变量，让我们替换它们，我们将得到

return :: [Int] -> IO [Int]

因此添加 \listOfInts ->对 listOfInts 和 return 一起排序，我们将得到：

\listOfInts ->返回 $ sort listOfInts :: [Int] -> IO [Int]

这正是我们想要作为 >>= 的第二个参数的内容。因此，最后让我们使用粘合剂将 getContent 和 sort 连接在一起：

getContent >>= (\listOfInts -> return $ sort listOfInts)

这与（使用 do 表示法）是一样的：

do listOfInts <- getContent
   return $ sort listOfInts

到了，最可怕的部分就结束了。现在可能会出现一个顿悟时刻，尝试思考我们刚刚建立的连接的结果类型是什么。我会破坏它，...

getContent >>= (\listOfInts -> return $ sort listOfInts) 的类型是 IO [Int]再次。

让我们总结一下：我们采用了 IO [Int] 类型和 [Int] -> 类型的内容。 [Int]，将这两个东西粘合在一起，并再次得到 IO [Int] 类型的东西！

现在继续尝试完全相同的事情：获取我们刚刚创建的 IO [Int] 对象并将其粘合在一起（使用 >>= 和 return) 和 reverse :: [Int] -> [整数]。

我想我写得太多了，但是如果有任何不清楚的地方或者您是否需要其余部分的帮助，请告诉我。

到目前为止我所描述的内容可能如下所示：

getContent :: IO [Int]   
getContent = return [5,2,1,7]

main :: IO ()
main = do
  listOfInts <- getContent
  return $ sort listOfInts
  return ()                   -- This is only to sattisfy the signature of main

Answer 4

如果是从 stdin 读取并将结果写入 stdout 的问题，而无需进一步干预用户输入 - 正如您提到的 getContents建议——然后是古老的 interact :: (String -> String) -> IO()，或者其他几个版本，例如Data.ByteString.interact :: (ByteString -> ByteString) -> IO() 或 Data.Text.interact::(Text -> Text) -> IO() 就是所需要的全部。 interact 基本上是“用这个函数制作一个小unix工具”函数——它将正确类型的纯函数映射到可执行操作（即类型的值） code>IO()。）所有 Haskell 教程都应该在第三页或第四页提到它，并附有编译说明。

因此，如果您

main = interact arthur

arthur :: String -> String
arthur = reverse

使用 ghc --make -O2 Reverse.hs -overse 编写和编译，那么您通过管道传输到 ./reverse 的任何内容都将被理解为字符列表，并且出现逆转。同样，无论您通过管道

main = interact (unlines . meredith  . lines)

meredith :: [String] -> [String]
meredith = filter (not.null)

传输到什么，都会出现省略空行的情况。更有趣的是，

main = interact ( unlines . map show . luther . map read . lines)

luther :: [Int] -> [Int]
luther = filter even 

将获取由换行符分隔的字符流，将它们读取为 Int，删除奇数字符，并生成适当过滤的流。

main = interact ( unlines . map show . emma . map read . lines)

emma :: [Int] -> Int
emma = sum . map square 
  where square x = x * x

将打印换行符分隔的数字的平方和。

在最后两种情况下，luther 和 emma 内部“数据结构”是 [Int]，这非常乏味，并且应用于它的函数非常简单，课程。要点是让一种interact 形式来处理所有 IO，从而让“填充结构”和“处理它”之类的图像从您的脑海中消失。要使用interact，您需要使用组合来使整体产生某种String ->字符串函数。但即使在这里，正如第一个例子中的那样 arthur:: String -> String 您正在定义一个更像数学意义上的真正函数。 String 和 ByteString 类型中的值与 Bool 或 Int 中的值一样纯粹。

在这种基本交互类型的更复杂的情况下，您的任务首先是考虑如何将您将关注的函数的所需纯值映射到String 值（这里，对于 Int 来说只是 show ，或者对于 [Int] 来说是 unlines .map show ） 。 interact 知道如何处理字符串。 -- 然后弄清楚如何定义从字符串或 ByteString（将包含“原始”数据）到主函数作为参数的一个或多个类型中的值的纯映射。在这里我只是使用 map read 。行 产生[Int]。如果您正在处理一些更复杂的树结构，您需要一个从 [Int] 到 MyTree Int 的函数。当然，放置在这个位置的更复杂的函数是解析器。

然后你就可以进城了，在这种情况下：根本没有理由认为自己是“编程”、“填充”和“处理”。这就是 LYAH 的所有炫酷功能发挥作用的地方。您的职责是在特定的定义规则内定义映射。在最后两种情况下，它们是从 [Int] 到 [Int] 以及从 [Int] 到 Int >，但这里有一个类似的示例，源自 优秀但仍不完整的教程 超级优秀的 Vector 包，其中处理初始数字结构是 Vector Int

{-# LANGUAGE BangPatterns #-}
import qualified Data.ByteString.Lazy.Char8      as L
import qualified Data.Vector.Unboxed            as U
import System.Environment

main = L.interact (L.pack . (++"\n") . show . roman . parse)
    where 
    parse :: L.ByteString -> U.Vector Int
    parse bytestr = U.unfoldr step bytestr
    step !s = case L.readInt s of
        Nothing       -> Nothing
        Just (!k, !t) -> Just (k, L.tail t)

-- now the IO and stringy nonsense is out of the way 
-- so we can calculate properly:

roman :: U.Vector Int -> Int
roman = U.sum

这里，roman 又是低能的，从 Int 向量到 Int 的任何函数，无论多么复杂，都可以取代它。写一个更好的roman永远不会是“填充”“多行编程”“处理”等问题，尽管我们当然是这样说的；这只是一个通过 Data.Vector 和其他地方的函数组合来定义真正函数的问题。天空是极限，也请查看该教程。