Default and reusable instance for CatsConcurrentForTask.
Default and reusable instance for CatsConcurrentForTask.
Globally available in scope, as it is returned by IO.catsAsync.
- Companion
- class
Document{}
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
- Inherited from
- ApplyArityFunctions
Value members
Inherited methods
Given a type A, create a concrete Semigroup[F[A]].
Given a type A, create a concrete Semigroup[F[A]].
Example:
scala> import cats.implicits._
scala> val s: Semigroup[List[Int]] = SemigroupK[List].algebra[Int]
- Inherited from
- SemigroupK
Replaces the A
value in F[A]
with the supplied value.
Replaces the A
value in F[A]
with the supplied value.
Example:
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)
- Inherited from
- Functor
Similar to attempt, but it only handles errors of type EE
.
Similar to attempt, but it only handles errors of type EE
.
- Inherited from
- ApplicativeError
Similar to attempt, but wraps the result in a cats.data.EitherT for convenience.
Similar to attempt, but wraps the result in a cats.data.EitherT for convenience.
- Inherited from
- ApplicativeError
Reifies the value or error of the source and performs an effect on the result,
then recovers the original value or error back into F
.
Reifies the value or error of the source and performs an effect on the result,
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> 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> val b: Try[Int] = Success(1)
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
- Inherited from
- MonadError
Returns a resource that will start execution of the effect in the background.
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 use
),
the background action will be canceled.
A basic example with IO:
val longProcess = (IO.sleep(5.seconds) *> IO(println("Ping!"))).foreverM
val srv: Resource[IO, ServerBinding[IO]] = for {
_ <- 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 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 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)
In case the result of such an action is canceled, both processes will receive cancelation signals.
The same result can be achieved by using anotherProcess &> longProcess
with the Parallel type class syntax.
- Inherited from
- Concurrent
- Definition Classes
- CatsAsyncForTask -> Bracket
- Inherited from
- CatsAsyncForTask
Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.
Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.
- Inherited from
- ApplicativeError
Similar to combineK but uses Eval to allow for laziness in the second argument. This can allow for "short-circuiting" of computations.
Similar to combineK but uses Eval to allow for laziness in the second argument. This can allow for "short-circuiting" of computations.
NOTE: the default implementation of combineKEval
does not short-circuit
computations. For data structures that can benefit from laziness, SemigroupK
instances should override this method.
In the following example, x.combineK(bomb)
would result in an error,
but combineKEval
"short-circuits" the computation. x
is Some
and thus the
result of bomb
doesn't even need to be evaluated in order to determine
that the result of combineKEval
should be x
.
scala> import cats.{Eval, Later}
scala> import cats.implicits._
scala> val bomb: Eval[Option[Int]] = Later(sys.error("boom"))
scala> val x: Option[Int] = Some(42)
scala> x.combineKEval(bomb).value
res0: Option[Int] = Some(42)
- Inherited from
- SemigroupK
Compose an Applicative[F]
and an Applicative[G]
into an
Applicative[λ[α => F[G[α]]]]
.
Compose an Applicative[F]
and an Applicative[G]
into an
Applicative[λ[α => F[G[α]]]]
.
Example:
scala> import cats.implicits._
scala> val alo = Applicative[List].compose[Option]
scala> alo.pure(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)
- Inherited from
- Applicative
Compose Invariant F[_]
and G[_]
then produce Invariant[F[G[_]]]
using their imap
.
Compose Invariant F[_]
and G[_]
then produce Invariant[F[G[_]]]
using their imap
.
Example:
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)
- Inherited from
- Invariant
Compose an Apply[F]
and an Apply[G]
into an Apply[λ[α => F[G[α]]]]
.
Compose an Apply[F]
and an Apply[G]
into an Apply[λ[α => F[G[α]]]]
.
Example:
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)
- Inherited from
- Apply
The composition of two Bifunctors is itself a Bifunctor
The composition of two Bifunctors is itself a Bifunctor
- Inherited from
- Bifunctor
"Compose" with a G[_]
type to form a SemigroupK
for λ[α => F[G[α]]]
.
Note that this universally works for any G
, because the "inner" structure
isn't considered when combining two instances.
"Compose" with a G[_]
type to form a SemigroupK
for λ[α => F[G[α]]]
.
Note that this universally works for any G
, because the "inner" structure
isn't considered when combining two instances.
Example:
scala> import cats.implicits._
scala> type ListOption[A] = List[Option[A]]
scala> val s: SemigroupK[ListOption] = SemigroupK[List].compose[Option]
scala> s.combineK(List(Some(1), None, Some(2)), List(Some(3), None))
res0: List[Option[Int]] = List(Some(1), None, Some(2), Some(3), None)
- Inherited from
- SemigroupK
- Definition Classes
- Functor -> Invariant
- Inherited from
- Functor
Compose an Applicative[F]
and a ContravariantMonoidal[G]
into a
ContravariantMonoidal[λ[α => F[G[α]]]]
.
Compose an Applicative[F]
and a ContravariantMonoidal[G]
into a
ContravariantMonoidal[λ[α => F[G[α]]]]
.
Example:
scala> import cats.kernel.Comparison
scala> import cats.implicits._
// compares strings by alphabetical order
scala> val alpha: Order[String] = Order[String]
// compares strings by their length
scala> val strLength: Order[String] = Order.by[String, Int](_.length)
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> 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)
// 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)
// create the `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)
- Inherited from
- Applicative
Compose Invariant F[_]
and Functor G[_]
then produce Invariant[F[G[_]]]
using F's imap
and G's map
.
Compose Invariant 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> 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)
- Inherited from
- Invariant
If no interruption happens during the execution of this method,
it behaves like .attempt.flatMap
.
If no interruption happens during the execution of this method,
it behaves like .attempt.flatMap
.
Unlike .attempt.flatMap
however, in the presence of
interruption this method offers the continual guarantee:
fa
is interruptible, but if it completes execution, the
effects of f
are guaranteed to execute.
This does not hold for attempt.flatMap
since interruption can
happen 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).
Note that for the use case above:
- 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 of waitingOp
.
- We cannot use
waitingOp.attempt.flatMap(modifyOp)
because it could be interrupted after waitingOp
is done, but
before modifyOp
executes.
To access this implementation as a standalone function, you can use Concurrent.continual in the companion object.
- Inherited from
- Concurrent
Alias for suspend
that suspends the evaluation of
an F
reference and implements cats.Defer
typeclass.
Alias for suspend
that suspends the evaluation of
an F
reference and implements cats.Defer
typeclass.
- Definition Classes
- Sync -> Defer
- Inherited from
- Sync
Turns a successful value into an error if it does not satisfy a given predicate.
Turns a successful value into an error if it does not satisfy a given predicate.
- Inherited from
- MonadError
Turns a successful value into an error specified by the error
function if it does not satisfy a given predicate.
Turns a successful value into an error specified by the error
function if it does not satisfy a given predicate.
- Inherited from
- MonadError
Defer instances, like functions, parsers, generators, IO, etc... often are used in recursive settings where this function is useful
Defer instances, like functions, parsers, generators, IO, etc... 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(")") }
Note, fn may not yield a terminating value in which case both of the above F[A] run forever.
- Inherited from
- Defer
Apply a monadic function and discard the result while keeping the effect.
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> List[Int](0).flatTap(nCats)
res2: List[Int] = List()
scala> List[Int](4).flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
- Inherited from
- FlatMap
Alias for map, since map can't be injected as syntax if
the implementing type already had a built-in .map
method.
Alias for map, since map can't be injected as syntax if
the implementing type already had a built-in .map
method.
Example:
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!)
- Inherited from
- Functor
Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.
Like an infinite loop of >> calls. This is most useful effect loops 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.
- Inherited from
- FlatMap
Tuple the values in fa with the result of applying a function with the value
Tuple the values in fa with the result of applying a function with the value
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option].fproduct(Option(42))(_.toString)
res0: Option[(Int, String)] = Some((42,42))
- Inherited from
- Functor
Pair the result of function application with A
.
Pair the result of function application with A
.
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option].fproductLeft(Option(42))(_.toString)
res0: Option[(String, Int)] = Some((42,42))
- Inherited from
- Functor
Convert from scala.Either
Convert from scala.Either
Example:
scala> import cats.ApplicativeError
scala> import cats.instances.option._
scala> ApplicativeError[Option, Unit].fromEither(Right(1))
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit].fromEither(Left(()))
res1: scala.Option[Nothing] = None
- Inherited from
- ApplicativeError
Convert from scala.Option
Convert from scala.Option
Example:
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)
scala> F.fromOption(Option.empty[Int], "Empty")
res1: scala.Either[String, Int] = Left(Empty)
- Inherited from
- ApplicativeError
Convert from cats.data.Validated
Convert from cats.data.Validated
Example:
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> ApplicativeError[Option, Unit].fromValidated(1.valid[Unit])
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit].fromValidated(().invalid[Int])
res1: scala.Option[Int] = None
- Inherited from
- ApplicativeError
- Definition Classes
- CatsAsyncForTask -> Bracket
- Inherited from
- CatsAsyncForTask
- Definition Classes
- CatsBaseForTask -> ApplicativeError
- Inherited from
- CatsBaseForTask
An 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.
An 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.
Example:
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 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 b3: Option[Boolean] = Some(true)
scala> val asInt3: Option[Int] = Apply[Option].ifA(b3)(Some(1), None)
asInt2: Option[Int] = None
- Inherited from
- Apply
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.
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.
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
Based on a gist by Daniel Spiewak with a stack-safe implementation due to P. Oscar Boykin
- See also
See https://gitter.im/typelevel/cats-effect?at=5f297e4314c413356f56d230 for the discussion.
- Inherited from
- Monad
Lifts if
to Functor
Lifts if
to Functor
Example:
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)
- Inherited from
- Functor
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.
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.
- Inherited from
- FlatMap
Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.
Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.
- Inherited from
- Monad
Apply a monadic function iteratively until its result satisfies the given predicate and return that result.
Apply a monadic function iteratively until its result satisfies the given predicate and return that result.
- Inherited from
- Monad
Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.
Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.
- Inherited from
- Monad
Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.
Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.
- Inherited from
- Monad
apply a function to the "left" functor
apply a function to the "left" functor
- Inherited from
- Bifunctor
Widens A into a supertype AA. Example:
Widens A into a supertype AA. Example:
scala> import cats.implicits._
scala> sealed trait Foo
scala> case object Bar extends Foo
scala> val x1: Either[Bar.type, Int] = Either.left(Bar)
scala> val x2: Either[Foo, Int] = x1.leftWiden
- Inherited from
- Bifunctor
Lift a function f to operate on Functors
Lift a function f to operate on Functors
Example:
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)
- Inherited from
- Functor
Inherited from LiftIO, defines a conversion from IO
in terms of the Concurrent
type class.
Inherited from LiftIO, defines a conversion from IO
in terms of the Concurrent
type class.
N.B. expressing this conversion in terms of Concurrent
and
its capabilities means that the resulting F
is cancelable in
case the source IO
is.
To access this implementation as a standalone function, you can use Concurrent.liftIO (on the object companion).
- Definition Classes
- Concurrent -> Async -> LiftIO
- Inherited from
- Concurrent
- Definition Classes
- Inherited from
- CatsBaseForTask
Similar to map2 but uses Eval to allow for laziness in the F[B]
argument. This can allow for "short-circuiting" of computations.
Similar to map2 but uses Eval to allow for laziness in the F[B]
argument. This can allow for "short-circuiting" of computations.
NOTE: the default implementation of map2Eval
does not short-circuit
computations. For data structures that can benefit from laziness, Apply
instances should override this method.
In the following example, x.map2(bomb)(_ + _)
would result in an error,
but map2Eval
"short-circuits" the computation. x
is None
and thus the
result of bomb
doesn't even need to be evaluated in order to determine
that 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
- Inherited from
- Apply
Pair A
with the result of function application.
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))
- Inherited from
- FlatMap
Returns a non-terminating F[_]
, that never completes
with a result, being equivalent to async(_ => ())
Returns a non-terminating F[_]
, that never completes
with a result, being equivalent to async(_ => ())
- Inherited from
- Async
Executes the given finalizer
when the source is canceled.
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.
waitingOp.onCancel(restoreState)
A direct use of bracket
is not a good fit for this case as it
would 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
- See also
guaranteeCase for the version that can discriminate between termination conditions
bracket for the more general operation
Concurrent.continual when you have a use case similar to the cancel/restore example above, but require access to the result of
F[A]
- Inherited from
- Bracket
Execute a callback on certain errors, then rethrow them. Any non matching error is rethrown as well.
Execute a callback on certain errors, then rethrow them. 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:
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"))
| }
scala> val prog1: F[Int] = (Err("one")).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)))
- Inherited from
- ApplicativeError
point
lifts any value into a Monoidal Functor.
point
lifts any value into a Monoidal Functor.
Example:
scala> import cats.implicits._
scala> InvariantMonoidal[Option].point(10)
res0: Option[Int] = Some(10)
- Inherited from
- InvariantMonoidal
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:
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:
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)
- Inherited from
- FlatMap
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:
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:
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)
- Inherited from
- FlatMap
- Definition Classes
- CatsConcurrentForTask -> Concurrent
- Inherited from
- CatsConcurrentForTask
- Definition Classes
- CatsBaseForTask -> ApplicativeError
- Inherited from
- CatsBaseForTask
Returns a new value that transforms the result of the source,
given the recover
or map
functions, which get executed depending
on whether the result is successful or if it ends in error.
Returns a new value that transforms the result of the source,
given the recover
or map
functions, which get executed depending
on whether the result is successful or if it ends in error.
This is an optimization on usage of attempt and map, this equivalence being available:
fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))
Usage of redeem
subsumes handleError because:
fa.redeem(fe, id) <-> fa.handleError(fe)
Implementations are free to override it in order to optimize 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
MonadError.redeemWith, attempt and handleError
- Inherited from
- ApplicativeError
Returns a new value that transforms the result of the source,
given the recover
or bind
functions, which get executed depending
on whether the result is successful or if it ends in error.
Returns a new value that transforms the result of the source,
given the recover
or bind
functions, which get executed depending
on whether the result is successful or if it ends in error.
This is an optimization on usage of attempt and flatMap, this equivalence being available:
fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))
Usage of redeemWith
subsumes handleErrorWith because:
fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)
Usage of redeemWith
also subsumes flatMap because:
fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)
Implementations are free to override it in order to optimize 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
redeem, attempt and handleErrorWith
- Inherited from
- MonadError
Given fa
and n
, apply fa
n
times to construct an F[List[A]]
value.
Given fa
and n
, apply fa
n
times to construct an F[List[A]]
value.
Example:
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))
- Inherited from
- Applicative
Inverse of attempt
Inverse of attempt
Example:
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> val b: Try[Either[Throwable, Int]] = Success(Right(1))
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
- Inherited from
- MonadError
Combines F[A]
and F[B]
into a F[Either[A,B]]]
.
Combines F[A]
and F[B]
into a F[Either[A,B]]]
.
Example:
scala> import cats.SemigroupK
scala> import cats.data.NonEmptyList
scala> SemigroupK[NonEmptyList].sum(NonEmptyList.one("abc"), NonEmptyList.one(2))
res0: NonEmptyList[Either[String,Int]] = NonEmptyList(Left(abc), Right(2))
- Inherited from
- SemigroupK
Tuples the A
value in F[A]
with the supplied B
value, with the B
value on the left.
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> Functor[Queue].tupleLeft(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
- Inherited from
- Functor
Tuples the A
value in F[A]
with the supplied B
value, with the B
value on the right.
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> Functor[Queue].tupleRight(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
- Inherited from
- Functor
Returns the given argument (mapped to Unit) if cond
is false
,
otherwise, unit lifted into F.
Returns the given argument (mapped to Unit) if cond
is false
,
otherwise, unit lifted into F.
Example:
scala> import cats.implicits._
scala> Applicative[List].unlessA(true)(List(1, 2, 3))
res0: List[Unit] = List(())
scala> Applicative[List].unlessA(false)(List(1, 2, 3))
res1: List[Unit] = List((), (), ())
scala> Applicative[List].unlessA(true)(List.empty[Int])
res2: List[Unit] = List(())
scala> Applicative[List].unlessA(false)(List.empty[Int])
res3: List[Unit] = List()
- Inherited from
- Applicative
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.
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.
- Inherited from
- FlatMap
Execute an action repeatedly until the 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
.
Execute an action repeatedly until the 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
.
- Inherited from
- Monad
Execute an action repeatedly until the Boolean
condition returns true
.
The condition is evaluated after the loop body. Discards results.
Execute an action repeatedly until the Boolean
condition returns true
.
The condition is evaluated after the loop body. Discards results.
- Inherited from
- Monad
Un-zips an F[(A, B)]
consisting of element pairs or Tuple2 into two separate F's tupled.
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> Functor[List].unzip(List((1,2), (3, 4)))
res0: (List[Int], List[Int]) = (List(1, 3),List(2, 4))
- Inherited from
- Functor
Empty the fa of the values, preserving the structure
Empty the fa of the values, preserving the structure
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List].void(List(1,2,3))
res0: List[Unit] = List((), (), ())
- Inherited from
- Functor
Returns the given argument (mapped to Unit) if cond
is true
, otherwise,
unit lifted into F.
Returns the given argument (mapped to Unit) if cond
is true
, otherwise,
unit lifted into F.
Example:
scala> import cats.implicits._
scala> Applicative[List].whenA(true)(List(1, 2, 3))
res0: List[Unit] = List((), (), ())
scala> Applicative[List].whenA(false)(List(1, 2, 3))
res1: List[Unit] = List(())
scala> Applicative[List].whenA(true)(List.empty[Int])
res2: List[Unit] = List()
scala> Applicative[List].whenA(false)(List.empty[Int])
res3: List[Unit] = List(())
- Inherited from
- Applicative
Execute an action repeatedly as long as the given Boolean
expression
returns 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
.
Execute an action repeatedly as long as the given Boolean
expression
returns 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
.
- Inherited from
- Monad
Execute an action repeatedly as long as the given Boolean
expression
returns true
. The condition is evaluated before the loop body.
Discards results.
Execute an action repeatedly as long as the given Boolean
expression
returns true
. The condition is evaluated before the loop body.
Discards results.
- Inherited from
- Monad
Lifts natural subtyping covariance of covariant Functors.
Lifts natural subtyping covariance of covariant Functors.
NOTE: In certain (perhaps contrived) situations that rely on universal
equality this can result in a ClassCastException
, because it is
implemented as a type cast. It could be implemented as map(identity)
, but
according to the functor laws, that should be equal to fa
, and a type
cast is often much more performant.
See this example
of widen
creating a ClassCastException
.
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val s = Some(42)
scala> Functor[Option].widen(s)
res0: Option[Int] = Some(42)
- Inherited from
- Functor