Concurrent
@implicitNotFound("Could not find an instance of Concurrent for ${F}") trait Concurrent[F <: ([_$1] =>> Any)] extends Async[F]
Type class for Async data types that are cancelable and
can be started concurrently.
can be started concurrently.
Thus this type class allows abstracting over data types that:
-
implement the Async algebra, with all its restrictions
-
can provide logic for cancellation, to be used in race
conditions in order to release resources early
(in its cancelable builder)
Due to these restrictions, this type class also affords to describe
a start operation that can start async
processes, suspended in the context of
canceled or joined.
a start operation that can start async
processes, suspended in the context of
F[_]
and that can becanceled or joined.
Without cancellation being baked in, we couldn't afford to do it.
See below.
See below.
==Cancelable builder==
The signature exposed by the cancelable
builder is this:
builder is this:
{{{
(Either[Throwable, A] => Unit) => CancelToken[F]
}}}
(Either[Throwable, A] => Unit) => CancelToken[F]
}}}
CancelToken[F] is just an alias for
used to represent a cancellation action which will send a signal
to the producer, that may observe it and cancel the asynchronous
process.
F[Unit]
andused to represent a cancellation action which will send a signal
to the producer, that may observe it and cancel the asynchronous
process.
==On Cancellation==
Simple asynchronous processes, like Scala's
described with this very basic and side-effectful type and you
should recognize what is more or less the signature of
handling):
Future
, can bedescribed with this very basic and side-effectful type and you
should recognize what is more or less the signature of
Future#onComplete
or of Async.async (minus the errorhandling):
{{{
(A => Unit) => Unit
}}}
(A => Unit) => Unit
}}}
But many times the abstractions built to deal with asynchronous
tasks can also provide a way to cancel such processes, to be used
in race conditions in order to cleanup resources early, so a very
basic and side-effectful definition of asynchronous processes that
can be canceled would be:
tasks can also provide a way to cancel such processes, to be used
in race conditions in order to cleanup resources early, so a very
basic and side-effectful definition of asynchronous processes that
can be canceled would be:
{{{
(A => Unit) => CancelToken
}}}
(A => Unit) => CancelToken
}}}
This is approximately the signature of JavaScript's
which will return a "task ID" that can be used to cancel it. Or of
Java's
Java
setTimeout
,which will return a "task ID" that can be used to cancel it. Or of
Java's
ScheduledExecutorService#schedule
, which will return aJava
ScheduledFuture
that has a .cancel()
operation on it.Similarly, for
cancellation logic that can be triggered in race conditions to
cancel the on-going processing, only that
cancelation token is an action suspended in an
Concurrent
data types, we can providecancellation logic that can be triggered in race conditions to
cancel the on-going processing, only that
Concurrent
'scancelation token is an action suspended in an
F[Unit]
.Suppose you want to describe a "sleep" operation, like that described
by Timer to mirror Java's
or JavaScript's
by Timer to mirror Java's
ScheduledExecutorService.schedule
or JavaScript's
setTimeout
:{{{
def sleep(d: FiniteDuration): F[Unit]
}}}
def sleep(d: FiniteDuration): F[Unit]
}}}
This signature is in fact incomplete for data types that are not
cancelable, because such equivalent operations always return some
cancellation token that can be used to trigger a forceful
interruption of the timer. This is not a normal "dispose" or
"finally" clause in a try/catch block, because "cancel" in the
context of an asynchronous process is ''concurrent'' with the
task's own run-loop.
cancelable, because such equivalent operations always return some
cancellation token that can be used to trigger a forceful
interruption of the timer. This is not a normal "dispose" or
"finally" clause in a try/catch block, because "cancel" in the
context of an asynchronous process is ''concurrent'' with the
task's own run-loop.
To understand what this means, consider that in the case of our
signal to the underlying
remove the scheduled
scheduled tasks, ''before'' its execution. Therefore, without a
cancelable data type, a safe signature needs to return a
cancellation token, so it would look like this:
sleep
as described above, on cancellation we'd need a way tosignal to the underlying
ScheduledExecutorService
to forcefullyremove the scheduled
Runnable
from its internal queue ofscheduled tasks, ''before'' its execution. Therefore, without a
cancelable data type, a safe signature needs to return a
cancellation token, so it would look like this:
{{{
def sleep(d: FiniteDuration): F[(F[Unit] , F[Unit] )]
}}}
def sleep(d: FiniteDuration): F[(F[Unit] , F[Unit] )]
}}}
This function is returning a tuple, with one
the completion of our sleep and a second
scheduled computation in case we need it. This is in fact the shape
of Fiber's API. And this is exactly what the
start operation returns.
F[Unit]
to wait forthe completion of our sleep and a second
F[Unit]
to cancel thescheduled computation in case we need it. This is in fact the shape
of Fiber's API. And this is exactly what the
start operation returns.
The difference between a Concurrent data type and one that
is only Async is that you can go from any
canceled should the need arise, in order to trigger an early
release of allocated resources.
is only Async is that you can go from any
F[A]
to aF[Fiber[F, A]]
, to participate in race conditions and that can becanceled should the need arise, in order to trigger an early
release of allocated resources.
Thus a Concurrent data type can safely participate in race
conditions, whereas a data type that is only Async cannot do it
without exposing and forcing the user to work with cancellation
tokens. An Async data type cannot expose for example a
operation that is safe.
conditions, whereas a data type that is only Async cannot do it
without exposing and forcing the user to work with cancellation
tokens. An Async data type cannot expose for example a
start
operation that is safe.
== Resource-safety ==
Concurrent data types are required to cooperate with Bracket.
corresponding
that in the case of bracketCase the
ExitCase.Canceled branch will get executed on cancelation.
Concurrent
being cancelable by law, what this means for thecorresponding
Bracket
is that cancelation can be observed andthat in the case of bracketCase the
ExitCase.Canceled branch will get executed on cancelation.
By default the
and from asyncF, so what this means is that
whatever you can express with
with
cancelable
builder is derived from bracketCase
and from asyncF, so what this means is that
whatever you can express with
cancelable
, you can also expresswith
bracketCase
.For uncancelable, the cancel
signal has no effect on the result of join and
the cancelable token returned by ConcurrentEffect.runCancelable
on evaluation will have no effect if evaluated.
signal has no effect on the result of join and
the cancelable token returned by ConcurrentEffect.runCancelable
on evaluation will have no effect if evaluated.
{{{
F.uncancelable(F.cancelable { cb => f(cb); token }) <-> F.async(f)
}}}
F.uncancelable(F.cancelable { cb => f(cb); token }) <-> F.async(f)
}}}
Sample:
{{{
val F = Concurrent[IO]
val timer = Timer[IO]
val F = Concurrent[IO]
val timer = Timer[IO]
// Normally Timer#sleep yields cancelable tasks
val tick = F.uncancelable(timer.sleep(10.seconds))
val tick = F.uncancelable(timer.sleep(10.seconds))
// This prints "Tick!" after 10 seconds, even if we are
// canceling the Fiber after start:
for {
fiber <- F.start(tick)
_ <- fiber.cancel
_ <- fiber.join
_ <- F.delay { println("Tick!") }
} yield ()
}}}
// canceling the Fiber after start:
for {
fiber <- F.start(tick)
_ <- fiber.cancel
_ <- fiber.join
_ <- F.delay { println("Tick!") }
} yield ()
}}}
When doing bracket or bracketCase,
acquire
and release
operations are guaranteed to be uncancelable as well.- Companion
- object
Document{}
def tuple9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8)]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def map21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap6[A0, A1, A2, A3, A4, A5, Z](f: F[(A0, A1, A2, A3, A4, A5) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def map20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[(A0, A1, A2, A3, A4, A5)]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[(A0, A1, A2, A3)]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def map6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5])(f: (A0, A1, A2, A3, A4, A5) => Z): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def map14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2]): F[(A0, A1, A2)]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def map7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => Z): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def map4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3])(f: (A0, A1, A2, A3) => Z): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap5[A0, A1, A2, A3, A4, Z](f: F[(A0, A1, A2, A3, A4) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[(A0, A1, A2, A3, A4, A5, A6)]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def map3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2])(f: (A0, A1, A2) => Z): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def map13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def map15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap3[A0, A1, A2, Z](f: F[(A0, A1, A2) => Z])(f0: F[A0], f1: F[A1], f2: F[A2]): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def map5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4])(f: (A0, A1, A2, A3, A4) => Z): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap4[A0, A1, A2, A3, Z](f: F[(A0, A1, A2, A3) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def map12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[(A0, A1, A2, A3, A4)]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def map22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def map11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def map18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def map19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def map8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def map9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[(A0, A1, A2, A3, A4, A5, A6, A7)]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def map10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap7[A0, A1, A2, A3, A4, A5, A6, Z](f: F[(A0, A1, A2, A3, A4, A5, A6) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def map16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def map17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z): F[Z]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8)]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def map21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap6[A0, A1, A2, A3, A4, A5, Z](f: F[(A0, A1, A2, A3, A4, A5) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def map20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[(A0, A1, A2, A3, A4, A5)]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[(A0, A1, A2, A3)]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def map6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5])(f: (A0, A1, A2, A3, A4, A5) => Z): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def map14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2]): F[(A0, A1, A2)]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def map7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => Z): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def map4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3])(f: (A0, A1, A2, A3) => Z): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap5[A0, A1, A2, A3, A4, Z](f: F[(A0, A1, A2, A3, A4) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[(A0, A1, A2, A3, A4, A5, A6)]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def map3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2])(f: (A0, A1, A2) => Z): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def map13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def map15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap3[A0, A1, A2, Z](f: F[(A0, A1, A2) => Z])(f0: F[A0], f1: F[A1], f2: F[A2]): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def map5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4])(f: (A0, A1, A2, A3, A4) => Z): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap4[A0, A1, A2, A3, Z](f: F[(A0, A1, A2, A3) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def map12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[(A0, A1, A2, A3, A4)]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def map22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def map11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def map18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def map19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def map8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def map9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[(A0, A1, A2, A3, A4, A5, A6, A7)]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def map10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def ap7[A0, A1, A2, A3, A4, A5, A6, Z](f: F[(A0, A1, A2, A3, A4, A5, A6) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def map16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def map17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z): F[Z]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8)]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def map21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def ap6[A0, A1, A2, A3, A4, A5, Z](f: F[(A0, A1, A2, A3, A4, A5) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def map20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def ap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[(A0, A1, A2, A3, A4, A5)]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def ap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[(A0, A1, A2, A3)]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def map6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5])(f: (A0, A1, A2, A3, A4, A5) => Z): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def map14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2]): F[(A0, A1, A2)]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def map7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => Z): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def map4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3])(f: (A0, A1, A2, A3) => Z): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def ap5[A0, A1, A2, A3, A4, Z](f: F[(A0, A1, A2, A3, A4) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def ap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[(A0, A1, A2, A3, A4, A5, A6)]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def ap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def ap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def ap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def ap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def ap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def ap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def ap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def map3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2])(f: (A0, A1, A2) => Z): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def map13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def map15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def ap3[A0, A1, A2, Z](f: F[(A0, A1, A2) => Z])(f0: F[A0], f1: F[A1], f2: F[A2]): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def map5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4])(f: (A0, A1, A2, A3, A4) => Z): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def ap4[A0, A1, A2, A3, Z](f: F[(A0, A1, A2, A3) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def map12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def ap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[(A0, A1, A2, A3, A4)]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def map22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def map11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def ap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def map18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def map19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def map8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def ap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def ap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def map9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[(A0, A1, A2, A3, A4, A5, A6, A7)]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def ap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def map10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def ap7[A0, A1, A2, A3, A4, A5, A6, Z](f: F[(A0, A1, A2, A3, A4, A5, A6) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def map16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def map17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z): F[Z]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
def tuple9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8)]
- Inhertied from
- ApplyArityFunctions
def tuple19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]
- Inhertied from
- ApplyArityFunctions
def map21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap6[A0, A1, A2, A3, A4, A5, Z](f: F[(A0, A1, A2, A3, A4, A5) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[Z]
- Inhertied from
- ApplyArityFunctions
def map20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[(A0, A1, A2, A3, A4, A5)]
- Inhertied from
- ApplyArityFunctions
def ap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[(A0, A1, A2, A3)]
- Inhertied from
- ApplyArityFunctions
def map6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5])(f: (A0, A1, A2, A3, A4, A5) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]
- Inhertied from
- ApplyArityFunctions
def map14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2]): F[(A0, A1, A2)]
- Inhertied from
- ApplyArityFunctions
def map7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def map4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3])(f: (A0, A1, A2, A3) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap5[A0, A1, A2, A3, A4, Z](f: F[(A0, A1, A2, A3, A4) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]
- Inhertied from
- ApplyArityFunctions
def tuple7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[(A0, A1, A2, A3, A4, A5, A6)]
- Inhertied from
- ApplyArityFunctions
def ap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]
- Inhertied from
- ApplyArityFunctions
def ap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]
- Inhertied from
- ApplyArityFunctions
def tuple21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]
- Inhertied from
- ApplyArityFunctions
def ap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[Z]
- Inhertied from
- ApplyArityFunctions
def map3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2])(f: (A0, A1, A2) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)]
- Inhertied from
- ApplyArityFunctions
def tuple17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]
- Inhertied from
- ApplyArityFunctions
def map13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]
- Inhertied from
- ApplyArityFunctions
def tuple22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)]
- Inhertied from
- ApplyArityFunctions
def map15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap3[A0, A1, A2, Z](f: F[(A0, A1, A2) => Z])(f0: F[A0], f1: F[A1], f2: F[A2]): F[Z]
- Inhertied from
- ApplyArityFunctions
def map5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4])(f: (A0, A1, A2, A3, A4) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap4[A0, A1, A2, A3, Z](f: F[(A0, A1, A2, A3) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[Z]
- Inhertied from
- ApplyArityFunctions
def map12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[(A0, A1, A2, A3, A4)]
- Inhertied from
- ApplyArityFunctions
def map22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def map11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[Z]
- Inhertied from
- ApplyArityFunctions
def map18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def map19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def map8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]
- Inhertied from
- ApplyArityFunctions
def tuple14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]
- Inhertied from
- ApplyArityFunctions
def ap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[Z]
- Inhertied from
- ApplyArityFunctions
def map9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[(A0, A1, A2, A3, A4, A5, A6, A7)]
- Inhertied from
- ApplyArityFunctions
def ap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[Z]
- Inhertied from
- ApplyArityFunctions
def map10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def ap7[A0, A1, A2, A3, A4, A5, A6, Z](f: F[(A0, A1, A2, A3, A4, A5, A6) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[Z]
- Inhertied from
- ApplyArityFunctions
def map16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def map17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z): F[Z]
- Inhertied from
- ApplyArityFunctions
def tuple13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]
- Inhertied from
- ApplyArityFunctions
Value members
Methods
Implicitly added by catsEitherTConcurrent
Start concurrent execution of the source suspended in
the
the
F
context.Returns a Fiber that can be used to either join or cancel
the running computation, being similar in spirit (but not
in implementation) to starting a thread.
the running computation, being similar in spirit (but not
in implementation) to starting a thread.
- See also
- background for a safer alternative.
Implicitly added by catsEitherTConcurrent
Returns a resource that will start execution of the effect in the background.
In case the resource is closed while the effect is still running (e.g. due to a failure in
the background action will be canceled.
use
),the background action will be canceled.
A basic example with IO:
{{{
val longProcess = (IO.sleep(5.seconds) *> IO(println("Ping!"))).foreverM
val longProcess = (IO.sleep(5.seconds) *> IO(println("Ping!"))).foreverM
val srv: Resource[IO, ServerBinding[IO]
] = for {
_ <- longProcess.background
server <- server.run
} yield server
_ <- longProcess.background
server <- server.run
} yield server
val application = srv.use(binding => IO(println("Bound to " + binding)) *> IO.never)
}}}
}}}
Here, we are starting a background process as part of the application's startup.
Afterwards, we initialize a server. Then, we use that server forever using
This will ensure we never close the server resource unless somebody cancels the whole
Afterwards, we initialize a server. Then, we use that server forever using
IO.never
.This will ensure we never close the server resource unless somebody cancels the whole
application
action.If at some point of using the resource you want to wait for the result of the background action,
you can do so by sequencing the value inside the resource (it's equivalent to
you can do so by sequencing the value inside the resource (it's equivalent to
join
on Fiber
).This will start the background process, run another action, and wait for the result of the background process:
{{{
longProcess.background.use(await => anotherProcess *> await)
}}}
longProcess.background.use(await => anotherProcess *> await)
}}}
In case the result of such an action is canceled, both processes will receive cancelation signals.
The same result can be achieved by using
The same result can be achieved by using
anotherProcess &> longProcess
with the Parallel type class syntax.Implicitly added by catsEitherTConcurrent
Run two tasks concurrently, creating a race between them and returns a
pair containing both the winner's successful value and the loser
represented as a still-unfinished fiber.
pair containing both the winner's successful value and the loser
represented as a still-unfinished fiber.
If the first task completes in error, then the result will
complete in error, the other task being canceled.
complete in error, the other task being canceled.
On usage the user has the option of canceling the losing task,
this being equivalent with plain race:
this being equivalent with plain race:
{{{
val ioA: IO[A] = ???
val ioB: IO[B] = ???
val ioA: IO[A] = ???
val ioB: IO[B] = ???
Concurrent[IO]
.racePair(ioA, ioB).flatMap {
case Left((a, fiberB)) =>
fiberB.cancel.map(_ => a)
case Right((fiberA, b)) =>
fiberA.cancel.map(_ => b)
}
}}}
case Left((a, fiberB)) =>
fiberB.cancel.map(_ => a)
case Right((fiberA, b)) =>
fiberA.cancel.map(_ => b)
}
}}}
See race for a simpler version that cancels the loser
immediately.
immediately.
Implicitly added by catsEitherTConcurrent
Run two tasks concurrently and return the first to finish,
either in success or error. The loser of the race is canceled.
either in success or error. The loser of the race is canceled.
The two tasks are potentially executed in parallel, the winner
being the first that signals a result.
being the first that signals a result.
As an example see Concurrent.timeoutTo
Also see racePair for a version that does not cancel
the loser automatically on successful results.
the loser automatically on successful results.
Implicitly added by catsEitherTConcurrent
Creates a cancelable
asynchronous process on evaluation.
F[A]
instance that executes anasynchronous process on evaluation.
This builder accepts a registration function that is
being injected with a side-effectful callback, to be called
when the asynchronous process is complete with a final result.
being injected with a side-effectful callback, to be called
when the asynchronous process is complete with a final result.
The registration function is also supposed to return
a CancelToken, which is nothing more than an
alias for
canceling the asynchronous process for as long as it
is still active.
a CancelToken, which is nothing more than an
alias for
F[Unit]
, capturing the logic necessary forcanceling the asynchronous process for as long as it
is still active.
Example:
{{{
import java.util.concurrent.ScheduledExecutorService
import scala.concurrent.duration._
import java.util.concurrent.ScheduledExecutorService
import scala.concurrent.duration._
def sleep[F[_]
](d: FiniteDuration)
(implicit F: Concurrent[F] , ec: ScheduledExecutorService): F[Unit] = {
(implicit F: Concurrent[F] , ec: ScheduledExecutorService): F[Unit] = {
F.cancelable { cb =>
// Schedules task to run after delay
val run = new Runnable { def run() = cb(Right(())) }
val future = ec.schedule(run, d.length, d.unit)
// Schedules task to run after delay
val run = new Runnable { def run() = cb(Right(())) }
val future = ec.schedule(run, d.length, d.unit)
// Cancellation logic, suspended in F
F.delay(future.cancel(true))
}
}
}}}
}
}}}
Implicitly added by catsEitherTConcurrent
If no interruption happens during the execution of this method,
it behaves like
it behaves like
.attempt.flatMap
.Unlike
interruption this method offers the continual guarantee:
effects of
This does not hold for
happen in between
.attempt.flatMap
however, in the presence ofinterruption this method offers the continual guarantee:
fa
is interruptible, but if it completes execution, theeffects of
f
are guaranteed to execute.This does not hold for
attempt.flatMap
since interruption canhappen in between
flatMap
steps.The typical use case for this function arises in the
implementation of concurrent abstractions, where you have
asynchronous operations waiting on some condition (which have to
be interruptible), mixed with operations that modify some shared
state if the condition holds true (which need to be guaranteed
to happen or the state will be inconsistent).
implementation of concurrent abstractions, where you have
asynchronous operations waiting on some condition (which have to
be interruptible), mixed with operations that modify some shared
state if the condition holds true (which need to be guaranteed
to happen or the state will be inconsistent).
Note that for the use case above:
- We cannot use:
{{{
waitingOp.bracket(..., modifyOp)
}}}
because it makes
- We cannot use:
{{{
waitingOp.bracket(..., modifyOp)
}}}
because it makes
waitingOp
uninterruptible.-
We cannot use
{{{
waitingOp.guaranteeCase {
case Success => modifyOp(???)
...
}}}
if we need to use the result ofwaitingOp
. -
We cannot use
{{{
waitingOp.attempt.flatMap(modifyOp)
}}}
because it could be interrupted afterwaitingOp
is done, but
beforemodifyOp
executes.
To access this implementation as a standalone function, you can
use Concurrent.continual in the
companion object.
use Concurrent.continual in the
companion object.
Implicitly added by catsOptionTConcurrent
Start concurrent execution of the source suspended in
the
the
F
context.Returns a Fiber that can be used to either join or cancel
the running computation, being similar in spirit (but not
in implementation) to starting a thread.
the running computation, being similar in spirit (but not
in implementation) to starting a thread.
- See also
- background for a safer alternative.
Implicitly added by catsOptionTConcurrent
Returns a resource that will start execution of the effect in the background.
In case the resource is closed while the effect is still running (e.g. due to a failure in
the background action will be canceled.
use
),the background action will be canceled.
A basic example with IO:
{{{
val longProcess = (IO.sleep(5.seconds) *> IO(println("Ping!"))).foreverM
val longProcess = (IO.sleep(5.seconds) *> IO(println("Ping!"))).foreverM
val srv: Resource[IO, ServerBinding[IO]
] = for {
_ <- longProcess.background
server <- server.run
} yield server
_ <- longProcess.background
server <- server.run
} yield server
val application = srv.use(binding => IO(println("Bound to " + binding)) *> IO.never)
}}}
}}}
Here, we are starting a background process as part of the application's startup.
Afterwards, we initialize a server. Then, we use that server forever using
This will ensure we never close the server resource unless somebody cancels the whole
Afterwards, we initialize a server. Then, we use that server forever using
IO.never
.This will ensure we never close the server resource unless somebody cancels the whole
application
action.If at some point of using the resource you want to wait for the result of the background action,
you can do so by sequencing the value inside the resource (it's equivalent to
you can do so by sequencing the value inside the resource (it's equivalent to
join
on Fiber
).This will start the background process, run another action, and wait for the result of the background process:
{{{
longProcess.background.use(await => anotherProcess *> await)
}}}
longProcess.background.use(await => anotherProcess *> await)
}}}
In case the result of such an action is canceled, both processes will receive cancelation signals.
The same result can be achieved by using
The same result can be achieved by using
anotherProcess &> longProcess
with the Parallel type class syntax.Implicitly added by catsOptionTConcurrent
Run two tasks concurrently, creating a race between them and returns a
pair containing both the winner's successful value and the loser
represented as a still-unfinished fiber.
pair containing both the winner's successful value and the loser
represented as a still-unfinished fiber.
If the first task completes in error, then the result will
complete in error, the other task being canceled.
complete in error, the other task being canceled.
On usage the user has the option of canceling the losing task,
this being equivalent with plain race:
this being equivalent with plain race:
{{{
val ioA: IO[A] = ???
val ioB: IO[B] = ???
val ioA: IO[A] = ???
val ioB: IO[B] = ???
Concurrent[IO]
.racePair(ioA, ioB).flatMap {
case Left((a, fiberB)) =>
fiberB.cancel.map(_ => a)
case Right((fiberA, b)) =>
fiberA.cancel.map(_ => b)
}
}}}
case Left((a, fiberB)) =>
fiberB.cancel.map(_ => a)
case Right((fiberA, b)) =>
fiberA.cancel.map(_ => b)
}
}}}
See race for a simpler version that cancels the loser
immediately.
immediately.
Implicitly added by catsOptionTConcurrent
Run two tasks concurrently and return the first to finish,
either in success or error. The loser of the race is canceled.
either in success or error. The loser of the race is canceled.
The two tasks are potentially executed in parallel, the winner
being the first that signals a result.
being the first that signals a result.
As an example see Concurrent.timeoutTo
Also see racePair for a version that does not cancel
the loser automatically on successful results.
the loser automatically on successful results.
Implicitly added by catsOptionTConcurrent
Creates a cancelable
asynchronous process on evaluation.
F[A]
instance that executes anasynchronous process on evaluation.
This builder accepts a registration function that is
being injected with a side-effectful callback, to be called
when the asynchronous process is complete with a final result.
being injected with a side-effectful callback, to be called
when the asynchronous process is complete with a final result.
The registration function is also supposed to return
a CancelToken, which is nothing more than an
alias for
canceling the asynchronous process for as long as it
is still active.
a CancelToken, which is nothing more than an
alias for
F[Unit]
, capturing the logic necessary forcanceling the asynchronous process for as long as it
is still active.
Example:
{{{
import java.util.concurrent.ScheduledExecutorService
import scala.concurrent.duration._
import java.util.concurrent.ScheduledExecutorService
import scala.concurrent.duration._
def sleep[F[_]
](d: FiniteDuration)
(implicit F: Concurrent[F] , ec: ScheduledExecutorService): F[Unit] = {
(implicit F: Concurrent[F] , ec: ScheduledExecutorService): F[Unit] = {
F.cancelable { cb =>
// Schedules task to run after delay
val run = new Runnable { def run() = cb(Right(())) }
val future = ec.schedule(run, d.length, d.unit)
// Schedules task to run after delay
val run = new Runnable { def run() = cb(Right(())) }
val future = ec.schedule(run, d.length, d.unit)
// Cancellation logic, suspended in F
F.delay(future.cancel(true))
}
}
}}}
}
}}}
Implicitly added by catsOptionTConcurrent
If no interruption happens during the execution of this method,
it behaves like
it behaves like
.attempt.flatMap
.Unlike
interruption this method offers the continual guarantee:
effects of
This does not hold for
happen in between
.attempt.flatMap
however, in the presence ofinterruption this method offers the continual guarantee:
fa
is interruptible, but if it completes execution, theeffects of
f
are guaranteed to execute.This does not hold for
attempt.flatMap
since interruption canhappen in between
flatMap
steps.The typical use case for this function arises in the
implementation of concurrent abstractions, where you have
asynchronous operations waiting on some condition (which have to
be interruptible), mixed with operations that modify some shared
state if the condition holds true (which need to be guaranteed
to happen or the state will be inconsistent).
implementation of concurrent abstractions, where you have
asynchronous operations waiting on some condition (which have to
be interruptible), mixed with operations that modify some shared
state if the condition holds true (which need to be guaranteed
to happen or the state will be inconsistent).
Note that for the use case above:
- We cannot use:
{{{
waitingOp.bracket(..., modifyOp)
}}}
because it makes
- We cannot use:
{{{
waitingOp.bracket(..., modifyOp)
}}}
because it makes
waitingOp
uninterruptible.-
We cannot use
{{{
waitingOp.guaranteeCase {
case Success => modifyOp(???)
...
}}}
if we need to use the result ofwaitingOp
. -
We cannot use
{{{
waitingOp.attempt.flatMap(modifyOp)
}}}
because it could be interrupted afterwaitingOp
is done, but
beforemodifyOp
executes.
To access this implementation as a standalone function, you can
use Concurrent.continual in the
companion object.
use Concurrent.continual in the
companion object.
Implicitly added by catsKleisliConcurrent
Start concurrent execution of the source suspended in
the
the
F
context.Returns a Fiber that can be used to either join or cancel
the running computation, being similar in spirit (but not
in implementation) to starting a thread.
the running computation, being similar in spirit (but not
in implementation) to starting a thread.
- See also
- background for a safer alternative.
Implicitly added by catsKleisliConcurrent
Returns a resource that will start execution of the effect in the background.
In case the resource is closed while the effect is still running (e.g. due to a failure in
the background action will be canceled.
use
),the background action will be canceled.
A basic example with IO:
{{{
val longProcess = (IO.sleep(5.seconds) *> IO(println("Ping!"))).foreverM
val longProcess = (IO.sleep(5.seconds) *> IO(println("Ping!"))).foreverM
val srv: Resource[IO, ServerBinding[IO]
] = for {
_ <- longProcess.background
server <- server.run
} yield server
_ <- longProcess.background
server <- server.run
} yield server
val application = srv.use(binding => IO(println("Bound to " + binding)) *> IO.never)
}}}
}}}
Here, we are starting a background process as part of the application's startup.
Afterwards, we initialize a server. Then, we use that server forever using
This will ensure we never close the server resource unless somebody cancels the whole
Afterwards, we initialize a server. Then, we use that server forever using
IO.never
.This will ensure we never close the server resource unless somebody cancels the whole
application
action.If at some point of using the resource you want to wait for the result of the background action,
you can do so by sequencing the value inside the resource (it's equivalent to
you can do so by sequencing the value inside the resource (it's equivalent to
join
on Fiber
).This will start the background process, run another action, and wait for the result of the background process:
{{{
longProcess.background.use(await => anotherProcess *> await)
}}}
longProcess.background.use(await => anotherProcess *> await)
}}}
In case the result of such an action is canceled, both processes will receive cancelation signals.
The same result can be achieved by using
The same result can be achieved by using
anotherProcess &> longProcess
with the Parallel type class syntax.Implicitly added by catsKleisliConcurrent
Run two tasks concurrently, creating a race between them and returns a
pair containing both the winner's successful value and the loser
represented as a still-unfinished fiber.
pair containing both the winner's successful value and the loser
represented as a still-unfinished fiber.
If the first task completes in error, then the result will
complete in error, the other task being canceled.
complete in error, the other task being canceled.
On usage the user has the option of canceling the losing task,
this being equivalent with plain race:
this being equivalent with plain race:
{{{
val ioA: IO[A] = ???
val ioB: IO[B] = ???
val ioA: IO[A] = ???
val ioB: IO[B] = ???
Concurrent[IO]
.racePair(ioA, ioB).flatMap {
case Left((a, fiberB)) =>
fiberB.cancel.map(_ => a)
case Right((fiberA, b)) =>
fiberA.cancel.map(_ => b)
}
}}}
case Left((a, fiberB)) =>
fiberB.cancel.map(_ => a)
case Right((fiberA, b)) =>
fiberA.cancel.map(_ => b)
}
}}}
See race for a simpler version that cancels the loser
immediately.
immediately.
Implicitly added by catsKleisliConcurrent
Run two tasks concurrently and return the first to finish,
either in success or error. The loser of the race is canceled.
either in success or error. The loser of the race is canceled.
The two tasks are potentially executed in parallel, the winner
being the first that signals a result.
being the first that signals a result.
As an example see Concurrent.timeoutTo
Also see racePair for a version that does not cancel
the loser automatically on successful results.
the loser automatically on successful results.
Implicitly added by catsKleisliConcurrent
Creates a cancelable
asynchronous process on evaluation.
F[A]
instance that executes anasynchronous process on evaluation.
This builder accepts a registration function that is
being injected with a side-effectful callback, to be called
when the asynchronous process is complete with a final result.
being injected with a side-effectful callback, to be called
when the asynchronous process is complete with a final result.
The registration function is also supposed to return
a CancelToken, which is nothing more than an
alias for
canceling the asynchronous process for as long as it
is still active.
a CancelToken, which is nothing more than an
alias for
F[Unit]
, capturing the logic necessary forcanceling the asynchronous process for as long as it
is still active.
Example:
{{{
import java.util.concurrent.ScheduledExecutorService
import scala.concurrent.duration._
import java.util.concurrent.ScheduledExecutorService
import scala.concurrent.duration._
def sleep[F[_]
](d: FiniteDuration)
(implicit F: Concurrent[F] , ec: ScheduledExecutorService): F[Unit] = {
(implicit F: Concurrent[F] , ec: ScheduledExecutorService): F[Unit] = {
F.cancelable { cb =>
// Schedules task to run after delay
val run = new Runnable { def run() = cb(Right(())) }
val future = ec.schedule(run, d.length, d.unit)
// Schedules task to run after delay
val run = new Runnable { def run() = cb(Right(())) }
val future = ec.schedule(run, d.length, d.unit)
// Cancellation logic, suspended in F
F.delay(future.cancel(true))
}
}
}}}
}
}}}
Implicitly added by catsKleisliConcurrent
If no interruption happens during the execution of this method,
it behaves like
it behaves like
.attempt.flatMap
.Unlike
interruption this method offers the continual guarantee:
effects of
This does not hold for
happen in between
.attempt.flatMap
however, in the presence ofinterruption this method offers the continual guarantee:
fa
is interruptible, but if it completes execution, theeffects of
f
are guaranteed to execute.This does not hold for
attempt.flatMap
since interruption canhappen in between
flatMap
steps.The typical use case for this function arises in the
implementation of concurrent abstractions, where you have
asynchronous operations waiting on some condition (which have to
be interruptible), mixed with operations that modify some shared
state if the condition holds true (which need to be guaranteed
to happen or the state will be inconsistent).
implementation of concurrent abstractions, where you have
asynchronous operations waiting on some condition (which have to
be interruptible), mixed with operations that modify some shared
state if the condition holds true (which need to be guaranteed
to happen or the state will be inconsistent).
Note that for the use case above:
- We cannot use:
{{{
waitingOp.bracket(..., modifyOp)
}}}
because it makes
- We cannot use:
{{{
waitingOp.bracket(..., modifyOp)
}}}
because it makes
waitingOp
uninterruptible.-
We cannot use
{{{
waitingOp.guaranteeCase {
case Success => modifyOp(???)
...
}}}
if we need to use the result ofwaitingOp
. -
We cannot use
{{{
waitingOp.attempt.flatMap(modifyOp)
}}}
because it could be interrupted afterwaitingOp
is done, but
beforemodifyOp
executes.
To access this implementation as a standalone function, you can
use Concurrent.continual in the
companion object.
use Concurrent.continual in the
companion object.
Start concurrent execution of the source suspended in
the
the
F
context.Returns a Fiber that can be used to either join or cancel
the running computation, being similar in spirit (but not
in implementation) to starting a thread.
the running computation, being similar in spirit (but not
in implementation) to starting a thread.
- See also
- background for a safer alternative.
Returns a resource that will start execution of the effect in the background.
In case the resource is closed while the effect is still running (e.g. due to a failure in
the background action will be canceled.
use
),the background action will be canceled.
A basic example with IO:
{{{
val longProcess = (IO.sleep(5.seconds) *> IO(println("Ping!"))).foreverM
val longProcess = (IO.sleep(5.seconds) *> IO(println("Ping!"))).foreverM
val srv: Resource[IO, ServerBinding[IO]
] = for {
_ <- longProcess.background
server <- server.run
} yield server
_ <- longProcess.background
server <- server.run
} yield server
val application = srv.use(binding => IO(println("Bound to " + binding)) *> IO.never)
}}}
}}}
Here, we are starting a background process as part of the application's startup.
Afterwards, we initialize a server. Then, we use that server forever using
This will ensure we never close the server resource unless somebody cancels the whole
Afterwards, we initialize a server. Then, we use that server forever using
IO.never
.This will ensure we never close the server resource unless somebody cancels the whole
application
action.If at some point of using the resource you want to wait for the result of the background action,
you can do so by sequencing the value inside the resource (it's equivalent to
you can do so by sequencing the value inside the resource (it's equivalent to
join
on Fiber
).This will start the background process, run another action, and wait for the result of the background process:
{{{
longProcess.background.use(await => anotherProcess *> await)
}}}
longProcess.background.use(await => anotherProcess *> await)
}}}
In case the result of such an action is canceled, both processes will receive cancelation signals.
The same result can be achieved by using
The same result can be achieved by using
anotherProcess &> longProcess
with the Parallel type class syntax.Run two tasks concurrently, creating a race between them and returns a
pair containing both the winner's successful value and the loser
represented as a still-unfinished fiber.
pair containing both the winner's successful value and the loser
represented as a still-unfinished fiber.
If the first task completes in error, then the result will
complete in error, the other task being canceled.
complete in error, the other task being canceled.
On usage the user has the option of canceling the losing task,
this being equivalent with plain race:
this being equivalent with plain race:
{{{
val ioA: IO[A] = ???
val ioB: IO[B] = ???
val ioA: IO[A] = ???
val ioB: IO[B] = ???
Concurrent[IO]
.racePair(ioA, ioB).flatMap {
case Left((a, fiberB)) =>
fiberB.cancel.map(_ => a)
case Right((fiberA, b)) =>
fiberA.cancel.map(_ => b)
}
}}}
case Left((a, fiberB)) =>
fiberB.cancel.map(_ => a)
case Right((fiberA, b)) =>
fiberA.cancel.map(_ => b)
}
}}}
See race for a simpler version that cancels the loser
immediately.
immediately.
Run two tasks concurrently and return the first to finish,
either in success or error. The loser of the race is canceled.
either in success or error. The loser of the race is canceled.
The two tasks are potentially executed in parallel, the winner
being the first that signals a result.
being the first that signals a result.
As an example see Concurrent.timeoutTo
Also see racePair for a version that does not cancel
the loser automatically on successful results.
the loser automatically on successful results.
Creates a cancelable
asynchronous process on evaluation.
F[A]
instance that executes anasynchronous process on evaluation.
This builder accepts a registration function that is
being injected with a side-effectful callback, to be called
when the asynchronous process is complete with a final result.
being injected with a side-effectful callback, to be called
when the asynchronous process is complete with a final result.
The registration function is also supposed to return
a CancelToken, which is nothing more than an
alias for
canceling the asynchronous process for as long as it
is still active.
a CancelToken, which is nothing more than an
alias for
F[Unit]
, capturing the logic necessary forcanceling the asynchronous process for as long as it
is still active.
Example:
{{{
import java.util.concurrent.ScheduledExecutorService
import scala.concurrent.duration._
import java.util.concurrent.ScheduledExecutorService
import scala.concurrent.duration._
def sleep[F[_]
](d: FiniteDuration)
(implicit F: Concurrent[F] , ec: ScheduledExecutorService): F[Unit] = {
(implicit F: Concurrent[F] , ec: ScheduledExecutorService): F[Unit] = {
F.cancelable { cb =>
// Schedules task to run after delay
val run = new Runnable { def run() = cb(Right(())) }
val future = ec.schedule(run, d.length, d.unit)
// Schedules task to run after delay
val run = new Runnable { def run() = cb(Right(())) }
val future = ec.schedule(run, d.length, d.unit)
// Cancellation logic, suspended in F
F.delay(future.cancel(true))
}
}
}}}
}
}}}
N.B. expressing this conversion in terms of
its capabilities means that the resulting
case the source
Concurrent
andits capabilities means that the resulting
F
is cancelable incase the source
IO
is.To access this implementation as a standalone function, you can
use Concurrent.liftIO
(on the object companion).
use Concurrent.liftIO
(on the object companion).
- Definition Classes
If no interruption happens during the execution of this method,
it behaves like
it behaves like
.attempt.flatMap
.Unlike
interruption this method offers the continual guarantee:
effects of
This does not hold for
happen in between
.attempt.flatMap
however, in the presence ofinterruption this method offers the continual guarantee:
fa
is interruptible, but if it completes execution, theeffects of
f
are guaranteed to execute.This does not hold for
attempt.flatMap
since interruption canhappen in between
flatMap
steps.The typical use case for this function arises in the
implementation of concurrent abstractions, where you have
asynchronous operations waiting on some condition (which have to
be interruptible), mixed with operations that modify some shared
state if the condition holds true (which need to be guaranteed
to happen or the state will be inconsistent).
implementation of concurrent abstractions, where you have
asynchronous operations waiting on some condition (which have to
be interruptible), mixed with operations that modify some shared
state if the condition holds true (which need to be guaranteed
to happen or the state will be inconsistent).
Note that for the use case above:
- We cannot use:
{{{
waitingOp.bracket(..., modifyOp)
}}}
because it makes
- We cannot use:
{{{
waitingOp.bracket(..., modifyOp)
}}}
because it makes
waitingOp
uninterruptible.-
We cannot use
{{{
waitingOp.guaranteeCase {
case Success => modifyOp(???)
...
}}}
if we need to use the result ofwaitingOp
. -
We cannot use
{{{
waitingOp.attempt.flatMap(modifyOp)
}}}
because it could be interrupted afterwaitingOp
is done, but
beforemodifyOp
executes.
To access this implementation as a standalone function, you can
use Concurrent.continual in the
companion object.
use Concurrent.continual in the
companion object.
Inherited methods
def fromEither[A](x: Either[E, A]): F[A]
Implicitly added by catsEitherTConcurrent
Convert from scala.Either
Example:
{{{
scala> import cats.ApplicativeError
scala> import cats.instances.option._
{{{
scala> import cats.ApplicativeError
scala> import cats.instances.option._
scala> ApplicativeError[Option, Unit]
.fromEither(Right(1))
res0: scala.Option[Int] = Some(1)
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit]
.fromEither(Left(()))
res1: scala.Option[Nothing] = None
}}}
res1: scala.Option[Nothing] = None
}}}
- Inhertied from
- ApplicativeError
def unlessA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by catsEitherTConcurrent
Returns the given argument (mapped to Unit) if
otherwise, unit lifted into F.
cond
is false
,otherwise, unit lifted into F.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[List]
.unlessA(true)(List(1, 2, 3))
res0: List[Unit] = List(())
res0: List[Unit] = List(())
scala> Applicative[List]
.unlessA(false)(List(1, 2, 3))
res1: List[Unit] = List((), (), ())
res1: List[Unit] = List((), (), ())
scala> Applicative[List]
.unlessA(true)(List.empty[Int]
)
res2: List[Unit] = List(())
res2: List[Unit] = List(())
scala> Applicative[List]
.unlessA(false)(List.empty[Int]
)
res3: List[Unit] = List()
}}}
res3: List[Unit] = List()
}}}
- Inhertied from
- Applicative
@noop
def unzip[A, B](fab: F[(A, B)]): (F[A], F[B])
Implicitly added by catsEitherTConcurrent
Un-zips an
F[(A, B)]
consisting of element pairs or Tuple2 into two separate F's tupled.NOTE: Check for effect duplication, possibly memoize before
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.unzip(List((1,2), (3, 4)))
res0: (List[Int] , List[Int] ) = (List(1, 3),List(2, 4))
}}}
res0: (List[Int] , List[Int] ) = (List(1, 3),List(2, 4))
}}}
- Inhertied from
- Functor
def fix[A](fn: F[A] => F[A]): F[A]
Implicitly added by catsEitherTConcurrent
Defer instances, like functions, parsers, generators, IO, etc...
often are used in recursive settings where this function is useful
often are used in recursive settings where this function is useful
fix(fn) == fn(fix(fn))
example:
val parser: P[Int]
=
Defer[P] .fix[Int] { rec =>
CharsIn("0123456789") | P("(") ~ rec ~ P(")")
}
Defer[P] .fix[Int] { rec =>
CharsIn("0123456789") | P("(") ~ rec ~ P(")")
}
Note, fn may not yield a terminating value in which case both
of the above F[A] run forever.
of the above F[A] run forever.
- Inhertied from
- Defer
def recover[A](fa: F[A])(pf: PartialFunction[E, A]): F[A]
Implicitly added by catsEitherTConcurrent
Recover from certain errors by mapping them to an
A
value.- See also
- handleError to handle any/all errors.recoverWith to recover from certain errors by mapping them to
F[A]
values. - Inhertied from
- ApplicativeError
def iterateUntilM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by catsEitherTConcurrent
Apply a monadic function iteratively until its result satisfies
the given predicate and return that result.
the given predicate and return that result.
- Inhertied from
- Monad
def as[A, B](fa: F[A], b: B): F[B]
Implicitly added by catsEitherTConcurrent
Replaces the
A
value in F[A]
with the supplied value.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.as(List(1,2,3), "hello")
res0: List[String] = List(hello, hello, hello)
}}}
res0: List[String] = List(hello, hello, hello)
}}}
- Inhertied from
- Functor
def redeemWith[A, B](fa: F[A])(recover: E => F[B], bind: A => F[B]): F[B]
Implicitly added by catsEitherTConcurrent
Returns a new value that transforms the result of the source,
given the
on whether the result is successful or if it ends in error.
given the
recover
or bind
functions, which get executed dependingon whether the result is successful or if it ends in error.
{{{
fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))
}}}
fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))
}}}
Usage of
redeemWith
subsumes handleErrorWith because:{{{
fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)
}}}
fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)
}}}
Usage of
redeemWith
also subsumes flatMap because:{{{
fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)
}}}
fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)
}}}
Implementations are free to override it in order to optimize
error recovery.
error recovery.
- Value Params
- bind
-
is the function that gets to transform the source
in case of success - fa
-
is the source whose result is going to get transformed
- recover
-
is the function that gets called to recover the source
in case of error
- See also
- Inhertied from
- MonadError
def tupleLeft[A, B](fa: F[A], b: B): F[(B, A)]
Implicitly added by catsEitherTConcurrent
Tuples the
A
value in F[A]
with the supplied B
value, with the B
value on the left.Example:
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue]
.tupleLeft(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
}}}
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
}}}
- Inhertied from
- Functor
def composeApply[G <: ([_$2] =>> Any)](evidence$1: Apply[G]): InvariantSemigroupal[[α] =>> F[G[α]]]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- InvariantSemigroupal
@noop
def untilDefinedM[A](foa: F[Option[A]]): F[A]
Implicitly added by catsEitherTConcurrent
This repeats an F until we get defined values. This can be useful
for polling type operations on State (or RNG) Monads, or in effect
monads.
for polling type operations on State (or RNG) Monads, or in effect
monads.
- Inhertied from
- FlatMap
def iterateWhile[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by catsEitherTConcurrent
Execute an action repeatedly until its result fails to satisfy the given predicate
and return that result, discarding all others.
and return that result, discarding all others.
- Inhertied from
- Monad
@inline
final def <*[A, B](fa: F[A])(fb: F[B]): F[A]
Implicitly added by catsEitherTConcurrent
Alias for productL.
- Inhertied from
- Apply
@noop
def ifA[A](fcond: F[Boolean])(ifTrue: F[A], ifFalse: F[A]): F[A]
Implicitly added by catsEitherTConcurrent
An
This function combines the effects of the
in the order in which they are given.
if-then-else
lifted into the F
context.This function combines the effects of the
fcond
condition and of the two branches,in the order in which they are given.
The value of the result is, depending on the value of the condition,
the value of the first argument, or the value of the second argument.
the value of the first argument, or the value of the second argument.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val b1: Option[Boolean]
= Some(true)
scala> val asInt1: Option[Int] = Apply[Option] .ifA(b1)(Some(1), Some(0))
scala> asInt1.get
res0: Int = 1
scala> val asInt1: Option[Int] = Apply[Option] .ifA(b1)(Some(1), Some(0))
scala> asInt1.get
res0: Int = 1
scala> val b2: Option[Boolean]
= Some(false)
scala> val asInt2: Option[Int] = Apply[Option] .ifA(b2)(Some(1), Some(0))
scala> asInt2.get
res1: Int = 0
scala> val asInt2: Option[Int] = Apply[Option] .ifA(b2)(Some(1), Some(0))
scala> asInt2.get
res1: Int = 0
scala> val b3: Option[Boolean]
= Some(true)
scala> val asInt3: Option[Int] = Apply[Option] .ifA(b3)(Some(1), None)
asInt2: Option[Int] = None
scala> val asInt3: Option[Int] = Apply[Option] .ifA(b3)(Some(1), None)
asInt2: Option[Int] = None
}}}
- Inhertied from
- Apply
def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- FlatMap
@noop
def ifElseM[A](branches: (F[Boolean], F[A])*)(els: F[A]): F[A]
Implicitly added by catsEitherTConcurrent
Simulates an if/else-if/else in the context of an F. It evaluates conditions until
one evaluates to true, and returns the associated F[A] . If no condition is true,
returns els.
one evaluates to true, and returns the associated F[A] . If no condition is true,
returns els.
{{{
scala> import cats._
scala> Monad[Eval] .ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2
}}}
scala> import cats._
scala> Monad[Eval] .ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2
}}}
- See also
- See https://gitter.im/typelevel/cats-effect?at=5f297e4314c413356f56d230 for the discussion.
- Inhertied from
- Monad
Implicitly added by catsEitherTConcurrent
Returns a non-terminating
with a result, being equivalent to
F[_]
, that never completeswith a result, being equivalent to
async(_ => ())
- Inhertied from
- Async
def pure[A](x: A): F[A]
Implicitly added by catsEitherTConcurrent
pure
lifts any value into the Applicative Functor.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[Option]
.pure(10)
res0: Option[Int] = Some(10)
}}}
res0: Option[Int] = Some(10)
}}}
- Inhertied from
- Applicative
def point[A](a: A): F[A]
Implicitly added by catsEitherTConcurrent
point
lifts any value into a Monoidal Functor.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> InvariantMonoidal[Option]
.point(10)
res0: Option[Int] = Some(10)
}}}
res0: Option[Int] = Some(10)
}}}
- Inhertied from
- InvariantMonoidal
def compose[G <: ([_$2] =>> Any)](evidence$1: Applicative[G]): Applicative[[α] =>> F[G[α]]]
Implicitly added by catsEitherTConcurrent
Compose an
Applicative[F]
and an Applicative[G]
into anApplicative[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val alo = Applicative[List]
.compose[Option]
scala> alo.pure(3)
res0: List[Option[Int] ] = List(Some(3))
res0: List[Option[Int] ] = List(Some(3))
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
- Inhertied from
- Applicative
def compose[G <: ([_$2] =>> Any)](evidence$1: Invariant[G]): Invariant[[α] =>> F[G[α]]]
Implicitly added by catsEitherTConcurrent
Compose Invariant
F[_]
and G[_]
then produce Invariant[F[G[_]]]
using their imap
.Example:
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]
] =
| Invariant[Semigroup] .compose[List] .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
| Invariant[Semigroup] .compose[List] .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
- Inhertied from
- Invariant
def compose[G <: ([_$3] =>> Any)](evidence$1: Apply[G]): Apply[[α] =>> F[G[α]]]
Implicitly added by catsEitherTConcurrent
Compose an
Apply[F]
and an Apply[G]
into an Apply[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val alo = Apply[List]
.compose[Option]
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
- Inhertied from
- Apply
def compose[G <: ([_$6] =>> Any)](evidence$1: Functor[G]): Functor[[α] =>> F[G[α]]]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- Functor
def ensure[A](fa: F[A])(error: => E)(predicate: A => Boolean): F[A]
Implicitly added by catsEitherTConcurrent
Turns a successful value into an error if it does not satisfy a given predicate.
- Inhertied from
- MonadError
def widen[A, B >: A](fa: F[A]): F[B]
Implicitly added by catsEitherTConcurrent
Lifts natural subtyping covariance of covariant Functors.
NOTE: In certain (perhaps contrived) situations that rely on universal
equality this can result in a
implemented as a type cast. It could be implemented as
according to the functor laws, that should be equal to
cast is often much more performant.
See this example
of
equality this can result in a
ClassCastException
, because it isimplemented as a type cast. It could be implemented as
map(identity)
, butaccording to the functor laws, that should be equal to
fa
, and a typecast is often much more performant.
See this example
of
widen
creating a ClassCastException
.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val s = Some(42)
scala> Functor[Option] .widen(s)
res0: Option[Int] = Some(42)
}}}
scala> Functor[Option] .widen(s)
res0: Option[Int] = Some(42)
}}}
- Inhertied from
- Functor
@noop
def foreverM[A, B](fa: F[A]): F[B]
Implicitly added by catsEitherTConcurrent
Like an infinite loop of >> calls. This is most useful effect loops
that you want to run forever in for instance a server.
that you want to run forever in for instance a server.
This will be an infinite loop, or it will return an F[Nothing]
.
Be careful using this.
For instance, a List of length k will produce a list of length k^n at iteration
n. This means if k = 0, we return an empty list, if k = 1, we loop forever
allocating single element lists, but if we have a k > 1, we will allocate
exponentially increasing memory and very quickly OOM.
For instance, a List of length k will produce a list of length k^n at iteration
n. This means if k = 0, we return an empty list, if k = 1, we loop forever
allocating single element lists, but if we have a k > 1, we will allocate
exponentially increasing memory and very quickly OOM.
- Inhertied from
- FlatMap
Implicitly added by catsEitherTConcurrent
Creates a simple, non-cancelable
executes an asynchronous process on evaluation.
F[A]
instance thatexecutes an asynchronous process on evaluation.
The given function is being injected with a side-effectful
callback for signaling the final result of an asynchronous
process. And its returned result needs to be a pure
that gets evaluated by the runtime.
callback for signaling the final result of an asynchronous
process. And its returned result needs to be a pure
F[Unit]
that gets evaluated by the runtime.
Note the simpler async variant async can be derived like this:
{{{
F.async(k) <-> F.asyncF(cb => F.delay(k(cb)))
}}}
F.async(k) <-> F.asyncF(cb => F.delay(k(cb)))
}}}
For wrapping impure APIs usually you can use the simpler async,
however
wrapped with the help of pure abstractions, such as
Ref.
however
asyncF
is useful in cases where impure APIs arewrapped with the help of pure abstractions, such as
Ref.
For example here's how a simple, "pure Promise" implementation
could be implemented via
as you have a far better
Deferred available):
could be implemented via
Ref
(sample is for didactic purposes,as you have a far better
Deferred available):
{{{
import cats.effect.concurrent.Ref
import cats.effect.concurrent.Ref
type Callback[-A]
= Either[Throwable, A]
=> Unit
class PurePromise[F[_]
, A](ref: Ref[F, Either[List[Callback[A]
], A]])
(implicit F: Async[F] ) {
(implicit F: Async[F] ) {
def get: F[A]
= F.asyncF { cb =>
ref.modify {
case current @ Right(result) =>
(current, F.delay(cb(Right(result))))
case Left(list) =>
(Left(cb :: list), F.unit)
}
}
ref.modify {
case current @ Right(result) =>
(current, F.delay(cb(Right(result))))
case Left(list) =>
(Left(cb :: list), F.unit)
}
}
def complete(value: A): F[Unit]
=
F.flatten(ref.modify {
case Left(list) =>
(Right(value), F.delay(list.foreach(_(Right(value)))))
case right =>
(right, F.unit)
})
}
}}}
F.flatten(ref.modify {
case Left(list) =>
(Right(value), F.delay(list.foreach(_(Right(value)))))
case right =>
(right, F.unit)
})
}
}}}
N.B. if
Concurrent), then the returned
its evaluation hooking into the underlying cancelation mechanism
of
F[_]
is a cancelable data type (i.e. implementingConcurrent), then the returned
F[Unit]
can be cancelable,its evaluation hooking into the underlying cancelation mechanism
of
F[_]
, so something like this behaves like you'd expect:{{{
def delayed[F[_] , A](thunk: => A)
(implicit F: Async[F] , timer: Timer[F] ): F[A] = {
def delayed[F[_] , A](thunk: => A)
(implicit F: Async[F] , timer: Timer[F] ): F[A] = {
timer.sleep(1.second) *> F.delay(cb(
try cb(Right(thunk))
catch { case NonFatal(e) => Left(cb(Left(e))) }
))
}
}}}
try cb(Right(thunk))
catch { case NonFatal(e) => Left(cb(Left(e))) }
))
}
}}}
The
that the result has to be signaled via the provided callback.
asyncF
operation behaves like Sync.suspend, exceptthat the result has to be signaled via the provided callback.
==ERROR HANDLING==
As a matter of contract the returned
throw errors. If it does, then the behavior is undefined.
F[Unit]
should notthrow errors. If it does, then the behavior is undefined.
This is because by contract the provided callback should
only be called once. Calling it concurrently, multiple times,
is a contract violation. And if the returned
then the implementation might have called it already, so it
would be a contract violation to call it without expensive
synchronization.
only be called once. Calling it concurrently, multiple times,
is a contract violation. And if the returned
F[Unit]
throws,then the implementation might have called it already, so it
would be a contract violation to call it without expensive
synchronization.
In case errors are thrown the behavior is implementation specific.
The error might get logged to stderr, or via other mechanisms
that are implementations specific.
The error might get logged to stderr, or via other mechanisms
that are implementations specific.
Implicitly added by catsEitherTConcurrent
Lifts any by-name parameter into the
F
context.Equivalent to
the purpose of this function is to suspend side effects
in
Applicative.pure
for pure expressions,the purpose of this function is to suspend side effects
in
F
.- Inhertied from
- Sync
def catchNonFatalEval[A](a: Eval[A])(ev: Throwable <:< E): F[A]
Implicitly added by catsEitherTConcurrent
Often E is Throwable. Here we try to call pure or catch
and raise
and raise
- Inhertied from
- ApplicativeError
Implicitly added by catsEitherTConcurrent
- Value Params
- acquire
-
is an action that "acquires" some expensive
resource, that needs to be used and then discarded - release
-
is the action that's supposed to release the
allocated resource afteruse
is done, by observing
and acting on its exit condition. Throwing inside
this function leads to undefined behavior since it's
left to the implementation. - use
-
is the action that uses the newly allocated
resource and that will provide the final result
- Inhertied from
- Bracket
@noop
def ifF[A](fb: F[Boolean])(ifTrue: => A, ifFalse: => A): F[A]
Implicitly added by catsEitherTConcurrent
Lifts
if
to FunctorExample:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.ifF(List(true, false, false))(1, 0)
res0: List[Int] = List(1, 0, 0)
}}}
res0: List[Int] = List(1, 0, 0)
}}}
- Inhertied from
- Functor
def replicateA[A](n: Int, fa: F[A]): F[List[A]]
Implicitly added by catsEitherTConcurrent
Given
fa
and n
, apply fa
n
times to construct an F[List[A]]
value.Example:
{{{
scala> import cats.data.State
{{{
scala> import cats.data.State
scala> type Counter[A]
= State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int] ] =
| Applicative[Counter] .replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int] ) = (5,List(0, 1, 2, 3, 4))
}}}
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int] ] =
| Applicative[Counter] .replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int] ) = (5,List(0, 1, 2, 3, 4))
}}}
- Inhertied from
- Applicative
def rethrow[A, EE <: E](fa: F[Either[EE, A]]): F[A]
Implicitly added by catsEitherTConcurrent
Inverse of
attempt
Example:
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success}
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success}
scala> val a: Try[Either[Throwable, Int]
] = Success(Left(new java.lang.Exception))
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Either[Throwable, Int]
] = Success(Right(1))
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
}}}
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
}}}
- Inhertied from
- MonadError
def raiseError[A](e: E): F[A]
Implicitly added by catsEitherTConcurrent
Lift an error into the
F
context.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
// integer-rounded division
scala> def divide[F[_] ](dividend: Int, divisor: Int)(implicit F: ApplicativeError[F, String] ): F[Int] =
| if (divisor === 0) F.raiseError("division by zero")
| else F.pure(dividend / divisor)
scala> def divide[F[_] ](dividend: Int, divisor: Int)(implicit F: ApplicativeError[F, String] ): F[Int] =
| if (divisor === 0) F.raiseError("division by zero")
| else F.pure(dividend / divisor)
scala> type ErrorOr[A]
= Either[String, A]
scala> divide[ErrorOr]
(6, 3)
res0: ErrorOr[Int] = Right(2)
res0: ErrorOr[Int] = Right(2)
scala> divide[ErrorOr]
(6, 0)
res1: ErrorOr[Int] = Left(division by zero)
}}}
res1: ErrorOr[Int] = Left(division by zero)
}}}
- Inhertied from
- ApplicativeError
def lift[A, B](f: A => B): F[A] => F[B]
Implicitly added by catsEitherTConcurrent
Lift a function f to operate on Functors
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val o = Option(42)
scala> Functor[Option] .lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
}}}
scala> Functor[Option] .lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
}}}
- Inhertied from
- Functor
def mproduct[A, B](fa: F[A])(f: A => F[B]): F[(A, B)]
Implicitly added by catsEitherTConcurrent
Pair
A
with the result of function application.Example:
{{{
scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
}}}
{{{
scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
}}}
- Inhertied from
- FlatMap
def whenA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by catsEitherTConcurrent
Returns the given argument (mapped to Unit) if
unit lifted into F.
cond
is true
, otherwise,unit lifted into F.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[List]
.whenA(true)(List(1, 2, 3))
res0: List[Unit] = List((), (), ())
res0: List[Unit] = List((), (), ())
scala> Applicative[List]
.whenA(false)(List(1, 2, 3))
res1: List[Unit] = List(())
res1: List[Unit] = List(())
scala> Applicative[List]
.whenA(true)(List.empty[Int]
)
res2: List[Unit] = List()
res2: List[Unit] = List()
scala> Applicative[List]
.whenA(false)(List.empty[Int]
)
res3: List[Unit] = List(())
}}}
res3: List[Unit] = List(())
}}}
- Inhertied from
- Applicative
def fromValidated[A](x: Validated[E, A]): F[A]
Implicitly added by catsEitherTConcurrent
Convert from cats.data.Validated
Example:
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> ApplicativeError[Option, Unit]
.fromValidated(1.valid[Unit]
)
res0: scala.Option[Int] = Some(1)
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit]
.fromValidated(().invalid[Int]
)
res1: scala.Option[Int] = None
}}}
res1: scala.Option[Int] = None
}}}
- Inhertied from
- ApplicativeError
def composeFunctor[G <: ([_$3] =>> Any)](evidence$2: Functor[G]): Invariant[[α] =>> F[G[α]]]
Implicitly added by catsEitherTConcurrent
Compose Invariant
using F's
F[_]
and Functor G[_]
then produce Invariant[F[G[_]]]
using F's
imap
and G's map
.Example:
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]
] =
| Invariant[Semigroup]
| .composeFunctor[List]
| .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
| Invariant[Semigroup]
| .composeFunctor[List]
| .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
- Inhertied from
- Invariant
def composeContravariantMonoidal[G <: ([_$3] =>> Any)](evidence$2: ContravariantMonoidal[G]): ContravariantMonoidal[[α] =>> F[G[α]]]
Implicitly added by catsEitherTConcurrent
Compose an
Applicative[F]
and a ContravariantMonoidal[G]
into aContravariantMonoidal[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.kernel.Comparison
scala> import cats.implicits._
{{{
scala> import cats.kernel.Comparison
scala> import cats.implicits._
// compares strings by alphabetical order
scala> val alpha: Order[String] = Order[String]
scala> val alpha: Order[String] = Order[String]
// compares strings by their length
scala> val strLength: Order[String] = Order.byString, Int
scala> val strLength: Order[String] = Order.byString, Int
scala> val stringOrders: List[Order[String]
] = List(alpha, strLength)
// first comparison is with alpha order, second is with string length
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)
scala> val le = Applicative[List]
.composeContravariantMonoidal[Order]
// create Int orders that convert ints to strings and then use the string orders
scala> val intOrders: List[Order[Int] ] = le.contramap(stringOrders)(_.toString)
scala> val intOrders: List[Order[Int] ] = le.contramap(stringOrders)(_.toString)
// first comparison is with alpha order, second is with string length
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)
// create the
//
// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)] ] = le.product(stringOrders, intOrders)
product
of the string order list and the int order list//
p
contains a list of the following orders:// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)] ] = le.product(stringOrders, intOrders)
scala> p.map(o => o.comparison(("abc", 12), ("def", 3)))
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
}}}
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
}}}
- Inhertied from
- Applicative
final def fmap[A, B](fa: F[A])(f: A => B): F[B]
Implicitly added by catsEitherTConcurrent
Alias for map, since map can't be injected as syntax if
the implementing type already had a built-in
the implementing type already had a built-in
.map
method.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val m: Map[Int, String]
= Map(1 -> "hi", 2 -> "there", 3 -> "you")
scala> m.fmap(_ ++ "!")
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
}}}
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
}}}
- Inhertied from
- Functor
def fromOption[A](oa: Option[A], ifEmpty: => E): F[A]
Implicitly added by catsEitherTConcurrent
Convert from scala.Option
Example:
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *] , String]
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *] , String]
scala> F.fromOption(Some(1), "Empty")
res0: scala.Either[String, Int] = Right(1)
res0: scala.Either[String, Int] = Right(1)
scala> F.fromOption(Option.empty[Int]
, "Empty")
res1: scala.Either[String, Int] = Left(Empty)
}}}
res1: scala.Either[String, Int] = Left(Empty)
}}}
- Inhertied from
- ApplicativeError
def tuple2[A, B](f1: F[A], f2: F[B]): F[(A, B)]
Implicitly added by catsEitherTConcurrent
- Inhertied from
- ApplyArityFunctions
@deprecated("use defer", "2.4.0")
Implicitly added by catsEitherTConcurrent
Suspends the evaluation of an
F
reference.Equivalent to
the purpose of this function is to suspend side effects
in
FlatMap.flatten
for pure expressions,the purpose of this function is to suspend side effects
in
F
.- Inhertied from
- Sync
def catchNonFatal[A](a: => A)(ev: Throwable <:< E): F[A]
Implicitly added by catsEitherTConcurrent
Often E is Throwable. Here we try to call pure or catch
and raise.
and raise.
- Inhertied from
- ApplicativeError
def handleError[A](fa: F[A])(f: E => A): F[A]
Implicitly added by catsEitherTConcurrent
Handle any error, by mapping it to an
A
value.- See also
- handleErrorWith to map to an
F[A]
value instead of simply anA
value.recover to only recover from certain errors. - Inhertied from
- ApplicativeError
def fromTry[A](t: Try[A])(ev: Throwable <:< E): F[A]
Implicitly added by catsEitherTConcurrent
If the error type is Throwable, we can convert from a scala.util.Try
- Inhertied from
- ApplicativeError
def tailRecM[A, B](a: A)(f: A => F[Either[A, B]]): F[B]
Implicitly added by catsEitherTConcurrent
Keeps calling
f
until a scala.util.Right[B]
is returned.Based on Phil Freeman's
Stack Safety for Free.
Stack Safety for Free.
Implementations of this method should use constant stack space relative to
f
.- Inhertied from
- FlatMap
Implicitly added by catsEitherTConcurrent
Executes the given
either in success or in error, or if canceled, allowing
for differentiating between exit conditions.
finalizer
when the source is finished,either in success or in error, or if canceled, allowing
for differentiating between exit conditions.
This variant of guarantee injects an ExitCase in
the provided function, allowing one to make a difference
between:
the provided function, allowing one to make a difference
between:
-
normal completion
-
completion in error
-
cancelation
This equivalence always holds:
{{{
F.guaranteeCase(fa)(f) <-> F.bracketCase(F.unit)(_ => fa)((_, e) => f(e))
}}}
F.guaranteeCase(fa)(f) <-> F.bracketCase(F.unit)(_ => fa)((_, e) => f(e))
}}}
As best practice, it's not a good idea to release resources
via
for the acquisition and release of resources.
via
guaranteeCase
in polymorphic code. Prefer bracketCasefor the acquisition and release of resources.
- See also
- guarantee for the simpler versionbracketCase for the more general operation
- Inhertied from
- Bracket
def untilM_[A](f: F[A])(cond: => F[Boolean]): F[Unit]
Implicitly added by catsEitherTConcurrent
Execute an action repeatedly until the
The condition is evaluated after the loop body. Discards results.
Boolean
condition returns true
.The condition is evaluated after the loop body. Discards results.
- Inhertied from
- Monad
def fproductLeft[A, B](fa: F[A])(f: A => B): F[(B, A)]
Implicitly added by catsEitherTConcurrent
Pair the result of function application with
A
.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option]
.fproductLeft(Option(42))(_.toString)
res0: Option[(String, Int)] = Some((42,42))
}}}
res0: Option[(String, Int)] = Some((42,42))
}}}
- Inhertied from
- Functor
@noop
def iterateForeverM[A, B](a: A)(f: A => F[A]): F[B]
Implicitly added by catsEitherTConcurrent
iterateForeverM is almost exclusively useful for effect types. For instance,
A may be some state, we may take the current state, run some effect to get
a new state and repeat.
A may be some state, we may take the current state, run some effect to get
a new state and repeat.
- Inhertied from
- FlatMap
def recoverWith[A](fa: F[A])(pf: PartialFunction[E, F[A]]): F[A]
Implicitly added by catsEitherTConcurrent
Recover from certain errors by mapping them to an
F[A]
value.- See also
- handleErrorWith to handle any/all errors.recover to recover from certain errors by mapping them to
A
values. - Inhertied from
- ApplicativeError
def iterateWhileM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by catsEitherTConcurrent
Apply a monadic function iteratively until its result fails
to satisfy the given predicate and return that result.
to satisfy the given predicate and return that result.
- Inhertied from
- Monad
@noop
def whileM_[A](p: F[Boolean])(body: => F[A]): F[Unit]
Implicitly added by catsEitherTConcurrent
Execute an action repeatedly as long as the given
returns
Discards results.
Boolean
expressionreturns
true
. The condition is evaluated before the loop body.Discards results.
- Inhertied from
- Monad
def map2Eval[A, B, Z](fa: F[A], fb: Eval[F[B]])(f: (A, B) => Z): Eval[F[Z]]
Implicitly added by catsEitherTConcurrent
Similar to map2 but uses Eval to allow for laziness in the
argument. This can allow for "short-circuiting" of computations.
F[B]
argument. This can allow for "short-circuiting" of computations.
NOTE: the default implementation of
computations. For data structures that can benefit from laziness, Apply
instances should override this method.
map2Eval
does not short-circuitcomputations. For data structures that can benefit from laziness, Apply
instances should override this method.
In the following example,
but
result of
that the result of
x.map2(bomb)(_ + _)
would result in an error,but
map2Eval
"short-circuits" the computation. x
is None
and thus theresult of
bomb
doesn't even need to be evaluated in order to determinethat the result of
map2Eval
should be None
.{{{
scala> import cats.{Eval, Later}
scala> import cats.implicits._
scala> val bomb: Eval[Option[Int] ] = Later(sys.error("boom"))
scala> val x: Option[Int] = None
scala> x.map2Eval(bomb)(_ + _).value
res0: Option[Int] = None
}}}
scala> import cats.{Eval, Later}
scala> import cats.implicits._
scala> val bomb: Eval[Option[Int] ] = Later(sys.error("boom"))
scala> val x: Option[Int] = None
scala> x.map2Eval(bomb)(_ + _).value
res0: Option[Int] = None
}}}
- Inhertied from
- Apply
def flatTap[A, B](fa: F[A])(f: A => F[B]): F[A]
Implicitly added by catsEitherTConcurrent
Apply a monadic function and discard the result while keeping the effect.
{{{
scala> import cats., implicits.
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> ListInt.flatTap(nCats)
res2: List[Int] = List()
scala> ListInt.flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
}}}
scala> import cats., implicits.
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> ListInt.flatTap(nCats)
res2: List[Int] = List()
scala> ListInt.flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
}}}
- Inhertied from
- FlatMap
def productREval[A, B](fa: F[A])(fb: Eval[F[B]]): F[B]
Implicitly added by catsEitherTConcurrent
Sequentially compose two actions, discarding any value produced by the first. This variant of
productR also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
productR also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
}}}
scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
}}}
- Inhertied from
- FlatMap
def flatten[A](ffa: F[F[A]]): F[A]
Implicitly added by catsEitherTConcurrent
"flatten" a nested
F
of F
structure into a single-layer F
structure.This is also commonly called
join
.Example:
{{{
scala> import cats.Eval
scala> import cats.implicits._
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> val nested: Eval[Eval[Int]
] = Eval.now(Eval.now(3))
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3
}}}
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3
}}}
- Inhertied from
- FlatMap
def catchOnly[T >: Null <: Throwable]: CatchOnlyPartiallyApplied[T, F, E]
Implicitly added by catsEitherTConcurrent
Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.
- Inhertied from
- ApplicativeError
def tupleRight[A, B](fa: F[A], b: B): F[(A, B)]
Implicitly added by catsEitherTConcurrent
Tuples the
A
value in F[A]
with the supplied B
value, with the B
value on the right.Example:
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue]
.tupleRight(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
}}}
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
}}}
- Inhertied from
- Functor
Implicitly added by catsEitherTConcurrent
Operation meant for ensuring a given task continues execution even
when interrupted.
when interrupted.
- Inhertied from
- Bracket
Implicitly added by catsEitherTConcurrent
Executes the given
finalizer
when the source is canceled.The typical use case for this function arises in the
implementation of concurrent abstractions, which generally
consist of operations that perform asynchronous waiting after
concurrently modifying some state: in case the user asks for
cancelation, we want to interrupt the waiting operation, and
restore the state to its previous value.
implementation of concurrent abstractions, which generally
consist of operations that perform asynchronous waiting after
concurrently modifying some state: in case the user asks for
cancelation, we want to interrupt the waiting operation, and
restore the state to its previous value.
{{{
waitingOp.onCancel(restoreState)
}}}
waitingOp.onCancel(restoreState)
}}}
A direct use of
would make the waiting action uncancelable.
bracket
is not a good fit for this case as itwould make the waiting action uncancelable.
NOTE: This function handles interruption only, you need to take
care of the success and error case elsewhere in your code
care of the success and error case elsewhere in your code
- See also
- guaranteeCase for the version that can discriminate
between termination conditionsbracket for the more general operationConcurrent.continual when you have a use case similar to
the cancel/restore example above, but require access to the
result ofF[A]
- Inhertied from
- Bracket
def iterateUntil[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by catsEitherTConcurrent
Execute an action repeatedly until its result satisfies the given predicate
and return that result, discarding all others.
and return that result, discarding all others.
- Inhertied from
- Monad
def attempt[A](fa: F[A]): F[Either[E, A]]
Implicitly added by catsEitherTConcurrent
Handle errors by turning them into scala.util.Either values.
If there is no error, then an
scala.util.Right
value will be returned instead.All non-fatal errors should be handled by this method.
- Inhertied from
- ApplicativeError
@noop
def ifM[B](fa: F[Boolean])(ifTrue: => F[B], ifFalse: => F[B]): F[B]
Implicitly added by catsEitherTConcurrent
if
lifted into monad.- Inhertied from
- FlatMap
Implicitly added by catsEitherTConcurrent
Creates a simple, non-cancelable
executes an asynchronous process on evaluation.
F[A]
instance thatexecutes an asynchronous process on evaluation.
The given function is being injected with a side-effectful
callback for signaling the final result of an asynchronous
process.
callback for signaling the final result of an asynchronous
process.
This operation could be derived from asyncF, because:
{{{
F.async(k) <-> F.asyncF(cb => F.delay(k(cb)))
}}}
F.async(k) <-> F.asyncF(cb => F.delay(k(cb)))
}}}
As an example of wrapping an impure async API, here's the
implementation of Async.shift:
implementation of Async.shift:
{{{
def shift[F[_] ](ec: ExecutionContext)(implicit F: Async[F] ): F[Unit] =
F.async { cb =>
// Scheduling an async boundary (logical thread fork)
ec.execute(new Runnable {
def run(): Unit = {
// Signaling successful completion
cb(Right(()))
}
})
}
}}}
def shift[F[_] ](ec: ExecutionContext)(implicit F: Async[F] ): F[Unit] =
F.async { cb =>
// Scheduling an async boundary (logical thread fork)
ec.execute(new Runnable {
def run(): Unit = {
// Signaling successful completion
cb(Right(()))
}
})
}
}}}
@noop
def whileM[G <: ([_$2] =>> Any), A](p: F[Boolean])(body: => F[A])(G: Alternative[G]): F[G[A]]
Implicitly added by catsEitherTConcurrent
Execute an action repeatedly as long as the given
returns
Collects the results into an arbitrary
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
Boolean
expressionreturns
true
. The condition is evaluated before the loop body.Collects the results into an arbitrary
Alternative
value, such as a Vector
.This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
List
.- Inhertied from
- Monad
def onError[A](fa: F[A])(pf: PartialFunction[E, F[Unit]]): F[A]
Implicitly added by catsEitherTConcurrent
Execute a callback on certain errors, then rethrow them.
Any non matching error is rethrown as well.
Any non matching error is rethrown as well.
In the following example, only one of the errors is logged,
but they are both rethrown, to be possibly handled by another
layer of the program:
but they are both rethrown, to be possibly handled by another
layer of the program:
{{{
scala> import cats., data., implicits._
scala> import cats., data., implicits._
scala> case class Err(msg: String)
scala> type F[A]
= EitherT[State[String, *]
, Err, A]
scala> val action: PartialFunction[Err, F[Unit]
] = {
| case Err("one") => EitherT.liftF(State.set("one"))
| }
| case Err("one") => EitherT.liftF(State.set("one"))
| }
scala> val prog1: F[Int]
= (Err("one")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]
scala> prog1.onError(action).value.run("").value
res0: (String, Either[Err,Int]
) = (one,Left(Err(one)))
scala> prog2.onError(action).value.run("").value
res1: (String, Either[Err,Int] ) = ("",Left(Err(two)))
}}}
res1: (String, Either[Err,Int] ) = ("",Left(Err(two)))
}}}
- Inhertied from
- ApplicativeError
Implicitly added by catsEitherTConcurrent
Operation meant for specifying tasks with safe resource
acquisition and release in the face of errors and interruption.
acquisition and release in the face of errors and interruption.
This operation provides the equivalent of
statements in mainstream imperative languages for resource
acquisition and release.
try/catch/finally
statements in mainstream imperative languages for resource
acquisition and release.
- Value Params
- acquire
-
is an action that "acquires" some expensive
resource, that needs to be used and then discarded - release
-
is the action that's supposed to release the
allocated resource afteruse
is done, regardless of
its exit condition. Throwing inside this function
is undefined behavior since it's left to the implementation. - use
-
is the action that uses the newly allocated
resource and that will provide the final result
- Inhertied from
- Bracket
def ensureOr[A](fa: F[A])(error: A => E)(predicate: A => Boolean): F[A]
Implicitly added by catsEitherTConcurrent
Turns a successful value into an error specified by the
error
function if it does not satisfy a given predicate.- Inhertied from
- MonadError
def attemptT[A](fa: F[A]): EitherT[F, E, A]
Implicitly added by catsEitherTConcurrent
Similar to attempt, but wraps the result in a data.EitherT for
convenience.
convenience.
- Inhertied from
- ApplicativeError
Implicitly added by catsEitherTConcurrent
Executes the given
either in success or in error, or if canceled.
finalizer
when the source is finished,either in success or in error, or if canceled.
This variant of guaranteeCase evaluates the given
regardless of how the source gets terminated:
finalizer
regardless of how the source gets terminated:
-
normal completion
-
completion in error
-
cancelation
This equivalence always holds:
{{{
F.guarantee(fa)(f) <-> F.bracket(F.unit)(_ => fa)(_ => f)
}}}
F.guarantee(fa)(f) <-> F.bracket(F.unit)(_ => fa)(_ => f)
}}}
As best practice, it's not a good idea to release resources
via
for the acquisition and release of resources.
via
guaranteeCase
in polymorphic code. Prefer bracketfor the acquisition and release of resources.
- See also
- guaranteeCase for the version that can discriminate
between termination conditionsbracket for the more general operation - Inhertied from
- Bracket
def void[A](fa: F[A]): F[Unit]
Implicitly added by catsEitherTConcurrent
Empty the fa of the values, preserving the structure
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.void(List(1,2,3))
res0: List[Unit] = List((), (), ())
}}}
res0: List[Unit] = List((), (), ())
}}}
- Inhertied from
- Functor
def untilM[G <: ([_$4] =>> Any), A](f: F[A])(cond: => F[Boolean])(G: Alternative[G]): F[G[A]]
Implicitly added by catsEitherTConcurrent
Execute an action repeatedly until the
The condition is evaluated after the loop body. Collects results into an
arbitrary
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
Boolean
condition returns true
.The condition is evaluated after the loop body. Collects results into an
arbitrary
Alternative
value, such as a Vector
.This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
List
.- Inhertied from
- Monad
@inline
final def <*>[A, B](ff: F[A => B])(fa: F[A]): F[B]
Implicitly added by catsEitherTConcurrent
Alias for ap.
- Inhertied from
- Apply
def handleErrorWith[A](fa: F[A])(f: E => F[A]): F[A]
Implicitly added by catsEitherTConcurrent
Handle any error, potentially recovering from it, by mapping it to an
F[A]
value.- See also
- handleError to handle any error by simply mapping it to an
A
value instead of anF[A]
.recoverWith to recover from only certain errors. - Inhertied from
- ApplicativeError
def attemptNarrow[EE <: Throwable, A](fa: F[A])(tag: ClassTag[EE], ev: EE <:< E): F[Either[EE, A]]
Implicitly added by catsEitherTConcurrent
Similar to attempt, but it only handles errors of type
EE
.- Inhertied from
- ApplicativeError
def attemptTap[A, B](fa: F[A])(f: Either[E, A] => F[B]): F[A]
Implicitly added by catsEitherTConcurrent
Reifies the value or error of the source and performs an effect on the result,
then recovers the original value or error back into
then recovers the original value or error back into
F
.Note that if the effect returned by
f
fails, the resulting effect will fail too.Alias for
fa.attempt.flatTap(f).rethrow
for convenience.Example:
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}
scala> def checkError(result: Either[Throwable, Int]
): Try[String]
= result.fold(_ => Failure(new java.lang.Exception), _ => Success("success"))
scala> val a: Try[Int]
= Failure(new Throwable("failed"))
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Int]
= Success(1)
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
}}}
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
}}}
- Inhertied from
- MonadError
@inline
final def *>[A, B](fa: F[A])(fb: F[B]): F[B]
Implicitly added by catsEitherTConcurrent
Alias for productR.
- Inhertied from
- Apply
def redeem[A, B](fa: F[A])(recover: E => B, f: A => B): F[B]
Implicitly added by catsEitherTConcurrent
Returns a new value that transforms the result of the source,
given the
on whether the result is successful or if it ends in error.
given the
recover
or map
functions, which get executed dependingon whether the result is successful or if it ends in error.
{{{
fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))
}}}
fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))
}}}
Usage of
redeem
subsumes handleError because:{{{
fa.redeem(fe, id) <-> fa.handleError(fe)
}}}
fa.redeem(fe, id) <-> fa.handleError(fe)
}}}
Implementations are free to override it in order to optimize
error recovery.
error recovery.
- Value Params
- fa
-
is the source whose result is going to get transformed
- recover
-
is the function that gets called to recover the source
in case of error
- See also
- Inhertied from
- ApplicativeError
def fproduct[A, B](fa: F[A])(f: A => B): F[(A, B)]
Implicitly added by catsEitherTConcurrent
Tuple the values in fa with the result of applying a function
with the value
with the value
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option]
.fproduct(Option(42))(_.toString)
res0: Option[(Int, String)] = Some((42,42))
}}}
res0: Option[(Int, String)] = Some((42,42))
}}}
- Inhertied from
- Functor
def unit: F[Unit]
Implicitly added by catsEitherTConcurrent
Returns an
F[Unit]
value, equivalent with pure(())
.A useful shorthand, also allowing implementations to optimize the
returned reference (e.g. it can be a
returned reference (e.g. it can be a
val
).Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[Option]
.unit
res0: Option[Unit] = Some(())
}}}
res0: Option[Unit] = Some(())
}}}
- Inhertied from
- Applicative
def productLEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[A]
Implicitly added by catsEitherTConcurrent
Sequentially compose two actions, discarding any value produced by the second. This variant of
productL also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
productL also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int] .productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
}}}
scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int] .productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
}}}
- Inhertied from
- FlatMap
def fromEither[A](x: Either[E, A]): F[A]
Implicitly added by catsOptionTConcurrent
Convert from scala.Either
Example:
{{{
scala> import cats.ApplicativeError
scala> import cats.instances.option._
{{{
scala> import cats.ApplicativeError
scala> import cats.instances.option._
scala> ApplicativeError[Option, Unit]
.fromEither(Right(1))
res0: scala.Option[Int] = Some(1)
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit]
.fromEither(Left(()))
res1: scala.Option[Nothing] = None
}}}
res1: scala.Option[Nothing] = None
}}}
- Inhertied from
- ApplicativeError
def unlessA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by catsOptionTConcurrent
Returns the given argument (mapped to Unit) if
otherwise, unit lifted into F.
cond
is false
,otherwise, unit lifted into F.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[List]
.unlessA(true)(List(1, 2, 3))
res0: List[Unit] = List(())
res0: List[Unit] = List(())
scala> Applicative[List]
.unlessA(false)(List(1, 2, 3))
res1: List[Unit] = List((), (), ())
res1: List[Unit] = List((), (), ())
scala> Applicative[List]
.unlessA(true)(List.empty[Int]
)
res2: List[Unit] = List(())
res2: List[Unit] = List(())
scala> Applicative[List]
.unlessA(false)(List.empty[Int]
)
res3: List[Unit] = List()
}}}
res3: List[Unit] = List()
}}}
- Inhertied from
- Applicative
@noop
def unzip[A, B](fab: F[(A, B)]): (F[A], F[B])
Implicitly added by catsOptionTConcurrent
Un-zips an
F[(A, B)]
consisting of element pairs or Tuple2 into two separate F's tupled.NOTE: Check for effect duplication, possibly memoize before
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.unzip(List((1,2), (3, 4)))
res0: (List[Int] , List[Int] ) = (List(1, 3),List(2, 4))
}}}
res0: (List[Int] , List[Int] ) = (List(1, 3),List(2, 4))
}}}
- Inhertied from
- Functor
def fix[A](fn: F[A] => F[A]): F[A]
Implicitly added by catsOptionTConcurrent
Defer instances, like functions, parsers, generators, IO, etc...
often are used in recursive settings where this function is useful
often are used in recursive settings where this function is useful
fix(fn) == fn(fix(fn))
example:
val parser: P[Int]
=
Defer[P] .fix[Int] { rec =>
CharsIn("0123456789") | P("(") ~ rec ~ P(")")
}
Defer[P] .fix[Int] { rec =>
CharsIn("0123456789") | P("(") ~ rec ~ P(")")
}
Note, fn may not yield a terminating value in which case both
of the above F[A] run forever.
of the above F[A] run forever.
- Inhertied from
- Defer
def recover[A](fa: F[A])(pf: PartialFunction[E, A]): F[A]
Implicitly added by catsOptionTConcurrent
Recover from certain errors by mapping them to an
A
value.- See also
- handleError to handle any/all errors.recoverWith to recover from certain errors by mapping them to
F[A]
values. - Inhertied from
- ApplicativeError
def iterateUntilM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by catsOptionTConcurrent
Apply a monadic function iteratively until its result satisfies
the given predicate and return that result.
the given predicate and return that result.
- Inhertied from
- Monad
def as[A, B](fa: F[A], b: B): F[B]
Implicitly added by catsOptionTConcurrent
Replaces the
A
value in F[A]
with the supplied value.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.as(List(1,2,3), "hello")
res0: List[String] = List(hello, hello, hello)
}}}
res0: List[String] = List(hello, hello, hello)
}}}
- Inhertied from
- Functor
def redeemWith[A, B](fa: F[A])(recover: E => F[B], bind: A => F[B]): F[B]
Implicitly added by catsOptionTConcurrent
Returns a new value that transforms the result of the source,
given the
on whether the result is successful or if it ends in error.
given the
recover
or bind
functions, which get executed dependingon whether the result is successful or if it ends in error.
{{{
fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))
}}}
fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))
}}}
Usage of
redeemWith
subsumes handleErrorWith because:{{{
fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)
}}}
fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)
}}}
Usage of
redeemWith
also subsumes flatMap because:{{{
fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)
}}}
fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)
}}}
Implementations are free to override it in order to optimize
error recovery.
error recovery.
- Value Params
- bind
-
is the function that gets to transform the source
in case of success - fa
-
is the source whose result is going to get transformed
- recover
-
is the function that gets called to recover the source
in case of error
- See also
- Inhertied from
- MonadError
def tupleLeft[A, B](fa: F[A], b: B): F[(B, A)]
Implicitly added by catsOptionTConcurrent
Tuples the
A
value in F[A]
with the supplied B
value, with the B
value on the left.Example:
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue]
.tupleLeft(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
}}}
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
}}}
- Inhertied from
- Functor
def composeApply[G <: ([_$2] =>> Any)](evidence$1: Apply[G]): InvariantSemigroupal[[α] =>> F[G[α]]]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- InvariantSemigroupal
@noop
def untilDefinedM[A](foa: F[Option[A]]): F[A]
Implicitly added by catsOptionTConcurrent
This repeats an F until we get defined values. This can be useful
for polling type operations on State (or RNG) Monads, or in effect
monads.
for polling type operations on State (or RNG) Monads, or in effect
monads.
- Inhertied from
- FlatMap
def iterateWhile[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by catsOptionTConcurrent
Execute an action repeatedly until its result fails to satisfy the given predicate
and return that result, discarding all others.
and return that result, discarding all others.
- Inhertied from
- Monad
@inline
final def <*[A, B](fa: F[A])(fb: F[B]): F[A]
Implicitly added by catsOptionTConcurrent
Alias for productL.
- Inhertied from
- Apply
@noop
def ifA[A](fcond: F[Boolean])(ifTrue: F[A], ifFalse: F[A]): F[A]
Implicitly added by catsOptionTConcurrent
An
This function combines the effects of the
in the order in which they are given.
if-then-else
lifted into the F
context.This function combines the effects of the
fcond
condition and of the two branches,in the order in which they are given.
The value of the result is, depending on the value of the condition,
the value of the first argument, or the value of the second argument.
the value of the first argument, or the value of the second argument.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val b1: Option[Boolean]
= Some(true)
scala> val asInt1: Option[Int] = Apply[Option] .ifA(b1)(Some(1), Some(0))
scala> asInt1.get
res0: Int = 1
scala> val asInt1: Option[Int] = Apply[Option] .ifA(b1)(Some(1), Some(0))
scala> asInt1.get
res0: Int = 1
scala> val b2: Option[Boolean]
= Some(false)
scala> val asInt2: Option[Int] = Apply[Option] .ifA(b2)(Some(1), Some(0))
scala> asInt2.get
res1: Int = 0
scala> val asInt2: Option[Int] = Apply[Option] .ifA(b2)(Some(1), Some(0))
scala> asInt2.get
res1: Int = 0
scala> val b3: Option[Boolean]
= Some(true)
scala> val asInt3: Option[Int] = Apply[Option] .ifA(b3)(Some(1), None)
asInt2: Option[Int] = None
scala> val asInt3: Option[Int] = Apply[Option] .ifA(b3)(Some(1), None)
asInt2: Option[Int] = None
}}}
- Inhertied from
- Apply
def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- FlatMap
@noop
def ifElseM[A](branches: (F[Boolean], F[A])*)(els: F[A]): F[A]
Implicitly added by catsOptionTConcurrent
Simulates an if/else-if/else in the context of an F. It evaluates conditions until
one evaluates to true, and returns the associated F[A] . If no condition is true,
returns els.
one evaluates to true, and returns the associated F[A] . If no condition is true,
returns els.
{{{
scala> import cats._
scala> Monad[Eval] .ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2
}}}
scala> import cats._
scala> Monad[Eval] .ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2
}}}
- See also
- See https://gitter.im/typelevel/cats-effect?at=5f297e4314c413356f56d230 for the discussion.
- Inhertied from
- Monad
Implicitly added by catsOptionTConcurrent
Returns a non-terminating
with a result, being equivalent to
F[_]
, that never completeswith a result, being equivalent to
async(_ => ())
- Inhertied from
- Async
def pure[A](x: A): F[A]
Implicitly added by catsOptionTConcurrent
pure
lifts any value into the Applicative Functor.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[Option]
.pure(10)
res0: Option[Int] = Some(10)
}}}
res0: Option[Int] = Some(10)
}}}
- Inhertied from
- Applicative
def point[A](a: A): F[A]
Implicitly added by catsOptionTConcurrent
point
lifts any value into a Monoidal Functor.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> InvariantMonoidal[Option]
.point(10)
res0: Option[Int] = Some(10)
}}}
res0: Option[Int] = Some(10)
}}}
- Inhertied from
- InvariantMonoidal
def compose[G <: ([_$2] =>> Any)](evidence$1: Applicative[G]): Applicative[[α] =>> F[G[α]]]
Implicitly added by catsOptionTConcurrent
Compose an
Applicative[F]
and an Applicative[G]
into anApplicative[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val alo = Applicative[List]
.compose[Option]
scala> alo.pure(3)
res0: List[Option[Int] ] = List(Some(3))
res0: List[Option[Int] ] = List(Some(3))
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
- Inhertied from
- Applicative
def compose[G <: ([_$2] =>> Any)](evidence$1: Invariant[G]): Invariant[[α] =>> F[G[α]]]
Implicitly added by catsOptionTConcurrent
Compose Invariant
F[_]
and G[_]
then produce Invariant[F[G[_]]]
using their imap
.Example:
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]
] =
| Invariant[Semigroup] .compose[List] .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
| Invariant[Semigroup] .compose[List] .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
- Inhertied from
- Invariant
def compose[G <: ([_$3] =>> Any)](evidence$1: Apply[G]): Apply[[α] =>> F[G[α]]]
Implicitly added by catsOptionTConcurrent
Compose an
Apply[F]
and an Apply[G]
into an Apply[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val alo = Apply[List]
.compose[Option]
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
- Inhertied from
- Apply
def compose[G <: ([_$6] =>> Any)](evidence$1: Functor[G]): Functor[[α] =>> F[G[α]]]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- Functor
def ensure[A](fa: F[A])(error: => E)(predicate: A => Boolean): F[A]
Implicitly added by catsOptionTConcurrent
Turns a successful value into an error if it does not satisfy a given predicate.
- Inhertied from
- MonadError
def widen[A, B >: A](fa: F[A]): F[B]
Implicitly added by catsOptionTConcurrent
Lifts natural subtyping covariance of covariant Functors.
NOTE: In certain (perhaps contrived) situations that rely on universal
equality this can result in a
implemented as a type cast. It could be implemented as
according to the functor laws, that should be equal to
cast is often much more performant.
See this example
of
equality this can result in a
ClassCastException
, because it isimplemented as a type cast. It could be implemented as
map(identity)
, butaccording to the functor laws, that should be equal to
fa
, and a typecast is often much more performant.
See this example
of
widen
creating a ClassCastException
.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val s = Some(42)
scala> Functor[Option] .widen(s)
res0: Option[Int] = Some(42)
}}}
scala> Functor[Option] .widen(s)
res0: Option[Int] = Some(42)
}}}
- Inhertied from
- Functor
@noop
def foreverM[A, B](fa: F[A]): F[B]
Implicitly added by catsOptionTConcurrent
Like an infinite loop of >> calls. This is most useful effect loops
that you want to run forever in for instance a server.
that you want to run forever in for instance a server.
This will be an infinite loop, or it will return an F[Nothing]
.
Be careful using this.
For instance, a List of length k will produce a list of length k^n at iteration
n. This means if k = 0, we return an empty list, if k = 1, we loop forever
allocating single element lists, but if we have a k > 1, we will allocate
exponentially increasing memory and very quickly OOM.
For instance, a List of length k will produce a list of length k^n at iteration
n. This means if k = 0, we return an empty list, if k = 1, we loop forever
allocating single element lists, but if we have a k > 1, we will allocate
exponentially increasing memory and very quickly OOM.
- Inhertied from
- FlatMap
Implicitly added by catsOptionTConcurrent
Creates a simple, non-cancelable
executes an asynchronous process on evaluation.
F[A]
instance thatexecutes an asynchronous process on evaluation.
The given function is being injected with a side-effectful
callback for signaling the final result of an asynchronous
process. And its returned result needs to be a pure
that gets evaluated by the runtime.
callback for signaling the final result of an asynchronous
process. And its returned result needs to be a pure
F[Unit]
that gets evaluated by the runtime.
Note the simpler async variant async can be derived like this:
{{{
F.async(k) <-> F.asyncF(cb => F.delay(k(cb)))
}}}
F.async(k) <-> F.asyncF(cb => F.delay(k(cb)))
}}}
For wrapping impure APIs usually you can use the simpler async,
however
wrapped with the help of pure abstractions, such as
Ref.
however
asyncF
is useful in cases where impure APIs arewrapped with the help of pure abstractions, such as
Ref.
For example here's how a simple, "pure Promise" implementation
could be implemented via
as you have a far better
Deferred available):
could be implemented via
Ref
(sample is for didactic purposes,as you have a far better
Deferred available):
{{{
import cats.effect.concurrent.Ref
import cats.effect.concurrent.Ref
type Callback[-A]
= Either[Throwable, A]
=> Unit
class PurePromise[F[_]
, A](ref: Ref[F, Either[List[Callback[A]
], A]])
(implicit F: Async[F] ) {
(implicit F: Async[F] ) {
def get: F[A]
= F.asyncF { cb =>
ref.modify {
case current @ Right(result) =>
(current, F.delay(cb(Right(result))))
case Left(list) =>
(Left(cb :: list), F.unit)
}
}
ref.modify {
case current @ Right(result) =>
(current, F.delay(cb(Right(result))))
case Left(list) =>
(Left(cb :: list), F.unit)
}
}
def complete(value: A): F[Unit]
=
F.flatten(ref.modify {
case Left(list) =>
(Right(value), F.delay(list.foreach(_(Right(value)))))
case right =>
(right, F.unit)
})
}
}}}
F.flatten(ref.modify {
case Left(list) =>
(Right(value), F.delay(list.foreach(_(Right(value)))))
case right =>
(right, F.unit)
})
}
}}}
N.B. if
Concurrent), then the returned
its evaluation hooking into the underlying cancelation mechanism
of
F[_]
is a cancelable data type (i.e. implementingConcurrent), then the returned
F[Unit]
can be cancelable,its evaluation hooking into the underlying cancelation mechanism
of
F[_]
, so something like this behaves like you'd expect:{{{
def delayed[F[_] , A](thunk: => A)
(implicit F: Async[F] , timer: Timer[F] ): F[A] = {
def delayed[F[_] , A](thunk: => A)
(implicit F: Async[F] , timer: Timer[F] ): F[A] = {
timer.sleep(1.second) *> F.delay(cb(
try cb(Right(thunk))
catch { case NonFatal(e) => Left(cb(Left(e))) }
))
}
}}}
try cb(Right(thunk))
catch { case NonFatal(e) => Left(cb(Left(e))) }
))
}
}}}
The
that the result has to be signaled via the provided callback.
asyncF
operation behaves like Sync.suspend, exceptthat the result has to be signaled via the provided callback.
==ERROR HANDLING==
As a matter of contract the returned
throw errors. If it does, then the behavior is undefined.
F[Unit]
should notthrow errors. If it does, then the behavior is undefined.
This is because by contract the provided callback should
only be called once. Calling it concurrently, multiple times,
is a contract violation. And if the returned
then the implementation might have called it already, so it
would be a contract violation to call it without expensive
synchronization.
only be called once. Calling it concurrently, multiple times,
is a contract violation. And if the returned
F[Unit]
throws,then the implementation might have called it already, so it
would be a contract violation to call it without expensive
synchronization.
In case errors are thrown the behavior is implementation specific.
The error might get logged to stderr, or via other mechanisms
that are implementations specific.
The error might get logged to stderr, or via other mechanisms
that are implementations specific.
Implicitly added by catsOptionTConcurrent
Lifts any by-name parameter into the
F
context.Equivalent to
the purpose of this function is to suspend side effects
in
Applicative.pure
for pure expressions,the purpose of this function is to suspend side effects
in
F
.- Inhertied from
- Sync
def catchNonFatalEval[A](a: Eval[A])(ev: Throwable <:< E): F[A]
Implicitly added by catsOptionTConcurrent
Often E is Throwable. Here we try to call pure or catch
and raise
and raise
- Inhertied from
- ApplicativeError
Implicitly added by catsOptionTConcurrent
- Value Params
- acquire
-
is an action that "acquires" some expensive
resource, that needs to be used and then discarded - release
-
is the action that's supposed to release the
allocated resource afteruse
is done, by observing
and acting on its exit condition. Throwing inside
this function leads to undefined behavior since it's
left to the implementation. - use
-
is the action that uses the newly allocated
resource and that will provide the final result
- Inhertied from
- Bracket
@noop
def ifF[A](fb: F[Boolean])(ifTrue: => A, ifFalse: => A): F[A]
Implicitly added by catsOptionTConcurrent
Lifts
if
to FunctorExample:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.ifF(List(true, false, false))(1, 0)
res0: List[Int] = List(1, 0, 0)
}}}
res0: List[Int] = List(1, 0, 0)
}}}
- Inhertied from
- Functor
def replicateA[A](n: Int, fa: F[A]): F[List[A]]
Implicitly added by catsOptionTConcurrent
Given
fa
and n
, apply fa
n
times to construct an F[List[A]]
value.Example:
{{{
scala> import cats.data.State
{{{
scala> import cats.data.State
scala> type Counter[A]
= State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int] ] =
| Applicative[Counter] .replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int] ) = (5,List(0, 1, 2, 3, 4))
}}}
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int] ] =
| Applicative[Counter] .replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int] ) = (5,List(0, 1, 2, 3, 4))
}}}
- Inhertied from
- Applicative
def rethrow[A, EE <: E](fa: F[Either[EE, A]]): F[A]
Implicitly added by catsOptionTConcurrent
Inverse of
attempt
Example:
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success}
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success}
scala> val a: Try[Either[Throwable, Int]
] = Success(Left(new java.lang.Exception))
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Either[Throwable, Int]
] = Success(Right(1))
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
}}}
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
}}}
- Inhertied from
- MonadError
def raiseError[A](e: E): F[A]
Implicitly added by catsOptionTConcurrent
Lift an error into the
F
context.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
// integer-rounded division
scala> def divide[F[_] ](dividend: Int, divisor: Int)(implicit F: ApplicativeError[F, String] ): F[Int] =
| if (divisor === 0) F.raiseError("division by zero")
| else F.pure(dividend / divisor)
scala> def divide[F[_] ](dividend: Int, divisor: Int)(implicit F: ApplicativeError[F, String] ): F[Int] =
| if (divisor === 0) F.raiseError("division by zero")
| else F.pure(dividend / divisor)
scala> type ErrorOr[A]
= Either[String, A]
scala> divide[ErrorOr]
(6, 3)
res0: ErrorOr[Int] = Right(2)
res0: ErrorOr[Int] = Right(2)
scala> divide[ErrorOr]
(6, 0)
res1: ErrorOr[Int] = Left(division by zero)
}}}
res1: ErrorOr[Int] = Left(division by zero)
}}}
- Inhertied from
- ApplicativeError
def lift[A, B](f: A => B): F[A] => F[B]
Implicitly added by catsOptionTConcurrent
Lift a function f to operate on Functors
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val o = Option(42)
scala> Functor[Option] .lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
}}}
scala> Functor[Option] .lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
}}}
- Inhertied from
- Functor
def mproduct[A, B](fa: F[A])(f: A => F[B]): F[(A, B)]
Implicitly added by catsOptionTConcurrent
Pair
A
with the result of function application.Example:
{{{
scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
}}}
{{{
scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
}}}
- Inhertied from
- FlatMap
def whenA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by catsOptionTConcurrent
Returns the given argument (mapped to Unit) if
unit lifted into F.
cond
is true
, otherwise,unit lifted into F.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[List]
.whenA(true)(List(1, 2, 3))
res0: List[Unit] = List((), (), ())
res0: List[Unit] = List((), (), ())
scala> Applicative[List]
.whenA(false)(List(1, 2, 3))
res1: List[Unit] = List(())
res1: List[Unit] = List(())
scala> Applicative[List]
.whenA(true)(List.empty[Int]
)
res2: List[Unit] = List()
res2: List[Unit] = List()
scala> Applicative[List]
.whenA(false)(List.empty[Int]
)
res3: List[Unit] = List(())
}}}
res3: List[Unit] = List(())
}}}
- Inhertied from
- Applicative
def fromValidated[A](x: Validated[E, A]): F[A]
Implicitly added by catsOptionTConcurrent
Convert from cats.data.Validated
Example:
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> ApplicativeError[Option, Unit]
.fromValidated(1.valid[Unit]
)
res0: scala.Option[Int] = Some(1)
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit]
.fromValidated(().invalid[Int]
)
res1: scala.Option[Int] = None
}}}
res1: scala.Option[Int] = None
}}}
- Inhertied from
- ApplicativeError
def composeFunctor[G <: ([_$3] =>> Any)](evidence$2: Functor[G]): Invariant[[α] =>> F[G[α]]]
Implicitly added by catsOptionTConcurrent
Compose Invariant
using F's
F[_]
and Functor G[_]
then produce Invariant[F[G[_]]]
using F's
imap
and G's map
.Example:
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]
] =
| Invariant[Semigroup]
| .composeFunctor[List]
| .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
| Invariant[Semigroup]
| .composeFunctor[List]
| .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
- Inhertied from
- Invariant
def composeContravariantMonoidal[G <: ([_$3] =>> Any)](evidence$2: ContravariantMonoidal[G]): ContravariantMonoidal[[α] =>> F[G[α]]]
Implicitly added by catsOptionTConcurrent
Compose an
Applicative[F]
and a ContravariantMonoidal[G]
into aContravariantMonoidal[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.kernel.Comparison
scala> import cats.implicits._
{{{
scala> import cats.kernel.Comparison
scala> import cats.implicits._
// compares strings by alphabetical order
scala> val alpha: Order[String] = Order[String]
scala> val alpha: Order[String] = Order[String]
// compares strings by their length
scala> val strLength: Order[String] = Order.byString, Int
scala> val strLength: Order[String] = Order.byString, Int
scala> val stringOrders: List[Order[String]
] = List(alpha, strLength)
// first comparison is with alpha order, second is with string length
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)
scala> val le = Applicative[List]
.composeContravariantMonoidal[Order]
// create Int orders that convert ints to strings and then use the string orders
scala> val intOrders: List[Order[Int] ] = le.contramap(stringOrders)(_.toString)
scala> val intOrders: List[Order[Int] ] = le.contramap(stringOrders)(_.toString)
// first comparison is with alpha order, second is with string length
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)
// create the
//
// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)] ] = le.product(stringOrders, intOrders)
product
of the string order list and the int order list//
p
contains a list of the following orders:// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)] ] = le.product(stringOrders, intOrders)
scala> p.map(o => o.comparison(("abc", 12), ("def", 3)))
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
}}}
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
}}}
- Inhertied from
- Applicative
final def fmap[A, B](fa: F[A])(f: A => B): F[B]
Implicitly added by catsOptionTConcurrent
Alias for map, since map can't be injected as syntax if
the implementing type already had a built-in
the implementing type already had a built-in
.map
method.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val m: Map[Int, String]
= Map(1 -> "hi", 2 -> "there", 3 -> "you")
scala> m.fmap(_ ++ "!")
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
}}}
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
}}}
- Inhertied from
- Functor
def fromOption[A](oa: Option[A], ifEmpty: => E): F[A]
Implicitly added by catsOptionTConcurrent
Convert from scala.Option
Example:
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *] , String]
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *] , String]
scala> F.fromOption(Some(1), "Empty")
res0: scala.Either[String, Int] = Right(1)
res0: scala.Either[String, Int] = Right(1)
scala> F.fromOption(Option.empty[Int]
, "Empty")
res1: scala.Either[String, Int] = Left(Empty)
}}}
res1: scala.Either[String, Int] = Left(Empty)
}}}
- Inhertied from
- ApplicativeError
def tuple2[A, B](f1: F[A], f2: F[B]): F[(A, B)]
Implicitly added by catsOptionTConcurrent
- Inhertied from
- ApplyArityFunctions
@deprecated("use defer", "2.4.0")
Implicitly added by catsOptionTConcurrent
Suspends the evaluation of an
F
reference.Equivalent to
the purpose of this function is to suspend side effects
in
FlatMap.flatten
for pure expressions,the purpose of this function is to suspend side effects
in
F
.- Inhertied from
- Sync
def catchNonFatal[A](a: => A)(ev: Throwable <:< E): F[A]
Implicitly added by catsOptionTConcurrent
Often E is Throwable. Here we try to call pure or catch
and raise.
and raise.
- Inhertied from
- ApplicativeError
def handleError[A](fa: F[A])(f: E => A): F[A]
Implicitly added by catsOptionTConcurrent
Handle any error, by mapping it to an
A
value.- See also
- handleErrorWith to map to an
F[A]
value instead of simply anA
value.recover to only recover from certain errors. - Inhertied from
- ApplicativeError
def fromTry[A](t: Try[A])(ev: Throwable <:< E): F[A]
Implicitly added by catsOptionTConcurrent
If the error type is Throwable, we can convert from a scala.util.Try
- Inhertied from
- ApplicativeError
def tailRecM[A, B](a: A)(f: A => F[Either[A, B]]): F[B]
Implicitly added by catsOptionTConcurrent
Keeps calling
f
until a scala.util.Right[B]
is returned.Based on Phil Freeman's
Stack Safety for Free.
Stack Safety for Free.
Implementations of this method should use constant stack space relative to
f
.- Inhertied from
- FlatMap
Implicitly added by catsOptionTConcurrent
Executes the given
either in success or in error, or if canceled, allowing
for differentiating between exit conditions.
finalizer
when the source is finished,either in success or in error, or if canceled, allowing
for differentiating between exit conditions.
This variant of guarantee injects an ExitCase in
the provided function, allowing one to make a difference
between:
the provided function, allowing one to make a difference
between:
-
normal completion
-
completion in error
-
cancelation
This equivalence always holds:
{{{
F.guaranteeCase(fa)(f) <-> F.bracketCase(F.unit)(_ => fa)((_, e) => f(e))
}}}
F.guaranteeCase(fa)(f) <-> F.bracketCase(F.unit)(_ => fa)((_, e) => f(e))
}}}
As best practice, it's not a good idea to release resources
via
for the acquisition and release of resources.
via
guaranteeCase
in polymorphic code. Prefer bracketCasefor the acquisition and release of resources.
- See also
- guarantee for the simpler versionbracketCase for the more general operation
- Inhertied from
- Bracket
def untilM_[A](f: F[A])(cond: => F[Boolean]): F[Unit]
Implicitly added by catsOptionTConcurrent
Execute an action repeatedly until the
The condition is evaluated after the loop body. Discards results.
Boolean
condition returns true
.The condition is evaluated after the loop body. Discards results.
- Inhertied from
- Monad
def fproductLeft[A, B](fa: F[A])(f: A => B): F[(B, A)]
Implicitly added by catsOptionTConcurrent
Pair the result of function application with
A
.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option]
.fproductLeft(Option(42))(_.toString)
res0: Option[(String, Int)] = Some((42,42))
}}}
res0: Option[(String, Int)] = Some((42,42))
}}}
- Inhertied from
- Functor
@noop
def iterateForeverM[A, B](a: A)(f: A => F[A]): F[B]
Implicitly added by catsOptionTConcurrent
iterateForeverM is almost exclusively useful for effect types. For instance,
A may be some state, we may take the current state, run some effect to get
a new state and repeat.
A may be some state, we may take the current state, run some effect to get
a new state and repeat.
- Inhertied from
- FlatMap
def recoverWith[A](fa: F[A])(pf: PartialFunction[E, F[A]]): F[A]
Implicitly added by catsOptionTConcurrent
Recover from certain errors by mapping them to an
F[A]
value.- See also
- handleErrorWith to handle any/all errors.recover to recover from certain errors by mapping them to
A
values. - Inhertied from
- ApplicativeError
def iterateWhileM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by catsOptionTConcurrent
Apply a monadic function iteratively until its result fails
to satisfy the given predicate and return that result.
to satisfy the given predicate and return that result.
- Inhertied from
- Monad
@noop
def whileM_[A](p: F[Boolean])(body: => F[A]): F[Unit]
Implicitly added by catsOptionTConcurrent
Execute an action repeatedly as long as the given
returns
Discards results.
Boolean
expressionreturns
true
. The condition is evaluated before the loop body.Discards results.
- Inhertied from
- Monad
def map2Eval[A, B, Z](fa: F[A], fb: Eval[F[B]])(f: (A, B) => Z): Eval[F[Z]]
Implicitly added by catsOptionTConcurrent
Similar to map2 but uses Eval to allow for laziness in the
argument. This can allow for "short-circuiting" of computations.
F[B]
argument. This can allow for "short-circuiting" of computations.
NOTE: the default implementation of
computations. For data structures that can benefit from laziness, Apply
instances should override this method.
map2Eval
does not short-circuitcomputations. For data structures that can benefit from laziness, Apply
instances should override this method.
In the following example,
but
result of
that the result of
x.map2(bomb)(_ + _)
would result in an error,but
map2Eval
"short-circuits" the computation. x
is None
and thus theresult of
bomb
doesn't even need to be evaluated in order to determinethat the result of
map2Eval
should be None
.{{{
scala> import cats.{Eval, Later}
scala> import cats.implicits._
scala> val bomb: Eval[Option[Int] ] = Later(sys.error("boom"))
scala> val x: Option[Int] = None
scala> x.map2Eval(bomb)(_ + _).value
res0: Option[Int] = None
}}}
scala> import cats.{Eval, Later}
scala> import cats.implicits._
scala> val bomb: Eval[Option[Int] ] = Later(sys.error("boom"))
scala> val x: Option[Int] = None
scala> x.map2Eval(bomb)(_ + _).value
res0: Option[Int] = None
}}}
- Inhertied from
- Apply
def flatTap[A, B](fa: F[A])(f: A => F[B]): F[A]
Implicitly added by catsOptionTConcurrent
Apply a monadic function and discard the result while keeping the effect.
{{{
scala> import cats., implicits.
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> ListInt.flatTap(nCats)
res2: List[Int] = List()
scala> ListInt.flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
}}}
scala> import cats., implicits.
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> ListInt.flatTap(nCats)
res2: List[Int] = List()
scala> ListInt.flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
}}}
- Inhertied from
- FlatMap
def productREval[A, B](fa: F[A])(fb: Eval[F[B]]): F[B]
Implicitly added by catsOptionTConcurrent
Sequentially compose two actions, discarding any value produced by the first. This variant of
productR also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
productR also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
}}}
scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
}}}
- Inhertied from
- FlatMap
def flatten[A](ffa: F[F[A]]): F[A]
Implicitly added by catsOptionTConcurrent
"flatten" a nested
F
of F
structure into a single-layer F
structure.This is also commonly called
join
.Example:
{{{
scala> import cats.Eval
scala> import cats.implicits._
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> val nested: Eval[Eval[Int]
] = Eval.now(Eval.now(3))
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3
}}}
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3
}}}
- Inhertied from
- FlatMap
def catchOnly[T >: Null <: Throwable]: CatchOnlyPartiallyApplied[T, F, E]
Implicitly added by catsOptionTConcurrent
Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.
- Inhertied from
- ApplicativeError
def tupleRight[A, B](fa: F[A], b: B): F[(A, B)]
Implicitly added by catsOptionTConcurrent
Tuples the
A
value in F[A]
with the supplied B
value, with the B
value on the right.Example:
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue]
.tupleRight(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
}}}
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
}}}
- Inhertied from
- Functor
Implicitly added by catsOptionTConcurrent
Operation meant for ensuring a given task continues execution even
when interrupted.
when interrupted.
- Inhertied from
- Bracket
Implicitly added by catsOptionTConcurrent
Executes the given
finalizer
when the source is canceled.The typical use case for this function arises in the
implementation of concurrent abstractions, which generally
consist of operations that perform asynchronous waiting after
concurrently modifying some state: in case the user asks for
cancelation, we want to interrupt the waiting operation, and
restore the state to its previous value.
implementation of concurrent abstractions, which generally
consist of operations that perform asynchronous waiting after
concurrently modifying some state: in case the user asks for
cancelation, we want to interrupt the waiting operation, and
restore the state to its previous value.
{{{
waitingOp.onCancel(restoreState)
}}}
waitingOp.onCancel(restoreState)
}}}
A direct use of
would make the waiting action uncancelable.
bracket
is not a good fit for this case as itwould make the waiting action uncancelable.
NOTE: This function handles interruption only, you need to take
care of the success and error case elsewhere in your code
care of the success and error case elsewhere in your code
- See also
- guaranteeCase for the version that can discriminate
between termination conditionsbracket for the more general operationConcurrent.continual when you have a use case similar to
the cancel/restore example above, but require access to the
result ofF[A]
- Inhertied from
- Bracket
def iterateUntil[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by catsOptionTConcurrent
Execute an action repeatedly until its result satisfies the given predicate
and return that result, discarding all others.
and return that result, discarding all others.
- Inhertied from
- Monad
def attempt[A](fa: F[A]): F[Either[E, A]]
Implicitly added by catsOptionTConcurrent
Handle errors by turning them into scala.util.Either values.
If there is no error, then an
scala.util.Right
value will be returned instead.All non-fatal errors should be handled by this method.
- Inhertied from
- ApplicativeError
@noop
def ifM[B](fa: F[Boolean])(ifTrue: => F[B], ifFalse: => F[B]): F[B]
Implicitly added by catsOptionTConcurrent
if
lifted into monad.- Inhertied from
- FlatMap
Implicitly added by catsOptionTConcurrent
Creates a simple, non-cancelable
executes an asynchronous process on evaluation.
F[A]
instance thatexecutes an asynchronous process on evaluation.
The given function is being injected with a side-effectful
callback for signaling the final result of an asynchronous
process.
callback for signaling the final result of an asynchronous
process.
This operation could be derived from asyncF, because:
{{{
F.async(k) <-> F.asyncF(cb => F.delay(k(cb)))
}}}
F.async(k) <-> F.asyncF(cb => F.delay(k(cb)))
}}}
As an example of wrapping an impure async API, here's the
implementation of Async.shift:
implementation of Async.shift:
{{{
def shift[F[_] ](ec: ExecutionContext)(implicit F: Async[F] ): F[Unit] =
F.async { cb =>
// Scheduling an async boundary (logical thread fork)
ec.execute(new Runnable {
def run(): Unit = {
// Signaling successful completion
cb(Right(()))
}
})
}
}}}
def shift[F[_] ](ec: ExecutionContext)(implicit F: Async[F] ): F[Unit] =
F.async { cb =>
// Scheduling an async boundary (logical thread fork)
ec.execute(new Runnable {
def run(): Unit = {
// Signaling successful completion
cb(Right(()))
}
})
}
}}}
@noop
def whileM[G <: ([_$2] =>> Any), A](p: F[Boolean])(body: => F[A])(G: Alternative[G]): F[G[A]]
Implicitly added by catsOptionTConcurrent
Execute an action repeatedly as long as the given
returns
Collects the results into an arbitrary
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
Boolean
expressionreturns
true
. The condition is evaluated before the loop body.Collects the results into an arbitrary
Alternative
value, such as a Vector
.This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
List
.- Inhertied from
- Monad
def onError[A](fa: F[A])(pf: PartialFunction[E, F[Unit]]): F[A]
Implicitly added by catsOptionTConcurrent
Execute a callback on certain errors, then rethrow them.
Any non matching error is rethrown as well.
Any non matching error is rethrown as well.
In the following example, only one of the errors is logged,
but they are both rethrown, to be possibly handled by another
layer of the program:
but they are both rethrown, to be possibly handled by another
layer of the program:
{{{
scala> import cats., data., implicits._
scala> import cats., data., implicits._
scala> case class Err(msg: String)
scala> type F[A]
= EitherT[State[String, *]
, Err, A]
scala> val action: PartialFunction[Err, F[Unit]
] = {
| case Err("one") => EitherT.liftF(State.set("one"))
| }
| case Err("one") => EitherT.liftF(State.set("one"))
| }
scala> val prog1: F[Int]
= (Err("one")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]
scala> prog1.onError(action).value.run("").value
res0: (String, Either[Err,Int]
) = (one,Left(Err(one)))
scala> prog2.onError(action).value.run("").value
res1: (String, Either[Err,Int] ) = ("",Left(Err(two)))
}}}
res1: (String, Either[Err,Int] ) = ("",Left(Err(two)))
}}}
- Inhertied from
- ApplicativeError
Implicitly added by catsOptionTConcurrent
Operation meant for specifying tasks with safe resource
acquisition and release in the face of errors and interruption.
acquisition and release in the face of errors and interruption.
This operation provides the equivalent of
statements in mainstream imperative languages for resource
acquisition and release.
try/catch/finally
statements in mainstream imperative languages for resource
acquisition and release.
- Value Params
- acquire
-
is an action that "acquires" some expensive
resource, that needs to be used and then discarded - release
-
is the action that's supposed to release the
allocated resource afteruse
is done, regardless of
its exit condition. Throwing inside this function
is undefined behavior since it's left to the implementation. - use
-
is the action that uses the newly allocated
resource and that will provide the final result
- Inhertied from
- Bracket
def ensureOr[A](fa: F[A])(error: A => E)(predicate: A => Boolean): F[A]
Implicitly added by catsOptionTConcurrent
Turns a successful value into an error specified by the
error
function if it does not satisfy a given predicate.- Inhertied from
- MonadError
def attemptT[A](fa: F[A]): EitherT[F, E, A]
Implicitly added by catsOptionTConcurrent
Similar to attempt, but wraps the result in a data.EitherT for
convenience.
convenience.
- Inhertied from
- ApplicativeError
Implicitly added by catsOptionTConcurrent
Executes the given
either in success or in error, or if canceled.
finalizer
when the source is finished,either in success or in error, or if canceled.
This variant of guaranteeCase evaluates the given
regardless of how the source gets terminated:
finalizer
regardless of how the source gets terminated:
-
normal completion
-
completion in error
-
cancelation
This equivalence always holds:
{{{
F.guarantee(fa)(f) <-> F.bracket(F.unit)(_ => fa)(_ => f)
}}}
F.guarantee(fa)(f) <-> F.bracket(F.unit)(_ => fa)(_ => f)
}}}
As best practice, it's not a good idea to release resources
via
for the acquisition and release of resources.
via
guaranteeCase
in polymorphic code. Prefer bracketfor the acquisition and release of resources.
- See also
- guaranteeCase for the version that can discriminate
between termination conditionsbracket for the more general operation - Inhertied from
- Bracket
def void[A](fa: F[A]): F[Unit]
Implicitly added by catsOptionTConcurrent
Empty the fa of the values, preserving the structure
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.void(List(1,2,3))
res0: List[Unit] = List((), (), ())
}}}
res0: List[Unit] = List((), (), ())
}}}
- Inhertied from
- Functor
def untilM[G <: ([_$4] =>> Any), A](f: F[A])(cond: => F[Boolean])(G: Alternative[G]): F[G[A]]
Implicitly added by catsOptionTConcurrent
Execute an action repeatedly until the
The condition is evaluated after the loop body. Collects results into an
arbitrary
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
Boolean
condition returns true
.The condition is evaluated after the loop body. Collects results into an
arbitrary
Alternative
value, such as a Vector
.This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
List
.- Inhertied from
- Monad
@inline
final def <*>[A, B](ff: F[A => B])(fa: F[A]): F[B]
Implicitly added by catsOptionTConcurrent
Alias for ap.
- Inhertied from
- Apply
def handleErrorWith[A](fa: F[A])(f: E => F[A]): F[A]
Implicitly added by catsOptionTConcurrent
Handle any error, potentially recovering from it, by mapping it to an
F[A]
value.- See also
- handleError to handle any error by simply mapping it to an
A
value instead of anF[A]
.recoverWith to recover from only certain errors. - Inhertied from
- ApplicativeError
def attemptNarrow[EE <: Throwable, A](fa: F[A])(tag: ClassTag[EE], ev: EE <:< E): F[Either[EE, A]]
Implicitly added by catsOptionTConcurrent
Similar to attempt, but it only handles errors of type
EE
.- Inhertied from
- ApplicativeError
def attemptTap[A, B](fa: F[A])(f: Either[E, A] => F[B]): F[A]
Implicitly added by catsOptionTConcurrent
Reifies the value or error of the source and performs an effect on the result,
then recovers the original value or error back into
then recovers the original value or error back into
F
.Note that if the effect returned by
f
fails, the resulting effect will fail too.Alias for
fa.attempt.flatTap(f).rethrow
for convenience.Example:
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}
scala> def checkError(result: Either[Throwable, Int]
): Try[String]
= result.fold(_ => Failure(new java.lang.Exception), _ => Success("success"))
scala> val a: Try[Int]
= Failure(new Throwable("failed"))
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Int]
= Success(1)
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
}}}
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
}}}
- Inhertied from
- MonadError
@inline
final def *>[A, B](fa: F[A])(fb: F[B]): F[B]
Implicitly added by catsOptionTConcurrent
Alias for productR.
- Inhertied from
- Apply
def redeem[A, B](fa: F[A])(recover: E => B, f: A => B): F[B]
Implicitly added by catsOptionTConcurrent
Returns a new value that transforms the result of the source,
given the
on whether the result is successful or if it ends in error.
given the
recover
or map
functions, which get executed dependingon whether the result is successful or if it ends in error.
{{{
fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))
}}}
fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))
}}}
Usage of
redeem
subsumes handleError because:{{{
fa.redeem(fe, id) <-> fa.handleError(fe)
}}}
fa.redeem(fe, id) <-> fa.handleError(fe)
}}}
Implementations are free to override it in order to optimize
error recovery.
error recovery.
- Value Params
- fa
-
is the source whose result is going to get transformed
- recover
-
is the function that gets called to recover the source
in case of error
- See also
- Inhertied from
- ApplicativeError
def fproduct[A, B](fa: F[A])(f: A => B): F[(A, B)]
Implicitly added by catsOptionTConcurrent
Tuple the values in fa with the result of applying a function
with the value
with the value
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option]
.fproduct(Option(42))(_.toString)
res0: Option[(Int, String)] = Some((42,42))
}}}
res0: Option[(Int, String)] = Some((42,42))
}}}
- Inhertied from
- Functor
def unit: F[Unit]
Implicitly added by catsOptionTConcurrent
Returns an
F[Unit]
value, equivalent with pure(())
.A useful shorthand, also allowing implementations to optimize the
returned reference (e.g. it can be a
returned reference (e.g. it can be a
val
).Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[Option]
.unit
res0: Option[Unit] = Some(())
}}}
res0: Option[Unit] = Some(())
}}}
- Inhertied from
- Applicative
def productLEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[A]
Implicitly added by catsOptionTConcurrent
Sequentially compose two actions, discarding any value produced by the second. This variant of
productL also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
productL also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int] .productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
}}}
scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int] .productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
}}}
- Inhertied from
- FlatMap
def fromEither[A](x: Either[E, A]): F[A]
Implicitly added by catsKleisliConcurrent
Convert from scala.Either
Example:
{{{
scala> import cats.ApplicativeError
scala> import cats.instances.option._
{{{
scala> import cats.ApplicativeError
scala> import cats.instances.option._
scala> ApplicativeError[Option, Unit]
.fromEither(Right(1))
res0: scala.Option[Int] = Some(1)
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit]
.fromEither(Left(()))
res1: scala.Option[Nothing] = None
}}}
res1: scala.Option[Nothing] = None
}}}
- Inhertied from
- ApplicativeError
def unlessA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by catsKleisliConcurrent
Returns the given argument (mapped to Unit) if
otherwise, unit lifted into F.
cond
is false
,otherwise, unit lifted into F.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[List]
.unlessA(true)(List(1, 2, 3))
res0: List[Unit] = List(())
res0: List[Unit] = List(())
scala> Applicative[List]
.unlessA(false)(List(1, 2, 3))
res1: List[Unit] = List((), (), ())
res1: List[Unit] = List((), (), ())
scala> Applicative[List]
.unlessA(true)(List.empty[Int]
)
res2: List[Unit] = List(())
res2: List[Unit] = List(())
scala> Applicative[List]
.unlessA(false)(List.empty[Int]
)
res3: List[Unit] = List()
}}}
res3: List[Unit] = List()
}}}
- Inhertied from
- Applicative
@noop
def unzip[A, B](fab: F[(A, B)]): (F[A], F[B])
Implicitly added by catsKleisliConcurrent
Un-zips an
F[(A, B)]
consisting of element pairs or Tuple2 into two separate F's tupled.NOTE: Check for effect duplication, possibly memoize before
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.unzip(List((1,2), (3, 4)))
res0: (List[Int] , List[Int] ) = (List(1, 3),List(2, 4))
}}}
res0: (List[Int] , List[Int] ) = (List(1, 3),List(2, 4))
}}}
- Inhertied from
- Functor
def fix[A](fn: F[A] => F[A]): F[A]
Implicitly added by catsKleisliConcurrent
Defer instances, like functions, parsers, generators, IO, etc...
often are used in recursive settings where this function is useful
often are used in recursive settings where this function is useful
fix(fn) == fn(fix(fn))
example:
val parser: P[Int]
=
Defer[P] .fix[Int] { rec =>
CharsIn("0123456789") | P("(") ~ rec ~ P(")")
}
Defer[P] .fix[Int] { rec =>
CharsIn("0123456789") | P("(") ~ rec ~ P(")")
}
Note, fn may not yield a terminating value in which case both
of the above F[A] run forever.
of the above F[A] run forever.
- Inhertied from
- Defer
def recover[A](fa: F[A])(pf: PartialFunction[E, A]): F[A]
Implicitly added by catsKleisliConcurrent
Recover from certain errors by mapping them to an
A
value.- See also
- handleError to handle any/all errors.recoverWith to recover from certain errors by mapping them to
F[A]
values. - Inhertied from
- ApplicativeError
def iterateUntilM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by catsKleisliConcurrent
Apply a monadic function iteratively until its result satisfies
the given predicate and return that result.
the given predicate and return that result.
- Inhertied from
- Monad
def as[A, B](fa: F[A], b: B): F[B]
Implicitly added by catsKleisliConcurrent
Replaces the
A
value in F[A]
with the supplied value.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.as(List(1,2,3), "hello")
res0: List[String] = List(hello, hello, hello)
}}}
res0: List[String] = List(hello, hello, hello)
}}}
- Inhertied from
- Functor
def redeemWith[A, B](fa: F[A])(recover: E => F[B], bind: A => F[B]): F[B]
Implicitly added by catsKleisliConcurrent
Returns a new value that transforms the result of the source,
given the
on whether the result is successful or if it ends in error.
given the
recover
or bind
functions, which get executed dependingon whether the result is successful or if it ends in error.
{{{
fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))
}}}
fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))
}}}
Usage of
redeemWith
subsumes handleErrorWith because:{{{
fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)
}}}
fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)
}}}
Usage of
redeemWith
also subsumes flatMap because:{{{
fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)
}}}
fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)
}}}
Implementations are free to override it in order to optimize
error recovery.
error recovery.
- Value Params
- bind
-
is the function that gets to transform the source
in case of success - fa
-
is the source whose result is going to get transformed
- recover
-
is the function that gets called to recover the source
in case of error
- See also
- Inhertied from
- MonadError
def tupleLeft[A, B](fa: F[A], b: B): F[(B, A)]
Implicitly added by catsKleisliConcurrent
Tuples the
A
value in F[A]
with the supplied B
value, with the B
value on the left.Example:
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue]
.tupleLeft(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
}}}
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
}}}
- Inhertied from
- Functor
def composeApply[G <: ([_$2] =>> Any)](evidence$1: Apply[G]): InvariantSemigroupal[[α] =>> F[G[α]]]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- InvariantSemigroupal
@noop
def untilDefinedM[A](foa: F[Option[A]]): F[A]
Implicitly added by catsKleisliConcurrent
This repeats an F until we get defined values. This can be useful
for polling type operations on State (or RNG) Monads, or in effect
monads.
for polling type operations on State (or RNG) Monads, or in effect
monads.
- Inhertied from
- FlatMap
def iterateWhile[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by catsKleisliConcurrent
Execute an action repeatedly until its result fails to satisfy the given predicate
and return that result, discarding all others.
and return that result, discarding all others.
- Inhertied from
- Monad
@inline
final def <*[A, B](fa: F[A])(fb: F[B]): F[A]
Implicitly added by catsKleisliConcurrent
Alias for productL.
- Inhertied from
- Apply
@noop
def ifA[A](fcond: F[Boolean])(ifTrue: F[A], ifFalse: F[A]): F[A]
Implicitly added by catsKleisliConcurrent
An
This function combines the effects of the
in the order in which they are given.
if-then-else
lifted into the F
context.This function combines the effects of the
fcond
condition and of the two branches,in the order in which they are given.
The value of the result is, depending on the value of the condition,
the value of the first argument, or the value of the second argument.
the value of the first argument, or the value of the second argument.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val b1: Option[Boolean]
= Some(true)
scala> val asInt1: Option[Int] = Apply[Option] .ifA(b1)(Some(1), Some(0))
scala> asInt1.get
res0: Int = 1
scala> val asInt1: Option[Int] = Apply[Option] .ifA(b1)(Some(1), Some(0))
scala> asInt1.get
res0: Int = 1
scala> val b2: Option[Boolean]
= Some(false)
scala> val asInt2: Option[Int] = Apply[Option] .ifA(b2)(Some(1), Some(0))
scala> asInt2.get
res1: Int = 0
scala> val asInt2: Option[Int] = Apply[Option] .ifA(b2)(Some(1), Some(0))
scala> asInt2.get
res1: Int = 0
scala> val b3: Option[Boolean]
= Some(true)
scala> val asInt3: Option[Int] = Apply[Option] .ifA(b3)(Some(1), None)
asInt2: Option[Int] = None
scala> val asInt3: Option[Int] = Apply[Option] .ifA(b3)(Some(1), None)
asInt2: Option[Int] = None
}}}
- Inhertied from
- Apply
def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- FlatMap
@noop
def ifElseM[A](branches: (F[Boolean], F[A])*)(els: F[A]): F[A]
Implicitly added by catsKleisliConcurrent
Simulates an if/else-if/else in the context of an F. It evaluates conditions until
one evaluates to true, and returns the associated F[A] . If no condition is true,
returns els.
one evaluates to true, and returns the associated F[A] . If no condition is true,
returns els.
{{{
scala> import cats._
scala> Monad[Eval] .ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2
}}}
scala> import cats._
scala> Monad[Eval] .ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2
}}}
- See also
- See https://gitter.im/typelevel/cats-effect?at=5f297e4314c413356f56d230 for the discussion.
- Inhertied from
- Monad
Implicitly added by catsKleisliConcurrent
Returns a non-terminating
with a result, being equivalent to
F[_]
, that never completeswith a result, being equivalent to
async(_ => ())
- Inhertied from
- Async
def pure[A](x: A): F[A]
Implicitly added by catsKleisliConcurrent
pure
lifts any value into the Applicative Functor.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[Option]
.pure(10)
res0: Option[Int] = Some(10)
}}}
res0: Option[Int] = Some(10)
}}}
- Inhertied from
- Applicative
def point[A](a: A): F[A]
Implicitly added by catsKleisliConcurrent
point
lifts any value into a Monoidal Functor.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> InvariantMonoidal[Option]
.point(10)
res0: Option[Int] = Some(10)
}}}
res0: Option[Int] = Some(10)
}}}
- Inhertied from
- InvariantMonoidal
def compose[G <: ([_$2] =>> Any)](evidence$1: Applicative[G]): Applicative[[α] =>> F[G[α]]]
Implicitly added by catsKleisliConcurrent
Compose an
Applicative[F]
and an Applicative[G]
into anApplicative[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val alo = Applicative[List]
.compose[Option]
scala> alo.pure(3)
res0: List[Option[Int] ] = List(Some(3))
res0: List[Option[Int] ] = List(Some(3))
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
- Inhertied from
- Applicative
def compose[G <: ([_$2] =>> Any)](evidence$1: Invariant[G]): Invariant[[α] =>> F[G[α]]]
Implicitly added by catsKleisliConcurrent
Compose Invariant
F[_]
and G[_]
then produce Invariant[F[G[_]]]
using their imap
.Example:
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]
] =
| Invariant[Semigroup] .compose[List] .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
| Invariant[Semigroup] .compose[List] .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
- Inhertied from
- Invariant
def compose[G <: ([_$3] =>> Any)](evidence$1: Apply[G]): Apply[[α] =>> F[G[α]]]
Implicitly added by catsKleisliConcurrent
Compose an
Apply[F]
and an Apply[G]
into an Apply[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val alo = Apply[List]
.compose[Option]
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
- Inhertied from
- Apply
def compose[G <: ([_$6] =>> Any)](evidence$1: Functor[G]): Functor[[α] =>> F[G[α]]]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- Functor
def ensure[A](fa: F[A])(error: => E)(predicate: A => Boolean): F[A]
Implicitly added by catsKleisliConcurrent
Turns a successful value into an error if it does not satisfy a given predicate.
- Inhertied from
- MonadError
def widen[A, B >: A](fa: F[A]): F[B]
Implicitly added by catsKleisliConcurrent
Lifts natural subtyping covariance of covariant Functors.
NOTE: In certain (perhaps contrived) situations that rely on universal
equality this can result in a
implemented as a type cast. It could be implemented as
according to the functor laws, that should be equal to
cast is often much more performant.
See this example
of
equality this can result in a
ClassCastException
, because it isimplemented as a type cast. It could be implemented as
map(identity)
, butaccording to the functor laws, that should be equal to
fa
, and a typecast is often much more performant.
See this example
of
widen
creating a ClassCastException
.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val s = Some(42)
scala> Functor[Option] .widen(s)
res0: Option[Int] = Some(42)
}}}
scala> Functor[Option] .widen(s)
res0: Option[Int] = Some(42)
}}}
- Inhertied from
- Functor
@noop
def foreverM[A, B](fa: F[A]): F[B]
Implicitly added by catsKleisliConcurrent
Like an infinite loop of >> calls. This is most useful effect loops
that you want to run forever in for instance a server.
that you want to run forever in for instance a server.
This will be an infinite loop, or it will return an F[Nothing]
.
Be careful using this.
For instance, a List of length k will produce a list of length k^n at iteration
n. This means if k = 0, we return an empty list, if k = 1, we loop forever
allocating single element lists, but if we have a k > 1, we will allocate
exponentially increasing memory and very quickly OOM.
For instance, a List of length k will produce a list of length k^n at iteration
n. This means if k = 0, we return an empty list, if k = 1, we loop forever
allocating single element lists, but if we have a k > 1, we will allocate
exponentially increasing memory and very quickly OOM.
- Inhertied from
- FlatMap
Implicitly added by catsKleisliConcurrent
Creates a simple, non-cancelable
executes an asynchronous process on evaluation.
F[A]
instance thatexecutes an asynchronous process on evaluation.
The given function is being injected with a side-effectful
callback for signaling the final result of an asynchronous
process. And its returned result needs to be a pure
that gets evaluated by the runtime.
callback for signaling the final result of an asynchronous
process. And its returned result needs to be a pure
F[Unit]
that gets evaluated by the runtime.
Note the simpler async variant async can be derived like this:
{{{
F.async(k) <-> F.asyncF(cb => F.delay(k(cb)))
}}}
F.async(k) <-> F.asyncF(cb => F.delay(k(cb)))
}}}
For wrapping impure APIs usually you can use the simpler async,
however
wrapped with the help of pure abstractions, such as
Ref.
however
asyncF
is useful in cases where impure APIs arewrapped with the help of pure abstractions, such as
Ref.
For example here's how a simple, "pure Promise" implementation
could be implemented via
as you have a far better
Deferred available):
could be implemented via
Ref
(sample is for didactic purposes,as you have a far better
Deferred available):
{{{
import cats.effect.concurrent.Ref
import cats.effect.concurrent.Ref
type Callback[-A]
= Either[Throwable, A]
=> Unit
class PurePromise[F[_]
, A](ref: Ref[F, Either[List[Callback[A]
], A]])
(implicit F: Async[F] ) {
(implicit F: Async[F] ) {
def get: F[A]
= F.asyncF { cb =>
ref.modify {
case current @ Right(result) =>
(current, F.delay(cb(Right(result))))
case Left(list) =>
(Left(cb :: list), F.unit)
}
}
ref.modify {
case current @ Right(result) =>
(current, F.delay(cb(Right(result))))
case Left(list) =>
(Left(cb :: list), F.unit)
}
}
def complete(value: A): F[Unit]
=
F.flatten(ref.modify {
case Left(list) =>
(Right(value), F.delay(list.foreach(_(Right(value)))))
case right =>
(right, F.unit)
})
}
}}}
F.flatten(ref.modify {
case Left(list) =>
(Right(value), F.delay(list.foreach(_(Right(value)))))
case right =>
(right, F.unit)
})
}
}}}
N.B. if
Concurrent), then the returned
its evaluation hooking into the underlying cancelation mechanism
of
F[_]
is a cancelable data type (i.e. implementingConcurrent), then the returned
F[Unit]
can be cancelable,its evaluation hooking into the underlying cancelation mechanism
of
F[_]
, so something like this behaves like you'd expect:{{{
def delayed[F[_] , A](thunk: => A)
(implicit F: Async[F] , timer: Timer[F] ): F[A] = {
def delayed[F[_] , A](thunk: => A)
(implicit F: Async[F] , timer: Timer[F] ): F[A] = {
timer.sleep(1.second) *> F.delay(cb(
try cb(Right(thunk))
catch { case NonFatal(e) => Left(cb(Left(e))) }
))
}
}}}
try cb(Right(thunk))
catch { case NonFatal(e) => Left(cb(Left(e))) }
))
}
}}}
The
that the result has to be signaled via the provided callback.
asyncF
operation behaves like Sync.suspend, exceptthat the result has to be signaled via the provided callback.
==ERROR HANDLING==
As a matter of contract the returned
throw errors. If it does, then the behavior is undefined.
F[Unit]
should notthrow errors. If it does, then the behavior is undefined.
This is because by contract the provided callback should
only be called once. Calling it concurrently, multiple times,
is a contract violation. And if the returned
then the implementation might have called it already, so it
would be a contract violation to call it without expensive
synchronization.
only be called once. Calling it concurrently, multiple times,
is a contract violation. And if the returned
F[Unit]
throws,then the implementation might have called it already, so it
would be a contract violation to call it without expensive
synchronization.
In case errors are thrown the behavior is implementation specific.
The error might get logged to stderr, or via other mechanisms
that are implementations specific.
The error might get logged to stderr, or via other mechanisms
that are implementations specific.
Implicitly added by catsKleisliConcurrent
Lifts any by-name parameter into the
F
context.Equivalent to
the purpose of this function is to suspend side effects
in
Applicative.pure
for pure expressions,the purpose of this function is to suspend side effects
in
F
.- Inhertied from
- Sync
def catchNonFatalEval[A](a: Eval[A])(ev: Throwable <:< E): F[A]
Implicitly added by catsKleisliConcurrent
Often E is Throwable. Here we try to call pure or catch
and raise
and raise
- Inhertied from
- ApplicativeError
Implicitly added by catsKleisliConcurrent
- Value Params
- acquire
-
is an action that "acquires" some expensive
resource, that needs to be used and then discarded - release
-
is the action that's supposed to release the
allocated resource afteruse
is done, by observing
and acting on its exit condition. Throwing inside
this function leads to undefined behavior since it's
left to the implementation. - use
-
is the action that uses the newly allocated
resource and that will provide the final result
- Inhertied from
- Bracket
@noop
def ifF[A](fb: F[Boolean])(ifTrue: => A, ifFalse: => A): F[A]
Implicitly added by catsKleisliConcurrent
Lifts
if
to FunctorExample:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.ifF(List(true, false, false))(1, 0)
res0: List[Int] = List(1, 0, 0)
}}}
res0: List[Int] = List(1, 0, 0)
}}}
- Inhertied from
- Functor
def replicateA[A](n: Int, fa: F[A]): F[List[A]]
Implicitly added by catsKleisliConcurrent
Given
fa
and n
, apply fa
n
times to construct an F[List[A]]
value.Example:
{{{
scala> import cats.data.State
{{{
scala> import cats.data.State
scala> type Counter[A]
= State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int] ] =
| Applicative[Counter] .replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int] ) = (5,List(0, 1, 2, 3, 4))
}}}
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int] ] =
| Applicative[Counter] .replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int] ) = (5,List(0, 1, 2, 3, 4))
}}}
- Inhertied from
- Applicative
def rethrow[A, EE <: E](fa: F[Either[EE, A]]): F[A]
Implicitly added by catsKleisliConcurrent
Inverse of
attempt
Example:
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success}
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success}
scala> val a: Try[Either[Throwable, Int]
] = Success(Left(new java.lang.Exception))
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Either[Throwable, Int]
] = Success(Right(1))
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
}}}
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
}}}
- Inhertied from
- MonadError
def raiseError[A](e: E): F[A]
Implicitly added by catsKleisliConcurrent
Lift an error into the
F
context.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
// integer-rounded division
scala> def divide[F[_] ](dividend: Int, divisor: Int)(implicit F: ApplicativeError[F, String] ): F[Int] =
| if (divisor === 0) F.raiseError("division by zero")
| else F.pure(dividend / divisor)
scala> def divide[F[_] ](dividend: Int, divisor: Int)(implicit F: ApplicativeError[F, String] ): F[Int] =
| if (divisor === 0) F.raiseError("division by zero")
| else F.pure(dividend / divisor)
scala> type ErrorOr[A]
= Either[String, A]
scala> divide[ErrorOr]
(6, 3)
res0: ErrorOr[Int] = Right(2)
res0: ErrorOr[Int] = Right(2)
scala> divide[ErrorOr]
(6, 0)
res1: ErrorOr[Int] = Left(division by zero)
}}}
res1: ErrorOr[Int] = Left(division by zero)
}}}
- Inhertied from
- ApplicativeError
def lift[A, B](f: A => B): F[A] => F[B]
Implicitly added by catsKleisliConcurrent
Lift a function f to operate on Functors
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val o = Option(42)
scala> Functor[Option] .lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
}}}
scala> Functor[Option] .lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
}}}
- Inhertied from
- Functor
def mproduct[A, B](fa: F[A])(f: A => F[B]): F[(A, B)]
Implicitly added by catsKleisliConcurrent
Pair
A
with the result of function application.Example:
{{{
scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
}}}
{{{
scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
}}}
- Inhertied from
- FlatMap
def whenA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by catsKleisliConcurrent
Returns the given argument (mapped to Unit) if
unit lifted into F.
cond
is true
, otherwise,unit lifted into F.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[List]
.whenA(true)(List(1, 2, 3))
res0: List[Unit] = List((), (), ())
res0: List[Unit] = List((), (), ())
scala> Applicative[List]
.whenA(false)(List(1, 2, 3))
res1: List[Unit] = List(())
res1: List[Unit] = List(())
scala> Applicative[List]
.whenA(true)(List.empty[Int]
)
res2: List[Unit] = List()
res2: List[Unit] = List()
scala> Applicative[List]
.whenA(false)(List.empty[Int]
)
res3: List[Unit] = List(())
}}}
res3: List[Unit] = List(())
}}}
- Inhertied from
- Applicative
def fromValidated[A](x: Validated[E, A]): F[A]
Implicitly added by catsKleisliConcurrent
Convert from cats.data.Validated
Example:
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> ApplicativeError[Option, Unit]
.fromValidated(1.valid[Unit]
)
res0: scala.Option[Int] = Some(1)
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit]
.fromValidated(().invalid[Int]
)
res1: scala.Option[Int] = None
}}}
res1: scala.Option[Int] = None
}}}
- Inhertied from
- ApplicativeError
def composeFunctor[G <: ([_$3] =>> Any)](evidence$2: Functor[G]): Invariant[[α] =>> F[G[α]]]
Implicitly added by catsKleisliConcurrent
Compose Invariant
using F's
F[_]
and Functor G[_]
then produce Invariant[F[G[_]]]
using F's
imap
and G's map
.Example:
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]
] =
| Invariant[Semigroup]
| .composeFunctor[List]
| .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
| Invariant[Semigroup]
| .composeFunctor[List]
| .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
- Inhertied from
- Invariant
def composeContravariantMonoidal[G <: ([_$3] =>> Any)](evidence$2: ContravariantMonoidal[G]): ContravariantMonoidal[[α] =>> F[G[α]]]
Implicitly added by catsKleisliConcurrent
Compose an
Applicative[F]
and a ContravariantMonoidal[G]
into aContravariantMonoidal[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.kernel.Comparison
scala> import cats.implicits._
{{{
scala> import cats.kernel.Comparison
scala> import cats.implicits._
// compares strings by alphabetical order
scala> val alpha: Order[String] = Order[String]
scala> val alpha: Order[String] = Order[String]
// compares strings by their length
scala> val strLength: Order[String] = Order.byString, Int
scala> val strLength: Order[String] = Order.byString, Int
scala> val stringOrders: List[Order[String]
] = List(alpha, strLength)
// first comparison is with alpha order, second is with string length
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)
scala> val le = Applicative[List]
.composeContravariantMonoidal[Order]
// create Int orders that convert ints to strings and then use the string orders
scala> val intOrders: List[Order[Int] ] = le.contramap(stringOrders)(_.toString)
scala> val intOrders: List[Order[Int] ] = le.contramap(stringOrders)(_.toString)
// first comparison is with alpha order, second is with string length
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)
// create the
//
// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)] ] = le.product(stringOrders, intOrders)
product
of the string order list and the int order list//
p
contains a list of the following orders:// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)] ] = le.product(stringOrders, intOrders)
scala> p.map(o => o.comparison(("abc", 12), ("def", 3)))
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
}}}
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
}}}
- Inhertied from
- Applicative
final def fmap[A, B](fa: F[A])(f: A => B): F[B]
Implicitly added by catsKleisliConcurrent
Alias for map, since map can't be injected as syntax if
the implementing type already had a built-in
the implementing type already had a built-in
.map
method.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val m: Map[Int, String]
= Map(1 -> "hi", 2 -> "there", 3 -> "you")
scala> m.fmap(_ ++ "!")
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
}}}
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
}}}
- Inhertied from
- Functor
def fromOption[A](oa: Option[A], ifEmpty: => E): F[A]
Implicitly added by catsKleisliConcurrent
Convert from scala.Option
Example:
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *] , String]
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *] , String]
scala> F.fromOption(Some(1), "Empty")
res0: scala.Either[String, Int] = Right(1)
res0: scala.Either[String, Int] = Right(1)
scala> F.fromOption(Option.empty[Int]
, "Empty")
res1: scala.Either[String, Int] = Left(Empty)
}}}
res1: scala.Either[String, Int] = Left(Empty)
}}}
- Inhertied from
- ApplicativeError
def tuple2[A, B](f1: F[A], f2: F[B]): F[(A, B)]
Implicitly added by catsKleisliConcurrent
- Inhertied from
- ApplyArityFunctions
@deprecated("use defer", "2.4.0")
Implicitly added by catsKleisliConcurrent
Suspends the evaluation of an
F
reference.Equivalent to
the purpose of this function is to suspend side effects
in
FlatMap.flatten
for pure expressions,the purpose of this function is to suspend side effects
in
F
.- Inhertied from
- Sync
def catchNonFatal[A](a: => A)(ev: Throwable <:< E): F[A]
Implicitly added by catsKleisliConcurrent
Often E is Throwable. Here we try to call pure or catch
and raise.
and raise.
- Inhertied from
- ApplicativeError
def handleError[A](fa: F[A])(f: E => A): F[A]
Implicitly added by catsKleisliConcurrent
Handle any error, by mapping it to an
A
value.- See also
- handleErrorWith to map to an
F[A]
value instead of simply anA
value.recover to only recover from certain errors. - Inhertied from
- ApplicativeError
def fromTry[A](t: Try[A])(ev: Throwable <:< E): F[A]
Implicitly added by catsKleisliConcurrent
If the error type is Throwable, we can convert from a scala.util.Try
- Inhertied from
- ApplicativeError
def tailRecM[A, B](a: A)(f: A => F[Either[A, B]]): F[B]
Implicitly added by catsKleisliConcurrent
Keeps calling
f
until a scala.util.Right[B]
is returned.Based on Phil Freeman's
Stack Safety for Free.
Stack Safety for Free.
Implementations of this method should use constant stack space relative to
f
.- Inhertied from
- FlatMap
Implicitly added by catsKleisliConcurrent
Executes the given
either in success or in error, or if canceled, allowing
for differentiating between exit conditions.
finalizer
when the source is finished,either in success or in error, or if canceled, allowing
for differentiating between exit conditions.
This variant of guarantee injects an ExitCase in
the provided function, allowing one to make a difference
between:
the provided function, allowing one to make a difference
between:
-
normal completion
-
completion in error
-
cancelation
This equivalence always holds:
{{{
F.guaranteeCase(fa)(f) <-> F.bracketCase(F.unit)(_ => fa)((_, e) => f(e))
}}}
F.guaranteeCase(fa)(f) <-> F.bracketCase(F.unit)(_ => fa)((_, e) => f(e))
}}}
As best practice, it's not a good idea to release resources
via
for the acquisition and release of resources.
via
guaranteeCase
in polymorphic code. Prefer bracketCasefor the acquisition and release of resources.
- See also
- guarantee for the simpler versionbracketCase for the more general operation
- Inhertied from
- Bracket
def untilM_[A](f: F[A])(cond: => F[Boolean]): F[Unit]
Implicitly added by catsKleisliConcurrent
Execute an action repeatedly until the
The condition is evaluated after the loop body. Discards results.
Boolean
condition returns true
.The condition is evaluated after the loop body. Discards results.
- Inhertied from
- Monad
def fproductLeft[A, B](fa: F[A])(f: A => B): F[(B, A)]
Implicitly added by catsKleisliConcurrent
Pair the result of function application with
A
.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option]
.fproductLeft(Option(42))(_.toString)
res0: Option[(String, Int)] = Some((42,42))
}}}
res0: Option[(String, Int)] = Some((42,42))
}}}
- Inhertied from
- Functor
@noop
def iterateForeverM[A, B](a: A)(f: A => F[A]): F[B]
Implicitly added by catsKleisliConcurrent
iterateForeverM is almost exclusively useful for effect types. For instance,
A may be some state, we may take the current state, run some effect to get
a new state and repeat.
A may be some state, we may take the current state, run some effect to get
a new state and repeat.
- Inhertied from
- FlatMap
def recoverWith[A](fa: F[A])(pf: PartialFunction[E, F[A]]): F[A]
Implicitly added by catsKleisliConcurrent
Recover from certain errors by mapping them to an
F[A]
value.- See also
- handleErrorWith to handle any/all errors.recover to recover from certain errors by mapping them to
A
values. - Inhertied from
- ApplicativeError
def iterateWhileM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by catsKleisliConcurrent
Apply a monadic function iteratively until its result fails
to satisfy the given predicate and return that result.
to satisfy the given predicate and return that result.
- Inhertied from
- Monad
@noop
def whileM_[A](p: F[Boolean])(body: => F[A]): F[Unit]
Implicitly added by catsKleisliConcurrent
Execute an action repeatedly as long as the given
returns
Discards results.
Boolean
expressionreturns
true
. The condition is evaluated before the loop body.Discards results.
- Inhertied from
- Monad
def map2Eval[A, B, Z](fa: F[A], fb: Eval[F[B]])(f: (A, B) => Z): Eval[F[Z]]
Implicitly added by catsKleisliConcurrent
Similar to map2 but uses Eval to allow for laziness in the
argument. This can allow for "short-circuiting" of computations.
F[B]
argument. This can allow for "short-circuiting" of computations.
NOTE: the default implementation of
computations. For data structures that can benefit from laziness, Apply
instances should override this method.
map2Eval
does not short-circuitcomputations. For data structures that can benefit from laziness, Apply
instances should override this method.
In the following example,
but
result of
that the result of
x.map2(bomb)(_ + _)
would result in an error,but
map2Eval
"short-circuits" the computation. x
is None
and thus theresult of
bomb
doesn't even need to be evaluated in order to determinethat the result of
map2Eval
should be None
.{{{
scala> import cats.{Eval, Later}
scala> import cats.implicits._
scala> val bomb: Eval[Option[Int] ] = Later(sys.error("boom"))
scala> val x: Option[Int] = None
scala> x.map2Eval(bomb)(_ + _).value
res0: Option[Int] = None
}}}
scala> import cats.{Eval, Later}
scala> import cats.implicits._
scala> val bomb: Eval[Option[Int] ] = Later(sys.error("boom"))
scala> val x: Option[Int] = None
scala> x.map2Eval(bomb)(_ + _).value
res0: Option[Int] = None
}}}
- Inhertied from
- Apply
def flatTap[A, B](fa: F[A])(f: A => F[B]): F[A]
Implicitly added by catsKleisliConcurrent
Apply a monadic function and discard the result while keeping the effect.
{{{
scala> import cats., implicits.
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> ListInt.flatTap(nCats)
res2: List[Int] = List()
scala> ListInt.flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
}}}
scala> import cats., implicits.
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> ListInt.flatTap(nCats)
res2: List[Int] = List()
scala> ListInt.flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
}}}
- Inhertied from
- FlatMap
def productREval[A, B](fa: F[A])(fb: Eval[F[B]]): F[B]
Implicitly added by catsKleisliConcurrent
Sequentially compose two actions, discarding any value produced by the first. This variant of
productR also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
productR also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
}}}
scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
}}}
- Inhertied from
- FlatMap
def flatten[A](ffa: F[F[A]]): F[A]
Implicitly added by catsKleisliConcurrent
"flatten" a nested
F
of F
structure into a single-layer F
structure.This is also commonly called
join
.Example:
{{{
scala> import cats.Eval
scala> import cats.implicits._
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> val nested: Eval[Eval[Int]
] = Eval.now(Eval.now(3))
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3
}}}
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3
}}}
- Inhertied from
- FlatMap
def catchOnly[T >: Null <: Throwable]: CatchOnlyPartiallyApplied[T, F, E]
Implicitly added by catsKleisliConcurrent
Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.
- Inhertied from
- ApplicativeError
def tupleRight[A, B](fa: F[A], b: B): F[(A, B)]
Implicitly added by catsKleisliConcurrent
Tuples the
A
value in F[A]
with the supplied B
value, with the B
value on the right.Example:
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue]
.tupleRight(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
}}}
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
}}}
- Inhertied from
- Functor
Implicitly added by catsKleisliConcurrent
Operation meant for ensuring a given task continues execution even
when interrupted.
when interrupted.
- Inhertied from
- Bracket
Implicitly added by catsKleisliConcurrent
Executes the given
finalizer
when the source is canceled.The typical use case for this function arises in the
implementation of concurrent abstractions, which generally
consist of operations that perform asynchronous waiting after
concurrently modifying some state: in case the user asks for
cancelation, we want to interrupt the waiting operation, and
restore the state to its previous value.
implementation of concurrent abstractions, which generally
consist of operations that perform asynchronous waiting after
concurrently modifying some state: in case the user asks for
cancelation, we want to interrupt the waiting operation, and
restore the state to its previous value.
{{{
waitingOp.onCancel(restoreState)
}}}
waitingOp.onCancel(restoreState)
}}}
A direct use of
would make the waiting action uncancelable.
bracket
is not a good fit for this case as itwould make the waiting action uncancelable.
NOTE: This function handles interruption only, you need to take
care of the success and error case elsewhere in your code
care of the success and error case elsewhere in your code
- See also
- guaranteeCase for the version that can discriminate
between termination conditionsbracket for the more general operationConcurrent.continual when you have a use case similar to
the cancel/restore example above, but require access to the
result ofF[A]
- Inhertied from
- Bracket
def iterateUntil[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by catsKleisliConcurrent
Execute an action repeatedly until its result satisfies the given predicate
and return that result, discarding all others.
and return that result, discarding all others.
- Inhertied from
- Monad
def attempt[A](fa: F[A]): F[Either[E, A]]
Implicitly added by catsKleisliConcurrent
Handle errors by turning them into scala.util.Either values.
If there is no error, then an
scala.util.Right
value will be returned instead.All non-fatal errors should be handled by this method.
- Inhertied from
- ApplicativeError
@noop
def ifM[B](fa: F[Boolean])(ifTrue: => F[B], ifFalse: => F[B]): F[B]
Implicitly added by catsKleisliConcurrent
if
lifted into monad.- Inhertied from
- FlatMap
Implicitly added by catsKleisliConcurrent
Creates a simple, non-cancelable
executes an asynchronous process on evaluation.
F[A]
instance thatexecutes an asynchronous process on evaluation.
The given function is being injected with a side-effectful
callback for signaling the final result of an asynchronous
process.
callback for signaling the final result of an asynchronous
process.
This operation could be derived from asyncF, because:
{{{
F.async(k) <-> F.asyncF(cb => F.delay(k(cb)))
}}}
F.async(k) <-> F.asyncF(cb => F.delay(k(cb)))
}}}
As an example of wrapping an impure async API, here's the
implementation of Async.shift:
implementation of Async.shift:
{{{
def shift[F[_] ](ec: ExecutionContext)(implicit F: Async[F] ): F[Unit] =
F.async { cb =>
// Scheduling an async boundary (logical thread fork)
ec.execute(new Runnable {
def run(): Unit = {
// Signaling successful completion
cb(Right(()))
}
})
}
}}}
def shift[F[_] ](ec: ExecutionContext)(implicit F: Async[F] ): F[Unit] =
F.async { cb =>
// Scheduling an async boundary (logical thread fork)
ec.execute(new Runnable {
def run(): Unit = {
// Signaling successful completion
cb(Right(()))
}
})
}
}}}
@noop
def whileM[G <: ([_$2] =>> Any), A](p: F[Boolean])(body: => F[A])(G: Alternative[G]): F[G[A]]
Implicitly added by catsKleisliConcurrent
Execute an action repeatedly as long as the given
returns
Collects the results into an arbitrary
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
Boolean
expressionreturns
true
. The condition is evaluated before the loop body.Collects the results into an arbitrary
Alternative
value, such as a Vector
.This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
List
.- Inhertied from
- Monad
def onError[A](fa: F[A])(pf: PartialFunction[E, F[Unit]]): F[A]
Implicitly added by catsKleisliConcurrent
Execute a callback on certain errors, then rethrow them.
Any non matching error is rethrown as well.
Any non matching error is rethrown as well.
In the following example, only one of the errors is logged,
but they are both rethrown, to be possibly handled by another
layer of the program:
but they are both rethrown, to be possibly handled by another
layer of the program:
{{{
scala> import cats., data., implicits._
scala> import cats., data., implicits._
scala> case class Err(msg: String)
scala> type F[A]
= EitherT[State[String, *]
, Err, A]
scala> val action: PartialFunction[Err, F[Unit]
] = {
| case Err("one") => EitherT.liftF(State.set("one"))
| }
| case Err("one") => EitherT.liftF(State.set("one"))
| }
scala> val prog1: F[Int]
= (Err("one")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]
scala> prog1.onError(action).value.run("").value
res0: (String, Either[Err,Int]
) = (one,Left(Err(one)))
scala> prog2.onError(action).value.run("").value
res1: (String, Either[Err,Int] ) = ("",Left(Err(two)))
}}}
res1: (String, Either[Err,Int] ) = ("",Left(Err(two)))
}}}
- Inhertied from
- ApplicativeError
Implicitly added by catsKleisliConcurrent
Operation meant for specifying tasks with safe resource
acquisition and release in the face of errors and interruption.
acquisition and release in the face of errors and interruption.
This operation provides the equivalent of
statements in mainstream imperative languages for resource
acquisition and release.
try/catch/finally
statements in mainstream imperative languages for resource
acquisition and release.
- Value Params
- acquire
-
is an action that "acquires" some expensive
resource, that needs to be used and then discarded - release
-
is the action that's supposed to release the
allocated resource afteruse
is done, regardless of
its exit condition. Throwing inside this function
is undefined behavior since it's left to the implementation. - use
-
is the action that uses the newly allocated
resource and that will provide the final result
- Inhertied from
- Bracket
def ensureOr[A](fa: F[A])(error: A => E)(predicate: A => Boolean): F[A]
Implicitly added by catsKleisliConcurrent
Turns a successful value into an error specified by the
error
function if it does not satisfy a given predicate.- Inhertied from
- MonadError
def attemptT[A](fa: F[A]): EitherT[F, E, A]
Implicitly added by catsKleisliConcurrent
Similar to attempt, but wraps the result in a data.EitherT for
convenience.
convenience.
- Inhertied from
- ApplicativeError
Implicitly added by catsKleisliConcurrent
Executes the given
either in success or in error, or if canceled.
finalizer
when the source is finished,either in success or in error, or if canceled.
This variant of guaranteeCase evaluates the given
regardless of how the source gets terminated:
finalizer
regardless of how the source gets terminated:
-
normal completion
-
completion in error
-
cancelation
This equivalence always holds:
{{{
F.guarantee(fa)(f) <-> F.bracket(F.unit)(_ => fa)(_ => f)
}}}
F.guarantee(fa)(f) <-> F.bracket(F.unit)(_ => fa)(_ => f)
}}}
As best practice, it's not a good idea to release resources
via
for the acquisition and release of resources.
via
guaranteeCase
in polymorphic code. Prefer bracketfor the acquisition and release of resources.
- See also
- guaranteeCase for the version that can discriminate
between termination conditionsbracket for the more general operation - Inhertied from
- Bracket
def void[A](fa: F[A]): F[Unit]
Implicitly added by catsKleisliConcurrent
Empty the fa of the values, preserving the structure
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.void(List(1,2,3))
res0: List[Unit] = List((), (), ())
}}}
res0: List[Unit] = List((), (), ())
}}}
- Inhertied from
- Functor
def untilM[G <: ([_$4] =>> Any), A](f: F[A])(cond: => F[Boolean])(G: Alternative[G]): F[G[A]]
Implicitly added by catsKleisliConcurrent
Execute an action repeatedly until the
The condition is evaluated after the loop body. Collects results into an
arbitrary
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
Boolean
condition returns true
.The condition is evaluated after the loop body. Collects results into an
arbitrary
Alternative
value, such as a Vector
.This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
List
.- Inhertied from
- Monad
@inline
final def <*>[A, B](ff: F[A => B])(fa: F[A]): F[B]
Implicitly added by catsKleisliConcurrent
Alias for ap.
- Inhertied from
- Apply
def handleErrorWith[A](fa: F[A])(f: E => F[A]): F[A]
Implicitly added by catsKleisliConcurrent
Handle any error, potentially recovering from it, by mapping it to an
F[A]
value.- See also
- handleError to handle any error by simply mapping it to an
A
value instead of anF[A]
.recoverWith to recover from only certain errors. - Inhertied from
- ApplicativeError
def attemptNarrow[EE <: Throwable, A](fa: F[A])(tag: ClassTag[EE], ev: EE <:< E): F[Either[EE, A]]
Implicitly added by catsKleisliConcurrent
Similar to attempt, but it only handles errors of type
EE
.- Inhertied from
- ApplicativeError
def attemptTap[A, B](fa: F[A])(f: Either[E, A] => F[B]): F[A]
Implicitly added by catsKleisliConcurrent
Reifies the value or error of the source and performs an effect on the result,
then recovers the original value or error back into
then recovers the original value or error back into
F
.Note that if the effect returned by
f
fails, the resulting effect will fail too.Alias for
fa.attempt.flatTap(f).rethrow
for convenience.Example:
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}
scala> def checkError(result: Either[Throwable, Int]
): Try[String]
= result.fold(_ => Failure(new java.lang.Exception), _ => Success("success"))
scala> val a: Try[Int]
= Failure(new Throwable("failed"))
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Int]
= Success(1)
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
}}}
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
}}}
- Inhertied from
- MonadError
@inline
final def *>[A, B](fa: F[A])(fb: F[B]): F[B]
Implicitly added by catsKleisliConcurrent
Alias for productR.
- Inhertied from
- Apply
def redeem[A, B](fa: F[A])(recover: E => B, f: A => B): F[B]
Implicitly added by catsKleisliConcurrent
Returns a new value that transforms the result of the source,
given the
on whether the result is successful or if it ends in error.
given the
recover
or map
functions, which get executed dependingon whether the result is successful or if it ends in error.
{{{
fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))
}}}
fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))
}}}
Usage of
redeem
subsumes handleError because:{{{
fa.redeem(fe, id) <-> fa.handleError(fe)
}}}
fa.redeem(fe, id) <-> fa.handleError(fe)
}}}
Implementations are free to override it in order to optimize
error recovery.
error recovery.
- Value Params
- fa
-
is the source whose result is going to get transformed
- recover
-
is the function that gets called to recover the source
in case of error
- See also
- Inhertied from
- ApplicativeError
def fproduct[A, B](fa: F[A])(f: A => B): F[(A, B)]
Implicitly added by catsKleisliConcurrent
Tuple the values in fa with the result of applying a function
with the value
with the value
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option]
.fproduct(Option(42))(_.toString)
res0: Option[(Int, String)] = Some((42,42))
}}}
res0: Option[(Int, String)] = Some((42,42))
}}}
- Inhertied from
- Functor
def unit: F[Unit]
Implicitly added by catsKleisliConcurrent
Returns an
F[Unit]
value, equivalent with pure(())
.A useful shorthand, also allowing implementations to optimize the
returned reference (e.g. it can be a
returned reference (e.g. it can be a
val
).Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[Option]
.unit
res0: Option[Unit] = Some(())
}}}
res0: Option[Unit] = Some(())
}}}
- Inhertied from
- Applicative
def productLEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[A]
Implicitly added by catsKleisliConcurrent
Sequentially compose two actions, discarding any value produced by the second. This variant of
productL also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
productL also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int] .productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
}}}
scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int] .productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
}}}
- Inhertied from
- FlatMap
def fromEither[A](x: Either[E, A]): F[A]
Convert from scala.Either
Example:
{{{
scala> import cats.ApplicativeError
scala> import cats.instances.option._
{{{
scala> import cats.ApplicativeError
scala> import cats.instances.option._
scala> ApplicativeError[Option, Unit]
.fromEither(Right(1))
res0: scala.Option[Int] = Some(1)
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit]
.fromEither(Left(()))
res1: scala.Option[Nothing] = None
}}}
res1: scala.Option[Nothing] = None
}}}
- Inhertied from
- ApplicativeError
def unlessA[A](cond: Boolean)(f: => F[A]): F[Unit]
Returns the given argument (mapped to Unit) if
otherwise, unit lifted into F.
cond
is false
,otherwise, unit lifted into F.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[List]
.unlessA(true)(List(1, 2, 3))
res0: List[Unit] = List(())
res0: List[Unit] = List(())
scala> Applicative[List]
.unlessA(false)(List(1, 2, 3))
res1: List[Unit] = List((), (), ())
res1: List[Unit] = List((), (), ())
scala> Applicative[List]
.unlessA(true)(List.empty[Int]
)
res2: List[Unit] = List(())
res2: List[Unit] = List(())
scala> Applicative[List]
.unlessA(false)(List.empty[Int]
)
res3: List[Unit] = List()
}}}
res3: List[Unit] = List()
}}}
- Inhertied from
- Applicative
@noop
def unzip[A, B](fab: F[(A, B)]): (F[A], F[B])
Un-zips an
F[(A, B)]
consisting of element pairs or Tuple2 into two separate F's tupled.NOTE: Check for effect duplication, possibly memoize before
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.unzip(List((1,2), (3, 4)))
res0: (List[Int] , List[Int] ) = (List(1, 3),List(2, 4))
}}}
res0: (List[Int] , List[Int] ) = (List(1, 3),List(2, 4))
}}}
- Inhertied from
- Functor
def fix[A](fn: F[A] => F[A]): F[A]
Defer instances, like functions, parsers, generators, IO, etc...
often are used in recursive settings where this function is useful
often are used in recursive settings where this function is useful
fix(fn) == fn(fix(fn))
example:
val parser: P[Int]
=
Defer[P] .fix[Int] { rec =>
CharsIn("0123456789") | P("(") ~ rec ~ P(")")
}
Defer[P] .fix[Int] { rec =>
CharsIn("0123456789") | P("(") ~ rec ~ P(")")
}
Note, fn may not yield a terminating value in which case both
of the above F[A] run forever.
of the above F[A] run forever.
- Inhertied from
- Defer
def recover[A](fa: F[A])(pf: PartialFunction[E, A]): F[A]
Recover from certain errors by mapping them to an
A
value.- See also
- handleError to handle any/all errors.recoverWith to recover from certain errors by mapping them to
F[A]
values. - Inhertied from
- ApplicativeError
def iterateUntilM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Apply a monadic function iteratively until its result satisfies
the given predicate and return that result.
the given predicate and return that result.
- Inhertied from
- Monad
def as[A, B](fa: F[A], b: B): F[B]
Replaces the
A
value in F[A]
with the supplied value.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.as(List(1,2,3), "hello")
res0: List[String] = List(hello, hello, hello)
}}}
res0: List[String] = List(hello, hello, hello)
}}}
- Inhertied from
- Functor
def redeemWith[A, B](fa: F[A])(recover: E => F[B], bind: A => F[B]): F[B]
Returns a new value that transforms the result of the source,
given the
on whether the result is successful or if it ends in error.
given the
recover
or bind
functions, which get executed dependingon whether the result is successful or if it ends in error.
{{{
fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))
}}}
fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))
}}}
Usage of
redeemWith
subsumes handleErrorWith because:{{{
fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)
}}}
fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)
}}}
Usage of
redeemWith
also subsumes flatMap because:{{{
fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)
}}}
fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)
}}}
Implementations are free to override it in order to optimize
error recovery.
error recovery.
- Value Params
- bind
-
is the function that gets to transform the source
in case of success - fa
-
is the source whose result is going to get transformed
- recover
-
is the function that gets called to recover the source
in case of error
- See also
- Inhertied from
- MonadError
override def productR[A, B](fa: F[A])(fb: F[B]): F[B]
- Definition Classes
- FlatMap -> Apply
- Inhertied from
- FlatMap
def tupleLeft[A, B](fa: F[A], b: B): F[(B, A)]
Tuples the
A
value in F[A]
with the supplied B
value, with the B
value on the left.Example:
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue]
.tupleLeft(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
}}}
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
}}}
- Inhertied from
- Functor
def composeApply[G <: ([_$2] =>> Any)](evidence$1: Apply[G]): InvariantSemigroupal[[α] =>> F[G[α]]]
- Inhertied from
- InvariantSemigroupal
@noop
def untilDefinedM[A](foa: F[Option[A]]): F[A]
This repeats an F until we get defined values. This can be useful
for polling type operations on State (or RNG) Monads, or in effect
monads.
for polling type operations on State (or RNG) Monads, or in effect
monads.
- Inhertied from
- FlatMap
def iterateWhile[A](f: F[A])(p: A => Boolean): F[A]
Execute an action repeatedly until its result fails to satisfy the given predicate
and return that result, discarding all others.
and return that result, discarding all others.
- Inhertied from
- Monad
@noop
def ifA[A](fcond: F[Boolean])(ifTrue: F[A], ifFalse: F[A]): F[A]
An
This function combines the effects of the
in the order in which they are given.
if-then-else
lifted into the F
context.This function combines the effects of the
fcond
condition and of the two branches,in the order in which they are given.
The value of the result is, depending on the value of the condition,
the value of the first argument, or the value of the second argument.
the value of the first argument, or the value of the second argument.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val b1: Option[Boolean]
= Some(true)
scala> val asInt1: Option[Int] = Apply[Option] .ifA(b1)(Some(1), Some(0))
scala> asInt1.get
res0: Int = 1
scala> val asInt1: Option[Int] = Apply[Option] .ifA(b1)(Some(1), Some(0))
scala> asInt1.get
res0: Int = 1
scala> val b2: Option[Boolean]
= Some(false)
scala> val asInt2: Option[Int] = Apply[Option] .ifA(b2)(Some(1), Some(0))
scala> asInt2.get
res1: Int = 0
scala> val asInt2: Option[Int] = Apply[Option] .ifA(b2)(Some(1), Some(0))
scala> asInt2.get
res1: Int = 0
scala> val b3: Option[Boolean]
= Some(true)
scala> val asInt3: Option[Int] = Apply[Option] .ifA(b3)(Some(1), None)
asInt2: Option[Int] = None
scala> val asInt3: Option[Int] = Apply[Option] .ifA(b3)(Some(1), None)
asInt2: Option[Int] = None
}}}
- Inhertied from
- Apply
override def adaptError[A](fa: F[A])(pf: PartialFunction[E, E]): F[A]
- Definition Classes
- MonadError -> ApplicativeError
- Inhertied from
- MonadError
@noop
def ifElseM[A](branches: (F[Boolean], F[A])*)(els: F[A]): F[A]
Simulates an if/else-if/else in the context of an F. It evaluates conditions until
one evaluates to true, and returns the associated F[A] . If no condition is true,
returns els.
one evaluates to true, and returns the associated F[A] . If no condition is true,
returns els.
{{{
scala> import cats._
scala> Monad[Eval] .ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2
}}}
scala> import cats._
scala> Monad[Eval] .ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2
}}}
- See also
- See https://gitter.im/typelevel/cats-effect?at=5f297e4314c413356f56d230 for the discussion.
- Inhertied from
- Monad
Returns a non-terminating
with a result, being equivalent to
F[_]
, that never completeswith a result, being equivalent to
async(_ => ())
- Inhertied from
- Async
def pure[A](x: A): F[A]
pure
lifts any value into the Applicative Functor.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[Option]
.pure(10)
res0: Option[Int] = Some(10)
}}}
res0: Option[Int] = Some(10)
}}}
- Inhertied from
- Applicative
override def ap[A, B](ff: F[A => B])(fa: F[A]): F[B]
- Definition Classes
- FlatMap -> Apply
- Inhertied from
- FlatMap
def point[A](a: A): F[A]
point
lifts any value into a Monoidal Functor.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> InvariantMonoidal[Option]
.point(10)
res0: Option[Int] = Some(10)
}}}
res0: Option[Int] = Some(10)
}}}
- Inhertied from
- InvariantMonoidal
def compose[G <: ([_$2] =>> Any)](evidence$1: Applicative[G]): Applicative[[α] =>> F[G[α]]]
Compose an
Applicative[F]
and an Applicative[G]
into anApplicative[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val alo = Applicative[List]
.compose[Option]
scala> alo.pure(3)
res0: List[Option[Int] ] = List(Some(3))
res0: List[Option[Int] ] = List(Some(3))
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
- Inhertied from
- Applicative
def compose[G <: ([_$2] =>> Any)](evidence$1: Invariant[G]): Invariant[[α] =>> F[G[α]]]
Compose Invariant
F[_]
and G[_]
then produce Invariant[F[G[_]]]
using their imap
.Example:
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]
] =
| Invariant[Semigroup] .compose[List] .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
| Invariant[Semigroup] .compose[List] .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
- Inhertied from
- Invariant
def compose[G <: ([_$3] =>> Any)](evidence$1: Apply[G]): Apply[[α] =>> F[G[α]]]
Compose an
Apply[F]
and an Apply[G]
into an Apply[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val alo = Apply[List]
.compose[Option]
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
res1: List[Option[(Boolean, Int)] ] = List(None, None, Some((true,2)), None, Some((false,2)), None)
}}}
- Inhertied from
- Apply
def compose[G <: ([_$6] =>> Any)](evidence$1: Functor[G]): Functor[[α] =>> F[G[α]]]
- Inhertied from
- Functor
override def imap[A, B](fa: F[A])(f: A => B)(g: B => A): F[B]
- Definition Classes
- Functor -> Invariant
- Inhertied from
- Functor
def ensure[A](fa: F[A])(error: => E)(predicate: A => Boolean): F[A]
Turns a successful value into an error if it does not satisfy a given predicate.
- Inhertied from
- MonadError
def widen[A, B >: A](fa: F[A]): F[B]
Lifts natural subtyping covariance of covariant Functors.
NOTE: In certain (perhaps contrived) situations that rely on universal
equality this can result in a
implemented as a type cast. It could be implemented as
according to the functor laws, that should be equal to
cast is often much more performant.
See this example
of
equality this can result in a
ClassCastException
, because it isimplemented as a type cast. It could be implemented as
map(identity)
, butaccording to the functor laws, that should be equal to
fa
, and a typecast is often much more performant.
See this example
of
widen
creating a ClassCastException
.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val s = Some(42)
scala> Functor[Option] .widen(s)
res0: Option[Int] = Some(42)
}}}
scala> Functor[Option] .widen(s)
res0: Option[Int] = Some(42)
}}}
- Inhertied from
- Functor
@noop
def foreverM[A, B](fa: F[A]): F[B]
Like an infinite loop of >> calls. This is most useful effect loops
that you want to run forever in for instance a server.
that you want to run forever in for instance a server.
This will be an infinite loop, or it will return an F[Nothing]
.
Be careful using this.
For instance, a List of length k will produce a list of length k^n at iteration
n. This means if k = 0, we return an empty list, if k = 1, we loop forever
allocating single element lists, but if we have a k > 1, we will allocate
exponentially increasing memory and very quickly OOM.
For instance, a List of length k will produce a list of length k^n at iteration
n. This means if k = 0, we return an empty list, if k = 1, we loop forever
allocating single element lists, but if we have a k > 1, we will allocate
exponentially increasing memory and very quickly OOM.
- Inhertied from
- FlatMap
override def map[A, B](fa: F[A])(f: A => B): F[B]
- Definition Classes
- Monad -> Applicative -> Functor
- Inhertied from
- Monad
Creates a simple, non-cancelable
executes an asynchronous process on evaluation.
F[A]
instance thatexecutes an asynchronous process on evaluation.
The given function is being injected with a side-effectful
callback for signaling the final result of an asynchronous
process. And its returned result needs to be a pure
that gets evaluated by the runtime.
callback for signaling the final result of an asynchronous
process. And its returned result needs to be a pure
F[Unit]
that gets evaluated by the runtime.
Note the simpler async variant async can be derived like this:
{{{
F.async(k) <-> F.asyncF(cb => F.delay(k(cb)))
}}}
F.async(k) <-> F.asyncF(cb => F.delay(k(cb)))
}}}
For wrapping impure APIs usually you can use the simpler async,
however
wrapped with the help of pure abstractions, such as
Ref.
however
asyncF
is useful in cases where impure APIs arewrapped with the help of pure abstractions, such as
Ref.
For example here's how a simple, "pure Promise" implementation
could be implemented via
as you have a far better
Deferred available):
could be implemented via
Ref
(sample is for didactic purposes,as you have a far better
Deferred available):
{{{
import cats.effect.concurrent.Ref
import cats.effect.concurrent.Ref
type Callback[-A]
= Either[Throwable, A]
=> Unit
class PurePromise[F[_]
, A](ref: Ref[F, Either[List[Callback[A]
], A]])
(implicit F: Async[F] ) {
(implicit F: Async[F] ) {
def get: F[A]
= F.asyncF { cb =>
ref.modify {
case current @ Right(result) =>
(current, F.delay(cb(Right(result))))
case Left(list) =>
(Left(cb :: list), F.unit)
}
}
ref.modify {
case current @ Right(result) =>
(current, F.delay(cb(Right(result))))
case Left(list) =>
(Left(cb :: list), F.unit)
}
}
def complete(value: A): F[Unit]
=
F.flatten(ref.modify {
case Left(list) =>
(Right(value), F.delay(list.foreach(_(Right(value)))))
case right =>
(right, F.unit)
})
}
}}}
F.flatten(ref.modify {
case Left(list) =>
(Right(value), F.delay(list.foreach(_(Right(value)))))
case right =>
(right, F.unit)
})
}
}}}
N.B. if
Concurrent), then the returned
its evaluation hooking into the underlying cancelation mechanism
of
F[_]
is a cancelable data type (i.e. implementingConcurrent), then the returned
F[Unit]
can be cancelable,its evaluation hooking into the underlying cancelation mechanism
of
F[_]
, so something like this behaves like you'd expect:{{{
def delayed[F[_] , A](thunk: => A)
(implicit F: Async[F] , timer: Timer[F] ): F[A] = {
def delayed[F[_] , A](thunk: => A)
(implicit F: Async[F] , timer: Timer[F] ): F[A] = {
timer.sleep(1.second) *> F.delay(cb(
try cb(Right(thunk))
catch { case NonFatal(e) => Left(cb(Left(e))) }
))
}
}}}
try cb(Right(thunk))
catch { case NonFatal(e) => Left(cb(Left(e))) }
))
}
}}}
The
that the result has to be signaled via the provided callback.
asyncF
operation behaves like Sync.suspend, exceptthat the result has to be signaled via the provided callback.
==ERROR HANDLING==
As a matter of contract the returned
throw errors. If it does, then the behavior is undefined.
F[Unit]
should notthrow errors. If it does, then the behavior is undefined.
This is because by contract the provided callback should
only be called once. Calling it concurrently, multiple times,
is a contract violation. And if the returned
then the implementation might have called it already, so it
would be a contract violation to call it without expensive
synchronization.
only be called once. Calling it concurrently, multiple times,
is a contract violation. And if the returned
F[Unit]
throws,then the implementation might have called it already, so it
would be a contract violation to call it without expensive
synchronization.
In case errors are thrown the behavior is implementation specific.
The error might get logged to stderr, or via other mechanisms
that are implementations specific.
The error might get logged to stderr, or via other mechanisms
that are implementations specific.
Lifts any by-name parameter into the
F
context.Equivalent to
the purpose of this function is to suspend side effects
in
Applicative.pure
for pure expressions,the purpose of this function is to suspend side effects
in
F
.- Inhertied from
- Sync
def catchNonFatalEval[A](a: Eval[A])(ev: Throwable <:< E): F[A]
Often E is Throwable. Here we try to call pure or catch
and raise
and raise
- Inhertied from
- ApplicativeError
- Value Params
- acquire
-
is an action that "acquires" some expensive
resource, that needs to be used and then discarded - release
-
is the action that's supposed to release the
allocated resource afteruse
is done, by observing
and acting on its exit condition. Throwing inside
this function leads to undefined behavior since it's
left to the implementation. - use
-
is the action that uses the newly allocated
resource and that will provide the final result
- Inhertied from
- Bracket
@noop
def ifF[A](fb: F[Boolean])(ifTrue: => A, ifFalse: => A): F[A]
Lifts
if
to FunctorExample:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.ifF(List(true, false, false))(1, 0)
res0: List[Int] = List(1, 0, 0)
}}}
res0: List[Int] = List(1, 0, 0)
}}}
- Inhertied from
- Functor
def replicateA[A](n: Int, fa: F[A]): F[List[A]]
Given
fa
and n
, apply fa
n
times to construct an F[List[A]]
value.Example:
{{{
scala> import cats.data.State
{{{
scala> import cats.data.State
scala> type Counter[A]
= State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int] ] =
| Applicative[Counter] .replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int] ) = (5,List(0, 1, 2, 3, 4))
}}}
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int] ] =
| Applicative[Counter] .replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int] ) = (5,List(0, 1, 2, 3, 4))
}}}
- Inhertied from
- Applicative
def rethrow[A, EE <: E](fa: F[Either[EE, A]]): F[A]
Inverse of
attempt
Example:
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success}
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success}
scala> val a: Try[Either[Throwable, Int]
] = Success(Left(new java.lang.Exception))
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Either[Throwable, Int]
] = Success(Right(1))
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
}}}
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
}}}
- Inhertied from
- MonadError
override def map2[A, B, Z](fa: F[A], fb: F[B])(f: (A, B) => Z): F[Z]
- Definition Classes
- FlatMap -> Apply
- Inhertied from
- FlatMap
def raiseError[A](e: E): F[A]
Lift an error into the
F
context.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
// integer-rounded division
scala> def divide[F[_] ](dividend: Int, divisor: Int)(implicit F: ApplicativeError[F, String] ): F[Int] =
| if (divisor === 0) F.raiseError("division by zero")
| else F.pure(dividend / divisor)
scala> def divide[F[_] ](dividend: Int, divisor: Int)(implicit F: ApplicativeError[F, String] ): F[Int] =
| if (divisor === 0) F.raiseError("division by zero")
| else F.pure(dividend / divisor)
scala> type ErrorOr[A]
= Either[String, A]
scala> divide[ErrorOr]
(6, 3)
res0: ErrorOr[Int] = Right(2)
res0: ErrorOr[Int] = Right(2)
scala> divide[ErrorOr]
(6, 0)
res1: ErrorOr[Int] = Left(division by zero)
}}}
res1: ErrorOr[Int] = Left(division by zero)
}}}
- Inhertied from
- ApplicativeError
def lift[A, B](f: A => B): F[A] => F[B]
Lift a function f to operate on Functors
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val o = Option(42)
scala> Functor[Option] .lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
}}}
scala> Functor[Option] .lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
}}}
- Inhertied from
- Functor
def mproduct[A, B](fa: F[A])(f: A => F[B]): F[(A, B)]
Pair
A
with the result of function application.Example:
{{{
scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
}}}
{{{
scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
}}}
- Inhertied from
- FlatMap
def whenA[A](cond: Boolean)(f: => F[A]): F[Unit]
Returns the given argument (mapped to Unit) if
unit lifted into F.
cond
is true
, otherwise,unit lifted into F.
Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[List]
.whenA(true)(List(1, 2, 3))
res0: List[Unit] = List((), (), ())
res0: List[Unit] = List((), (), ())
scala> Applicative[List]
.whenA(false)(List(1, 2, 3))
res1: List[Unit] = List(())
res1: List[Unit] = List(())
scala> Applicative[List]
.whenA(true)(List.empty[Int]
)
res2: List[Unit] = List()
res2: List[Unit] = List()
scala> Applicative[List]
.whenA(false)(List.empty[Int]
)
res3: List[Unit] = List(())
}}}
res3: List[Unit] = List(())
}}}
- Inhertied from
- Applicative
def fromValidated[A](x: Validated[E, A]): F[A]
Convert from cats.data.Validated
Example:
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> ApplicativeError[Option, Unit]
.fromValidated(1.valid[Unit]
)
res0: scala.Option[Int] = Some(1)
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit]
.fromValidated(().invalid[Int]
)
res1: scala.Option[Int] = None
}}}
res1: scala.Option[Int] = None
}}}
- Inhertied from
- ApplicativeError
def composeFunctor[G <: ([_$3] =>> Any)](evidence$2: Functor[G]): Invariant[[α] =>> F[G[α]]]
Compose Invariant
using F's
F[_]
and Functor G[_]
then produce Invariant[F[G[_]]]
using F's
imap
and G's map
.Example:
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
{{{
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]
] =
| Invariant[Semigroup]
| .composeFunctor[List]
| .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
| Invariant[Semigroup]
| .composeFunctor[List]
| .imap(Semigroup[List[Long] ])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
}}}
- Inhertied from
- Invariant
def composeContravariantMonoidal[G <: ([_$3] =>> Any)](evidence$2: ContravariantMonoidal[G]): ContravariantMonoidal[[α] =>> F[G[α]]]
Compose an
Applicative[F]
and a ContravariantMonoidal[G]
into aContravariantMonoidal[λ[α => F[G[α]]]]
.Example:
{{{
scala> import cats.kernel.Comparison
scala> import cats.implicits._
{{{
scala> import cats.kernel.Comparison
scala> import cats.implicits._
// compares strings by alphabetical order
scala> val alpha: Order[String] = Order[String]
scala> val alpha: Order[String] = Order[String]
// compares strings by their length
scala> val strLength: Order[String] = Order.byString, Int
scala> val strLength: Order[String] = Order.byString, Int
scala> val stringOrders: List[Order[String]
] = List(alpha, strLength)
// first comparison is with alpha order, second is with string length
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)
scala> val le = Applicative[List]
.composeContravariantMonoidal[Order]
// create Int orders that convert ints to strings and then use the string orders
scala> val intOrders: List[Order[Int] ] = le.contramap(stringOrders)(_.toString)
scala> val intOrders: List[Order[Int] ] = le.contramap(stringOrders)(_.toString)
// first comparison is with alpha order, second is with string length
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)
// create the
//
// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)] ] = le.product(stringOrders, intOrders)
product
of the string order list and the int order list//
p
contains a list of the following orders:// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)] ] = le.product(stringOrders, intOrders)
scala> p.map(o => o.comparison(("abc", 12), ("def", 3)))
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
}}}
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
}}}
- Inhertied from
- Applicative
override def productL[A, B](fa: F[A])(fb: F[B]): F[A]
- Definition Classes
- FlatMap -> Apply
- Inhertied from
- FlatMap
override def product[A, B](fa: F[A], fb: F[B]): F[(A, B)]
- Definition Classes
- FlatMap -> Apply -> Semigroupal
- Inhertied from
- FlatMap
final def fmap[A, B](fa: F[A])(f: A => B): F[B]
Alias for map, since map can't be injected as syntax if
the implementing type already had a built-in
the implementing type already had a built-in
.map
method.Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> val m: Map[Int, String]
= Map(1 -> "hi", 2 -> "there", 3 -> "you")
scala> m.fmap(_ ++ "!")
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
}}}
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
}}}
- Inhertied from
- Functor
def fromOption[A](oa: Option[A], ifEmpty: => E): F[A]
Convert from scala.Option
Example:
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *] , String]
{{{
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *] , String]
scala> F.fromOption(Some(1), "Empty")
res0: scala.Either[String, Int] = Right(1)
res0: scala.Either[String, Int] = Right(1)
scala> F.fromOption(Option.empty[Int]
, "Empty")
res1: scala.Either[String, Int] = Left(Empty)
}}}
res1: scala.Either[String, Int] = Left(Empty)
}}}
- Inhertied from
- ApplicativeError
@deprecated("use defer", "2.4.0")
Suspends the evaluation of an
F
reference.Equivalent to
the purpose of this function is to suspend side effects
in
FlatMap.flatten
for pure expressions,the purpose of this function is to suspend side effects
in
F
.- Inhertied from
- Sync
def catchNonFatal[A](a: => A)(ev: Throwable <:< E): F[A]
Often E is Throwable. Here we try to call pure or catch
and raise.
and raise.
- Inhertied from
- ApplicativeError
def handleError[A](fa: F[A])(f: E => A): F[A]
Handle any error, by mapping it to an
A
value.- See also
- handleErrorWith to map to an
F[A]
value instead of simply anA
value.recover to only recover from certain errors. - Inhertied from
- ApplicativeError
def fromTry[A](t: Try[A])(ev: Throwable <:< E): F[A]
If the error type is Throwable, we can convert from a scala.util.Try
- Inhertied from
- ApplicativeError
def tailRecM[A, B](a: A)(f: A => F[Either[A, B]]): F[B]
Keeps calling
f
until a scala.util.Right[B]
is returned.Based on Phil Freeman's
Stack Safety for Free.
Stack Safety for Free.
Implementations of this method should use constant stack space relative to
f
.- Inhertied from
- FlatMap
override def ap2[A, B, Z](ff: F[(A, B) => Z])(fa: F[A], fb: F[B]): F[Z]
- Definition Classes
- FlatMap -> Apply
- Inhertied from
- FlatMap
Executes the given
either in success or in error, or if canceled, allowing
for differentiating between exit conditions.
finalizer
when the source is finished,either in success or in error, or if canceled, allowing
for differentiating between exit conditions.
This variant of guarantee injects an ExitCase in
the provided function, allowing one to make a difference
between:
the provided function, allowing one to make a difference
between:
-
normal completion
-
completion in error
-
cancelation
This equivalence always holds:
{{{
F.guaranteeCase(fa)(f) <-> F.bracketCase(F.unit)(_ => fa)((_, e) => f(e))
}}}
F.guaranteeCase(fa)(f) <-> F.bracketCase(F.unit)(_ => fa)((_, e) => f(e))
}}}
As best practice, it's not a good idea to release resources
via
for the acquisition and release of resources.
via
guaranteeCase
in polymorphic code. Prefer bracketCasefor the acquisition and release of resources.
- See also
- guarantee for the simpler versionbracketCase for the more general operation
- Inhertied from
- Bracket
def untilM_[A](f: F[A])(cond: => F[Boolean]): F[Unit]
Execute an action repeatedly until the
The condition is evaluated after the loop body. Discards results.
Boolean
condition returns true
.The condition is evaluated after the loop body. Discards results.
- Inhertied from
- Monad
def fproductLeft[A, B](fa: F[A])(f: A => B): F[(B, A)]
Pair the result of function application with
A
.Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option]
.fproductLeft(Option(42))(_.toString)
res0: Option[(String, Int)] = Some((42,42))
}}}
res0: Option[(String, Int)] = Some((42,42))
}}}
- Inhertied from
- Functor
@noop
def iterateForeverM[A, B](a: A)(f: A => F[A]): F[B]
iterateForeverM is almost exclusively useful for effect types. For instance,
A may be some state, we may take the current state, run some effect to get
a new state and repeat.
A may be some state, we may take the current state, run some effect to get
a new state and repeat.
- Inhertied from
- FlatMap
def recoverWith[A](fa: F[A])(pf: PartialFunction[E, F[A]]): F[A]
Recover from certain errors by mapping them to an
F[A]
value.- See also
- handleErrorWith to handle any/all errors.recover to recover from certain errors by mapping them to
A
values. - Inhertied from
- ApplicativeError
def iterateWhileM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Apply a monadic function iteratively until its result fails
to satisfy the given predicate and return that result.
to satisfy the given predicate and return that result.
- Inhertied from
- Monad
@noop
def whileM_[A](p: F[Boolean])(body: => F[A]): F[Unit]
Execute an action repeatedly as long as the given
returns
Discards results.
Boolean
expressionreturns
true
. The condition is evaluated before the loop body.Discards results.
- Inhertied from
- Monad
def map2Eval[A, B, Z](fa: F[A], fb: Eval[F[B]])(f: (A, B) => Z): Eval[F[Z]]
Similar to map2 but uses Eval to allow for laziness in the
argument. This can allow for "short-circuiting" of computations.
F[B]
argument. This can allow for "short-circuiting" of computations.
NOTE: the default implementation of
computations. For data structures that can benefit from laziness, Apply
instances should override this method.
map2Eval
does not short-circuitcomputations. For data structures that can benefit from laziness, Apply
instances should override this method.
In the following example,
but
result of
that the result of
x.map2(bomb)(_ + _)
would result in an error,but
map2Eval
"short-circuits" the computation. x
is None
and thus theresult of
bomb
doesn't even need to be evaluated in order to determinethat the result of
map2Eval
should be None
.{{{
scala> import cats.{Eval, Later}
scala> import cats.implicits._
scala> val bomb: Eval[Option[Int] ] = Later(sys.error("boom"))
scala> val x: Option[Int] = None
scala> x.map2Eval(bomb)(_ + _).value
res0: Option[Int] = None
}}}
scala> import cats.{Eval, Later}
scala> import cats.implicits._
scala> val bomb: Eval[Option[Int] ] = Later(sys.error("boom"))
scala> val x: Option[Int] = None
scala> x.map2Eval(bomb)(_ + _).value
res0: Option[Int] = None
}}}
- Inhertied from
- Apply
def flatTap[A, B](fa: F[A])(f: A => F[B]): F[A]
Apply a monadic function and discard the result while keeping the effect.
{{{
scala> import cats., implicits.
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> ListInt.flatTap(nCats)
res2: List[Int] = List()
scala> ListInt.flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
}}}
scala> import cats., implicits.
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> ListInt.flatTap(nCats)
res2: List[Int] = List()
scala> ListInt.flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
}}}
- Inhertied from
- FlatMap
def productREval[A, B](fa: F[A])(fb: Eval[F[B]]): F[B]
Sequentially compose two actions, discarding any value produced by the first. This variant of
productR also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
productR also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
}}}
scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
}}}
- Inhertied from
- FlatMap
def flatten[A](ffa: F[F[A]]): F[A]
"flatten" a nested
F
of F
structure into a single-layer F
structure.This is also commonly called
join
.Example:
{{{
scala> import cats.Eval
scala> import cats.implicits._
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> val nested: Eval[Eval[Int]
] = Eval.now(Eval.now(3))
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3
}}}
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3
}}}
- Inhertied from
- FlatMap
def catchOnly[T >: Null <: Throwable]: CatchOnlyPartiallyApplied[T, F, E]
Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.
- Inhertied from
- ApplicativeError
def tupleRight[A, B](fa: F[A], b: B): F[(A, B)]
Tuples the
A
value in F[A]
with the supplied B
value, with the B
value on the right.Example:
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
{{{
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue]
.tupleRight(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
}}}
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
}}}
- Inhertied from
- Functor
Operation meant for ensuring a given task continues execution even
when interrupted.
when interrupted.
- Inhertied from
- Bracket
Executes the given
finalizer
when the source is canceled.The typical use case for this function arises in the
implementation of concurrent abstractions, which generally
consist of operations that perform asynchronous waiting after
concurrently modifying some state: in case the user asks for
cancelation, we want to interrupt the waiting operation, and
restore the state to its previous value.
implementation of concurrent abstractions, which generally
consist of operations that perform asynchronous waiting after
concurrently modifying some state: in case the user asks for
cancelation, we want to interrupt the waiting operation, and
restore the state to its previous value.
{{{
waitingOp.onCancel(restoreState)
}}}
waitingOp.onCancel(restoreState)
}}}
A direct use of
would make the waiting action uncancelable.
bracket
is not a good fit for this case as itwould make the waiting action uncancelable.
NOTE: This function handles interruption only, you need to take
care of the success and error case elsewhere in your code
care of the success and error case elsewhere in your code
- See also
- guaranteeCase for the version that can discriminate
between termination conditionsbracket for the more general operationConcurrent.continual when you have a use case similar to
the cancel/restore example above, but require access to the
result ofF[A]
- Inhertied from
- Bracket
def iterateUntil[A](f: F[A])(p: A => Boolean): F[A]
Execute an action repeatedly until its result satisfies the given predicate
and return that result, discarding all others.
and return that result, discarding all others.
- Inhertied from
- Monad
def attempt[A](fa: F[A]): F[Either[E, A]]
Handle errors by turning them into scala.util.Either values.
If there is no error, then an
scala.util.Right
value will be returned instead.All non-fatal errors should be handled by this method.
- Inhertied from
- ApplicativeError
@noop
def ifM[B](fa: F[Boolean])(ifTrue: => F[B], ifFalse: => F[B]): F[B]
if
lifted into monad.- Inhertied from
- FlatMap
Creates a simple, non-cancelable
executes an asynchronous process on evaluation.
F[A]
instance thatexecutes an asynchronous process on evaluation.
The given function is being injected with a side-effectful
callback for signaling the final result of an asynchronous
process.
callback for signaling the final result of an asynchronous
process.
This operation could be derived from asyncF, because:
{{{
F.async(k) <-> F.asyncF(cb => F.delay(k(cb)))
}}}
F.async(k) <-> F.asyncF(cb => F.delay(k(cb)))
}}}
As an example of wrapping an impure async API, here's the
implementation of Async.shift:
implementation of Async.shift:
{{{
def shift[F[_] ](ec: ExecutionContext)(implicit F: Async[F] ): F[Unit] =
F.async { cb =>
// Scheduling an async boundary (logical thread fork)
ec.execute(new Runnable {
def run(): Unit = {
// Signaling successful completion
cb(Right(()))
}
})
}
}}}
def shift[F[_] ](ec: ExecutionContext)(implicit F: Async[F] ): F[Unit] =
F.async { cb =>
// Scheduling an async boundary (logical thread fork)
ec.execute(new Runnable {
def run(): Unit = {
// Signaling successful completion
cb(Right(()))
}
})
}
}}}
@noop
def whileM[G <: ([_$2] =>> Any), A](p: F[Boolean])(body: => F[A])(G: Alternative[G]): F[G[A]]
Execute an action repeatedly as long as the given
returns
Collects the results into an arbitrary
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
Boolean
expressionreturns
true
. The condition is evaluated before the loop body.Collects the results into an arbitrary
Alternative
value, such as a Vector
.This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
List
.- Inhertied from
- Monad
def onError[A](fa: F[A])(pf: PartialFunction[E, F[Unit]]): F[A]
Execute a callback on certain errors, then rethrow them.
Any non matching error is rethrown as well.
Any non matching error is rethrown as well.
In the following example, only one of the errors is logged,
but they are both rethrown, to be possibly handled by another
layer of the program:
but they are both rethrown, to be possibly handled by another
layer of the program:
{{{
scala> import cats., data., implicits._
scala> import cats., data., implicits._
scala> case class Err(msg: String)
scala> type F[A]
= EitherT[State[String, *]
, Err, A]
scala> val action: PartialFunction[Err, F[Unit]
] = {
| case Err("one") => EitherT.liftF(State.set("one"))
| }
| case Err("one") => EitherT.liftF(State.set("one"))
| }
scala> val prog1: F[Int]
= (Err("one")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]
scala> prog1.onError(action).value.run("").value
res0: (String, Either[Err,Int]
) = (one,Left(Err(one)))
scala> prog2.onError(action).value.run("").value
res1: (String, Either[Err,Int] ) = ("",Left(Err(two)))
}}}
res1: (String, Either[Err,Int] ) = ("",Left(Err(two)))
}}}
- Inhertied from
- ApplicativeError
Operation meant for specifying tasks with safe resource
acquisition and release in the face of errors and interruption.
acquisition and release in the face of errors and interruption.
This operation provides the equivalent of
statements in mainstream imperative languages for resource
acquisition and release.
try/catch/finally
statements in mainstream imperative languages for resource
acquisition and release.
- Value Params
- acquire
-
is an action that "acquires" some expensive
resource, that needs to be used and then discarded - release
-
is the action that's supposed to release the
allocated resource afteruse
is done, regardless of
its exit condition. Throwing inside this function
is undefined behavior since it's left to the implementation. - use
-
is the action that uses the newly allocated
resource and that will provide the final result
- Inhertied from
- Bracket
def ensureOr[A](fa: F[A])(error: A => E)(predicate: A => Boolean): F[A]
Turns a successful value into an error specified by the
error
function if it does not satisfy a given predicate.- Inhertied from
- MonadError
def attemptT[A](fa: F[A]): EitherT[F, E, A]
Similar to attempt, but wraps the result in a data.EitherT for
convenience.
convenience.
- Inhertied from
- ApplicativeError
override def composeContravariant[G <: ([_$7] =>> Any)](evidence$2: Contravariant[G]): Contravariant[[α] =>> F[G[α]]]
- Definition Classes
- Functor -> Invariant
- Inhertied from
- Functor
Executes the given
either in success or in error, or if canceled.
finalizer
when the source is finished,either in success or in error, or if canceled.
This variant of guaranteeCase evaluates the given
regardless of how the source gets terminated:
finalizer
regardless of how the source gets terminated:
-
normal completion
-
completion in error
-
cancelation
This equivalence always holds:
{{{
F.guarantee(fa)(f) <-> F.bracket(F.unit)(_ => fa)(_ => f)
}}}
F.guarantee(fa)(f) <-> F.bracket(F.unit)(_ => fa)(_ => f)
}}}
As best practice, it's not a good idea to release resources
via
for the acquisition and release of resources.
via
guaranteeCase
in polymorphic code. Prefer bracketfor the acquisition and release of resources.
- See also
- guaranteeCase for the version that can discriminate
between termination conditionsbracket for the more general operation - Inhertied from
- Bracket
def void[A](fa: F[A]): F[Unit]
Empty the fa of the values, preserving the structure
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List]
.void(List(1,2,3))
res0: List[Unit] = List((), (), ())
}}}
res0: List[Unit] = List((), (), ())
}}}
- Inhertied from
- Functor
def untilM[G <: ([_$4] =>> Any), A](f: F[A])(cond: => F[Boolean])(G: Alternative[G]): F[G[A]]
Execute an action repeatedly until the
The condition is evaluated after the loop body. Collects results into an
arbitrary
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
Boolean
condition returns true
.The condition is evaluated after the loop body. Collects results into an
arbitrary
Alternative
value, such as a Vector
.This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g.
List
.- Inhertied from
- Monad
def handleErrorWith[A](fa: F[A])(f: E => F[A]): F[A]
Handle any error, potentially recovering from it, by mapping it to an
F[A]
value.- See also
- handleError to handle any error by simply mapping it to an
A
value instead of anF[A]
.recoverWith to recover from only certain errors. - Inhertied from
- ApplicativeError
def attemptNarrow[EE <: Throwable, A](fa: F[A])(tag: ClassTag[EE], ev: EE <:< E): F[Either[EE, A]]
Similar to attempt, but it only handles errors of type
EE
.- Inhertied from
- ApplicativeError
def attemptTap[A, B](fa: F[A])(f: Either[E, A] => F[B]): F[A]
Reifies the value or error of the source and performs an effect on the result,
then recovers the original value or error back into
then recovers the original value or error back into
F
.Note that if the effect returned by
f
fails, the resulting effect will fail too.Alias for
fa.attempt.flatTap(f).rethrow
for convenience.Example:
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}
{{{
scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}
scala> def checkError(result: Either[Throwable, Int]
): Try[String]
= result.fold(_ => Failure(new java.lang.Exception), _ => Success("success"))
scala> val a: Try[Int]
= Failure(new Throwable("failed"))
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Int]
= Success(1)
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
}}}
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
}}}
- Inhertied from
- MonadError
def redeem[A, B](fa: F[A])(recover: E => B, f: A => B): F[B]
Returns a new value that transforms the result of the source,
given the
on whether the result is successful or if it ends in error.
given the
recover
or map
functions, which get executed dependingon whether the result is successful or if it ends in error.
{{{
fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))
}}}
fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))
}}}
Usage of
redeem
subsumes handleError because:{{{
fa.redeem(fe, id) <-> fa.handleError(fe)
}}}
fa.redeem(fe, id) <-> fa.handleError(fe)
}}}
Implementations are free to override it in order to optimize
error recovery.
error recovery.
- Value Params
- fa
-
is the source whose result is going to get transformed
- recover
-
is the function that gets called to recover the source
in case of error
- See also
- Inhertied from
- ApplicativeError
def fproduct[A, B](fa: F[A])(f: A => B): F[(A, B)]
Tuple the values in fa with the result of applying a function
with the value
with the value
Example:
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
{{{
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option]
.fproduct(Option(42))(_.toString)
res0: Option[(Int, String)] = Some((42,42))
}}}
res0: Option[(Int, String)] = Some((42,42))
}}}
- Inhertied from
- Functor
def unit: F[Unit]
Returns an
F[Unit]
value, equivalent with pure(())
.A useful shorthand, also allowing implementations to optimize the
returned reference (e.g. it can be a
returned reference (e.g. it can be a
val
).Example:
{{{
scala> import cats.implicits._
{{{
scala> import cats.implicits._
scala> Applicative[Option]
.unit
res0: Option[Unit] = Some(())
}}}
res0: Option[Unit] = Some(())
}}}
- Inhertied from
- Applicative
def productLEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[A]
Sequentially compose two actions, discarding any value produced by the second. This variant of
productL also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
productL also lets you define the evaluation strategy of the second action. For instance
you can evaluate it only ''after'' the first action has finished:
{{{
scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int] .productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
}}}
scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int] .productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
}}}
- Inhertied from
- FlatMap