Adding helper function to instanciate caches within Cats Resource

modules/cats-effect/src/main/scala/scalacache/CatsEffect.scala

@@ -1,6 +1,8 @@
 package scalacache
 
-import cats.effect.{Async => CatsAsync, IO}
+import cats.Functor
+import cats.evidence.<~<
+import cats.effect.{Async => CatsAsync, IO, Resource}
 
 import scala.language.higherKinds
 import scala.util.control.NonFatal
@@ -9,13 +11,6 @@ object CatsEffect {
 
   object modes {
 
-    /**
-      * A mode that wraps computations in cats-effect IO.
-      */
-    implicit val io: Mode[IO] = new Mode[IO] {
-      val M: Async[IO] = asyncForCatsEffectAsync[IO]
-    }
-
     /**
       * A mode that wraps computations in F[_],
       * where there is an instance of cats-effect Async available for F.
@@ -48,4 +43,8 @@ object CatsEffect {
 
   }
 
+  def resourceCache[F[_]: CatsAsync: Functor: Mode, G[_], V](cacheF: F[G[V]])(
+      implicit ev: G[V] <~< Cache[V]): Resource[F, G[V]] =
+    Resource.make(cacheF)(toClose => Functor[F].map(ev(toClose).close())(_ => ()))
+
 }

modules/doc/src/main/tut/docs/modes.md

@@ -62,6 +62,20 @@ import scalacache.CatsEffect.modes._
 
 * Wraps the operation in `IO`, deferring execution until it is explicitly run
 
+Note that `CatsEffect` also has a Function `resourceCache[F[_]:Async, V](cacheF: F[Cache[V]]):Resource[F, Cache[V]]`. This resource will discard the values of `close:F[Any]` upon closing the Resource. 
+
+Usage would look like this:
+
+```tut:silent
+import scalacache._
+import scalacache.caffeine._
+import scalacache.CatsEffect.modes._
+import cats.effect.IO
+import cats.implicits._
+
+val cacheResource = CatsEffect.resourceCache( IO {CaffeineCache[String]})
+```
+
 #### Monix Task
 
 You will need a dependency on the `scalacache-monix` module:

modules/tests/src/test/scala/integrationtests/IntegrationTests.scala

@@ -91,7 +91,7 @@ class IntegrationTests extends FlatSpec with Matchers with BeforeAndAfterAll {
 
     s"$name ⇔ (cats-effect IO)" should "defer the computation and give the correct result" in {
       implicit val theCache: Cache[String] = cache
-      implicit val mode: Mode[CatsIO] = CatsEffect.modes.io
+      implicit val mode: Mode[CatsIO] = CatsEffect.modes.async[CatsIO]
 
       val key = UUID.randomUUID().toString
       val initialValue = UUID.randomUUID().toString