Add ZIO#cached

core-tests/jvm/src/test/scala/zio/IOSpec.scala

@@ -7,6 +7,7 @@ import org.specs2.execute.Result
 import scala.collection.mutable
 import scala.util.Try
 import zio.Cause.{ die, fail, interrupt, Both }
+import zio.duration._
 
 class IOSpec(implicit ee: org.specs2.concurrent.ExecutionEnv) extends TestRuntime with GenIO with ScalaCheck {
   import Prop.forAll
@@ -45,6 +46,7 @@ class IOSpec(implicit ee: org.specs2.concurrent.ExecutionEnv) extends TestRuntim
    Check `absolve` method on IO[E, Either[E, A]] returns the same IO[E, Either[E, String]] as `IO.absolve` does. $testAbsolve
    Check non-`memoize`d IO[E, A] returns new instances on repeated calls due to referential transparency. $testNonMemoizationRT
    Check `memoize` method on IO[E, A] returns the same instance on repeated calls. $testMemoization
+   Check `cached` method on IO[E, A] returns new instances after duration. $testCached
    Check `raceAll` method returns the same IO[E, A] as `IO.raceAll` does. $testRaceAll
    Check `firstSuccessOf` method returns the same IO[E, A] as `IO.firstSuccessOf` does. $testfirstSuccessOf
    Check `zipPar` method does not swallow exit causes of loser. $testZipParInterupt
@@ -305,6 +307,21 @@ class IOSpec(implicit ee: org.specs2.concurrent.ExecutionEnv) extends TestRuntim
     )
   }
 
+  def testCached = {
+    def incrementAndGet(ref: Ref[Int]): UIO[Int] = ref.modify(n => (n + 1, n + 1))
+    unsafeRun {
+      for {
+        ref   <- Ref.make(0)
+        cache <- incrementAndGet(ref).cached(100.milliseconds)
+        a     <- cache
+        b     <- cache
+        _     <- clock.sleep(100.milliseconds)
+        c     <- cache
+        d     <- cache
+      } yield (a must_=== b) && (b must_!== c) && (c must_=== d)
+    }
+  }
+
   def testRaceAll = {
     val io  = IO.effectTotal("supercalifragilisticexpialadocious")
     val ios = List.empty[UIO[String]]

core/shared/src/main/scala/zio/ZIO.scala

@@ -147,6 +147,30 @@ sealed trait ZIO[-R, +E, +A] extends Serializable { self =>
         }
     )(use)
 
+  /**
+   * Returns an effect that, if evaluated, will return the cached result of
+   * this effect. Cached results will expire after `timeToLive` duration.
+   */
+  final def cached(timeToLive: Duration): ZIO[R with Clock, Nothing, IO[E, A]] = {
+
+    def get(cache: RefM[Option[Promise[E, A]]]): ZIO[R with Clock, E, A] =
+      cache.update {
+        case Some(p) =>
+          ZIO.succeed(Some(p))
+        case None =>
+          for {
+            p <- Promise.make[E, A]
+            _ <- self.to(p)
+            _ <- p.await.delay(timeToLive).flatMap(_ => cache.set(None)).fork
+          } yield Some(p)
+      }.flatMap(_.get.await)
+
+    for {
+      r     <- ZIO.environment[R with Clock]
+      cache <- RefM.make[Option[Promise[E, A]]](None)
+    } yield get(cache).provide(r)
+  }
+
   /**
    * Recovers from all errors.
    *