编程IO

区分纯函数和不纯函数

还记得上周的单词计数功能吗？

• 单词计数 :: 字符串 -> 字符串

• putStr（wordCounts“hello clouds\nhello sky”）云：1你好：2天空：1
• 如果我们想创建一个独立的计算单词的程序，而不仅仅是测试GHCi中的功能？

独立Haskell程序

• 程序应该有一个名为主要,包含一个名为

  主要的

  :

  • 模块 主要 哪里
    
    主要的 :: IO（输入输出）()主要的 =(...)

• 第一行可以省略，因为默认的模块名称是主要.
• 我们如何创建类型的东西

  IO（输入输出）()

  ？

创建IO操作

• 类型

  IO（输入输出）()

  表示“IO操作”。
• 下面是一些返回的函数（有些可能已经很熟悉了）IO操作：

  • putStr（输入Str）   :: 字符串 -> IO（输入输出）()打印    :: 显示 一 => 一 -> IO（输入输出）()相互作用 ::(字符串->字符串)-> IO（输入输出）()

• 请注意

  相互作用

  非常适合我们的功能

  单词计数

  !

节目countWords

• 主要的 :: IO（输入输出）()主要的 = 相互作用 单词计数
  
  单词计数 :: 字符串 -> 字符串
  单词计数 =(...)--和以前一样

• 编译它（假设文件名为countWords.hs)
• ghc—生成countWords.hs
• 运行它（从文件中获取输入示例.txt):
  ./countWords<示例.txt云：1你好：2天空：1

纯粹的功能

在Haskell中，函数是纯函数

• 当应用一个函数时，它计算并返回一个结果，但不返回任何结果否则就会发生。他们没有副作用.
• 因此，相同的参数=>相同的结果。考虑

  • 第1组 x个 = 年 + 年 哪里 年 = （f） x个
    
    第二组 x个 = （f） x个 + （f） x个

• g1和g2总是计算相同的结果，无论f是什么。
  • g2可能会因为重复工作而变慢。
• 有利于模块化！使调试和测试更容易！
• 子表达式可以按任何顺序计算，甚至可以并行计算！

相等且可互换

• 在Haskell中，方程如下y=f x意味着我们有二平等的,可互换的比如数学！
• 无论我们是用名字来指代某物还是直接使用它，都不会差异。
• 你可以使用等式推理就像数学一样，证明这一点函数具有所需的属性。
  • 您可以证明的事情示例：

    • 地图 克 . 地图 （f） == 地图(克.（f）)

    • 地图 （f）(X轴++年)== 地图 （f） X轴 ++ 地图 （f） 年

    • 滤波器 第页(X轴++年)== 滤波器 第页 X轴 ++ 滤波器 第页 年

    • 颠倒(X轴++年)== 颠倒 年 ++ 颠倒 X轴

    • 颠倒 . 地图 （f） == 地图 （f） . 颠倒

Python示例

• >>>input（）-input（） 15 12 三>>>
• 功能输入不是纯粹的。
  • 它与用户交互。
  • 即使参数相同，它也可以返回不同的结果。
• 从结果可以看出，左操作数是计算出来的在右操作数之前。

Haskell中的更多IO

• 实际上有一个类似于Python的函数输入（）在哈斯克尔：
  • 获取线路 你好“你好”
• 还有更多：
• writeFile“hello.txt”“你好，世界！” readFile“hello.txt” “你好，世界！”
  但这不破坏纯洁吗？

Haskell中的IO和纯度

• 让我们再看看一些“不纯”函数的类型：

• putStr（输入Str）    :: 字符串 -> IO（输入输出）()获取线路   :: IO（输入输出） 字符串
  写入文件 :: 文件路径 -> 字符串 -> IO（输入输出）()readFile（读取文件）  :: 文件路径 -> IO（输入输出） 字符串
  
  类型 文件路径 = 字符串

• 诀窍在于使用类型

  IO（输入输出）

  .
  • 以某种方式与外界互动的所有功能有

    IO（输入输出）

    在结果类型中。
  • 无法在纯函数中“隐藏”对“不纯”函数的调用功能。
  • 那么我们如何从获取线路和readFile（读取文件）？

在GHCi中使用IO结果

• s<-readFile“hello.txt” （s，反向s） （“你好，世界！”，“！dlrow olleH”）
• 左箭头<-让我们得到IO操作。注意类型

  • readFile（读取文件） “hello.txt” :: IO（输入输出） 字符串

    
    

    秒 :: 字符串

  • 类型不同！
    • 哈斯克尔不让你写信秒=

      readFile（读取文件） “你好.txt”

      在这里，因为它会建议我们有两个平等、可互换的东西，的相同的类型。

do符号

• 这个做符号允许我们使用左箭头<-以同样的方式在函数定义中。

• 显示差异 :: IO（输入输出）()显示差异 = 做 输入StrLn “输入两个数字：”
                         x个 <- 读取Ln
                         年 <- 读取Ln
                         putStr（输入Str） “区别在于：”
                         打印(x个-年)

• 我们使用了以下功能：

• 读取Ln   :: 阅读 一 => IO（输入输出） 一
  打印    :: 显示 一 => 一 -> IO（输入输出）()putStr（输入Str）   :: 字符串 -> IO（输入输出）()输入StrLn :: 字符串 -> IO（输入输出）()

测试它

显示差异输入两个数字：15 12 区别是：3

执行IO并返回结果

• 如果我们想要一个返回差异而不是显示差异的函数呢？

• 获取差异 :: IO（输入输出） 整数
  获取差异 = 做 x个 <- 读取Ln
                        年 <- 读取Ln
                        返回(x个-年)显示差异 :: IO（输入输出）()显示差异 = 做 d日 <- 获取差异
                         putStr（输入Str） “区别在于：”
                         打印 d日

• 我们需要使用返回:

• 返回 :: 一 -> IO（输入输出） 一

差异

• Haskell的一个关键特性是它是一个纯粹地功能性的语言。功能包括纯净的.
• 但Haskell仍具有IO的“不纯”函数与其他语言不同的是，纯粹的和不纯洁的功能是分开的，通过使用

  IO（输入输出）

  键入以标记“不纯”功能。
• 你永远无法隐藏IO在某处使用的事实在一个大型程序中。
  • 您可以在

    做

    块，然后对其应用纯函数，但整体

    做

    块具有类型

    IO（输入输出）

    .

为什么是纯函数？

纯度有利于模块化，并简化调试和测试。

• 意外的副作用是错误的主要来源。
• 使用QuickCheck进行自动化测试就是一个例子一个好的功能是纯粹的！
• 子表达式可以按任何顺序计算，即使是并行计算，不改变程序的结果。

更多示例1

copyFile（复制文件） :: 文件路径 -> 文件路径 -> IO（输入输出）()copyFile（复制文件） 从 到 = 做 秒 <- readFile（读取文件） 从
                      写入文件 到 秒

更多示例2

• sortFile（排序文件） :: 文件路径 -> 文件路径 -> IO（输入输出）()sortFile（排序文件） 从 到 = 做 秒 <- readFile（读取文件） 从
                        写入文件 到(分拣线 秒)分拣行 = 无线条 . 分类 . 线

• 你可能不想随机测试sortFile（排序文件）（例如，将其应用于随机文件名100次）
• 但测试是有意义的分拣行使用QuickCheck。
• 保持程序中大多数函数的纯净和并使IO功能尽可能小和少。

更多示例3

• do两次 :: IO（输入输出） 一 -> IO（输入输出）(一,一)do两次 国际奥委会 = 做 x个 <- 国际奥委会
                  年 <- 国际奥委会
                  返回(x个,年)不要 :: IO（输入输出） 一 -> IO（输入输出）()不要 国际奥委会 = 返回()

• 试试GHCi！

一个更大的例子

刽子手

• 这是一个简单的猜词游戏。
• 请参见Hangman.hs公司