我怎样才能让Scalaz ZIO变懒？

我有一个严重的副作用函数（想想数据库调用），我想将其用作一个惰性值，这样它只在第一次使用时被调用（如果从未使用过，则根本不会被调用）

我该怎么处理齐奥

如果我的程序是这样的，那么函数只会被调用一次（但即使结果也不会被使用）：

---

有没有一种方法可以将

longRunningDbAction

包装成某种让它变得懒惰的东西？

我想到了以下几点：

 def lazyIO[E,A](io: IO[E,A]): IO[Nothing, IO[E, A]] = {
    for {
      barrier <- Promise.make[Nothing, Unit]
      fiber <- (barrier.get *> io).fork
    } yield barrier.complete(()) *> putStrLn("getting it") *> fiber.join
  }

控制台输出显示，确实两次提取lazy值，但只有第一次触发“数据库访问”：

齐奥现在有了

override def run（args:List[String]）：IO[Nothing，Main.ExitStatus]=for{
valueFromDb为什么不添加
）。在末尾展平
，以避免ZIO或ZIO作为返回类型？它似乎对我不起作用，正在调用它times@Wonay：我认为它必须是一个ZIO中的ZIO，因为它是一个有效的函数（创建承诺），产生另一个有效的函数（将完成承诺）.但我可能错了。你能把不适合你的代码发布到某个地方吗？我称之为
LazyIO（…）
分两次理解，执行两次。我发布了是的，这不起作用。你应该只调用一次
lazyIO
，这会给你另一个ZIO，你可以重复调用。这就是我所说的不能将其展平的意思。我必须查看该线程中提到的
memoize
内容。注意t这个
memoize
也有相同类型的ZIO-of-ZIO签名。什么决定你是否需要再次调用数据库？这是在第一次调用时确定的吗？@user305652它应该像一个常规的
lazy val-dbResult=callDatabase（）一样工作
在Scala中，即在第一次调用时进行计算，然后再次返回相同的值（不做任何其他操作）。另一个答案的主要区别在于它也捕获了资源，因此使用延迟值不需要
R
（仅创建它）。
object Main extends scalaz.zio.App {

  def longRunningDbAction: IO[Nothing, Integer] = for {
    _ <- putStrLn("Calling the database now")
  } yield 42


  def maybeUseTheValue(x: IO[Nothing, Integer]): IO[Nothing, Unit] = for {
    gettingItNow <- x
    _ <- putStrLn(s"The database said ${gettingItNow}")
  } yield ()

  def maybeNeedItAgain(x: IO[Nothing, Integer]): IO[Nothing, Unit] = for {
    gettingItNow <- x
    _ <- putStrLn(s"Okay, we need it again here: ${gettingItNow}")
  } yield ()

  override def run(args: List[String]): IO[Nothing, Main.ExitStatus] = for {
    _ <- maybeUseTheValue(longRunningDbAction)
    _ <- maybeNeedItAgain(longRunningDbAction)
  } yield ExitStatus.ExitNow(0)

}

 def lazyIO[E,A](io: IO[E,A]): IO[Nothing, IO[E, A]] = {
    for {
      barrier <- Promise.make[Nothing, Unit]
      fiber <- (barrier.get *> io).fork
    } yield barrier.complete(()) *> putStrLn("getting it") *> fiber.join
  }

def lazyIO[R, E, A](io: ZIO[R, E, A]): ZIO[R, Nothing, ZIO[R, E, A]] = {
  for {
    barrier <- Promise.make[Nothing, Unit]
    fiber <- (barrier.await *> io).fork
  } yield barrier.succeed(()) *> fiber.join
}

override def run(args: List[String]): IO[Nothing, Main.ExitStatus] = for {
    valueFromDb <- lazyIO(longRunningDbAction)
    _ <- maybeUseTheValue(valueFromDb)
    _ <- maybeNeedItAgain(valueFromDb)
  } yield ExitStatus.ExitNow(0)

getting it
Calling the database now
The database said 42
getting it
Okay, we need it again here: 42

override def run(args: List[String]): IO[Nothing, Main.ExitStatus] = for {
   valueFromDb <- ZIO.memoize(longRunningDbAction)
   _ <- maybeUseTheValue(valueFromDb)
   _ <- maybeNeedItAgain(valueFromDb)
} yield ExitStatus.ExitNow(0)

/**
   * Returns an effect that, if evaluated, will return the lazily computed result
   * of this effect.
   */
  final def memoize: ZIO[R, Nothing, IO[E, A]] =
    for {
      r <- ZIO.environment[R]
      p <- Promise.make[E, A]
      l <- Promise.make[Nothing, Unit]
      _ <- (l.await *> ((self provide r) to p)).fork
    } yield l.succeed(()) *> p.await