26

我最近看了一个关于如何提出 IO monad 的视频，谈话是在 scala 中进行的。我实际上想知道让函数返回 IO[A] 有什么意义。包裹在 IO 对象中的 lambda 表达式就是突变，在某个更高的点上，它们必须被观察到，我的意思是被执行，以便发生一些事情。你不只是把问题推到树上更高的地方吗？

我能看到的唯一好处是它允许延迟评估，从某种意义上说，如果您不调用 unsafePerformIO 操作，则不会发生副作用。另外我猜该程序的其他部分可以使用/共享代码并决定何时发生副作用。

我想知道这就是全部吗？可测试性有什么优势吗？我假设不是因为您必须观察某种否定这一点的效果。如果您使用特征/接口，您可以控制依赖关系，但不能控制对这些依赖关系产生影响的时间。

我将以下示例放在代码中。

case class IO[+A](val ra: () => A){
  def unsafePerformIO() : A = ra();
  def map[B](f: A => B) : IO[B] = IO[B]( () => f(unsafePerformIO()))
  def flatMap[B](f: A => IO[B]) : IO[B] = {
    IO( () =>  f(ra()).unsafePerformIO())
  }
}



case class Person(age: Int, name: String)

object Runner {

  def getOlderPerson(p1: Person,p2:Person) : Person = 
    if(p1.age > p2.age) 
        p1
      else
        p2

  def printOlder(p1: Person, p2: Person): IO[Unit] = {
    IO( () => println(getOlderPerson(p1,p2)) ).map( x => println("Next") )
  }

  def printPerson(p:Person) = IO(() => {
    println(p)
    p
  })

  def main(args: Array[String]): Unit = {

    val result = printPerson(Person(31,"Blair")).flatMap(a => printPerson(Person(23,"Tom"))
                                   .flatMap(b => printOlder(a,b)))

   result.unsafePerformIO()
  }

}

你可以看到效果是如何延迟到 main 的，我认为这很酷。我是在从视频中了解到这一点后想到的。

我的实施是否正确，我的理解是否正确。

我还想知道是否要获得里程，它应该与 ValidationMonad 结合使用，如 ValidationMonad[IO[Person]] 这样我们可以在发生异常时短路吗？请思想。

布莱尔

4

2 回答 2

28

函数的类型签名记录它是否有副作用是很有价值的。您的 IO 实现很有价值，因为它确实完成了这么多。它使您的代码更好地记录在案；如果您重构代码以尽可能多地将涉及 IO 的逻辑与不涉及 IO 的逻辑分开，那么您就使不涉及 IO 的函数更具可组合性和可测试性。您可以在没有显式 IO 类型的情况下进行相同的重构；但是使用显式类型意味着编译器可以帮助您进行分离。

但这仅仅是开始。在您问题的代码中，IO 操作被编码为 lambda，因此是不透明的；除了运行 IO 操作之外，您无能为力，并且它在运行时的效果是硬编码的。

这不是实现 IO monad 的唯一可能方式。

例如，我可以让我的 IO 操作案例类扩展一个共同的特征。然后，例如，我可以编写一个运行函数并查看它是否返回正确类型的 IO 操作的测试。

在那些代表不同类型 IO 操作的案例类中，我可能不包括在我运行时操作的硬编码实现。相反，我可以使用 typeclass 模式将其解耦。这将允许交换 IO 操作的不同实现。例如，我可能有一组实现与生产数据库通信，另一组实现与模拟内存数据库通信以进行测试。

Bjarnason 和 Chiusano 的《Scala 函数式编程》一书的第 13 章（“外部效果和 I/O”）对这些问题进行了很好的处理。尤其参见第 13.2.2 节，“简单 IO 类型的优点和缺点”。

更新（2015 年 12 月）：重新“交换 IO 操作的不同实现”，现在越来越多的人使用“免费单子”来做这种事情；参见例如 John De Goes 的博文“<a href="http://degoes.net/articles/modern-fp" rel="noreferrer">A Modern Architecture for FP”。

于 2013-10-30T16:28:44.483 回答
19

使用 IO monad 的好处是拥有纯程序。您不会将副作用推向更高的链条，而是消除它们。如果你有一个不纯的函数，如下所示：

def greet {
  println("What is your name?")
  val name = readLine
  println(s"Hello, $name!")
}

您可以通过将其重写为来消除副作用：

def greet: IO[Unit] = for {
  _ <- putStrLn("What is your name?")
  name <- readLn
  _ <- putStrLn(s"Hello, $name!")
} yield ()

第二个功能是参照透明的。

在 Rúnar Bjarnason 的 scala.io 幻灯片中可以找到一个很好的解释为什么使用 IO monads 会导致纯程序（视频可以在这里找到）。

于 2013-10-30T16:17:45.607 回答