Creates an always-empty implementation of cache.

The implementation *almost* always returns scala.None regardess the key. The notable exception are Cache#getOrUpdate, Cache#getOrUpdate1 and Cache#getOrUpdateOpt methods, which return the value passed to them to ensure the consistent behavior (i.e. it could be a suprise if someone calls Cache#getOrUpdateOpt with scala.Some and gets scala.None as a result).

It is meant to be used in tests, or as a stub in the code where cache should be disabled.

Creates a cache implementation, which is able remove the stale values.

The underlying storage implementation is the same as in #loading[F[_],K,V](partitions:Option[Int])*, but the expiration routines are added on top of it.

Besides a value expiration leading to specific key being removed from the cache, the implementation is capable of _refreshing_ the values instead of removing them, which might be useful if the cache is used as a wrapper for setting or configuration service. The feature is possible to configure using config parameter.

In adddition to context bounds used in #loading[F[_],K,V](partitions:Option[Int])*, this implementation also adds cats.effect.Clock (as part of cats.effect.Temporal), to have the ability to schedule cache clean up in a concurrent way.

Minimal usage example:

Cache.expiring[F, String, User](
  config = ExpiringCache.Config(expireAfterRead = 1.minute),
  partitions = None,
)

Creates Cache interface to a set of precreated caches.

This method is required to use common partitioning implementation for various caches and is not intended to be called directly. Cache partitioning itself allows splitting underlying cache into multiple partitions, so there is no contention on a single cats.effect.Ref when cache need to be updated.

It is only left public for sake of backwards compatibility.

Please consider using either #loading[F[_],K,V](partitions:Option[Int])* or #expiring instead.

Here is a short description of why some of the context bounds are required on F[_]:

• cats.MonadError is required to throw an error in case partitioning function passed as part of Partitions does not return any values.
• cats.Parallel is required for an efficient Cache#foldMapPar implementation.

Creates a cache implementation, which is able to load the missing values.

To speed the operations, the cache may use several partitions each of whom may be accessed in parallel.

Note, that the values getting into this cache never expire, i.e. the cache will grow indefinetely unless Cache#remove is called. See #expiring for the implementation, which allows automatic expriation of the values.

Here is a short description of why some of the context bounds are required on F[_]:

• cats.Parallel is required for an efficient Cache#foldMapPar implementation whenever cache partitioning is used. Cache partitioning itself allows splitting underlying cache into multiple partitions, so there is no contention on a single cats.effect.Ref when cache need to be updated.
• Runtime is used to determine optimal number of partitions based on CPU count if the value is not provided as a parameter.
• cats.effect.Sync (which comes as part of cats.effect.Concurrent), allows internal structures using cats.effect.Ref and cats.effect.Deferred to be created.
• cats.effect.Concurrent, allows release parameter in Cache#put(key:K,value:V,release:Cache* and Cache#getOrUpdate1 methods to be called in background without waiting for release to be completed.

Minimal usage example:

Cache.loading[F, String, User](partitions = None)

Creates a cache implementation, which is able to load the missing values.

Same as #loading[F[_],K,V](partitions:Option[Int])*, but without the need to use Option.

Minimal usage example:

Cache.loading[F, String, User](partitions = 8)

Creates a cache implementation, which is able to load the missing values.

Same as #loading[F[_],K,V](partitions:Int)*, but with number of paritions determined automatically using passed Runtime implementation.

Minimal usage example:

Cache.loading[F, String, User]