I have this in-memory implementation of a simple Cache in Scala using cats effects.

我在Scala中使用cats效果实现了一个简单Cache的内存实现。

Here is my trait:

这是我的特点：

trait Cache[F[_], K, V] {
  def get(key: K): F[Option[V]]
  def put(key: K, value: V): F[Cache[F, K, V]]
}

import cats.effect.kernel.Async

case class ImmutableMapCache[F[_]: Async, K, V](map: Map[K, V]) extends Cache[F, K, V] {
  override def get(key: K): F[Option[V]] =
    Async[F].blocking(map.get(key))

  override def put(key: K, value: V): F[Cache[F, K, V]] =
    Async[F].blocking(ImmutableMapCache(map.updated(key, value)))
}

object ImmutableMapCache {
  def empty[F[_]: Async, K, V]: F[Cache[F, K, V]] =
    Async[F].pure(ImmutableMapCache(Map.empty))
}

Is this a good enough implementation? I'm restricting my effect to Async. Can I make it even more generic to work with other effect types in my ImmutableMapCache?

这是一个足够好的实现吗？我将我的效果限制为异步。我可以在ImmutableMapCache中使用其他效果类型吗？

What other pitfalls are there with my approach?

我的方法还有哪些陷阱？

EDIT:

编辑：

Is this a better implementation where I wrap the Map in a Cats Ref context?

这是一个更好的实现吗？我将Map封装在Cats-Ref上下文中？

import cats.effect.{Ref, Sync}
import cats.syntax.all._

class SimpleCache[F[_]: Sync, K, V] extends Cache[F, K, V] {
  private val cache: Ref[F, Map[K, V]] = Ref.unsafe[F, Map[K, V]](Map.empty)

  override def put(key: K, value: V): F[Unit] = cache.update(_.updated(key, value))

  override def get(key: K): F[Option[V]] = cache.get.map(_.get(key))
}

First of all, the right answer is not to reinvent the wheel, and just use a library that already does all this, like mules.

首先，正确的答案不是重新发明轮子，而是使用一个已经做了这一切的库，就像骡子一样。

However, for the sake of learning, let's take a look to some of the things you could improve.

然而，为了学习，让我们来看看你可以改进的一些地方。

1. Interface. Especially put

def put(key: K, value: V): F[Cache[F, K, V]]

If putting a new value in the Cache returns a new one, it means it is immutable, if it is immutable there is no need for effects, meaning it is just a simple Map.

You want your put to mutate something; but in a concurrent-safe way. So it could actually be used to share data between different Fibers. Thus, put should be defined like this:

如果在缓存中放入一个新值会返回一个新的值，这意味着它是不可变的，如果它是不可更改的，则不需要效果，也就是说它只是一个简单的Map。你想让你的推杆变异一些东西；但是以同时安全的方式。因此，它实际上可以用于在不同的光纤之间共享数据。因此，put应该这样定义：

def put(key: K, value: V): F[Unit]

2. Creation. Since a Cache is a mutable state, its creation must be an effect as well; like your original example but unlike your attempt with Ref

def empty[F[_], K, V]: F[Cache[F, K, V]] 

3. Implementation. Your intuition was right, we want to use a mutable reference to an immutable Map. Now, in order to make it concurrent safe, we need to either look the access to it, or use a CAS loop. cats-effect provides both options: AtomicCell and Ref respectively. In this case is better to just use a CAS loop so we go with Ref

object Cache {
  def empty[F[_], K, V]: F[Cache[F, K, V]] =
    Ref[F].of(Map.empty[K, V]).map { ref =>
      new Cache[F[_], K, V] {
        override def get(key: K): F[Option[V]] =
          ref.get.map(map => map.get(key))

        override def put(key: K, value: V): F[Unit] =
          ref.update(map => map.updated(key, value))
      }
    }
}

4. The constraints, the above code needs a constraint on F to actually work. But actually, we don't need all the Async power, but rather just Concurrent, since all we need is to create a Ref :)

def empty[F[_] : Concurrent, K, V]: F[Cache[F, K, V]] = ...