cats-effect-kernel/cats.effect.kernel/Resource$/Bind

Bind

final case class Bind[F <: ([_$40] =>> Any), S, +A](source: Resource[F, S], fs: S => Resource[F, A]) extends Resource[F, A]
Resource data constructor that encodes the flatMap operation.
trait Serializable
trait Product
trait Equals
class Resource[F, A]
class Object
trait Matchable
class Any

Value members

Inherited methods

def flatMap[B](f: A => Resource[F, B]): Resource[F, B]
Implementation for the flatMap operation, as described via the
cats.Monad type class.
Inhertied from
Resource
def useKleisliK[B >: A](F: MonadCancel[F, Throwable]): FunctionK[[_$4] =>> Kleisli[F, B, _$4], F]
Creates a FunctionK that, when applied, will allocate the resource and use it to run the given Kleisli.
Inhertied from
Resource
def mapK[G <: ([_$11] =>> Any)](f: FunctionK[F, G])(F: MonadCancel[F, ], G: MonadCancel[G, ]): Resource[G, A]
Given a natural transformation from F to G, transforms this
Resource from effect F to effect G.
The F and G constraint can also be satisfied by requiring a
MonadCancelThrow[F] and MonadCancelThrow[G] .
Inhertied from
Resource
def useForever(F: Spawn[F]): F[Nothing]
Allocates a resource with a non-terminating use action.
Useful to run programs that are expressed entirely in Resource.
The finalisers run when the resulting program fails or gets interrupted.
Inhertied from
Resource
def surroundK(F: MonadCancel[F, Throwable]): FunctionK[F, F]
Creates a FunctionK that can run gb within a resource, which is then closed once gb terminates, fails or gets interrupted
Inhertied from
Resource
def use_(F: MonadCancel[F, Throwable]): F[Unit]
Allocates a resource and closes it immediately.
Inhertied from
Resource
def evalMap[B](f: A => F[B]): Resource[F, B]
Applies an effectful transformation to the allocated resource. Like a
flatMap on F[A] while maintaining the resource context
Inhertied from
Resource
def preAllocate(precede: F[Unit]): Resource[F, A]
Runs precede before this resource is allocated.
Inhertied from
Resource
def productIterator: Iterator[Any]
Inhertied from
Product
def onFinalizeCase(f: ExitCase => F[Unit])(F: Applicative[F]): Resource[F, A]
Like onFinalize, but the action performed depends on the exit case.
Inhertied from
Resource
def use[B](f: A => F[B])(F: MonadCancel[F, Throwable]): F[B]
Allocates a resource and supplies it to the given function.
The resource is released as soon as the resulting F[B] is
completed, whether normally or as a raised error.
Value Params
f
the function to apply to the allocated resource
Returns
the result of applying [F] to
Inhertied from
Resource
def map[B](f: A => B): Resource[F, B]
Given a mapping function, transforms the resource provided by
this Resource.
This is the standard Functor.map.
Inhertied from
Resource
def onFinalize(finalizer: F[Unit])(F: Applicative[F]): Resource[F, A]
Runs finalizer when this resource is closed. Unlike the release action passed to Resource.make, this will
run even if resource acquisition fails or is canceled.
Inhertied from
Resource
def surround[B](gb: F[B])(F: MonadCancel[F, Throwable]): F[B]
Acquires the resource, runs gb and closes the resource once gb terminates, fails or gets interrupted
Inhertied from
Resource
def useKleisli[B >: A, C](usage: Kleisli[F, B, C])(F: MonadCancel[F, Throwable]): F[C]
Allocates the resource and uses it to run the given Kleisli.
Inhertied from
Resource
def parZip[B](that: Resource[F, B])(F: Concurrent[F]): Resource[F, (A, B)]
Allocates two resources concurrently, and combines their results in a tuple.
The finalizers for the two resources are also run concurrently with each other,
but within each of the two resources, nested finalizers are run in the usual
reverse order of acquisition.
Note that Resource also comes with a cats.Parallel instance
that offers more convenient access to the same functionality as
parZip, for example via parMapN:
{{{
def mkResource(name: String) = {
val acquire =
IO(scala.util.Random.nextInt(1000).millis).flatMap(IO.sleep) *>
IO(println(s"Acquiring $$name")).as(name)
val release = IO(println(s"Releasing $$name"))
Resource.make(acquire)(release)
}
val r = (mkResource("one"), mkResource("two"))
.parMapN((s1, s2) => s"I have $s1 and $s2")
.use(msg => IO(println(msg)))
}}}
Inhertied from
Resource
def evalTap[B](f: A => F[B]): Resource[F, A]
Applies an effectful transformation to the allocated resource. Like a
flatTap on F[A] while maintaining the resource context
Inhertied from
Resource
def allocated[B >: A](F: MonadCancel[F, Throwable]): F[(B, F[Unit])]
Given a Resource, possibly built by composing multiple
Resources monadically, returns the acquired resource, as well
as an action that runs all the finalizers for releasing it.
If the outer F fails or is interrupted, allocated guarantees
that the finalizers will be called. However, if the outer F
succeeds, it's up to the user to ensure the returned F[Unit]
is called once A needs to be released. If the returned
F[Unit] is not called, the finalizers will not be run.
For this reason, this is an advanced and potentially unsafe api
which can cause a resource leak if not used correctly, please
prefer use as the standard way of running a Resource
program.
Use cases include interacting with side-effectful apis that
expect separate acquire and release actions (like the before
and after methods of many test frameworks), or complex library
code that needs to modify or move the finalizer for an existing
resource.
Inhertied from
Resource
def productElementNames: Iterator[String]
Inhertied from
Product