Hotswap

cats.effect.std.Hotswap

See theHotswap companion object

sealed trait Hotswap[F[_], R]

A concurrent data structure that exposes a linear sequence of R resources as a single cats.effect.kernel.Resource in F without accumulation.

A Hotswap is allocated within a cats.effect.kernel.Resource that dictates the scope of its lifetime. After creation, a Resource[F, R] can be swapped in by calling swap. The newly acquired resource is returned and is released either when the Hotswap is finalized or upon the next call to swap, whichever occurs first.

The following diagram illustrates the linear allocation and release of three resources r1, r2, and r3 cycled through Hotswap:

>----- swap(r1) ---- swap(r2) ---- swap(r3) ----X
|        |             |             |          |
Creation |             |             |          |
       r1 acquired    |             |          |
                     r2 acquired    |          |
                     r1 released   r3 acquired |
                                   r2 released |
                                               r3 released

Hotswap is particularly useful when working with effects that cycle through resources, like writing bytes to files or rotating files every N bytes or M seconds. Without Hotswap, such effects leak resources: on each file rotation, a file handle or some internal resource handle accumulates. With Hotswap, the only registered resource is the Hotswap itself, and each file is swapped in only after swapping the previous one out.

Ported from https://github.com/typelevel/fs2.

Attributes

Companion:: object
Source:: Hotswap.scala
Graph
Supertypes: class Object
trait Matchable
class Any

Members list

Concise view

Value members

Abstract methods

Pops and runs the finalizer of the current resource, if it exists.

Like swap, users must ensure that the old R is not used after calling clear. Calling clear after the lifetime of this Hotswap results in an error.

Attributes

Source:: Hotswap.scala

Allocates a new resource, closes the previous one if it exists, and returns the newly allocated R.

When the lifetime of the Hotswap is completed, the resource allocated by the most recent swap will be finalized.

swap finalizes the previous resource immediately, so users must ensure that the old R is not used thereafter. Failure to do so may result in an error on the consumer side. In any case, no resources will be leaked.

If swap is called after the lifetime of the Hotswap is over, it will raise an error, but will ensure that all resources are finalized before returning.

Attributes

Source:: Hotswap.scala

Generated with