对猫效果Async.memoize感到困惑

问题描述

我对猫效应还很陌生，但我想我对此有所了解。但是我遇到了一种情况，我想记住一个IO的结果，但它没有达到我的期望。

我要记住的函数转换String => String，但是转换需要网络调用，因此将其实现为String => IO [String]函数。在非IO环境中，我只是保存调用的结果，但是定义函数实际上无法访问它，因为它直到稍后才执行。而且，如果我保存构造的IO [String]，它实际上将无济于事，因为该IO每次使用都会重复网络调用。因此，我尝试使用具有以下文档的Async.memoize：

懒洋洋地记住f。每次绑定返回的F [F [A]]时， 效果f最多执行一次（当内部F [A]绑定 第一次）。

我从回忆中期望的是，对于给定的输入仅执行一次的功能，并且返回的IO的内容仅进行一次评估。换句话说，我希望最终的IO就像第一次执行IO.pure（result）一样。但这不是正在发生的事情。相反，我发现虽然被调用的函数本身仅执行一次，但是每次仍会评估IO的内容-就像我试图天真地保存和重用IO时的情况一样。

我构造了一个例子来说明问题：

def plus1(num: Int): IO[Int] = {
      println("foo")
      IO(println("bar")) *> IO(num + 1)
    }
    var fooMap = Map[Int,IO[IO[Int]]]()
    def mplus1(num: Int): IO[Int] = {
      val check = fooMap.get(num)
      val res = check.getOrElse {
        val plus = Async.memoize(plus1(num))
        fooMap = fooMap + ((num,plus))
        plus
      }
      res.flatten
    }

    println("start")
    val call1 = mplus1(2)
    val call2 = mplus1(2)
    val result = (call1 *> call2).unsafeRunSync()
    println(result)
    println(fooMap.toString)
    println("finish")

该程序的输出为：

start
foo
bar
bar
3
Map(2 -> <function1>)
finish

尽管plus1函数本身仅执行一次（打印一个“ foo”），但是IO中包含的输出“ bar”打印两次，而我希望它也仅打印一次。 （我还尝试过先将Async.memoize返回的IO展平，然后再将其存储在地图中，但这没什么用。）

解决方法

考虑以下示例

给出以下辅助方法

def plus1(num: Int): IO[IO[Int]] = {
  IO(IO(println("plus1")) *> IO(num + 1))
}

def mPlus1(num: Int): IO[IO[Int]] = {
  Async.memoize(plus1(num).flatten)
}

让我们构建一个对plus1(1)进行两次评估的程序。

val program1 = for {
  io <- plus1(1)
  _ <- io
  _ <- io
} yield {}
program1.unsafeRunSync()

这将产生两次打印plus1的预期输出。

如果您执行相同的操作，而是使用mPlus1方法

val program2 = for {
  io <- mPlus1(1)
  _ <- io
  _ <- io
} yield {}
program2.unsafeRunSync()

仅在确认备忘录有效后，它将打印plus1。

记住的窍门是，只应对其进行一次评估即可达到预期的效果。现在考虑以下突出显示它的程序。

val memIo = mPlus1(1)
val program3 = for {
  io1 <- memIo
  io2 <- memIo
  _ <- io1
  _ <- io2
} yield {}
program3.unsafeRunSync()

由于plus1和io1分别被记忆，因此它输出两次io2。

以您的示例为例，foo仅打印一次，因为您正在使用地图，并在找不到该值时更新该值，并且只会发生一次。每次评估bar时都会打印IO，因为调用res.flatten会失去记忆效果。