Port caffeine module

Author: kubukoz

modules/caffeine/src/main/scala/scalacache/caffeine/CaffeineCache.scala

@@ -1,79 +1,87 @@
 package scalacache.caffeine
 
 import java.time.temporal.ChronoUnit
-import java.time.{Clock, Instant}
+import java.time.{Instant}
 
 import com.github.benmanes.caffeine.cache.{Caffeine, Cache => CCache}
-
+import cats.effect.Clock
 import scalacache.logging.Logger
-import scalacache.{AbstractCache, CacheConfig, Entry, Mode}
+import scalacache.{AbstractCache, CacheConfig, Entry}
 import scala.concurrent.duration.Duration
 import scala.language.higherKinds
+import cats.effect.Sync
+import java.util.concurrent.TimeUnit
+import cats.implicits._
+import cats.MonadError
+import cats.Defer
 
 /*
  * Thin wrapper around Caffeine.
  *
  * This cache implementation is synchronous.
  */
-class CaffeineCache[V](val underlying: CCache[String, Entry[V]])(
+class CaffeineCache[F[_], V](val underlying: CCache[String, Entry[F, V]])(
     implicit val config: CacheConfig,
-    clock: Clock = Clock.systemUTC()
-) extends AbstractCache[V] {
+    clock: Clock[F],
+    val F: Sync[F]
+) extends AbstractCache[F, V] {
+  protected implicit val Defer: Defer[F] = F
 
   override protected final val logger = Logger.getLogger(getClass.getName)
 
-  def doGet[F[_]](key: String)(implicit mode: Mode[F]): F[Option[V]] = {
-    mode.M.delay {
-      val entry = underlying.getIfPresent(key)
-      val result = {
-        if (entry == null || entry.isExpired)
-          None
-        else
-          Some(entry.value)
+  def doGet(key: String): F[Option[V]] = {
+    F.delay {
+        Option(underlying.getIfPresent(key))
+      }
+      .flatMap(_.filterA(_.isExpired))
+      .map(_.map(_.value))
+      .flatTap { result =>
+        F.delay {
+          logCacheHitOrMiss(key, result)
+        }
       }
-      logCacheHitOrMiss(key, result)
-      result
-    }
   }
 
-  def doPut[F[_]](key: String, value: V, ttl: Option[Duration])(implicit mode: Mode[F]): F[Any] = {
-    mode.M.delay {
-      val entry = Entry(value, ttl.map(toExpiryTime))
+  def doPut(key: String, value: V, ttl: Option[Duration]): F[Any] = ttl.traverse(toExpiryTime).flatMap { expiry =>
+    F.delay {
+      val entry = Entry[F, V](value, expiry)
       underlying.put(key, entry)
       logCachePut(key, ttl)
     }
   }
 
-  override def doRemove[F[_]](key: String)(implicit mode: Mode[F]): F[Any] =
-    mode.M.delay(underlying.invalidate(key))
+  override def doRemove(key: String): F[Any] =
+    F.delay(underlying.invalidate(key))
 
-  override def doRemoveAll[F[_]]()(implicit mode: Mode[F]): F[Any] =
-    mode.M.delay(underlying.invalidateAll())
+  override def doRemoveAll(): F[Any] =
+    F.delay(underlying.invalidateAll())
 
-  override def close[F[_]]()(implicit mode: Mode[F]): F[Any] = {
+  override def close: F[Any] = {
     // Nothing to do
-    mode.M.pure(())
+    F.pure(())
   }
 
-  private def toExpiryTime(ttl: Duration): Instant =
-    Instant.now(clock).plus(ttl.toMillis, ChronoUnit.MILLIS)
+  private def toExpiryTime(ttl: Duration): F[Instant] =
+    clock.monotonic(TimeUnit.MILLISECONDS).map(Instant.ofEpochMilli(_).plusMillis(ttl.toMillis))
 
 }
 
 object CaffeineCache {
 
   /**
-    * Create a new Caffeine cache
+    * Create a new Caffeine cache.
     */
-  def apply[V](implicit config: CacheConfig): CaffeineCache[V] =
-    apply(Caffeine.newBuilder().build[String, Entry[V]]())
+  def apply[F[_]: Sync: Clock, V](implicit config: CacheConfig): F[CaffeineCache[F, V]] =
+    Sync[F].delay(Caffeine.newBuilder().build[String, Entry[F, V]]()).map(apply(_))
 
   /**
     * Create a new cache utilizing the given underlying Caffeine cache.
     *
     * @param underlying a Caffeine cache
     */
-  def apply[V](underlying: CCache[String, Entry[V]])(implicit config: CacheConfig): CaffeineCache[V] =
+  def apply[F[_]: Sync: Clock, V](
+      underlying: CCache[String, Entry[F, V]]
+  )(implicit config: CacheConfig): CaffeineCache[F, V] =
     new CaffeineCache(underlying)
 
 }

modules/core/shared/src/main/scala/scalacache/Entry.scala

@@ -1,16 +1,20 @@
 package scalacache
 
-import java.time.{Clock, Instant}
+import java.time.{Instant}
+import cats.effect.Clock
+import java.util.concurrent.TimeUnit
+import cats.implicits._
+import language.higherKinds
+import cats.Functor
 
 /**
   * A cache entry with an optional expiry time
   */
-case class Entry[+A](value: A, expiresAt: Option[Instant]) {
+case class Entry[F[_], +A](value: A, expiresAt: Option[Instant]) {
 
   /**
     * Has the entry expired yet?
     */
-  def isExpired(implicit clock: Clock): Boolean =
-    expiresAt.exists(_.isBefore(Instant.now(clock)))
-
+  def isExpired(implicit clock: Clock[F], functor: Functor[F]): F[Boolean] =
+    clock.monotonic(TimeUnit.MILLISECONDS).map(Instant.ofEpochMilli(_)).map(now => expiresAt.exists(_.isBefore(now)))
 }