Question

试图了解如何最好地应对FP中的副作用。

我实现了这个基本的IO实现：

  trait IO[A] {
    def run: A
  }
  object IO {
    def unit[A](a: => A): IO[A] = new IO[A] { def run = a }
    def loadFile(fileResourcePath: String) = IO.unit[List[String]]{ 
        Source.fromResource(fileResourcePath).getLines.toList }
    def printMessage(message: String) = IO.unit[Unit]{ println(message) }
    def readLine(message:String) = IO.unit[String]{ StdIn.readLine() }
  }

我有以下用例：

- load lines from log file
- parse each line to BusinessType object
- process each BusinessType object
- print process result

情况1：所以Scala代码可能看起来像这样

val load: String => List[String]
val parse: List[String] => List[BusinessType]
val process: List[BusinessType] => String
val output: String => Unit

情况2：我决定在上面使用IO：

val load: String => IO[List[String]]
val parse: IO[List[String]] => List[BusinessType]
val process: List[BusinessType] => IO[Unit]
val output: IO[Unit] => Unit

在第一种情况下，加载是不纯的，因为它是从文件中读取的，所以输出也是不纯的，因为它是将结果写入控制台。

为了更加实用，我使用了案例2。

问题：

- Aren't case 1 and 2 really the same thing?
- In case 2 aren't we just delaying the inevitable? 
  as the parse function will need to call the io.run 
  method and cause a side-effect?
- when they say "leave side-effects until the end of the world" 
  how does this apply to the example above? where is the 
  end of the world here?

Answer 1

您的IO monad似乎缺少所有monad内容，即您可以在其中flatMap上用较小的IO构建更大的IO的部分。这样，一切将保持“纯净”，直到通话结束run。

在第2种情况下，我们是否只是延迟不可避免的事情？因为解析功能将需要调用io.run 方法并引起副作用？

不。 parse函数不应调用io.run。它应该返回另一个IO，然后可以将其与其输入IO组合在一起。

当他们说“将副作用留到世界尽头”时这如何适用于以上示例？哪儿是世界末日在这里？

世界末日将是您的程序要做的最后一件事。您只run一次。程序的其余部分“纯粹”为此构建了一个大型IO。

类似

def load(): IO[Seq[String]]    
def parse(data: Seq[String]): IO[Parsed]  // returns IO, because has side-effects
def pureComputation(data: Parsed): Result  // no side-effects, no need to use I/O
def output(data: Result): IO[Unit]

// combining effects is "pure", so the whole thing
// can be a `val` (or a `def` if it takes some input params)
val program: IO[Unit] = for {
      data <- load()    // use <- to "map" over IO
      parsed <- parse()
      result = pureComputation(parsed)  // = instead of <-, no I/O here 
      _ <- output(result)
   } yield ()

// only `run` at the end produces any effects
def main() {
   program.run()
}

处理IO Monad FP中不纯净的副作用

1 个答案: