cats-effect-kernel
3.4.4
API
Generated with
© 2002-2021 · LAMP/EPFL
© 2002-2021 · LAMP/EPFL
cats-effect-kernel/cats.effect.kernel/Async

Async

cats.effect.kernel.Async
See theAsync companion object
trait Async[F[_]] extends Sync[F] with Temporal[F]

A typeclass that encodes the notion of suspending asynchronous side effects in the F[_] context

An asynchronous task is one whose results are computed somewhere else (eg by a scala.concurrent.Future running on some other threadpool). We await the results of that execution by giving it a callback to be invoked with the result.

That computation may fail hence the callback is of type Either[Throwable, A] => (). This awaiting is semantic only - no threads are blocked, the current fiber is simply descheduled until the callback completes.

This leads us directly to the simplest asynchronous FFI

def async_[A](k: (Either[Throwable, A] => Unit) => Unit): F[A]

async(k)

is semantically blocked until the callback is invoked.

async_ is somewhat contrained however. We can't perform any F[_] effects in the process of registering the callback and we also can't register a finalizer to eg cancel the asynchronous task in the event that the fiber running async_ is canceled.

This leads us directly to the more general asynchronous FFI

def async[A](k: (Either[Throwable, A] => Unit) => F[Option[F[Unit]]]): F[A]

As evidenced by the type signature, k may perform F[_] effects and it returns an Option[F[Unit]] which is an optional finalizer to be run in the event that the fiber running

async(k)

is canceled.

async(k) }}}

async(k) }}}

async_ is somewhat contrained however. We can't perform any F[_] effects in the process of registering the callback and we also can't register a finalizer to eg cancel the asynchronous task in the event that the fiber running async_ is canceled.

This leads us directly to the more general asynchronous FFI

def async[A](k: (Either[Throwable, A] => Unit) => F[Option[F[Unit]]]): F[A]

As evidenced by the type signature, k may perform F[_] effects and it returns an Option[F[Unit]] which is an optional finalizer to be run in the event that the fiber running

async(k)

is canceled.

async(k) }}}

Attributes

Companion:
object
Source:
Async.scala
Graph
Supertypes
trait Sync[F]
trait Defer[F]
trait Unique[F]
trait Clock[F]
trait Monad[F]
trait FlatMap[F]
trait Applicative[F]
trait Apply[F]
trait Semigroupal[F]
trait Functor[F]
trait Invariant[F]
trait Serializable
class Object
trait Matchable
class Any

Members list

Concise view

Value members

Abstract methods

def cont[K, R](body: Cont[F, K, R]): F[R]
Implicitly added by asyncForEitherT

Attributes

Source:
Async.scala
def cont[K, R](body: Cont[F, K, R]): F[R]
Implicitly added by asyncForKleisli

Attributes

Source:
Async.scala
def cont[K, R](body: Cont[F, K, R]): F[R]
Implicitly added by asyncForOptionT

Attributes

Source:
Async.scala
def cont[K, R](body: Cont[F, K, R]): F[R]

Attributes

Source:
Async.scala
def evalOn[A](fa: F[A], ec: ExecutionContext): F[A]
Implicitly added by asyncForEitherT

Shift execution of the effect fa to the execution context ec. Execution is shifted back to the previous execution context when fa completes.

Shift execution of the effect fa to the execution context ec. Execution is shifted back to the previous execution context when fa completes.

evalOn(executionContext, ec) <-> pure(ec)

Attributes

Source:
Async.scala
def evalOn[A](fa: F[A], ec: ExecutionContext): F[A]
Implicitly added by asyncForKleisli

Shift execution of the effect fa to the execution context ec. Execution is shifted back to the previous execution context when fa completes.

Shift execution of the effect fa to the execution context ec. Execution is shifted back to the previous execution context when fa completes.

evalOn(executionContext, ec) <-> pure(ec)

Attributes

Source:
Async.scala
def evalOn[A](fa: F[A], ec: ExecutionContext): F[A]
Implicitly added by asyncForOptionT

Shift execution of the effect fa to the execution context ec. Execution is shifted back to the previous execution context when fa completes.

Shift execution of the effect fa to the execution context ec. Execution is shifted back to the previous execution context when fa completes.

evalOn(executionContext, ec) <-> pure(ec)

Attributes

Source:
Async.scala
def evalOn[A](fa: F[A], ec: ExecutionContext): F[A]

Shift execution of the effect fa to the execution context ec. Execution is shifted back to the previous execution context when fa completes.

Shift execution of the effect fa to the execution context ec. Execution is shifted back to the previous execution context when fa completes.

evalOn(executionContext, ec) <-> pure(ec)

Attributes

Source:
Async.scala
def executionContext: F[ExecutionContext]
Implicitly added by asyncForEitherT

Obtain a reference to the current execution context.

Obtain a reference to the current execution context.

Attributes

Source:
Async.scala
def executionContext: F[ExecutionContext]
Implicitly added by asyncForKleisli

Obtain a reference to the current execution context.

Obtain a reference to the current execution context.

Attributes

Source:
Async.scala
def executionContext: F[ExecutionContext]
Implicitly added by asyncForOptionT

Obtain a reference to the current execution context.

Obtain a reference to the current execution context.

Attributes

Source:
Async.scala
def executionContext: F[ExecutionContext]

Obtain a reference to the current execution context.

Obtain a reference to the current execution context.

Attributes

Source:
Async.scala

Concrete methods

def async[A](k: (Either[Throwable, A] => Unit) => F[Option[F[Unit]]]): F[A]
Implicitly added by asyncForEitherT

The asynchronous FFI.

The asynchronous FFI.

k takes a callback of type Either[Throwable, A] => Unit to signal the result of the asynchronous computation. The execution of async(k) is semantically blocked until the callback is invoked.

k returns an Option[F[Unit]] which is an optional finalizer to be run in the event that the fiber running

async(k)

is canceled.

async(k) }}}

Attributes

Source:
Async.scala
def async[A](k: (Either[Throwable, A] => Unit) => F[Option[F[Unit]]]): F[A]
Implicitly added by asyncForKleisli

The asynchronous FFI.

The asynchronous FFI.

k takes a callback of type Either[Throwable, A] => Unit to signal the result of the asynchronous computation. The execution of async(k) is semantically blocked until the callback is invoked.

k returns an Option[F[Unit]] which is an optional finalizer to be run in the event that the fiber running

async(k)

is canceled.

async(k) }}}

Attributes

Source:
Async.scala
def async[A](k: (Either[Throwable, A] => Unit) => F[Option[F[Unit]]]): F[A]
Implicitly added by asyncForOptionT

The asynchronous FFI.

The asynchronous FFI.

k takes a callback of type Either[Throwable, A] => Unit to signal the result of the asynchronous computation. The execution of async(k) is semantically blocked until the callback is invoked.

k returns an Option[F[Unit]] which is an optional finalizer to be run in the event that the fiber running

async(k)

is canceled.

async(k) }}}

Attributes

Source:
Async.scala
def async[A](k: (Either[Throwable, A] => Unit) => F[Option[F[Unit]]]): F[A]

The asynchronous FFI.

The asynchronous FFI.

k takes a callback of type Either[Throwable, A] => Unit to signal the result of the asynchronous computation. The execution of async(k) is semantically blocked until the callback is invoked.

k returns an Option[F[Unit]] which is an optional finalizer to be run in the event that the fiber running

async(k)

is canceled.

async(k) }}}

Attributes

Source:
Async.scala
def async_[A](k: (Either[Throwable, A] => Unit) => Unit): F[A]
Implicitly added by asyncForEitherT

A convenience version of Async.async for when we don't need to perform F[_] effects or perform finalization in the event of cancelation.

A convenience version of Async.async for when we don't need to perform F[_] effects or perform finalization in the event of cancelation.

Attributes

Source:
Async.scala
def async_[A](k: (Either[Throwable, A] => Unit) => Unit): F[A]
Implicitly added by asyncForKleisli

A convenience version of Async.async for when we don't need to perform F[_] effects or perform finalization in the event of cancelation.

A convenience version of Async.async for when we don't need to perform F[_] effects or perform finalization in the event of cancelation.

Attributes

Source:
Async.scala
def async_[A](k: (Either[Throwable, A] => Unit) => Unit): F[A]
Implicitly added by asyncForOptionT

A convenience version of Async.async for when we don't need to perform F[_] effects or perform finalization in the event of cancelation.

A convenience version of Async.async for when we don't need to perform F[_] effects or perform finalization in the event of cancelation.

Attributes

Source:
Async.scala
def async_[A](k: (Either[Throwable, A] => Unit) => Unit): F[A]

A convenience version of Async.async for when we don't need to perform F[_] effects or perform finalization in the event of cancelation.

A convenience version of Async.async for when we don't need to perform F[_] effects or perform finalization in the event of cancelation.

Attributes

Source:
Async.scala
def backgroundOn[A](fa: F[A], ec: ExecutionContext): Resource[F, F[Outcome[F, Throwable, A]]]
Implicitly added by asyncForEitherT

Start a new background fiber on a different execution context.

Start a new background fiber on a different execution context.

See GenSpawn.background for more details.

Attributes

Source:
Async.scala
def backgroundOn[A](fa: F[A], ec: ExecutionContext): Resource[F, F[Outcome[F, Throwable, A]]]
Implicitly added by asyncForKleisli

Start a new background fiber on a different execution context.

Start a new background fiber on a different execution context.

See GenSpawn.background for more details.

Attributes

Source:
Async.scala
def backgroundOn[A](fa: F[A], ec: ExecutionContext): Resource[F, F[Outcome[F, Throwable, A]]]
Implicitly added by asyncForOptionT

Start a new background fiber on a different execution context.

Start a new background fiber on a different execution context.

See GenSpawn.background for more details.

Attributes

Source:
Async.scala
def backgroundOn[A](fa: F[A], ec: ExecutionContext): Resource[F, F[Outcome[F, Throwable, A]]]

Start a new background fiber on a different execution context.

Start a new background fiber on a different execution context.

See GenSpawn.background for more details.

Attributes

Source:
Async.scala
def evalOnK(ec: ExecutionContext): FunctionK[F, F]
Implicitly added by asyncForEitherT

Async.evalOn as a natural transformation.

Async.evalOn as a natural transformation.

Attributes

Source:
Async.scala
def evalOnK(ec: ExecutionContext): FunctionK[F, F]
Implicitly added by asyncForKleisli

Async.evalOn as a natural transformation.

Async.evalOn as a natural transformation.

Attributes

Source:
Async.scala
def evalOnK(ec: ExecutionContext): FunctionK[F, F]
Implicitly added by asyncForOptionT

Async.evalOn as a natural transformation.

Async.evalOn as a natural transformation.

Attributes

Source:
Async.scala
def evalOnK(ec: ExecutionContext): FunctionK[F, F]

Async.evalOn as a natural transformation.

Async.evalOn as a natural transformation.

Attributes

Source:
Async.scala
def executor: F[Executor]
Implicitly added by asyncForEitherT

Obtain a reference to the current execution context as a java.util.concurrent.Executor.

Obtain a reference to the current execution context as a java.util.concurrent.Executor.

Attributes

Source:
Async.scala
def executor: F[Executor]
Implicitly added by asyncForKleisli

Obtain a reference to the current execution context as a java.util.concurrent.Executor.

Obtain a reference to the current execution context as a java.util.concurrent.Executor.

Attributes

Source:
Async.scala
def executor: F[Executor]
Implicitly added by asyncForOptionT

Obtain a reference to the current execution context as a java.util.concurrent.Executor.

Obtain a reference to the current execution context as a java.util.concurrent.Executor.

Attributes

Source:
Async.scala
def executor: F[Executor]

Obtain a reference to the current execution context as a java.util.concurrent.Executor.

Obtain a reference to the current execution context as a java.util.concurrent.Executor.

Attributes

Source:
Async.scala
def fromFuture[A](fut: F[Future[A]]): F[A]
Implicitly added by asyncForEitherT

Lifts a scala.concurrent.Future into an F effect.

Lifts a scala.concurrent.Future into an F effect.

Attributes

Source:
Async.scala
def fromFuture[A](fut: F[Future[A]]): F[A]
Implicitly added by asyncForKleisli

Lifts a scala.concurrent.Future into an F effect.

Lifts a scala.concurrent.Future into an F effect.

Attributes

Source:
Async.scala
def fromFuture[A](fut: F[Future[A]]): F[A]
Implicitly added by asyncForOptionT

Lifts a scala.concurrent.Future into an F effect.

Lifts a scala.concurrent.Future into an F effect.

Attributes

Source:
Async.scala
def fromFuture[A](fut: F[Future[A]]): F[A]

Lifts a scala.concurrent.Future into an F effect.

Lifts a scala.concurrent.Future into an F effect.

Attributes

Source:
Async.scala
def never[A]: F[A]
Implicitly added by asyncForEitherT

An effect that never terminates.

An effect that never terminates.

Polymorphic so it can be used in situations where an arbitrary effect is expected eg Fiber.joinWithNever

Attributes

Source:
Async.scala
def never[A]: F[A]
Implicitly added by asyncForKleisli

An effect that never terminates.

An effect that never terminates.

Polymorphic so it can be used in situations where an arbitrary effect is expected eg Fiber.joinWithNever

Attributes

Source:
Async.scala
def never[A]: F[A]
Implicitly added by asyncForOptionT

An effect that never terminates.

An effect that never terminates.

Polymorphic so it can be used in situations where an arbitrary effect is expected eg Fiber.joinWithNever

Attributes

Source:
Async.scala
def never[A]: F[A]

An effect that never terminates.

An effect that never terminates.

Polymorphic so it can be used in situations where an arbitrary effect is expected eg Fiber.joinWithNever

Attributes

Source:
Async.scala
def startOn[A](fa: F[A], ec: ExecutionContext): F[Fiber[F, Throwable, A]]
Implicitly added by asyncForEitherT

Start a new fiber on a different execution context.

Start a new fiber on a different execution context.

See GenSpawn.start for more details.

Attributes

Source:
Async.scala
def startOn[A](fa: F[A], ec: ExecutionContext): F[Fiber[F, Throwable, A]]
Implicitly added by asyncForKleisli

Start a new fiber on a different execution context.

Start a new fiber on a different execution context.

See GenSpawn.start for more details.

Attributes

Source:
Async.scala
def startOn[A](fa: F[A], ec: ExecutionContext): F[Fiber[F, Throwable, A]]
Implicitly added by asyncForOptionT

Start a new fiber on a different execution context.

Start a new fiber on a different execution context.

See GenSpawn.start for more details.

Attributes

Source:
Async.scala
def startOn[A](fa: F[A], ec: ExecutionContext): F[Fiber[F, Throwable, A]]

Start a new fiber on a different execution context.

Start a new fiber on a different execution context.

See GenSpawn.start for more details.

Attributes

Source:
Async.scala
def syncStep[G[_], A](fa: F[A], limit: Int)(implicit G: Sync[G]): G[Either[F[A], A]]
Implicitly added by asyncForEitherT

Translates this F[A] into a G value which, when evaluated, runs the original F to its completion, the limit number of stages, or until the first stage that cannot be expressed with Sync (typically an asynchronous boundary).

Translates this F[A] into a G value which, when evaluated, runs the original F to its completion, the limit number of stages, or until the first stage that cannot be expressed with Sync (typically an asynchronous boundary).

Note that syncStep is merely a hint to the runtime system; implementations have the liberty to interpret this method to their liking as long as it obeys the respective laws. For example, a lawful implementation of this function is G.pure(Left(fa)), in which case the original F[A] value is returned unchanged.

Attributes

limit

The maximum number of stages to evaluate prior to forcibly yielding to F

Source:
Async.scala
def syncStep[G[_], A](fa: F[A], limit: Int)(implicit G: Sync[G]): G[Either[F[A], A]]
Implicitly added by asyncForKleisli

Translates this F[A] into a G value which, when evaluated, runs the original F to its completion, the limit number of stages, or until the first stage that cannot be expressed with Sync (typically an asynchronous boundary).

Translates this F[A] into a G value which, when evaluated, runs the original F to its completion, the limit number of stages, or until the first stage that cannot be expressed with Sync (typically an asynchronous boundary).

Note that syncStep is merely a hint to the runtime system; implementations have the liberty to interpret this method to their liking as long as it obeys the respective laws. For example, a lawful implementation of this function is G.pure(Left(fa)), in which case the original F[A] value is returned unchanged.

Attributes

limit

The maximum number of stages to evaluate prior to forcibly yielding to F

Source:
Async.scala
def syncStep[G[_], A](fa: F[A], limit: Int)(implicit G: Sync[G]): G[Either[F[A], A]]
Implicitly added by asyncForOptionT

Translates this F[A] into a G value which, when evaluated, runs the original F to its completion, the limit number of stages, or until the first stage that cannot be expressed with Sync (typically an asynchronous boundary).

Translates this F[A] into a G value which, when evaluated, runs the original F to its completion, the limit number of stages, or until the first stage that cannot be expressed with Sync (typically an asynchronous boundary).

Note that syncStep is merely a hint to the runtime system; implementations have the liberty to interpret this method to their liking as long as it obeys the respective laws. For example, a lawful implementation of this function is G.pure(Left(fa)), in which case the original F[A] value is returned unchanged.

Attributes

limit

The maximum number of stages to evaluate prior to forcibly yielding to F

Source:
Async.scala
def syncStep[G[_], A](fa: F[A], limit: Int)(implicit G: Sync[G]): G[Either[F[A], A]]

Translates this F[A] into a G value which, when evaluated, runs the original F to its completion, the limit number of stages, or until the first stage that cannot be expressed with Sync (typically an asynchronous boundary).

Translates this F[A] into a G value which, when evaluated, runs the original F to its completion, the limit number of stages, or until the first stage that cannot be expressed with Sync (typically an asynchronous boundary).

Note that syncStep is merely a hint to the runtime system; implementations have the liberty to interpret this method to their liking as long as it obeys the respective laws. For example, a lawful implementation of this function is G.pure(Left(fa)), in which case the original F[A] value is returned unchanged.

Attributes

limit

The maximum number of stages to evaluate prior to forcibly yielding to F

Source:
Async.scala

Inherited methods

final def *>[A, B](fa: F[A])(fb: F[B]): F[B]
Implicitly added by asyncForEitherT

Alias for productR.

Alias for productR.

Attributes

Inherited from:
Apply
Source:
Apply.scala
final def *>[A, B](fa: F[A])(fb: F[B]): F[B]
Implicitly added by asyncForKleisli

Alias for productR.

Alias for productR.

Attributes

Inherited from:
Apply
Source:
Apply.scala
final def *>[A, B](fa: F[A])(fb: F[B]): F[B]
Implicitly added by asyncForOptionT

Alias for productR.

Alias for productR.

Attributes

Inherited from:
Apply
Source:
Apply.scala
final def *>[A, B](fa: F[A])(fb: F[B]): F[B]

Alias for productR.

Alias for productR.

Attributes

Inherited from:
Apply
Source:
Apply.scala
final def <*[A, B](fa: F[A])(fb: F[B]): F[A]
Implicitly added by asyncForEitherT

Alias for productL.

Alias for productL.

Attributes

Inherited from:
Apply
Source:
Apply.scala
final def <*[A, B](fa: F[A])(fb: F[B]): F[A]
Implicitly added by asyncForKleisli

Alias for productL.

Alias for productL.

Attributes

Inherited from:
Apply
Source:
Apply.scala
final def <*[A, B](fa: F[A])(fb: F[B]): F[A]
Implicitly added by asyncForOptionT

Alias for productL.

Alias for productL.

Attributes

Inherited from:
Apply
Source:
Apply.scala
final def <*[A, B](fa: F[A])(fb: F[B]): F[A]

Alias for productL.

Alias for productL.

Attributes

Inherited from:
Apply
Source:
Apply.scala
final def <*>[A, B](ff: F[A => B])(fa: F[A]): F[B]
Implicitly added by asyncForEitherT

Alias for ap.

Alias for ap.

Attributes

Inherited from:
Apply
Source:
Apply.scala
final def <*>[A, B](ff: F[A => B])(fa: F[A]): F[B]
Implicitly added by asyncForKleisli

Alias for ap.

Alias for ap.

Attributes

Inherited from:
Apply
Source:
Apply.scala
final def <*>[A, B](ff: F[A => B])(fa: F[A]): F[B]
Implicitly added by asyncForOptionT

Alias for ap.

Alias for ap.

Attributes

Inherited from:
Apply
Source:
Apply.scala
final def <*>[A, B](ff: F[A => B])(fa: F[A]): F[B]

Alias for ap.

Alias for ap.

Attributes

Inherited from:
Apply
Source:
Apply.scala
override def adaptError[A](fa: F[A])(pf: PartialFunction[Throwable, Throwable]): F[A]

Transform certain errors using pf and rethrow them. Non matching errors and successful values are not affected by this function.

Transform certain errors using pf and rethrow them. Non matching errors and successful values are not affected by this function.

Example:

scala> import cats._, implicits._

scala> def pf: PartialFunction[String, String] = { case "error" => "ERROR" }

scala> ApplicativeError[Either[String, *], String].adaptError("error".asLeft[Int])(pf)
res0: Either[String,Int] = Left(ERROR)

scala> ApplicativeError[Either[String, *], String].adaptError("err".asLeft[Int])(pf)
res1: Either[String,Int] = Left(err)

scala> ApplicativeError[Either[String, *], String].adaptError(1.asRight[String])(pf)
res2: Either[String,Int] = Right(1)

The same function is available in ApplicativeErrorOps as adaptErr - it cannot have the same name because this would result in ambiguous implicits due to adaptError having originally been included in the MonadError API and syntax.

Attributes

Definition Classes
Inherited from:
MonadError
Source:
MonadError.scala
def andWait[A](fa: F[A], time: Duration): F[A]
Implicitly added by asyncForEitherT

Wait for the specified duration after the execution of fa before returning the result.

Wait for the specified duration after the execution of fa before returning the result.

Attributes

fa

The effect to execute

time

The duration to wait after executing fa

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def andWait[A](fa: F[A], time: Duration): F[A]
Implicitly added by asyncForKleisli

Wait for the specified duration after the execution of fa before returning the result.

Wait for the specified duration after the execution of fa before returning the result.

Attributes

fa

The effect to execute

time

The duration to wait after executing fa

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def andWait[A](fa: F[A], time: Duration): F[A]
Implicitly added by asyncForOptionT

Wait for the specified duration after the execution of fa before returning the result.

Wait for the specified duration after the execution of fa before returning the result.

Attributes

fa

The effect to execute

time

The duration to wait after executing fa

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def andWait[A](fa: F[A], time: Duration): F[A]

Wait for the specified duration after the execution of fa before returning the result.

Wait for the specified duration after the execution of fa before returning the result.

Attributes

fa

The effect to execute

time

The duration to wait after executing fa

Inherited from:
GenTemporal
Source:
GenTemporal.scala
override def ap[A, B](ff: F[A => B])(fa: F[A]): F[B]

Given a value and a function in the Apply context, applies the function to the value.

Given a value and a function in the Apply context, applies the function to the value.

Example:

scala> import cats.implicits._

scala> val someF: Option[Int => Long] = Some(_.toLong + 1L)
scala> val noneF: Option[Int => Long] = None
scala> val someInt: Option[Int] = Some(3)
scala> val noneInt: Option[Int] = None

scala> Apply[Option].ap(someF)(someInt)
res0: Option[Long] = Some(4)

scala> Apply[Option].ap(noneF)(someInt)
res1: Option[Long] = None

scala> Apply[Option].ap(someF)(noneInt)
res2: Option[Long] = None

scala> Apply[Option].ap(noneF)(noneInt)
res3: Option[Long] = None

Attributes

Definition Classes
Inherited from:
FlatMap
Source:
FlatMap.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
override def ap2[A, B, Z](ff: F[(A, B) => Z])(fa: F[A], fb: F[B]): F[Z]

ap2 is a binary version of ap, defined in terms of ap.

ap2 is a binary version of ap, defined in terms of ap.

Attributes

Definition Classes
Inherited from:
FlatMap
Source:
FlatMap.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def ap3[A0, A1, A2, Z](f: F[(A0, A1, A2) => Z])(f0: F[A0], f1: F[A1], f2: F[A2]): F[Z]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
override def applicative: Applicative[F]

Attributes

Definition Classes
Inherited from:
GenTemporal
Source:
GenTemporal.scala
def as[A, B](fa: F[A], b: B): F[B]
Implicitly added by asyncForEitherT

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)

Attributes

Inherited from:
Functor
Source:
Functor.scala
def as[A, B](fa: F[A], b: B): F[B]
Implicitly added by asyncForKleisli

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)

Attributes

Inherited from:
Functor
Source:
Functor.scala
def as[A, B](fa: F[A], b: B): F[B]
Implicitly added by asyncForOptionT

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)

Attributes

Inherited from:
Functor
Source:
Functor.scala
def as[A, B](fa: F[A], b: B): F[B]

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)

Attributes

Inherited from:
Functor
Source:
Functor.scala
def attempt[A](fa: F[A]): F[Either[E, A]]
Implicitly added by asyncForEitherT

Handle errors by turning them into scala.util.Either values.

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.

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def attempt[A](fa: F[A]): F[Either[E, A]]
Implicitly added by asyncForKleisli

Handle errors by turning them into scala.util.Either values.

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.

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def attempt[A](fa: F[A]): F[Either[E, A]]
Implicitly added by asyncForOptionT

Handle errors by turning them into scala.util.Either values.

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.

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def attempt[A](fa: F[A]): F[Either[E, A]]

Handle errors by turning them into scala.util.Either values.

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.

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def attemptNarrow[EE <: Throwable, A](fa: F[A])(implicit tag: ClassTag[EE], ev: EE <:< Throwable): F[Either[EE, A]]
Implicitly added by asyncForEitherT

Similar to attempt, but it only handles errors of type EE.

Similar to attempt, but it only handles errors of type EE.

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def attemptNarrow[EE <: Throwable, A](fa: F[A])(implicit tag: ClassTag[EE], ev: EE <:< Throwable): F[Either[EE, A]]
Implicitly added by asyncForKleisli

Similar to attempt, but it only handles errors of type EE.

Similar to attempt, but it only handles errors of type EE.

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def attemptNarrow[EE <: Throwable, A](fa: F[A])(implicit tag: ClassTag[EE], ev: EE <:< Throwable): F[Either[EE, A]]
Implicitly added by asyncForOptionT

Similar to attempt, but it only handles errors of type EE.

Similar to attempt, but it only handles errors of type EE.

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def attemptNarrow[EE <: Throwable, A](fa: F[A])(implicit tag: ClassTag[EE], ev: EE <:< Throwable): F[Either[EE, A]]

Similar to attempt, but it only handles errors of type EE.

Similar to attempt, but it only handles errors of type EE.

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def attemptT[A](fa: F[A]): EitherT[F, E, A]
Implicitly added by asyncForEitherT

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.

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def attemptT[A](fa: F[A]): EitherT[F, E, A]
Implicitly added by asyncForKleisli

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.

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def attemptT[A](fa: F[A]): EitherT[F, E, A]
Implicitly added by asyncForOptionT

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.

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def attemptT[A](fa: F[A]): EitherT[F, E, A]

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.

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def attemptTap[A, B](fa: F[A])(f: Either[Throwable, A] => F[B]): F[A]
Implicitly added by asyncForEitherT

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)

Attributes

Inherited from:
MonadError
Source:
MonadError.scala
def attemptTap[A, B](fa: F[A])(f: Either[Throwable, A] => F[B]): F[A]
Implicitly added by asyncForKleisli

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)

Attributes

Inherited from:
MonadError
Source:
MonadError.scala
def attemptTap[A, B](fa: F[A])(f: Either[Throwable, A] => F[B]): F[A]
Implicitly added by asyncForOptionT

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)

Attributes

Inherited from:
MonadError
Source:
MonadError.scala
def attemptTap[A, B](fa: F[A])(f: Either[Throwable, 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 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)

Attributes

Inherited from:
MonadError
Source:
MonadError.scala
def background[A](fa: F[A]): Resource[F, F[Outcome[F, E, A]]]
Implicitly added by asyncForEitherT

Returns a Resource that manages the concurrent execution of a fiber. The inner effect can be used to wait on the outcome of the child fiber; it is effectively a join.

Returns a Resource that manages the concurrent execution of a fiber. The inner effect can be used to wait on the outcome of the child fiber; it is effectively a join.

The child fiber is canceled in two cases: either the resource goes out of scope or the parent fiber is canceled. If the child fiber terminates before one of these cases occurs, then cancelation is a no-op. This avoids fiber leaks because the child fiber is always canceled before the parent fiber drops the reference to it.


 // Starts a fiber that continously prints "A".
 // After 10 seconds, the resource scope exits so the fiber is canceled.
 F.background(F.delay(println("A")).foreverM).use { _ =>
   F.sleep(10.seconds)
 }

Attributes

fa

the effect for the spawned fiber

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def background[A](fa: F[A]): Resource[F, F[Outcome[F, E, A]]]
Implicitly added by asyncForKleisli

Returns a Resource that manages the concurrent execution of a fiber. The inner effect can be used to wait on the outcome of the child fiber; it is effectively a join.

Returns a Resource that manages the concurrent execution of a fiber. The inner effect can be used to wait on the outcome of the child fiber; it is effectively a join.

The child fiber is canceled in two cases: either the resource goes out of scope or the parent fiber is canceled. If the child fiber terminates before one of these cases occurs, then cancelation is a no-op. This avoids fiber leaks because the child fiber is always canceled before the parent fiber drops the reference to it.


 // Starts a fiber that continously prints "A".
 // After 10 seconds, the resource scope exits so the fiber is canceled.
 F.background(F.delay(println("A")).foreverM).use { _ =>
   F.sleep(10.seconds)
 }

Attributes

fa

the effect for the spawned fiber

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def background[A](fa: F[A]): Resource[F, F[Outcome[F, E, A]]]
Implicitly added by asyncForOptionT

Returns a Resource that manages the concurrent execution of a fiber. The inner effect can be used to wait on the outcome of the child fiber; it is effectively a join.

Returns a Resource that manages the concurrent execution of a fiber. The inner effect can be used to wait on the outcome of the child fiber; it is effectively a join.

The child fiber is canceled in two cases: either the resource goes out of scope or the parent fiber is canceled. If the child fiber terminates before one of these cases occurs, then cancelation is a no-op. This avoids fiber leaks because the child fiber is always canceled before the parent fiber drops the reference to it.


 // Starts a fiber that continously prints "A".
 // After 10 seconds, the resource scope exits so the fiber is canceled.
 F.background(F.delay(println("A")).foreverM).use { _ =>
   F.sleep(10.seconds)
 }

Attributes

fa

the effect for the spawned fiber

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def background[A](fa: F[A]): Resource[F, F[Outcome[F, E, A]]]

Returns a Resource that manages the concurrent execution of a fiber. The inner effect can be used to wait on the outcome of the child fiber; it is effectively a join.

Returns a Resource that manages the concurrent execution of a fiber. The inner effect can be used to wait on the outcome of the child fiber; it is effectively a join.

The child fiber is canceled in two cases: either the resource goes out of scope or the parent fiber is canceled. If the child fiber terminates before one of these cases occurs, then cancelation is a no-op. This avoids fiber leaks because the child fiber is always canceled before the parent fiber drops the reference to it.


 // Starts a fiber that continously prints "A".
 // After 10 seconds, the resource scope exits so the fiber is canceled.
 F.background(F.delay(println("A")).foreverM).use { _ =>
   F.sleep(10.seconds)
 }

Attributes

fa

the effect for the spawned fiber

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def blocking[A](thunk: => A): F[A]
Implicitly added by asyncForEitherT

Like Sync.delay but intended for thread blocking operations. blocking will shift the execution of the blocking operation to a separate threadpool to avoid blocking on the main execution context. See the thread-model documentation for more information on why this is necessary. Note that the created effect will be uncancelable; if you need cancelation then you should use Sync.interruptible or Sync.interruptibleMany.

Like Sync.delay but intended for thread blocking operations. blocking will shift the execution of the blocking operation to a separate threadpool to avoid blocking on the main execution context. See the thread-model documentation for more information on why this is necessary. Note that the created effect will be uncancelable; if you need cancelation then you should use Sync.interruptible or Sync.interruptibleMany.

Sync[F].blocking(scala.io.Source.fromFile("path").mkString)

Attributes

thunk

The side effect which is to be suspended in F[_] and evaluated on a blocking execution context

Inherited from:
Sync
Source:
Sync.scala
def blocking[A](thunk: => A): F[A]
Implicitly added by asyncForKleisli

Like Sync.delay but intended for thread blocking operations. blocking will shift the execution of the blocking operation to a separate threadpool to avoid blocking on the main execution context. See the thread-model documentation for more information on why this is necessary. Note that the created effect will be uncancelable; if you need cancelation then you should use Sync.interruptible or Sync.interruptibleMany.

Like Sync.delay but intended for thread blocking operations. blocking will shift the execution of the blocking operation to a separate threadpool to avoid blocking on the main execution context. See the thread-model documentation for more information on why this is necessary. Note that the created effect will be uncancelable; if you need cancelation then you should use Sync.interruptible or Sync.interruptibleMany.

Sync[F].blocking(scala.io.Source.fromFile("path").mkString)

Attributes

thunk

The side effect which is to be suspended in F[_] and evaluated on a blocking execution context

Inherited from:
Sync
Source:
Sync.scala
def blocking[A](thunk: => A): F[A]
Implicitly added by asyncForOptionT

Like Sync.delay but intended for thread blocking operations. blocking will shift the execution of the blocking operation to a separate threadpool to avoid blocking on the main execution context. See the thread-model documentation for more information on why this is necessary. Note that the created effect will be uncancelable; if you need cancelation then you should use Sync.interruptible or Sync.interruptibleMany.

Like Sync.delay but intended for thread blocking operations. blocking will shift the execution of the blocking operation to a separate threadpool to avoid blocking on the main execution context. See the thread-model documentation for more information on why this is necessary. Note that the created effect will be uncancelable; if you need cancelation then you should use Sync.interruptible or Sync.interruptibleMany.

Sync[F].blocking(scala.io.Source.fromFile("path").mkString)

Attributes

thunk

The side effect which is to be suspended in F[_] and evaluated on a blocking execution context

Inherited from:
Sync
Source:
Sync.scala
def blocking[A](thunk: => A): F[A]

Like Sync.delay but intended for thread blocking operations. blocking will shift the execution of the blocking operation to a separate threadpool to avoid blocking on the main execution context. See the thread-model documentation for more information on why this is necessary. Note that the created effect will be uncancelable; if you need cancelation then you should use Sync.interruptible or Sync.interruptibleMany.

Like Sync.delay but intended for thread blocking operations. blocking will shift the execution of the blocking operation to a separate threadpool to avoid blocking on the main execution context. See the thread-model documentation for more information on why this is necessary. Note that the created effect will be uncancelable; if you need cancelation then you should use Sync.interruptible or Sync.interruptibleMany.

Sync[F].blocking(scala.io.Source.fromFile("path").mkString)

Attributes

thunk

The side effect which is to be suspended in F[_] and evaluated on a blocking execution context

Inherited from:
Sync
Source:
Sync.scala
def both[A, B](fa: F[A], fb: F[B]): F[(A, B)]
Implicitly added by asyncForEitherT

Races the evaluation of two fibers and returns the result of both.

Races the evaluation of two fibers and returns the result of both.

The following rules describe the semantics of both:

  1. If the winner completes with Outcome.Succeeded, the race waits for the loser to complete. 2. If the winner completes with Outcome.Errored, the race raises the error. The loser is canceled. 3. If the winner completes with Outcome.Canceled, the loser and the race are canceled as well. 4. If the loser completes with Outcome.Succeeded, the race returns the successful value of both fibers. 5. If the loser completes with Outcome.Errored, the race returns the error. 6. If the loser completes with Outcome.Canceled, the race is canceled. 7. If the race is canceled before one or both participants complete, then whichever ones are incomplete are canceled. 8. If the race is masked and is canceled because one or both participants canceled, the fiber will block indefinitely.

Attributes

fa

the effect for the first racing fiber

fb

the effect for the second racing fiber

See also:

bothOutcome for a variant that returns the Outcome of both fibers.

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def both[A, B](fa: F[A], fb: F[B]): F[(A, B)]
Implicitly added by asyncForKleisli

Races the evaluation of two fibers and returns the result of both.

Races the evaluation of two fibers and returns the result of both.

The following rules describe the semantics of both:

  1. If the winner completes with Outcome.Succeeded, the race waits for the loser to complete. 2. If the winner completes with Outcome.Errored, the race raises the error. The loser is canceled. 3. If the winner completes with Outcome.Canceled, the loser and the race are canceled as well. 4. If the loser completes with Outcome.Succeeded, the race returns the successful value of both fibers. 5. If the loser completes with Outcome.Errored, the race returns the error. 6. If the loser completes with Outcome.Canceled, the race is canceled. 7. If the race is canceled before one or both participants complete, then whichever ones are incomplete are canceled. 8. If the race is masked and is canceled because one or both participants canceled, the fiber will block indefinitely.

Attributes

fa

the effect for the first racing fiber

fb

the effect for the second racing fiber

See also:

bothOutcome for a variant that returns the Outcome of both fibers.

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def both[A, B](fa: F[A], fb: F[B]): F[(A, B)]
Implicitly added by asyncForOptionT

Races the evaluation of two fibers and returns the result of both.

Races the evaluation of two fibers and returns the result of both.

The following rules describe the semantics of both:

  1. If the winner completes with Outcome.Succeeded, the race waits for the loser to complete. 2. If the winner completes with Outcome.Errored, the race raises the error. The loser is canceled. 3. If the winner completes with Outcome.Canceled, the loser and the race are canceled as well. 4. If the loser completes with Outcome.Succeeded, the race returns the successful value of both fibers. 5. If the loser completes with Outcome.Errored, the race returns the error. 6. If the loser completes with Outcome.Canceled, the race is canceled. 7. If the race is canceled before one or both participants complete, then whichever ones are incomplete are canceled. 8. If the race is masked and is canceled because one or both participants canceled, the fiber will block indefinitely.

Attributes

fa

the effect for the first racing fiber

fb

the effect for the second racing fiber

See also:

bothOutcome for a variant that returns the Outcome of both fibers.

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def both[A, B](fa: F[A], fb: F[B]): F[(A, B)]

Races the evaluation of two fibers and returns the result of both.

Races the evaluation of two fibers and returns the result of both.

The following rules describe the semantics of both:

  1. If the winner completes with Outcome.Succeeded, the race waits for the loser to complete. 2. If the winner completes with Outcome.Errored, the race raises the error. The loser is canceled. 3. If the winner completes with Outcome.Canceled, the loser and the race are canceled as well. 4. If the loser completes with Outcome.Succeeded, the race returns the successful value of both fibers. 5. If the loser completes with Outcome.Errored, the race returns the error. 6. If the loser completes with Outcome.Canceled, the race is canceled. 7. If the race is canceled before one or both participants complete, then whichever ones are incomplete are canceled. 8. If the race is masked and is canceled because one or both participants canceled, the fiber will block indefinitely.

Attributes

fa

the effect for the first racing fiber

fb

the effect for the second racing fiber

See also:

bothOutcome for a variant that returns the Outcome of both fibers.

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def bothOutcome[A, B](fa: F[A], fb: F[B]): F[(Outcome[F, E, A], Outcome[F, E, B])]
Implicitly added by asyncForEitherT

Races the evaluation of two fibers and returns the Outcome of both. If the race is canceled before one or both participants complete, then then whichever ones are incomplete are canceled.

Races the evaluation of two fibers and returns the Outcome of both. If the race is canceled before one or both participants complete, then then whichever ones are incomplete are canceled.

Attributes

fa

the effect for the first racing fiber

fb

the effect for the second racing fiber

See also:

both for a simpler variant that returns the results of both fibers.

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def bothOutcome[A, B](fa: F[A], fb: F[B]): F[(Outcome[F, E, A], Outcome[F, E, B])]
Implicitly added by asyncForKleisli

Races the evaluation of two fibers and returns the Outcome of both. If the race is canceled before one or both participants complete, then then whichever ones are incomplete are canceled.

Races the evaluation of two fibers and returns the Outcome of both. If the race is canceled before one or both participants complete, then then whichever ones are incomplete are canceled.

Attributes

fa

the effect for the first racing fiber

fb

the effect for the second racing fiber

See also:

both for a simpler variant that returns the results of both fibers.

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def bothOutcome[A, B](fa: F[A], fb: F[B]): F[(Outcome[F, E, A], Outcome[F, E, B])]
Implicitly added by asyncForOptionT

Races the evaluation of two fibers and returns the Outcome of both. If the race is canceled before one or both participants complete, then then whichever ones are incomplete are canceled.

Races the evaluation of two fibers and returns the Outcome of both. If the race is canceled before one or both participants complete, then then whichever ones are incomplete are canceled.

Attributes

fa

the effect for the first racing fiber

fb

the effect for the second racing fiber

See also:

both for a simpler variant that returns the results of both fibers.

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def bothOutcome[A, B](fa: F[A], fb: F[B]): F[(Outcome[F, E, A], Outcome[F, E, B])]

Races the evaluation of two fibers and returns the Outcome of both. If the race is canceled before one or both participants complete, then then whichever ones are incomplete are canceled.

Races the evaluation of two fibers and returns the Outcome of both. If the race is canceled before one or both participants complete, then then whichever ones are incomplete are canceled.

Attributes

fa

the effect for the first racing fiber

fb

the effect for the second racing fiber

See also:

both for a simpler variant that returns the results of both fibers.

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def bracket[A, B](acquire: F[A])(use: A => F[B])(release: A => F[Unit]): F[B]
Implicitly added by asyncForEitherT

A pattern for safely interacting with effectful lifecycles.

A pattern for safely interacting with effectful lifecycles.

If acquire completes successfully, use is called. If use succeeds, fails, or is canceled, release is guaranteed to be called exactly once.

acquire is uncancelable. release is uncancelable. use is cancelable by default, but can be masked.

Attributes

acquire

the lifecycle acquisition action

release

the lifecycle release action

use

the effect to which the lifecycle is scoped, whose result is the return value of this function

See also:

bracketCase for a more powerful variant

Resource for a composable datatype encoding of effectful lifecycles

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def bracket[A, B](acquire: F[A])(use: A => F[B])(release: A => F[Unit]): F[B]
Implicitly added by asyncForKleisli

A pattern for safely interacting with effectful lifecycles.

A pattern for safely interacting with effectful lifecycles.

If acquire completes successfully, use is called. If use succeeds, fails, or is canceled, release is guaranteed to be called exactly once.

acquire is uncancelable. release is uncancelable. use is cancelable by default, but can be masked.

Attributes

acquire

the lifecycle acquisition action

release

the lifecycle release action

use

the effect to which the lifecycle is scoped, whose result is the return value of this function

See also:

bracketCase for a more powerful variant

Resource for a composable datatype encoding of effectful lifecycles

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def bracket[A, B](acquire: F[A])(use: A => F[B])(release: A => F[Unit]): F[B]
Implicitly added by asyncForOptionT

A pattern for safely interacting with effectful lifecycles.

A pattern for safely interacting with effectful lifecycles.

If acquire completes successfully, use is called. If use succeeds, fails, or is canceled, release is guaranteed to be called exactly once.

acquire is uncancelable. release is uncancelable. use is cancelable by default, but can be masked.

Attributes

acquire

the lifecycle acquisition action

release

the lifecycle release action

use

the effect to which the lifecycle is scoped, whose result is the return value of this function

See also:

bracketCase for a more powerful variant

Resource for a composable datatype encoding of effectful lifecycles

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def bracket[A, B](acquire: F[A])(use: A => F[B])(release: A => F[Unit]): F[B]

A pattern for safely interacting with effectful lifecycles.

A pattern for safely interacting with effectful lifecycles.

If acquire completes successfully, use is called. If use succeeds, fails, or is canceled, release is guaranteed to be called exactly once.

acquire is uncancelable. release is uncancelable. use is cancelable by default, but can be masked.

Attributes

acquire

the lifecycle acquisition action

release

the lifecycle release action

use

the effect to which the lifecycle is scoped, whose result is the return value of this function

See also:

bracketCase for a more powerful variant

Resource for a composable datatype encoding of effectful lifecycles

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def bracketCase[A, B](acquire: F[A])(use: A => F[B])(release: (A, Outcome[F, Throwable, B]) => F[Unit]): F[B]
Implicitly added by asyncForEitherT

A pattern for safely interacting with effectful lifecycles.

A pattern for safely interacting with effectful lifecycles.

If acquire completes successfully, use is called. If use succeeds, fails, or is canceled, release is guaranteed to be called exactly once.

acquire is uncancelable. release is uncancelable. use is cancelable by default, but can be masked.

Attributes

acquire

the lifecycle acquisition action

release

the lifecycle release action which depends on the outcome of use

use

the effect to which the lifecycle is scoped, whose result is the return value of this function

See also:

bracketFull for a more powerful variant

Resource for a composable datatype encoding of effectful lifecycles

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def bracketCase[A, B](acquire: F[A])(use: A => F[B])(release: (A, Outcome[F, Throwable, B]) => F[Unit]): F[B]
Implicitly added by asyncForKleisli

A pattern for safely interacting with effectful lifecycles.

A pattern for safely interacting with effectful lifecycles.

If acquire completes successfully, use is called. If use succeeds, fails, or is canceled, release is guaranteed to be called exactly once.

acquire is uncancelable. release is uncancelable. use is cancelable by default, but can be masked.

Attributes

acquire

the lifecycle acquisition action

release

the lifecycle release action which depends on the outcome of use

use

the effect to which the lifecycle is scoped, whose result is the return value of this function

See also:

bracketFull for a more powerful variant

Resource for a composable datatype encoding of effectful lifecycles

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def bracketCase[A, B](acquire: F[A])(use: A => F[B])(release: (A, Outcome[F, Throwable, B]) => F[Unit]): F[B]
Implicitly added by asyncForOptionT

A pattern for safely interacting with effectful lifecycles.

A pattern for safely interacting with effectful lifecycles.

If acquire completes successfully, use is called. If use succeeds, fails, or is canceled, release is guaranteed to be called exactly once.

acquire is uncancelable. release is uncancelable. use is cancelable by default, but can be masked.

Attributes

acquire

the lifecycle acquisition action

release

the lifecycle release action which depends on the outcome of use

use

the effect to which the lifecycle is scoped, whose result is the return value of this function

See also:

bracketFull for a more powerful variant

Resource for a composable datatype encoding of effectful lifecycles

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def bracketCase[A, B](acquire: F[A])(use: A => F[B])(release: (A, Outcome[F, Throwable, B]) => F[Unit]): F[B]

A pattern for safely interacting with effectful lifecycles.

A pattern for safely interacting with effectful lifecycles.

If acquire completes successfully, use is called. If use succeeds, fails, or is canceled, release is guaranteed to be called exactly once.

acquire is uncancelable. release is uncancelable. use is cancelable by default, but can be masked.

Attributes

acquire

the lifecycle acquisition action

release

the lifecycle release action which depends on the outcome of use

use

the effect to which the lifecycle is scoped, whose result is the return value of this function

See also:

bracketFull for a more powerful variant

Resource for a composable datatype encoding of effectful lifecycles

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def bracketFull[A, B](acquire: Poll[F] => F[A])(use: A => F[B])(release: (A, Outcome[F, Throwable, B]) => F[Unit]): F[B]
Implicitly added by asyncForEitherT

A pattern for safely interacting with effectful lifecycles.

A pattern for safely interacting with effectful lifecycles.

If acquire completes successfully, use is called. If use succeeds, fails, or is canceled, release is guaranteed to be called exactly once.

If use succeeds the returned value B is returned. If use returns an exception, the exception is returned.

acquire is uncancelable by default, but can be unmasked. release is uncancelable. use is cancelable by default, but can be masked.

Attributes

acquire

the lifecycle acquisition action which can be canceled

release

the lifecycle release action which depends on the outcome of use

use

the effect to which the lifecycle is scoped, whose result is the return value of this function

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def bracketFull[A, B](acquire: Poll[F] => F[A])(use: A => F[B])(release: (A, Outcome[F, Throwable, B]) => F[Unit]): F[B]
Implicitly added by asyncForKleisli

A pattern for safely interacting with effectful lifecycles.

A pattern for safely interacting with effectful lifecycles.

If acquire completes successfully, use is called. If use succeeds, fails, or is canceled, release is guaranteed to be called exactly once.

If use succeeds the returned value B is returned. If use returns an exception, the exception is returned.

acquire is uncancelable by default, but can be unmasked. release is uncancelable. use is cancelable by default, but can be masked.

Attributes

acquire

the lifecycle acquisition action which can be canceled

release

the lifecycle release action which depends on the outcome of use

use

the effect to which the lifecycle is scoped, whose result is the return value of this function

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def bracketFull[A, B](acquire: Poll[F] => F[A])(use: A => F[B])(release: (A, Outcome[F, Throwable, B]) => F[Unit]): F[B]
Implicitly added by asyncForOptionT

A pattern for safely interacting with effectful lifecycles.

A pattern for safely interacting with effectful lifecycles.

If acquire completes successfully, use is called. If use succeeds, fails, or is canceled, release is guaranteed to be called exactly once.

If use succeeds the returned value B is returned. If use returns an exception, the exception is returned.

acquire is uncancelable by default, but can be unmasked. release is uncancelable. use is cancelable by default, but can be masked.

Attributes

acquire

the lifecycle acquisition action which can be canceled

release

the lifecycle release action which depends on the outcome of use

use

the effect to which the lifecycle is scoped, whose result is the return value of this function

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def bracketFull[A, B](acquire: Poll[F] => F[A])(use: A => F[B])(release: (A, Outcome[F, Throwable, B]) => F[Unit]): F[B]

A pattern for safely interacting with effectful lifecycles.

A pattern for safely interacting with effectful lifecycles.

If acquire completes successfully, use is called. If use succeeds, fails, or is canceled, release is guaranteed to be called exactly once.

If use succeeds the returned value B is returned. If use returns an exception, the exception is returned.

acquire is uncancelable by default, but can be unmasked. release is uncancelable. use is cancelable by default, but can be masked.

Attributes

acquire

the lifecycle acquisition action which can be canceled

release

the lifecycle release action which depends on the outcome of use

use

the effect to which the lifecycle is scoped, whose result is the return value of this function

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def cachedRealTime(ttl: Duration): F[F[FiniteDuration]]
Implicitly added by asyncForEitherT

Returns a nested effect which returns the time in a much faster way than Clock[F]#realTime. This is achieved by caching the real time when the outer effect is run and, when the inner effect is run, the offset is used in combination with Clock[F]#monotonic to give an approximation of the real time. The practical benefit of this is a reduction in the number of syscalls, since realTime will only be sequenced once per ttl window, and it tends to be (on most platforms) multiple orders of magnitude slower than monotonic.

Returns a nested effect which returns the time in a much faster way than Clock[F]#realTime. This is achieved by caching the real time when the outer effect is run and, when the inner effect is run, the offset is used in combination with Clock[F]#monotonic to give an approximation of the real time. The practical benefit of this is a reduction in the number of syscalls, since realTime will only be sequenced once per ttl window, and it tends to be (on most platforms) multiple orders of magnitude slower than monotonic.

This should generally be used in situations where precise "to the millisecond" alignment to the system real clock is not needed. In particular, if the system clock is updated (e.g. via an NTP sync), the inner effect will not observe that update until up to ttl. This is an acceptable tradeoff in most practical scenarios, particularly with frequent sequencing of the inner effect.

Attributes

ttl

The period of time after which the cached real time will be refreshed. Note that it will only be refreshed upon execution of the nested effect

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def cachedRealTime(ttl: Duration): F[F[FiniteDuration]]
Implicitly added by asyncForKleisli

Returns a nested effect which returns the time in a much faster way than Clock[F]#realTime. This is achieved by caching the real time when the outer effect is run and, when the inner effect is run, the offset is used in combination with Clock[F]#monotonic to give an approximation of the real time. The practical benefit of this is a reduction in the number of syscalls, since realTime will only be sequenced once per ttl window, and it tends to be (on most platforms) multiple orders of magnitude slower than monotonic.

Returns a nested effect which returns the time in a much faster way than Clock[F]#realTime. This is achieved by caching the real time when the outer effect is run and, when the inner effect is run, the offset is used in combination with Clock[F]#monotonic to give an approximation of the real time. The practical benefit of this is a reduction in the number of syscalls, since realTime will only be sequenced once per ttl window, and it tends to be (on most platforms) multiple orders of magnitude slower than monotonic.

This should generally be used in situations where precise "to the millisecond" alignment to the system real clock is not needed. In particular, if the system clock is updated (e.g. via an NTP sync), the inner effect will not observe that update until up to ttl. This is an acceptable tradeoff in most practical scenarios, particularly with frequent sequencing of the inner effect.

Attributes

ttl

The period of time after which the cached real time will be refreshed. Note that it will only be refreshed upon execution of the nested effect

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def cachedRealTime(ttl: Duration): F[F[FiniteDuration]]
Implicitly added by asyncForOptionT

Returns a nested effect which returns the time in a much faster way than Clock[F]#realTime. This is achieved by caching the real time when the outer effect is run and, when the inner effect is run, the offset is used in combination with Clock[F]#monotonic to give an approximation of the real time. The practical benefit of this is a reduction in the number of syscalls, since realTime will only be sequenced once per ttl window, and it tends to be (on most platforms) multiple orders of magnitude slower than monotonic.

Returns a nested effect which returns the time in a much faster way than Clock[F]#realTime. This is achieved by caching the real time when the outer effect is run and, when the inner effect is run, the offset is used in combination with Clock[F]#monotonic to give an approximation of the real time. The practical benefit of this is a reduction in the number of syscalls, since realTime will only be sequenced once per ttl window, and it tends to be (on most platforms) multiple orders of magnitude slower than monotonic.

This should generally be used in situations where precise "to the millisecond" alignment to the system real clock is not needed. In particular, if the system clock is updated (e.g. via an NTP sync), the inner effect will not observe that update until up to ttl. This is an acceptable tradeoff in most practical scenarios, particularly with frequent sequencing of the inner effect.

Attributes

ttl

The period of time after which the cached real time will be refreshed. Note that it will only be refreshed upon execution of the nested effect

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def cachedRealTime(ttl: Duration): F[F[FiniteDuration]]

Returns a nested effect which returns the time in a much faster way than Clock[F]#realTime. This is achieved by caching the real time when the outer effect is run and, when the inner effect is run, the offset is used in combination with Clock[F]#monotonic to give an approximation of the real time. The practical benefit of this is a reduction in the number of syscalls, since realTime will only be sequenced once per ttl window, and it tends to be (on most platforms) multiple orders of magnitude slower than monotonic.

Returns a nested effect which returns the time in a much faster way than Clock[F]#realTime. This is achieved by caching the real time when the outer effect is run and, when the inner effect is run, the offset is used in combination with Clock[F]#monotonic to give an approximation of the real time. The practical benefit of this is a reduction in the number of syscalls, since realTime will only be sequenced once per ttl window, and it tends to be (on most platforms) multiple orders of magnitude slower than monotonic.

This should generally be used in situations where precise "to the millisecond" alignment to the system real clock is not needed. In particular, if the system clock is updated (e.g. via an NTP sync), the inner effect will not observe that update until up to ttl. This is an acceptable tradeoff in most practical scenarios, particularly with frequent sequencing of the inner effect.

Attributes

ttl

The period of time after which the cached real time will be refreshed. Note that it will only be refreshed upon execution of the nested effect

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def canceled: F[Unit]
Implicitly added by asyncForEitherT

An effect that requests self-cancelation on the current fiber.

An effect that requests self-cancelation on the current fiber.

canceled has a return type of F[Unit] instead of F[Nothing] due to execution continuing in a masked region. In the following example, the fiber requests self-cancelation in a masked region, so cancelation is suppressed until the fiber is completely unmasked. fa will run but fb will not. If canceled had a return type of F[Nothing], then it would not be possible to continue execution to fa (there would be no Nothing value to pass to the flatMap).


 F.uncancelable { _ =>
   F.canceled *> fa
 } *> fb

Attributes

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def canceled: F[Unit]
Implicitly added by asyncForKleisli

An effect that requests self-cancelation on the current fiber.

An effect that requests self-cancelation on the current fiber.

canceled has a return type of F[Unit] instead of F[Nothing] due to execution continuing in a masked region. In the following example, the fiber requests self-cancelation in a masked region, so cancelation is suppressed until the fiber is completely unmasked. fa will run but fb will not. If canceled had a return type of F[Nothing], then it would not be possible to continue execution to fa (there would be no Nothing value to pass to the flatMap).


 F.uncancelable { _ =>
   F.canceled *> fa
 } *> fb

Attributes

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def canceled: F[Unit]
Implicitly added by asyncForOptionT

An effect that requests self-cancelation on the current fiber.

An effect that requests self-cancelation on the current fiber.

canceled has a return type of F[Unit] instead of F[Nothing] due to execution continuing in a masked region. In the following example, the fiber requests self-cancelation in a masked region, so cancelation is suppressed until the fiber is completely unmasked. fa will run but fb will not. If canceled had a return type of F[Nothing], then it would not be possible to continue execution to fa (there would be no Nothing value to pass to the flatMap).


 F.uncancelable { _ =>
   F.canceled *> fa
 } *> fb

Attributes

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def canceled: F[Unit]

An effect that requests self-cancelation on the current fiber.

An effect that requests self-cancelation on the current fiber.

canceled has a return type of F[Unit] instead of F[Nothing] due to execution continuing in a masked region. In the following example, the fiber requests self-cancelation in a masked region, so cancelation is suppressed until the fiber is completely unmasked. fa will run but fb will not. If canceled had a return type of F[Nothing], then it would not be possible to continue execution to fa (there would be no Nothing value to pass to the flatMap).


 F.uncancelable { _ =>
   F.canceled *> fa
 } *> fb

Attributes

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def catchNonFatal[A](a: => A)(implicit ev: Throwable <:< Throwable): F[A]
Implicitly added by asyncForEitherT

Often E is Throwable. Here we try to call pure or catch and raise.

Often E is Throwable. Here we try to call pure or catch and raise.

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def catchNonFatal[A](a: => A)(implicit ev: Throwable <:< Throwable): F[A]
Implicitly added by asyncForKleisli

Often E is Throwable. Here we try to call pure or catch and raise.

Often E is Throwable. Here we try to call pure or catch and raise.

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def catchNonFatal[A](a: => A)(implicit ev: Throwable <:< Throwable): F[A]
Implicitly added by asyncForOptionT

Often E is Throwable. Here we try to call pure or catch and raise.

Often E is Throwable. Here we try to call pure or catch and raise.

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def catchNonFatal[A](a: => A)(implicit ev: Throwable <:< Throwable): F[A]

Often E is Throwable. Here we try to call pure or catch and raise.

Often E is Throwable. Here we try to call pure or catch and raise.

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def catchNonFatalEval[A](a: Eval[A])(implicit ev: Throwable <:< Throwable): F[A]
Implicitly added by asyncForEitherT

Often E is Throwable. Here we try to call pure or catch and raise

Often E is Throwable. Here we try to call pure or catch and raise

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def catchNonFatalEval[A](a: Eval[A])(implicit ev: Throwable <:< Throwable): F[A]
Implicitly added by asyncForKleisli

Often E is Throwable. Here we try to call pure or catch and raise

Often E is Throwable. Here we try to call pure or catch and raise

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def catchNonFatalEval[A](a: Eval[A])(implicit ev: Throwable <:< Throwable): F[A]
Implicitly added by asyncForOptionT

Often E is Throwable. Here we try to call pure or catch and raise

Often E is Throwable. Here we try to call pure or catch and raise

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def catchNonFatalEval[A](a: Eval[A])(implicit ev: Throwable <:< Throwable): F[A]

Often E is Throwable. Here we try to call pure or catch and raise

Often E is Throwable. Here we try to call pure or catch and raise

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def catchOnly[T >: Null <: Throwable]: CatchOnlyPartiallyApplied[T, F, E]
Implicitly added by asyncForEitherT

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.

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def catchOnly[T >: Null <: Throwable]: CatchOnlyPartiallyApplied[T, F, E]
Implicitly added by asyncForKleisli

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.

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def catchOnly[T >: Null <: Throwable]: CatchOnlyPartiallyApplied[T, F, E]
Implicitly added by asyncForOptionT

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.

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def catchOnly[T >: Null <: Throwable]: CatchOnlyPartiallyApplied[T, F, E]

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.

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def cede: F[Unit]
Implicitly added by asyncForEitherT

Introduces a fairness boundary that yields control back to the scheduler of the runtime system. This allows the carrier thread to resume execution of another waiting fiber.

Introduces a fairness boundary that yields control back to the scheduler of the runtime system. This allows the carrier thread to resume execution of another waiting fiber.

This function is primarily useful when performing long-running computation that is outside of the monadic context. For example:

 fa.map(data => expensiveWork(data))

In the above, we're assuming that expensiveWork is a function which is entirely compute-bound but very long-running. A good rule of thumb is to consider a function "expensive" when its runtime is around three or more orders of magnitude higher than the overhead of the map function itself (which runs in around 5 nanoseconds on modern hardware). Thus, any expensiveWork function which requires around 10 microseconds or longer to execute should be considered "long-running".

The danger is that these types of long-running actions outside of the monadic context can result in degraded fairness properties. The solution is to add an explicit cede both before and after the expensive operation:

 (fa <* F.cede).map(data => expensiveWork(data)).guarantee(F.cede)

Note that extremely long-running expensiveWork functions can still cause fairness issues, even when used with cede. This problem is somewhat fundamental to the nature of scheduling such computation on carrier threads. Whenever possible, it is best to break apart any such functions into multiple pieces invoked independently (e.g. via chained map calls) whenever the execution time exceeds five or six orders of magnitude beyond the overhead of map itself (around 1 millisecond on most hardware).

Note that cede is merely a hint to the runtime system; implementations have the liberty to interpret this method to their liking as long as it obeys the respective laws. For example, a lawful, but atypical, implementation of this function is F.unit, in which case the fairness boundary is a no-op.

Attributes

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def cede: F[Unit]
Implicitly added by asyncForKleisli

Introduces a fairness boundary that yields control back to the scheduler of the runtime system. This allows the carrier thread to resume execution of another waiting fiber.

Introduces a fairness boundary that yields control back to the scheduler of the runtime system. This allows the carrier thread to resume execution of another waiting fiber.

This function is primarily useful when performing long-running computation that is outside of the monadic context. For example:

 fa.map(data => expensiveWork(data))

In the above, we're assuming that expensiveWork is a function which is entirely compute-bound but very long-running. A good rule of thumb is to consider a function "expensive" when its runtime is around three or more orders of magnitude higher than the overhead of the map function itself (which runs in around 5 nanoseconds on modern hardware). Thus, any expensiveWork function which requires around 10 microseconds or longer to execute should be considered "long-running".

The danger is that these types of long-running actions outside of the monadic context can result in degraded fairness properties. The solution is to add an explicit cede both before and after the expensive operation:

 (fa <* F.cede).map(data => expensiveWork(data)).guarantee(F.cede)

Note that extremely long-running expensiveWork functions can still cause fairness issues, even when used with cede. This problem is somewhat fundamental to the nature of scheduling such computation on carrier threads. Whenever possible, it is best to break apart any such functions into multiple pieces invoked independently (e.g. via chained map calls) whenever the execution time exceeds five or six orders of magnitude beyond the overhead of map itself (around 1 millisecond on most hardware).

Note that cede is merely a hint to the runtime system; implementations have the liberty to interpret this method to their liking as long as it obeys the respective laws. For example, a lawful, but atypical, implementation of this function is F.unit, in which case the fairness boundary is a no-op.

Attributes

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def cede: F[Unit]
Implicitly added by asyncForOptionT

Introduces a fairness boundary that yields control back to the scheduler of the runtime system. This allows the carrier thread to resume execution of another waiting fiber.

Introduces a fairness boundary that yields control back to the scheduler of the runtime system. This allows the carrier thread to resume execution of another waiting fiber.

This function is primarily useful when performing long-running computation that is outside of the monadic context. For example:

 fa.map(data => expensiveWork(data))

In the above, we're assuming that expensiveWork is a function which is entirely compute-bound but very long-running. A good rule of thumb is to consider a function "expensive" when its runtime is around three or more orders of magnitude higher than the overhead of the map function itself (which runs in around 5 nanoseconds on modern hardware). Thus, any expensiveWork function which requires around 10 microseconds or longer to execute should be considered "long-running".

The danger is that these types of long-running actions outside of the monadic context can result in degraded fairness properties. The solution is to add an explicit cede both before and after the expensive operation:

 (fa <* F.cede).map(data => expensiveWork(data)).guarantee(F.cede)

Note that extremely long-running expensiveWork functions can still cause fairness issues, even when used with cede. This problem is somewhat fundamental to the nature of scheduling such computation on carrier threads. Whenever possible, it is best to break apart any such functions into multiple pieces invoked independently (e.g. via chained map calls) whenever the execution time exceeds five or six orders of magnitude beyond the overhead of map itself (around 1 millisecond on most hardware).

Note that cede is merely a hint to the runtime system; implementations have the liberty to interpret this method to their liking as long as it obeys the respective laws. For example, a lawful, but atypical, implementation of this function is F.unit, in which case the fairness boundary is a no-op.

Attributes

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def cede: F[Unit]

Introduces a fairness boundary that yields control back to the scheduler of the runtime system. This allows the carrier thread to resume execution of another waiting fiber.

Introduces a fairness boundary that yields control back to the scheduler of the runtime system. This allows the carrier thread to resume execution of another waiting fiber.

This function is primarily useful when performing long-running computation that is outside of the monadic context. For example:

 fa.map(data => expensiveWork(data))

In the above, we're assuming that expensiveWork is a function which is entirely compute-bound but very long-running. A good rule of thumb is to consider a function "expensive" when its runtime is around three or more orders of magnitude higher than the overhead of the map function itself (which runs in around 5 nanoseconds on modern hardware). Thus, any expensiveWork function which requires around 10 microseconds or longer to execute should be considered "long-running".

The danger is that these types of long-running actions outside of the monadic context can result in degraded fairness properties. The solution is to add an explicit cede both before and after the expensive operation:

 (fa <* F.cede).map(data => expensiveWork(data)).guarantee(F.cede)

Note that extremely long-running expensiveWork functions can still cause fairness issues, even when used with cede. This problem is somewhat fundamental to the nature of scheduling such computation on carrier threads. Whenever possible, it is best to break apart any such functions into multiple pieces invoked independently (e.g. via chained map calls) whenever the execution time exceeds five or six orders of magnitude beyond the overhead of map itself (around 1 millisecond on most hardware).

Note that cede is merely a hint to the runtime system; implementations have the liberty to interpret this method to their liking as long as it obeys the respective laws. For example, a lawful, but atypical, implementation of this function is F.unit, in which case the fairness boundary is a no-op.

Attributes

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def compose[G[_] : Applicative]: Applicative[[α] =>> F[G[α]]]
Implicitly added by asyncForEitherT

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)

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def compose[G[_] : Invariant]: Invariant[[α] =>> F[G[α]]]
Implicitly added by asyncForEitherT

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)

Attributes

Inherited from:
Invariant
Source:
Invariant.scala
def compose[G[_] : Apply]: Apply[[α] =>> F[G[α]]]
Implicitly added by asyncForEitherT

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)

Attributes

Inherited from:
Apply
Source:
Apply.scala
def compose[G[_] : Functor]: Functor[[α] =>> F[G[α]]]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
Functor
Source:
Functor.scala
def compose[G[_] : Applicative]: Applicative[[α] =>> F[G[α]]]
Implicitly added by asyncForKleisli

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)

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def compose[G[_] : Invariant]: Invariant[[α] =>> F[G[α]]]
Implicitly added by asyncForKleisli

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)

Attributes

Inherited from:
Invariant
Source:
Invariant.scala
def compose[G[_] : Apply]: Apply[[α] =>> F[G[α]]]
Implicitly added by asyncForKleisli

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)

Attributes

Inherited from:
Apply
Source:
Apply.scala
def compose[G[_] : Functor]: Functor[[α] =>> F[G[α]]]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
Functor
Source:
Functor.scala
def compose[G[_] : Applicative]: Applicative[[α] =>> F[G[α]]]
Implicitly added by asyncForOptionT

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)

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def compose[G[_] : Invariant]: Invariant[[α] =>> F[G[α]]]
Implicitly added by asyncForOptionT

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)

Attributes

Inherited from:
Invariant
Source:
Invariant.scala
def compose[G[_] : Apply]: Apply[[α] =>> F[G[α]]]
Implicitly added by asyncForOptionT

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)

Attributes

Inherited from:
Apply
Source:
Apply.scala
def compose[G[_] : Functor]: Functor[[α] =>> F[G[α]]]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
Functor
Source:
Functor.scala
def compose[G[_] : Applicative]: Applicative[[α] =>> F[G[α]]]

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)

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def compose[G[_] : Invariant]: Invariant[[α] =>> F[G[α]]]

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)

Attributes

Inherited from:
Invariant
Source:
Invariant.scala
def compose[G[_] : Apply]: Apply[[α] =>> F[G[α]]]

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)

Attributes

Inherited from:
Apply
Source:
Apply.scala
def compose[G[_] : Functor]: Functor[[α] =>> F[G[α]]]

Attributes

Inherited from:
Functor
Source:
Functor.scala
def composeApply[G[_] : Apply]: InvariantSemigroupal[[α] =>> F[G[α]]]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
InvariantSemigroupal
Source:
InvariantSemigroupal.scala
def composeApply[G[_] : Apply]: InvariantSemigroupal[[α] =>> F[G[α]]]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
InvariantSemigroupal
Source:
InvariantSemigroupal.scala
def composeApply[G[_] : Apply]: InvariantSemigroupal[[α] =>> F[G[α]]]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
InvariantSemigroupal
Source:
InvariantSemigroupal.scala
def composeApply[G[_] : Apply]: InvariantSemigroupal[[α] =>> F[G[α]]]

Attributes

Inherited from:
InvariantSemigroupal
Source:
InvariantSemigroupal.scala
override def composeContravariant[G[_] : Contravariant]: Contravariant[[α] =>> F[G[α]]]

Compose Invariant F[_] and Contravariant G[_] then produce Invariant[F[G[_]]] using F's imap and G's contramap.

Compose Invariant F[_] and Contravariant G[_] then produce Invariant[F[G[_]]] using F's imap and G's contramap.

Example:

scala> import cats.implicits._
scala> import scala.concurrent.duration._

scala> type ToInt[T] = T => Int
scala> val durSemigroupToInt: Semigroup[ToInt[FiniteDuration]] =
    | Invariant[Semigroup]
    |   .composeContravariant[ToInt]
    |   .imap(Semigroup[ToInt[Long]])(Duration.fromNanos)(_.toNanos)
// semantically equal to (2.seconds.toSeconds.toInt + 1) + (2.seconds.toSeconds.toInt * 2) = 7
scala> durSemigroupToInt.combine(_.toSeconds.toInt + 1, _.toSeconds.toInt * 2)(2.seconds)
res1: Int = 7

Attributes

Definition Classes
Inherited from:
Functor
Source:
Functor.scala
def composeContravariantMonoidal[G[_] : ContravariantMonoidal]: ContravariantMonoidal[[α] =>> F[G[α]]]
Implicitly added by asyncForEitherT

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)

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def composeContravariantMonoidal[G[_] : ContravariantMonoidal]: ContravariantMonoidal[[α] =>> F[G[α]]]
Implicitly added by asyncForKleisli

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)

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def composeContravariantMonoidal[G[_] : ContravariantMonoidal]: ContravariantMonoidal[[α] =>> F[G[α]]]
Implicitly added by asyncForOptionT

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)

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def composeContravariantMonoidal[G[_] : ContravariantMonoidal]: ContravariantMonoidal[[α] =>> F[G[α]]]

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)

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def composeFunctor[G[_] : Functor]: Invariant[[α] =>> F[G[α]]]
Implicitly added by asyncForEitherT

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)

Attributes

Inherited from:
Invariant
Source:
Invariant.scala
def composeFunctor[G[_] : Functor]: Invariant[[α] =>> F[G[α]]]
Implicitly added by asyncForKleisli

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)

Attributes

Inherited from:
Invariant
Source:
Invariant.scala
def composeFunctor[G[_] : Functor]: Invariant[[α] =>> F[G[α]]]
Implicitly added by asyncForOptionT

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)

Attributes

Inherited from:
Invariant
Source:
Invariant.scala
def composeFunctor[G[_] : Functor]: Invariant[[α] =>> F[G[α]]]

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)

Attributes

Inherited from:
Invariant
Source:
Invariant.scala
def defer[A](thunk: => F[A]): F[A]
Implicitly added by asyncForEitherT

Suspends the evaluation of an F[_] reference.

Suspends the evaluation of an F[_] reference.

Equivalent to FlatMap.flatten for pure expressions, the purpose of this function is to suspend side effects in F[_].

Attributes

Inherited from:
Sync
Source:
Sync.scala
def defer[A](thunk: => F[A]): F[A]
Implicitly added by asyncForKleisli

Suspends the evaluation of an F[_] reference.

Suspends the evaluation of an F[_] reference.

Equivalent to FlatMap.flatten for pure expressions, the purpose of this function is to suspend side effects in F[_].

Attributes

Inherited from:
Sync
Source:
Sync.scala
def defer[A](thunk: => F[A]): F[A]
Implicitly added by asyncForOptionT

Suspends the evaluation of an F[_] reference.

Suspends the evaluation of an F[_] reference.

Equivalent to FlatMap.flatten for pure expressions, the purpose of this function is to suspend side effects in F[_].

Attributes

Inherited from:
Sync
Source:
Sync.scala
def defer[A](thunk: => F[A]): F[A]

Suspends the evaluation of an F[_] reference.

Suspends the evaluation of an F[_] reference.

Equivalent to FlatMap.flatten for pure expressions, the purpose of this function is to suspend side effects in F[_].

Attributes

Inherited from:
Sync
Source:
Sync.scala
def deferred[A]: F[Deferred[F, A]]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def deferred[A]: F[Deferred[F, A]]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def deferred[A]: F[Deferred[F, A]]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def deferred[A]: F[Deferred[F, A]]

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def delay[A](thunk: => A): F[A]
Implicitly added by asyncForEitherT

The synchronous FFI - lifts any by-name parameter into the F[_] context.

The synchronous FFI - lifts any by-name parameter into the F[_] context.

Equivalent to Applicative.pure for pure expressions, the purpose of this function is to suspend side effects in F. Use Sync.delay if your side effect is not thread-blocking; otherwise you should use Sync.blocking (uncancelable) or Sync.interruptible (cancelable).

Attributes

thunk

The side effect which is to be suspended in F[_]

Inherited from:
Sync
Source:
Sync.scala
def delay[A](thunk: => A): F[A]
Implicitly added by asyncForKleisli

The synchronous FFI - lifts any by-name parameter into the F[_] context.

The synchronous FFI - lifts any by-name parameter into the F[_] context.

Equivalent to Applicative.pure for pure expressions, the purpose of this function is to suspend side effects in F. Use Sync.delay if your side effect is not thread-blocking; otherwise you should use Sync.blocking (uncancelable) or Sync.interruptible (cancelable).

Attributes

thunk

The side effect which is to be suspended in F[_]

Inherited from:
Sync
Source:
Sync.scala
def delay[A](thunk: => A): F[A]
Implicitly added by asyncForOptionT

The synchronous FFI - lifts any by-name parameter into the F[_] context.

The synchronous FFI - lifts any by-name parameter into the F[_] context.

Equivalent to Applicative.pure for pure expressions, the purpose of this function is to suspend side effects in F. Use Sync.delay if your side effect is not thread-blocking; otherwise you should use Sync.blocking (uncancelable) or Sync.interruptible (cancelable).

Attributes

thunk

The side effect which is to be suspended in F[_]

Inherited from:
Sync
Source:
Sync.scala
def delay[A](thunk: => A): F[A]

The synchronous FFI - lifts any by-name parameter into the F[_] context.

The synchronous FFI - lifts any by-name parameter into the F[_] context.

Equivalent to Applicative.pure for pure expressions, the purpose of this function is to suspend side effects in F. Use Sync.delay if your side effect is not thread-blocking; otherwise you should use Sync.blocking (uncancelable) or Sync.interruptible (cancelable).

Attributes

thunk

The side effect which is to be suspended in F[_]

Inherited from:
Sync
Source:
Sync.scala
def delayBy[A](fa: F[A], time: Duration): F[A]
Implicitly added by asyncForEitherT

Delay the execution of fa by a given duration.

Delay the execution of fa by a given duration.

Attributes

fa

The effect to execute

time

The duration to wait before executing fa

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def delayBy[A](fa: F[A], time: Duration): F[A]
Implicitly added by asyncForKleisli

Delay the execution of fa by a given duration.

Delay the execution of fa by a given duration.

Attributes

fa

The effect to execute

time

The duration to wait before executing fa

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def delayBy[A](fa: F[A], time: Duration): F[A]
Implicitly added by asyncForOptionT

Delay the execution of fa by a given duration.

Delay the execution of fa by a given duration.

Attributes

fa

The effect to execute

time

The duration to wait before executing fa

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def delayBy[A](fa: F[A], time: Duration): F[A]

Delay the execution of fa by a given duration.

Delay the execution of fa by a given duration.

Attributes

fa

The effect to execute

time

The duration to wait before executing fa

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def ensure[A](fa: F[A])(error: => Throwable)(predicate: A => Boolean): F[A]
Implicitly added by asyncForEitherT

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.

Attributes

Inherited from:
MonadError
Source:
MonadError.scala
def ensure[A](fa: F[A])(error: => Throwable)(predicate: A => Boolean): F[A]
Implicitly added by asyncForKleisli

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.

Attributes

Inherited from:
MonadError
Source:
MonadError.scala
def ensure[A](fa: F[A])(error: => Throwable)(predicate: A => Boolean): F[A]
Implicitly added by asyncForOptionT

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.

Attributes

Inherited from:
MonadError
Source:
MonadError.scala
def ensure[A](fa: F[A])(error: => Throwable)(predicate: A => Boolean): F[A]

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.

Attributes

Inherited from:
MonadError
Source:
MonadError.scala
def ensureOr[A](fa: F[A])(error: A => Throwable)(predicate: A => Boolean): F[A]
Implicitly added by asyncForEitherT

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.

Attributes

Inherited from:
MonadError
Source:
MonadError.scala
def ensureOr[A](fa: F[A])(error: A => Throwable)(predicate: A => Boolean): F[A]
Implicitly added by asyncForKleisli

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.

Attributes

Inherited from:
MonadError
Source:
MonadError.scala
def ensureOr[A](fa: F[A])(error: A => Throwable)(predicate: A => Boolean): F[A]
Implicitly added by asyncForOptionT

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.

Attributes

Inherited from:
MonadError
Source:
MonadError.scala
def ensureOr[A](fa: F[A])(error: A => Throwable)(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.

Turns a successful value into an error specified by the error function if it does not satisfy a given predicate.

Attributes

Inherited from:
MonadError
Source:
MonadError.scala
def fix[A](fn: F[A] => F[A]): F[A]
Implicitly added by asyncForEitherT

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.

Attributes

Inherited from:
Defer
Source:
Defer.scala
def fix[A](fn: F[A] => F[A]): F[A]
Implicitly added by asyncForKleisli

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.

Attributes

Inherited from:
Defer
Source:
Defer.scala
def fix[A](fn: F[A] => F[A]): F[A]
Implicitly added by asyncForOptionT

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.

Attributes

Inherited from:
Defer
Source:
Defer.scala
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

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.

Attributes

Inherited from:
Defer
Source:
Defer.scala
def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B]

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def flatMap10[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) => F[Z]): F[Z]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap10[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) => F[Z]): F[Z]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap10[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) => F[Z]): F[Z]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap10[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) => F[Z]): F[Z]

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap11[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) => F[Z]): F[Z]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap11[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) => F[Z]): F[Z]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap11[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) => F[Z]): F[Z]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap11[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) => F[Z]): F[Z]

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap12[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) => F[Z]): F[Z]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap12[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) => F[Z]): F[Z]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap12[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) => F[Z]): F[Z]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap12[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) => F[Z]): F[Z]

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap13[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) => F[Z]): F[Z]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap13[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) => F[Z]): F[Z]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap13[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) => F[Z]): F[Z]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap13[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) => F[Z]): F[Z]

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap14[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) => F[Z]): F[Z]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap14[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) => F[Z]): F[Z]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap14[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) => F[Z]): F[Z]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap14[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) => F[Z]): F[Z]

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap15[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) => F[Z]): F[Z]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap15[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) => F[Z]): F[Z]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap15[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) => F[Z]): F[Z]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap15[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) => F[Z]): F[Z]

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap16[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) => F[Z]): F[Z]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap16[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) => F[Z]): F[Z]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap16[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) => F[Z]): F[Z]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap16[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) => F[Z]): F[Z]

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap17[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) => F[Z]): F[Z]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap17[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) => F[Z]): F[Z]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap17[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) => F[Z]): F[Z]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap17[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) => F[Z]): F[Z]

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap18[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) => F[Z]): F[Z]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap18[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) => F[Z]): F[Z]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap18[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) => F[Z]): F[Z]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap18[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) => F[Z]): F[Z]

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap19[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) => F[Z]): F[Z]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap19[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) => F[Z]): F[Z]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap19[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) => F[Z]): F[Z]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap19[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) => F[Z]): F[Z]

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap2[A0, A1, Z](f0: F[A0], f1: F[A1])(f: (A0, A1) => F[Z]): F[Z]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap2[A0, A1, Z](f0: F[A0], f1: F[A1])(f: (A0, A1) => F[Z]): F[Z]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap2[A0, A1, Z](f0: F[A0], f1: F[A1])(f: (A0, A1) => F[Z]): F[Z]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap2[A0, A1, Z](f0: F[A0], f1: F[A1])(f: (A0, A1) => F[Z]): F[Z]

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap20[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) => F[Z]): F[Z]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap20[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) => F[Z]): F[Z]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap20[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) => F[Z]): F[Z]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap20[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) => F[Z]): F[Z]

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap21[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) => F[Z]): F[Z]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap21[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) => F[Z]): F[Z]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap21[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) => F[Z]): F[Z]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap21[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) => F[Z]): F[Z]

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap22[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) => F[Z]): F[Z]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap22[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) => F[Z]): F[Z]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap22[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) => F[Z]): F[Z]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap22[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) => F[Z]): F[Z]

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2])(f: (A0, A1, A2) => F[Z]): F[Z]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2])(f: (A0, A1, A2) => F[Z]): F[Z]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2])(f: (A0, A1, A2) => F[Z]): F[Z]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2])(f: (A0, A1, A2) => F[Z]): F[Z]

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3])(f: (A0, A1, A2, A3) => F[Z]): F[Z]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3])(f: (A0, A1, A2, A3) => F[Z]): F[Z]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3])(f: (A0, A1, A2, A3) => F[Z]): F[Z]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3])(f: (A0, A1, A2, A3) => F[Z]): F[Z]

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap5[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) => F[Z]): F[Z]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap5[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) => F[Z]): F[Z]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap5[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) => F[Z]): F[Z]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap5[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) => F[Z]): F[Z]

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap6[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) => F[Z]): F[Z]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap6[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) => F[Z]): F[Z]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap6[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) => F[Z]): F[Z]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap6[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) => F[Z]): F[Z]

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap7[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) => F[Z]): F[Z]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap7[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) => F[Z]): F[Z]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap7[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) => F[Z]): F[Z]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap7[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) => F[Z]): F[Z]

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap8[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) => F[Z]): F[Z]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap8[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) => F[Z]): F[Z]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap8[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) => F[Z]): F[Z]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap8[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) => F[Z]): F[Z]

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap9[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) => F[Z]): F[Z]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap9[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) => F[Z]): F[Z]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap9[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) => F[Z]): F[Z]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatMap9[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) => F[Z]): F[Z]

Attributes

Inherited from:
FlatMapArityFunctions
Source:
FlatMapArityFunctions.scala
def flatTap[A, B](fa: F[A])(f: A => F[B]): F[A]
Implicitly added by asyncForEitherT

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)

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def flatTap[A, B](fa: F[A])(f: A => F[B]): F[A]
Implicitly added by asyncForKleisli

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)

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def flatTap[A, B](fa: F[A])(f: A => F[B]): F[A]
Implicitly added by asyncForOptionT

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)

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
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.

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)

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def flatten[A](ffa: F[F[A]]): F[A]
Implicitly added by asyncForEitherT

"flatten" a nested F of F structure into a single-layer F structure.

"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> val nested: Eval[Eval[Int]] = Eval.now(Eval.now(3))
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def flatten[A](ffa: F[F[A]]): F[A]
Implicitly added by asyncForKleisli

"flatten" a nested F of F structure into a single-layer F structure.

"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> val nested: Eval[Eval[Int]] = Eval.now(Eval.now(3))
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def flatten[A](ffa: F[F[A]]): F[A]
Implicitly added by asyncForOptionT

"flatten" a nested F of F structure into a single-layer F structure.

"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> val nested: Eval[Eval[Int]] = Eval.now(Eval.now(3))
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def flatten[A](ffa: F[F[A]]): F[A]

"flatten" a nested F of F structure into a single-layer F structure.

"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> val nested: Eval[Eval[Int]] = Eval.now(Eval.now(3))
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
final def fmap[A, B](fa: F[A])(f: A => B): F[B]
Implicitly added by asyncForEitherT

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!)

Attributes

Inherited from:
Functor
Source:
Functor.scala
final def fmap[A, B](fa: F[A])(f: A => B): F[B]
Implicitly added by asyncForKleisli

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!)

Attributes

Inherited from:
Functor
Source:
Functor.scala
final def fmap[A, B](fa: F[A])(f: A => B): F[B]
Implicitly added by asyncForOptionT

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!)

Attributes

Inherited from:
Functor
Source:
Functor.scala
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 .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!)

Attributes

Inherited from:
Functor
Source:
Functor.scala
def forceR[A, B](fa: F[A])(fb: F[B]): F[B]
Implicitly added by asyncForEitherT

Analogous to productR, but suppresses short-circuiting behavior except for cancelation.

Analogous to productR, but suppresses short-circuiting behavior except for cancelation.

Attributes

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def forceR[A, B](fa: F[A])(fb: F[B]): F[B]
Implicitly added by asyncForKleisli

Analogous to productR, but suppresses short-circuiting behavior except for cancelation.

Analogous to productR, but suppresses short-circuiting behavior except for cancelation.

Attributes

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def forceR[A, B](fa: F[A])(fb: F[B]): F[B]
Implicitly added by asyncForOptionT

Analogous to productR, but suppresses short-circuiting behavior except for cancelation.

Analogous to productR, but suppresses short-circuiting behavior except for cancelation.

Attributes

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def forceR[A, B](fa: F[A])(fb: F[B]): F[B]

Analogous to productR, but suppresses short-circuiting behavior except for cancelation.

Analogous to productR, but suppresses short-circuiting behavior except for cancelation.

Attributes

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def foreverM[A, B](fa: F[A]): F[B]
Implicitly added by asyncForEitherT

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.

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def foreverM[A, B](fa: F[A]): F[B]
Implicitly added by asyncForKleisli

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.

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def foreverM[A, B](fa: F[A]): F[B]
Implicitly added by asyncForOptionT

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.

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
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.

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.

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def fproduct[A, B](fa: F[A])(f: A => B): F[(A, B)]
Implicitly added by asyncForEitherT

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))

Attributes

Inherited from:
Functor
Source:
Functor.scala
def fproduct[A, B](fa: F[A])(f: A => B): F[(A, B)]
Implicitly added by asyncForKleisli

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))

Attributes

Inherited from:
Functor
Source:
Functor.scala
def fproduct[A, B](fa: F[A])(f: A => B): F[(A, B)]
Implicitly added by asyncForOptionT

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))

Attributes

Inherited from:
Functor
Source:
Functor.scala
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

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))

Attributes

Inherited from:
Functor
Source:
Functor.scala
def fproductLeft[A, B](fa: F[A])(f: A => B): F[(B, A)]
Implicitly added by asyncForEitherT

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))

Attributes

Inherited from:
Functor
Source:
Functor.scala
def fproductLeft[A, B](fa: F[A])(f: A => B): F[(B, A)]
Implicitly added by asyncForKleisli

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))

Attributes

Inherited from:
Functor
Source:
Functor.scala
def fproductLeft[A, B](fa: F[A])(f: A => B): F[(B, A)]
Implicitly added by asyncForOptionT

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))

Attributes

Inherited from:
Functor
Source:
Functor.scala
def fproductLeft[A, B](fa: F[A])(f: A => B): F[(B, A)]

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))

Attributes

Inherited from:
Functor
Source:
Functor.scala
def fromCompletableFuture[A](fut: F[CompletableFuture[A]]): F[A]
Implicitly added by asyncForEitherT

Suspend a java.util.concurrent.CompletableFuture into the F[_] context.

Suspend a java.util.concurrent.CompletableFuture into the F[_] context.

Attributes

fut

The java.util.concurrent.CompletableFuture to suspend in F[_]

Inherited from:
AsyncPlatform (hidden)
Source:
AsyncPlatform.scala
def fromCompletableFuture[A](fut: F[CompletableFuture[A]]): F[A]
Implicitly added by asyncForKleisli

Suspend a java.util.concurrent.CompletableFuture into the F[_] context.

Suspend a java.util.concurrent.CompletableFuture into the F[_] context.

Attributes

fut

The java.util.concurrent.CompletableFuture to suspend in F[_]

Inherited from:
AsyncPlatform (hidden)
Source:
AsyncPlatform.scala
def fromCompletableFuture[A](fut: F[CompletableFuture[A]]): F[A]
Implicitly added by asyncForOptionT

Suspend a java.util.concurrent.CompletableFuture into the F[_] context.

Suspend a java.util.concurrent.CompletableFuture into the F[_] context.

Attributes

fut

The java.util.concurrent.CompletableFuture to suspend in F[_]

Inherited from:
AsyncPlatform (hidden)
Source:
AsyncPlatform.scala
def fromCompletableFuture[A](fut: F[CompletableFuture[A]]): F[A]

Suspend a java.util.concurrent.CompletableFuture into the F[_] context.

Suspend a java.util.concurrent.CompletableFuture into the F[_] context.

Attributes

fut

The java.util.concurrent.CompletableFuture to suspend in F[_]

Inherited from:
AsyncPlatform (hidden)
Source:
AsyncPlatform.scala
def fromCompletionStage[A](completionStage: F[CompletionStage[A]]): F[A]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
AsyncPlatform (hidden)
Source:
AsyncPlatform.scala
def fromCompletionStage[A](completionStage: F[CompletionStage[A]]): F[A]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
AsyncPlatform (hidden)
Source:
AsyncPlatform.scala
def fromCompletionStage[A](completionStage: F[CompletionStage[A]]): F[A]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
AsyncPlatform (hidden)
Source:
AsyncPlatform.scala
def fromCompletionStage[A](completionStage: F[CompletionStage[A]]): F[A]

Attributes

Inherited from:
AsyncPlatform (hidden)
Source:
AsyncPlatform.scala
def fromEither[A](x: Either[Throwable, A]): F[A]
Implicitly added by asyncForEitherT

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

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def fromEither[A](x: Either[Throwable, A]): F[A]
Implicitly added by asyncForKleisli

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

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def fromEither[A](x: Either[Throwable, A]): F[A]
Implicitly added by asyncForOptionT

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

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def fromEither[A](x: Either[Throwable, A]): F[A]

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

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def fromOption[A](oa: Option[A], ifEmpty: => Throwable): F[A]
Implicitly added by asyncForEitherT

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)

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def fromOption[A](oa: Option[A], ifEmpty: => Throwable): F[A]
Implicitly added by asyncForKleisli

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)

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def fromOption[A](oa: Option[A], ifEmpty: => Throwable): F[A]
Implicitly added by asyncForOptionT

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)

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def fromOption[A](oa: Option[A], ifEmpty: => Throwable): F[A]

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)

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def fromTry[A](t: Try[A])(implicit ev: Throwable <:< Throwable): F[A]
Implicitly added by asyncForEitherT

If the error type is Throwable, we can convert from a scala.util.Try

If the error type is Throwable, we can convert from a scala.util.Try

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def fromTry[A](t: Try[A])(implicit ev: Throwable <:< Throwable): F[A]
Implicitly added by asyncForKleisli

If the error type is Throwable, we can convert from a scala.util.Try

If the error type is Throwable, we can convert from a scala.util.Try

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def fromTry[A](t: Try[A])(implicit ev: Throwable <:< Throwable): F[A]
Implicitly added by asyncForOptionT

If the error type is Throwable, we can convert from a scala.util.Try

If the error type is Throwable, we can convert from a scala.util.Try

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def fromTry[A](t: Try[A])(implicit ev: Throwable <:< Throwable): F[A]

If the error type is Throwable, we can convert from a scala.util.Try

If the error type is Throwable, we can convert from a scala.util.Try

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def fromValidated[A](x: Validated[Throwable, A]): F[A]
Implicitly added by asyncForEitherT

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

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def fromValidated[A](x: Validated[Throwable, A]): F[A]
Implicitly added by asyncForKleisli

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

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def fromValidated[A](x: Validated[Throwable, A]): F[A]
Implicitly added by asyncForOptionT

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

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def fromValidated[A](x: Validated[Throwable, A]): F[A]

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

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def guarantee[A](fa: F[A], fin: F[Unit]): F[A]
Implicitly added by asyncForEitherT

Specifies an effect that is always invoked after evaluation of fa completes, regardless of the outcome.

Specifies an effect that is always invoked after evaluation of fa completes, regardless of the outcome.

This function can be thought of as a combination of flatTap, onError, and onCancel.

Attributes

fa

The effect that is run after fin is registered.

fin

The effect to run in the event of a cancelation or error.

See also:

guaranteeCase for a more powerful variant

Outcome for the various outcomes of evaluation

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def guarantee[A](fa: F[A], fin: F[Unit]): F[A]
Implicitly added by asyncForKleisli

Specifies an effect that is always invoked after evaluation of fa completes, regardless of the outcome.

Specifies an effect that is always invoked after evaluation of fa completes, regardless of the outcome.

This function can be thought of as a combination of flatTap, onError, and onCancel.

Attributes

fa

The effect that is run after fin is registered.

fin

The effect to run in the event of a cancelation or error.

See also:

guaranteeCase for a more powerful variant

Outcome for the various outcomes of evaluation

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def guarantee[A](fa: F[A], fin: F[Unit]): F[A]
Implicitly added by asyncForOptionT

Specifies an effect that is always invoked after evaluation of fa completes, regardless of the outcome.

Specifies an effect that is always invoked after evaluation of fa completes, regardless of the outcome.

This function can be thought of as a combination of flatTap, onError, and onCancel.

Attributes

fa

The effect that is run after fin is registered.

fin

The effect to run in the event of a cancelation or error.

See also:

guaranteeCase for a more powerful variant

Outcome for the various outcomes of evaluation

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def guarantee[A](fa: F[A], fin: F[Unit]): F[A]

Specifies an effect that is always invoked after evaluation of fa completes, regardless of the outcome.

Specifies an effect that is always invoked after evaluation of fa completes, regardless of the outcome.

This function can be thought of as a combination of flatTap, onError, and onCancel.

Attributes

fa

The effect that is run after fin is registered.

fin

The effect to run in the event of a cancelation or error.

See also:

guaranteeCase for a more powerful variant

Outcome for the various outcomes of evaluation

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def guaranteeCase[A](fa: F[A])(fin: Outcome[F, Throwable, A] => F[Unit]): F[A]
Implicitly added by asyncForEitherT

Specifies an effect that is always invoked after evaluation of fa completes, but depends on the outcome.

Specifies an effect that is always invoked after evaluation of fa completes, but depends on the outcome.

This function can be thought of as a combination of flatTap, onError, and onCancel.

Attributes

fa

The effect that is run after fin is registered.

fin

A function that returns the effect to run based on the outcome.

See also:

bracketCase for a more powerful variant

Outcome for the various outcomes of evaluation

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def guaranteeCase[A](fa: F[A])(fin: Outcome[F, Throwable, A] => F[Unit]): F[A]
Implicitly added by asyncForKleisli

Specifies an effect that is always invoked after evaluation of fa completes, but depends on the outcome.

Specifies an effect that is always invoked after evaluation of fa completes, but depends on the outcome.

This function can be thought of as a combination of flatTap, onError, and onCancel.

Attributes

fa

The effect that is run after fin is registered.

fin

A function that returns the effect to run based on the outcome.

See also:

bracketCase for a more powerful variant

Outcome for the various outcomes of evaluation

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def guaranteeCase[A](fa: F[A])(fin: Outcome[F, Throwable, A] => F[Unit]): F[A]
Implicitly added by asyncForOptionT

Specifies an effect that is always invoked after evaluation of fa completes, but depends on the outcome.

Specifies an effect that is always invoked after evaluation of fa completes, but depends on the outcome.

This function can be thought of as a combination of flatTap, onError, and onCancel.

Attributes

fa

The effect that is run after fin is registered.

fin

A function that returns the effect to run based on the outcome.

See also:

bracketCase for a more powerful variant

Outcome for the various outcomes of evaluation

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def guaranteeCase[A](fa: F[A])(fin: Outcome[F, Throwable, A] => F[Unit]): F[A]

Specifies an effect that is always invoked after evaluation of fa completes, but depends on the outcome.

Specifies an effect that is always invoked after evaluation of fa completes, but depends on the outcome.

This function can be thought of as a combination of flatTap, onError, and onCancel.

Attributes

fa

The effect that is run after fin is registered.

fin

A function that returns the effect to run based on the outcome.

See also:

bracketCase for a more powerful variant

Outcome for the various outcomes of evaluation

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def handleError[A](fa: F[A])(f: Throwable => A): F[A]
Implicitly added by asyncForEitherT

Handle any error, by mapping it to an A value.

Handle any error, by mapping it to an A value.

Attributes

See also:

handleErrorWith to map to an F[A] value instead of simply an A value.

recover to only recover from certain errors.

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def handleError[A](fa: F[A])(f: Throwable => A): F[A]
Implicitly added by asyncForKleisli

Handle any error, by mapping it to an A value.

Handle any error, by mapping it to an A value.

Attributes

See also:

handleErrorWith to map to an F[A] value instead of simply an A value.

recover to only recover from certain errors.

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def handleError[A](fa: F[A])(f: Throwable => A): F[A]
Implicitly added by asyncForOptionT

Handle any error, by mapping it to an A value.

Handle any error, by mapping it to an A value.

Attributes

See also:

handleErrorWith to map to an F[A] value instead of simply an A value.

recover to only recover from certain errors.

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def handleError[A](fa: F[A])(f: Throwable => A): F[A]

Handle any error, by mapping it to an A value.

Handle any error, by mapping it to an A value.

Attributes

See also:

handleErrorWith to map to an F[A] value instead of simply an A value.

recover to only recover from certain errors.

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def handleErrorWith[A](fa: F[A])(f: Throwable => F[A]): F[A]
Implicitly added by asyncForEitherT

Handle any error, potentially recovering from it, by mapping it to an F[A] value.

Handle any error, potentially recovering from it, by mapping it to an F[A] value.

Attributes

See also:

handleError to handle any error by simply mapping it to an A value instead of an F[A].

recoverWith to recover from only certain errors.

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def handleErrorWith[A](fa: F[A])(f: Throwable => F[A]): F[A]
Implicitly added by asyncForKleisli

Handle any error, potentially recovering from it, by mapping it to an F[A] value.

Handle any error, potentially recovering from it, by mapping it to an F[A] value.

Attributes

See also:

handleError to handle any error by simply mapping it to an A value instead of an F[A].

recoverWith to recover from only certain errors.

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def handleErrorWith[A](fa: F[A])(f: Throwable => F[A]): F[A]
Implicitly added by asyncForOptionT

Handle any error, potentially recovering from it, by mapping it to an F[A] value.

Handle any error, potentially recovering from it, by mapping it to an F[A] value.

Attributes

See also:

handleError to handle any error by simply mapping it to an A value instead of an F[A].

recoverWith to recover from only certain errors.

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def handleErrorWith[A](fa: F[A])(f: Throwable => F[A]): F[A]

Handle any error, potentially recovering from it, by mapping it to an F[A] value.

Handle any error, potentially recovering from it, by mapping it to an F[A] value.

Attributes

See also:

handleError to handle any error by simply mapping it to an A value instead of an F[A].

recoverWith to recover from only certain errors.

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def ifElseM[A](branches: (F[Boolean], F[A])*)(els: F[A]): F[A]
Implicitly added by asyncForEitherT

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

Attributes

See also:
Inherited from:
Monad
Source:
Monad.scala
def ifElseM[A](branches: (F[Boolean], F[A])*)(els: F[A]): F[A]
Implicitly added by asyncForKleisli

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

Attributes

See also:
Inherited from:
Monad
Source:
Monad.scala
def ifElseM[A](branches: (F[Boolean], F[A])*)(els: F[A]): F[A]
Implicitly added by asyncForOptionT

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

Attributes

See also:
Inherited from:
Monad
Source:
Monad.scala
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.

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

Attributes

See also:
Inherited from:
Monad
Source:
Monad.scala
def ifF[A](fb: F[Boolean])(ifTrue: => A, ifFalse: => A): F[A]
Implicitly added by asyncForEitherT

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)

Attributes

Inherited from:
Functor
Source:
Functor.scala
def ifF[A](fb: F[Boolean])(ifTrue: => A, ifFalse: => A): F[A]
Implicitly added by asyncForKleisli

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)

Attributes

Inherited from:
Functor
Source:
Functor.scala
def ifF[A](fb: F[Boolean])(ifTrue: => A, ifFalse: => A): F[A]
Implicitly added by asyncForOptionT

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)

Attributes

Inherited from:
Functor
Source:
Functor.scala
def ifF[A](fb: F[Boolean])(ifTrue: => A, ifFalse: => A): F[A]

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)

Attributes

Inherited from:
Functor
Source:
Functor.scala
def ifM[B](fa: F[Boolean])(ifTrue: => F[B], ifFalse: => F[B]): F[B]
Implicitly added by asyncForEitherT

if lifted into monad.

if lifted into monad.

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def ifM[B](fa: F[Boolean])(ifTrue: => F[B], ifFalse: => F[B]): F[B]
Implicitly added by asyncForKleisli

if lifted into monad.

if lifted into monad.

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def ifM[B](fa: F[Boolean])(ifTrue: => F[B], ifFalse: => F[B]): F[B]
Implicitly added by asyncForOptionT

if lifted into monad.

if lifted into monad.

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def ifM[B](fa: F[Boolean])(ifTrue: => F[B], ifFalse: => F[B]): F[B]

if lifted into monad.

if lifted into monad.

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
override def imap[A, B](fa: F[A])(f: A => B)(g: B => A): F[B]

Transform an F[A] into an F[B] by providing a transformation from A to B and one from B to A.

Transform an F[A] into an F[B] by providing a transformation from A to B and one from B to A.

Example:

scala> import cats.implicits._
scala> import scala.concurrent.duration._

scala> val durSemigroup: Semigroup[FiniteDuration] =
    | Invariant[Semigroup].imap(Semigroup[Long])(Duration.fromNanos)(_.toNanos)
scala> durSemigroup.combine(2.seconds, 3.seconds)
res1: FiniteDuration = 5 seconds

Attributes

Definition Classes
Inherited from:
Functor
Source:
Functor.scala
def interruptible[A](thunk: => A): F[A]
Implicitly added by asyncForEitherT

Like Sync.blocking but will attempt to abort the blocking operation using thread interrupts in the event of cancelation. The interrupt will be attempted only once.

Like Sync.blocking but will attempt to abort the blocking operation using thread interrupts in the event of cancelation. The interrupt will be attempted only once.

Attributes

thunk

The side effect which is to be suspended in F[_] and evaluated on a blocking execution context

Inherited from:
Sync
Source:
Sync.scala
def interruptible[A](thunk: => A): F[A]
Implicitly added by asyncForKleisli

Like Sync.blocking but will attempt to abort the blocking operation using thread interrupts in the event of cancelation. The interrupt will be attempted only once.

Like Sync.blocking but will attempt to abort the blocking operation using thread interrupts in the event of cancelation. The interrupt will be attempted only once.

Attributes

thunk

The side effect which is to be suspended in F[_] and evaluated on a blocking execution context

Inherited from:
Sync
Source:
Sync.scala
def interruptible[A](thunk: => A): F[A]
Implicitly added by asyncForOptionT

Like Sync.blocking but will attempt to abort the blocking operation using thread interrupts in the event of cancelation. The interrupt will be attempted only once.

Like Sync.blocking but will attempt to abort the blocking operation using thread interrupts in the event of cancelation. The interrupt will be attempted only once.

Attributes

thunk

The side effect which is to be suspended in F[_] and evaluated on a blocking execution context

Inherited from:
Sync
Source:
Sync.scala
def interruptible[A](thunk: => A): F[A]

Like Sync.blocking but will attempt to abort the blocking operation using thread interrupts in the event of cancelation. The interrupt will be attempted only once.

Like Sync.blocking but will attempt to abort the blocking operation using thread interrupts in the event of cancelation. The interrupt will be attempted only once.

Attributes

thunk

The side effect which is to be suspended in F[_] and evaluated on a blocking execution context

Inherited from:
Sync
Source:
Sync.scala
def interruptibleMany[A](thunk: => A): F[A]
Implicitly added by asyncForEitherT

Like Sync.blocking but will attempt to abort the blocking operation using thread interrupts in the event of cancelation. The interrupt will be attempted repeatedly until the blocking operation completes or exits.

Like Sync.blocking but will attempt to abort the blocking operation using thread interrupts in the event of cancelation. The interrupt will be attempted repeatedly until the blocking operation completes or exits.

Attributes

thunk

The side effect which is to be suspended in F[_] and evaluated on a blocking execution context

Note:

that this really means what it says - it will throw exceptions in a tight loop until the offending blocking operation exits. This is extremely expensive if it happens on a hot path and the blocking operation is badly behaved and doesn't exit immediately.

Inherited from:
Sync
Source:
Sync.scala
def interruptibleMany[A](thunk: => A): F[A]
Implicitly added by asyncForKleisli

Like Sync.blocking but will attempt to abort the blocking operation using thread interrupts in the event of cancelation. The interrupt will be attempted repeatedly until the blocking operation completes or exits.

Like Sync.blocking but will attempt to abort the blocking operation using thread interrupts in the event of cancelation. The interrupt will be attempted repeatedly until the blocking operation completes or exits.

Attributes

thunk

The side effect which is to be suspended in F[_] and evaluated on a blocking execution context

Note:

that this really means what it says - it will throw exceptions in a tight loop until the offending blocking operation exits. This is extremely expensive if it happens on a hot path and the blocking operation is badly behaved and doesn't exit immediately.

Inherited from:
Sync
Source:
Sync.scala
def interruptibleMany[A](thunk: => A): F[A]
Implicitly added by asyncForOptionT

Like Sync.blocking but will attempt to abort the blocking operation using thread interrupts in the event of cancelation. The interrupt will be attempted repeatedly until the blocking operation completes or exits.

Like Sync.blocking but will attempt to abort the blocking operation using thread interrupts in the event of cancelation. The interrupt will be attempted repeatedly until the blocking operation completes or exits.

Attributes

thunk

The side effect which is to be suspended in F[_] and evaluated on a blocking execution context

Note:

that this really means what it says - it will throw exceptions in a tight loop until the offending blocking operation exits. This is extremely expensive if it happens on a hot path and the blocking operation is badly behaved and doesn't exit immediately.

Inherited from:
Sync
Source:
Sync.scala
def interruptibleMany[A](thunk: => A): F[A]

Like Sync.blocking but will attempt to abort the blocking operation using thread interrupts in the event of cancelation. The interrupt will be attempted repeatedly until the blocking operation completes or exits.

Like Sync.blocking but will attempt to abort the blocking operation using thread interrupts in the event of cancelation. The interrupt will be attempted repeatedly until the blocking operation completes or exits.

Attributes

thunk

The side effect which is to be suspended in F[_] and evaluated on a blocking execution context

Note:

that this really means what it says - it will throw exceptions in a tight loop until the offending blocking operation exits. This is extremely expensive if it happens on a hot path and the blocking operation is badly behaved and doesn't exit immediately.

Inherited from:
Sync
Source:
Sync.scala
def iterateForeverM[A, B](a: A)(f: A => F[A]): F[B]
Implicitly added by asyncForEitherT

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.

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def iterateForeverM[A, B](a: A)(f: A => F[A]): F[B]
Implicitly added by asyncForKleisli

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.

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def iterateForeverM[A, B](a: A)(f: A => F[A]): F[B]
Implicitly added by asyncForOptionT

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.

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
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.

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.

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def iterateUntil[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by asyncForEitherT

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def iterateUntil[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by asyncForKleisli

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def iterateUntil[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by asyncForOptionT

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
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.

Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def iterateUntilM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by asyncForEitherT

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def iterateUntilM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by asyncForKleisli

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def iterateUntilM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by asyncForOptionT

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
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.

Apply a monadic function iteratively until its result satisfies the given predicate and return that result.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def iterateWhile[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by asyncForEitherT

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def iterateWhile[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by asyncForKleisli

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def iterateWhile[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by asyncForOptionT

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
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.

Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def iterateWhileM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by asyncForEitherT

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def iterateWhileM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by asyncForKleisli

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def iterateWhileM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by asyncForOptionT

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
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.

Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def lift[A, B](f: A => B): F[A] => F[B]
Implicitly added by asyncForEitherT

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)

Attributes

Inherited from:
Functor
Source:
Functor.scala
def lift[A, B](f: A => B): F[A] => F[B]
Implicitly added by asyncForKleisli

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)

Attributes

Inherited from:
Functor
Source:
Functor.scala
def lift[A, B](f: A => B): F[A] => F[B]
Implicitly added by asyncForOptionT

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)

Attributes

Inherited from:
Functor
Source:
Functor.scala
def lift[A, B](f: A => B): F[A] => F[B]

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)

Attributes

Inherited from:
Functor
Source:
Functor.scala
override def map[A, B](fa: F[A])(f: A => B): F[B]

Attributes

Definition Classes
Inherited from:
Monad
Source:
Monad.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
override def map2[A, B, Z](fa: F[A], fb: F[B])(f: (A, B) => Z): F[Z]

Applies the pure (binary) function f to the effectful values fa and fb.

Applies the pure (binary) function f to the effectful values fa and fb.

map2 can be seen as a binary version of cats.Functor#map.

Example:

scala> import cats.implicits._

scala> val someInt: Option[Int] = Some(3)
scala> val noneInt: Option[Int] = None
scala> val someLong: Option[Long] = Some(4L)
scala> val noneLong: Option[Long] = None

scala> Apply[Option].map2(someInt, someLong)((i, l) => i.toString + l.toString)
res0: Option[String] = Some(34)

scala> Apply[Option].map2(someInt, noneLong)((i, l) => i.toString + l.toString)
res0: Option[String] = None

scala> Apply[Option].map2(noneInt, noneLong)((i, l) => i.toString + l.toString)
res0: Option[String] = None

scala> Apply[Option].map2(noneInt, someLong)((i, l) => i.toString + l.toString)
res0: Option[String] = None

Attributes

Definition Classes
Inherited from:
FlatMap
Source:
FlatMap.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
override 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 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

Attributes

Definition Classes
Inherited from:
FlatMap
Source:
FlatMap.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def map3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2])(f: (A0, A1, A2) => Z): F[Z]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
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]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def memoize[A](fa: F[A]): F[F[A]]
Implicitly added by asyncForEitherT

Caches the result of fa.

Caches the result of fa.

The returned inner effect, hence referred to as get, when sequenced, will evaluate fa and cache the result. If get is sequenced multiple times fa will only be evaluated once.

If all gets are canceled prior to fa completing, it will be canceled and evaluated again the next time get is sequenced.

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def memoize[A](fa: F[A]): F[F[A]]
Implicitly added by asyncForKleisli

Caches the result of fa.

Caches the result of fa.

The returned inner effect, hence referred to as get, when sequenced, will evaluate fa and cache the result. If get is sequenced multiple times fa will only be evaluated once.

If all gets are canceled prior to fa completing, it will be canceled and evaluated again the next time get is sequenced.

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def memoize[A](fa: F[A]): F[F[A]]
Implicitly added by asyncForOptionT

Caches the result of fa.

Caches the result of fa.

The returned inner effect, hence referred to as get, when sequenced, will evaluate fa and cache the result. If get is sequenced multiple times fa will only be evaluated once.

If all gets are canceled prior to fa completing, it will be canceled and evaluated again the next time get is sequenced.

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def memoize[A](fa: F[A]): F[F[A]]

Caches the result of fa.

Caches the result of fa.

The returned inner effect, hence referred to as get, when sequenced, will evaluate fa and cache the result. If get is sequenced multiple times fa will only be evaluated once.

If all gets are canceled prior to fa completing, it will be canceled and evaluated again the next time get is sequenced.

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def monotonic: F[FiniteDuration]
Implicitly added by asyncForEitherT

Monotonic time subject to the law that (monotonic, monotonic).mapN(_ <= _)

Monotonic time subject to the law that (monotonic, monotonic).mapN(_ <= _)

Analogous to java.lang.System.nanoTime.

Attributes

Inherited from:
Clock
Source:
Clock.scala
def monotonic: F[FiniteDuration]
Implicitly added by asyncForKleisli

Monotonic time subject to the law that (monotonic, monotonic).mapN(_ <= _)

Monotonic time subject to the law that (monotonic, monotonic).mapN(_ <= _)

Analogous to java.lang.System.nanoTime.

Attributes

Inherited from:
Clock
Source:
Clock.scala
def monotonic: F[FiniteDuration]
Implicitly added by asyncForOptionT

Monotonic time subject to the law that (monotonic, monotonic).mapN(_ <= _)

Monotonic time subject to the law that (monotonic, monotonic).mapN(_ <= _)

Analogous to java.lang.System.nanoTime.

Attributes

Inherited from:
Clock
Source:
Clock.scala
def monotonic: F[FiniteDuration]

Monotonic time subject to the law that (monotonic, monotonic).mapN(_ <= _)

Monotonic time subject to the law that (monotonic, monotonic).mapN(_ <= _)

Analogous to java.lang.System.nanoTime.

Attributes

Inherited from:
Clock
Source:
Clock.scala
def mproduct[A, B](fa: F[A])(f: A => F[B]): F[(A, B)]
Implicitly added by asyncForEitherT

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))

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def mproduct[A, B](fa: F[A])(f: A => F[B]): F[(A, B)]
Implicitly added by asyncForKleisli

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))

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def mproduct[A, B](fa: F[A])(f: A => F[B]): F[(A, B)]
Implicitly added by asyncForOptionT

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))

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def mproduct[A, B](fa: F[A])(f: A => F[B]): F[(A, B)]

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))

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def onCancel[A](fa: F[A], fin: F[Unit]): F[A]
Implicitly added by asyncForEitherT

Registers a finalizer that is invoked if cancelation is observed during the evaluation of fa. If the evaluation of fa completes without encountering a cancelation, the finalizer is unregistered before proceeding.

Registers a finalizer that is invoked if cancelation is observed during the evaluation of fa. If the evaluation of fa completes without encountering a cancelation, the finalizer is unregistered before proceeding.

During finalization, all actively registered finalizers are run exactly once. The order by which finalizers are run is dictated by nesting: innermost finalizers are run before outermost finalizers. For example, in the following program, the finalizer f1 is run before the finalizer f2:


 F.onCancel(F.onCancel(F.canceled, f1), f2)

If a finalizer throws an error during evaluation, the error is suppressed, and implementations may choose to report it via a side channel. Finalizers are always uncancelable, so cannot otherwise be interrupted.

Attributes

fa

The effect that is evaluated after fin is registered.

fin

The finalizer to register before evaluating fa.

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def onCancel[A](fa: F[A], fin: F[Unit]): F[A]
Implicitly added by asyncForKleisli

Registers a finalizer that is invoked if cancelation is observed during the evaluation of fa. If the evaluation of fa completes without encountering a cancelation, the finalizer is unregistered before proceeding.

Registers a finalizer that is invoked if cancelation is observed during the evaluation of fa. If the evaluation of fa completes without encountering a cancelation, the finalizer is unregistered before proceeding.

During finalization, all actively registered finalizers are run exactly once. The order by which finalizers are run is dictated by nesting: innermost finalizers are run before outermost finalizers. For example, in the following program, the finalizer f1 is run before the finalizer f2:


 F.onCancel(F.onCancel(F.canceled, f1), f2)

If a finalizer throws an error during evaluation, the error is suppressed, and implementations may choose to report it via a side channel. Finalizers are always uncancelable, so cannot otherwise be interrupted.

Attributes

fa

The effect that is evaluated after fin is registered.

fin

The finalizer to register before evaluating fa.

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def onCancel[A](fa: F[A], fin: F[Unit]): F[A]
Implicitly added by asyncForOptionT

Registers a finalizer that is invoked if cancelation is observed during the evaluation of fa. If the evaluation of fa completes without encountering a cancelation, the finalizer is unregistered before proceeding.

Registers a finalizer that is invoked if cancelation is observed during the evaluation of fa. If the evaluation of fa completes without encountering a cancelation, the finalizer is unregistered before proceeding.

During finalization, all actively registered finalizers are run exactly once. The order by which finalizers are run is dictated by nesting: innermost finalizers are run before outermost finalizers. For example, in the following program, the finalizer f1 is run before the finalizer f2:


 F.onCancel(F.onCancel(F.canceled, f1), f2)

If a finalizer throws an error during evaluation, the error is suppressed, and implementations may choose to report it via a side channel. Finalizers are always uncancelable, so cannot otherwise be interrupted.

Attributes

fa

The effect that is evaluated after fin is registered.

fin

The finalizer to register before evaluating fa.

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def onCancel[A](fa: F[A], fin: F[Unit]): F[A]

Registers a finalizer that is invoked if cancelation is observed during the evaluation of fa. If the evaluation of fa completes without encountering a cancelation, the finalizer is unregistered before proceeding.

Registers a finalizer that is invoked if cancelation is observed during the evaluation of fa. If the evaluation of fa completes without encountering a cancelation, the finalizer is unregistered before proceeding.

During finalization, all actively registered finalizers are run exactly once. The order by which finalizers are run is dictated by nesting: innermost finalizers are run before outermost finalizers. For example, in the following program, the finalizer f1 is run before the finalizer f2:


 F.onCancel(F.onCancel(F.canceled, f1), f2)

If a finalizer throws an error during evaluation, the error is suppressed, and implementations may choose to report it via a side channel. Finalizers are always uncancelable, so cannot otherwise be interrupted.

Attributes

fa

The effect that is evaluated after fin is registered.

fin

The finalizer to register before evaluating fa.

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def onError[A](fa: F[A])(pf: PartialFunction[Throwable, F[Unit]]): F[A]
Implicitly added by asyncForEitherT

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)))

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def onError[A](fa: F[A])(pf: PartialFunction[Throwable, F[Unit]]): F[A]
Implicitly added by asyncForKleisli

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)))

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def onError[A](fa: F[A])(pf: PartialFunction[Throwable, F[Unit]]): F[A]
Implicitly added by asyncForOptionT

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)))

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def onError[A](fa: F[A])(pf: PartialFunction[Throwable, F[Unit]]): F[A]

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)))

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def parReplicateAN[A](n: Int)(replicas: Int, ma: F[A]): F[List[A]]
Implicitly added by asyncForEitherT

Like Parallel.parReplicateA, but limits the degree of parallelism.

Like Parallel.parReplicateA, but limits the degree of parallelism.

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def parReplicateAN[A](n: Int)(replicas: Int, ma: F[A]): F[List[A]]
Implicitly added by asyncForKleisli

Like Parallel.parReplicateA, but limits the degree of parallelism.

Like Parallel.parReplicateA, but limits the degree of parallelism.

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def parReplicateAN[A](n: Int)(replicas: Int, ma: F[A]): F[List[A]]
Implicitly added by asyncForOptionT

Like Parallel.parReplicateA, but limits the degree of parallelism.

Like Parallel.parReplicateA, but limits the degree of parallelism.

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def parReplicateAN[A](n: Int)(replicas: Int, ma: F[A]): F[List[A]]

Like Parallel.parReplicateA, but limits the degree of parallelism.

Like Parallel.parReplicateA, but limits the degree of parallelism.

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def parSequenceN[T[_] : Traverse, A](n: Int)(tma: T[F[A]]): F[T[A]]
Implicitly added by asyncForEitherT

Like Parallel.parSequence, but limits the degree of parallelism.

Like Parallel.parSequence, but limits the degree of parallelism.

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def parSequenceN[T[_] : Traverse, A](n: Int)(tma: T[F[A]]): F[T[A]]
Implicitly added by asyncForKleisli

Like Parallel.parSequence, but limits the degree of parallelism.

Like Parallel.parSequence, but limits the degree of parallelism.

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def parSequenceN[T[_] : Traverse, A](n: Int)(tma: T[F[A]]): F[T[A]]
Implicitly added by asyncForOptionT

Like Parallel.parSequence, but limits the degree of parallelism.

Like Parallel.parSequence, but limits the degree of parallelism.

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def parSequenceN[T[_] : Traverse, A](n: Int)(tma: T[F[A]]): F[T[A]]

Like Parallel.parSequence, but limits the degree of parallelism.

Like Parallel.parSequence, but limits the degree of parallelism.

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def parTraverseN[T[_] : Traverse, A, B](n: Int)(ta: T[A])(f: A => F[B]): F[T[B]]
Implicitly added by asyncForEitherT

Like Parallel.parTraverse, but limits the degree of parallelism. Note that the semantics of this operation aim to maximise fairness: when a spot to execute becomes available, every task has a chance to claim it, and not only the next n tasks in ta

Like Parallel.parTraverse, but limits the degree of parallelism. Note that the semantics of this operation aim to maximise fairness: when a spot to execute becomes available, every task has a chance to claim it, and not only the next n tasks in ta

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def parTraverseN[T[_] : Traverse, A, B](n: Int)(ta: T[A])(f: A => F[B]): F[T[B]]
Implicitly added by asyncForKleisli

Like Parallel.parTraverse, but limits the degree of parallelism. Note that the semantics of this operation aim to maximise fairness: when a spot to execute becomes available, every task has a chance to claim it, and not only the next n tasks in ta

Like Parallel.parTraverse, but limits the degree of parallelism. Note that the semantics of this operation aim to maximise fairness: when a spot to execute becomes available, every task has a chance to claim it, and not only the next n tasks in ta

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def parTraverseN[T[_] : Traverse, A, B](n: Int)(ta: T[A])(f: A => F[B]): F[T[B]]
Implicitly added by asyncForOptionT

Like Parallel.parTraverse, but limits the degree of parallelism. Note that the semantics of this operation aim to maximise fairness: when a spot to execute becomes available, every task has a chance to claim it, and not only the next n tasks in ta

Like Parallel.parTraverse, but limits the degree of parallelism. Note that the semantics of this operation aim to maximise fairness: when a spot to execute becomes available, every task has a chance to claim it, and not only the next n tasks in ta

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def parTraverseN[T[_] : Traverse, A, B](n: Int)(ta: T[A])(f: A => F[B]): F[T[B]]

Like Parallel.parTraverse, but limits the degree of parallelism. Note that the semantics of this operation aim to maximise fairness: when a spot to execute becomes available, every task has a chance to claim it, and not only the next n tasks in ta

Like Parallel.parTraverse, but limits the degree of parallelism. Note that the semantics of this operation aim to maximise fairness: when a spot to execute becomes available, every task has a chance to claim it, and not only the next n tasks in ta

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def point[A](a: A): F[A]
Implicitly added by asyncForEitherT

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)

Attributes

Inherited from:
InvariantMonoidal
Source:
InvariantMonoidal.scala
def point[A](a: A): F[A]
Implicitly added by asyncForKleisli

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)

Attributes

Inherited from:
InvariantMonoidal
Source:
InvariantMonoidal.scala
def point[A](a: A): F[A]
Implicitly added by asyncForOptionT

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)

Attributes

Inherited from:
InvariantMonoidal
Source:
InvariantMonoidal.scala
def point[A](a: A): F[A]

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)

Attributes

Inherited from:
InvariantMonoidal
Source:
InvariantMonoidal.scala
override def product[A, B](fa: F[A], fb: F[B]): F[(A, B)]

Combine an F[A] and an F[B] into an F[(A, B)] that maintains the effects of both fa and fb.

Combine an F[A] and an F[B] into an F[(A, B)] that maintains the effects of both fa and fb.

Example:

scala> import cats.implicits._

scala> val noneInt: Option[Int] = None
scala> val some3: Option[Int] = Some(3)
scala> val noneString: Option[String] = None
scala> val someFoo: Option[String] = Some("foo")

scala> Semigroupal[Option].product(noneInt, noneString)
res0: Option[(Int, String)] = None

scala> Semigroupal[Option].product(noneInt, someFoo)
res1: Option[(Int, String)] = None

scala> Semigroupal[Option].product(some3, noneString)
res2: Option[(Int, String)] = None

scala> Semigroupal[Option].product(some3, someFoo)
res3: Option[(Int, String)] = Some((3,foo))

Attributes

Definition Classes
Inherited from:
FlatMap
Source:
FlatMap.scala
override def productL[A, B](fa: F[A])(fb: F[B]): F[A]

Compose two actions, discarding any value produced by the second.

Compose two actions, discarding any value produced by the second.

Attributes

See also:

productR to discard the value of the first instead. Example:

scala> import cats.implicits._
scala> import cats.data.Validated
scala> import Validated.{Valid, Invalid}
scala> type ErrOr[A] = Validated[String, A]
scala> val validInt: ErrOr[Int] = Valid(3)
scala> val validBool: ErrOr[Boolean] = Valid(true)
scala> val invalidInt: ErrOr[Int] = Invalid("Invalid int.")
scala> val invalidBool: ErrOr[Boolean] = Invalid("Invalid boolean.")
scala> Apply[ErrOr].productL(validInt)(validBool)
res0: ErrOr[Int] = Valid(3)
scala> Apply[ErrOr].productL(invalidInt)(validBool)
res1: ErrOr[Int] = Invalid(Invalid int.)
scala> Apply[ErrOr].productL(validInt)(invalidBool)
res2: ErrOr[Int] = Invalid(Invalid boolean.)
scala> Apply[ErrOr].productL(invalidInt)(invalidBool)
res3: ErrOr[Int] = Invalid(Invalid int.Invalid boolean.)
Definition Classes
Inherited from:
FlatMap
Source:
FlatMap.scala
def productLEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[A]
Implicitly added by asyncForEitherT

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)

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def productLEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[A]
Implicitly added by asyncForKleisli

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)

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def productLEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[A]
Implicitly added by asyncForOptionT

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)

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
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:

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)

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
override def productR[A, B](fa: F[A])(fb: F[B]): F[B]

Compose two actions, discarding any value produced by the first.

Compose two actions, discarding any value produced by the first.

Attributes

See also:

productL to discard the value of the second instead. Example:

scala> import cats.implicits._
scala> import cats.data.Validated
scala> import Validated.{Valid, Invalid}
scala> type ErrOr[A] = Validated[String, A]
scala> val validInt: ErrOr[Int] = Valid(3)
scala> val validBool: ErrOr[Boolean] = Valid(true)
scala> val invalidInt: ErrOr[Int] = Invalid("Invalid int.")
scala> val invalidBool: ErrOr[Boolean] = Invalid("Invalid boolean.")
scala> Apply[ErrOr].productR(validInt)(validBool)
res0: ErrOr[Boolean] = Valid(true)
scala> Apply[ErrOr].productR(invalidInt)(validBool)
res1: ErrOr[Boolean] = Invalid(Invalid int.)
scala> Apply[ErrOr].productR(validInt)(invalidBool)
res2: ErrOr[Boolean] = Invalid(Invalid boolean.)
scala> Apply[ErrOr].productR(invalidInt)(invalidBool)
res3: ErrOr[Boolean] = Invalid(Invalid int.Invalid boolean.)
Definition Classes
Inherited from:
FlatMap
Source:
FlatMap.scala
def productREval[A, B](fa: F[A])(fb: Eval[F[B]]): F[B]
Implicitly added by asyncForEitherT

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)

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def productREval[A, B](fa: F[A])(fb: Eval[F[B]]): F[B]
Implicitly added by asyncForKleisli

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)

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def productREval[A, B](fa: F[A])(fb: Eval[F[B]]): F[B]
Implicitly added by asyncForOptionT

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)

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
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:

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)

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def pure[A](x: A): F[A]
Implicitly added by asyncForEitherT

pure lifts any value into the Applicative Functor.

pure lifts any value into the Applicative Functor.

Example:

scala> import cats.implicits._

scala> Applicative[Option].pure(10)
res0: Option[Int] = Some(10)

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def pure[A](x: A): F[A]
Implicitly added by asyncForKleisli

pure lifts any value into the Applicative Functor.

pure lifts any value into the Applicative Functor.

Example:

scala> import cats.implicits._

scala> Applicative[Option].pure(10)
res0: Option[Int] = Some(10)

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def pure[A](x: A): F[A]
Implicitly added by asyncForOptionT

pure lifts any value into the Applicative Functor.

pure lifts any value into the Applicative Functor.

Example:

scala> import cats.implicits._

scala> Applicative[Option].pure(10)
res0: Option[Int] = Some(10)

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def pure[A](x: A): F[A]

pure lifts any value into the Applicative Functor.

pure lifts any value into the Applicative Functor.

Example:

scala> import cats.implicits._

scala> Applicative[Option].pure(10)
res0: Option[Int] = Some(10)

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def race[A, B](fa: F[A], fb: F[B]): F[Either[A, B]]
Implicitly added by asyncForEitherT

Races the evaluation of two fibers that returns the result of the winner, except in the case of cancelation.

Races the evaluation of two fibers that returns the result of the winner, except in the case of cancelation.

The semantics of race are described by the following rules:

  1. If the winner completes with Outcome.Succeeded, the race returns the successful value. The loser is canceled before returning. 2. If the winner completes with Outcome.Errored, the race raises the error. The loser is canceled before returning. 3. If the winner completes with Outcome.Canceled, the race returns the result of the loser, consistent with the first two rules. 4. If both the winner and loser complete with Outcome.Canceled, the race is canceled. 8. If the race is masked and is canceled because both participants canceled, the fiber will block indefinitely.

Attributes

fa

the effect for the first racing fiber

fb

the effect for the second racing fiber

See also:

raceOutcome for a variant that returns the outcome of the winner.

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def race[A, B](fa: F[A], fb: F[B]): F[Either[A, B]]
Implicitly added by asyncForKleisli

Races the evaluation of two fibers that returns the result of the winner, except in the case of cancelation.

Races the evaluation of two fibers that returns the result of the winner, except in the case of cancelation.

The semantics of race are described by the following rules:

  1. If the winner completes with Outcome.Succeeded, the race returns the successful value. The loser is canceled before returning. 2. If the winner completes with Outcome.Errored, the race raises the error. The loser is canceled before returning. 3. If the winner completes with Outcome.Canceled, the race returns the result of the loser, consistent with the first two rules. 4. If both the winner and loser complete with Outcome.Canceled, the race is canceled. 8. If the race is masked and is canceled because both participants canceled, the fiber will block indefinitely.

Attributes

fa

the effect for the first racing fiber

fb

the effect for the second racing fiber

See also:

raceOutcome for a variant that returns the outcome of the winner.

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def race[A, B](fa: F[A], fb: F[B]): F[Either[A, B]]
Implicitly added by asyncForOptionT

Races the evaluation of two fibers that returns the result of the winner, except in the case of cancelation.

Races the evaluation of two fibers that returns the result of the winner, except in the case of cancelation.

The semantics of race are described by the following rules:

  1. If the winner completes with Outcome.Succeeded, the race returns the successful value. The loser is canceled before returning. 2. If the winner completes with Outcome.Errored, the race raises the error. The loser is canceled before returning. 3. If the winner completes with Outcome.Canceled, the race returns the result of the loser, consistent with the first two rules. 4. If both the winner and loser complete with Outcome.Canceled, the race is canceled. 8. If the race is masked and is canceled because both participants canceled, the fiber will block indefinitely.

Attributes

fa

the effect for the first racing fiber

fb

the effect for the second racing fiber

See also:

raceOutcome for a variant that returns the outcome of the winner.

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def race[A, B](fa: F[A], fb: F[B]): F[Either[A, B]]

Races the evaluation of two fibers that returns the result of the winner, except in the case of cancelation.

Races the evaluation of two fibers that returns the result of the winner, except in the case of cancelation.

The semantics of race are described by the following rules:

  1. If the winner completes with Outcome.Succeeded, the race returns the successful value. The loser is canceled before returning. 2. If the winner completes with Outcome.Errored, the race raises the error. The loser is canceled before returning. 3. If the winner completes with Outcome.Canceled, the race returns the result of the loser, consistent with the first two rules. 4. If both the winner and loser complete with Outcome.Canceled, the race is canceled. 8. If the race is masked and is canceled because both participants canceled, the fiber will block indefinitely.

Attributes

fa

the effect for the first racing fiber

fb

the effect for the second racing fiber

See also:

raceOutcome for a variant that returns the outcome of the winner.

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def raceOutcome[A, B](fa: F[A], fb: F[B]): F[Either[Outcome[F, E, A], Outcome[F, E, B]]]
Implicitly added by asyncForEitherT

Races the evaluation of two fibers that returns the Outcome of the winner. The winner of the race is considered to be the first fiber that completes with an outcome. The loser of the race is canceled before returning.

Races the evaluation of two fibers that returns the Outcome of the winner. The winner of the race is considered to be the first fiber that completes with an outcome. The loser of the race is canceled before returning.

Attributes

fa

the effect for the first racing fiber

fb

the effect for the second racing fiber

See also:

race for a simpler variant that returns the successful outcome.

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def raceOutcome[A, B](fa: F[A], fb: F[B]): F[Either[Outcome[F, E, A], Outcome[F, E, B]]]
Implicitly added by asyncForKleisli

Races the evaluation of two fibers that returns the Outcome of the winner. The winner of the race is considered to be the first fiber that completes with an outcome. The loser of the race is canceled before returning.

Races the evaluation of two fibers that returns the Outcome of the winner. The winner of the race is considered to be the first fiber that completes with an outcome. The loser of the race is canceled before returning.

Attributes

fa

the effect for the first racing fiber

fb

the effect for the second racing fiber

See also:

race for a simpler variant that returns the successful outcome.

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def raceOutcome[A, B](fa: F[A], fb: F[B]): F[Either[Outcome[F, E, A], Outcome[F, E, B]]]
Implicitly added by asyncForOptionT

Races the evaluation of two fibers that returns the Outcome of the winner. The winner of the race is considered to be the first fiber that completes with an outcome. The loser of the race is canceled before returning.

Races the evaluation of two fibers that returns the Outcome of the winner. The winner of the race is considered to be the first fiber that completes with an outcome. The loser of the race is canceled before returning.

Attributes

fa

the effect for the first racing fiber

fb

the effect for the second racing fiber

See also:

race for a simpler variant that returns the successful outcome.

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def raceOutcome[A, B](fa: F[A], fb: F[B]): F[Either[Outcome[F, E, A], Outcome[F, E, B]]]

Races the evaluation of two fibers that returns the Outcome of the winner. The winner of the race is considered to be the first fiber that completes with an outcome. The loser of the race is canceled before returning.

Races the evaluation of two fibers that returns the Outcome of the winner. The winner of the race is considered to be the first fiber that completes with an outcome. The loser of the race is canceled before returning.

Attributes

fa

the effect for the first racing fiber

fb

the effect for the second racing fiber

See also:

race for a simpler variant that returns the successful outcome.

Inherited from:
GenSpawn
Source:
GenSpawn.scala
override def racePair[A, B](fa: F[A], fb: F[B]): F[Either[(Outcome[F, E, A], Fiber[F, E, B]), (Fiber[F, E, A], Outcome[F, E, B])]]

A low-level primitive for racing the evaluation of two fibers that returns the Outcome of the winner and the Fiber of the loser. The winner of the race is considered to be the first fiber that completes with an outcome.

A low-level primitive for racing the evaluation of two fibers that returns the Outcome of the winner and the Fiber of the loser. The winner of the race is considered to be the first fiber that completes with an outcome.

racePair is a cancelation-unsafe function; it is recommended to use the safer variants.

Attributes

fa

the effect for the first racing fiber

fb

the effect for the second racing fiber

See also:

raceOutcome and race for safer race variants.

Definition Classes
Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def raiseError[A](e: Throwable): F[A]
Implicitly added by asyncForEitherT

Lift an error into the F context.

Lift an error into the F context.

Example:

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> type ErrorOr[A] = Either[String, A]

scala> divide[ErrorOr](6, 3)
res0: ErrorOr[Int] = Right(2)

scala> divide[ErrorOr](6, 0)
res1: ErrorOr[Int] = Left(division by zero)

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def raiseError[A](e: Throwable): F[A]
Implicitly added by asyncForKleisli

Lift an error into the F context.

Lift an error into the F context.

Example:

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> type ErrorOr[A] = Either[String, A]

scala> divide[ErrorOr](6, 3)
res0: ErrorOr[Int] = Right(2)

scala> divide[ErrorOr](6, 0)
res1: ErrorOr[Int] = Left(division by zero)

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def raiseError[A](e: Throwable): F[A]
Implicitly added by asyncForOptionT

Lift an error into the F context.

Lift an error into the F context.

Example:

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> type ErrorOr[A] = Either[String, A]

scala> divide[ErrorOr](6, 3)
res0: ErrorOr[Int] = Right(2)

scala> divide[ErrorOr](6, 0)
res1: ErrorOr[Int] = Left(division by zero)

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def raiseError[A](e: Throwable): F[A]

Lift an error into the F context.

Lift an error into the F context.

Example:

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> type ErrorOr[A] = Either[String, A]

scala> divide[ErrorOr](6, 3)
res0: ErrorOr[Int] = Right(2)

scala> divide[ErrorOr](6, 0)
res1: ErrorOr[Int] = Left(division by zero)

Attributes

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def raiseUnless(cond: Boolean)(e: => Throwable): F[Unit]
Implicitly added by asyncForEitherT

Returns raiseError when cond is false, otherwise F.unit

Returns raiseError when cond is false, otherwise F.unit

Attributes

Example:
val tooMany = 5
val x: Int = ???
F.raiseUnless(x < tooMany)(new IllegalArgumentException("Too many"))
Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def raiseUnless(cond: Boolean)(e: => Throwable): F[Unit]
Implicitly added by asyncForKleisli

Returns raiseError when cond is false, otherwise F.unit

Returns raiseError when cond is false, otherwise F.unit

Attributes

Example:
val tooMany = 5
val x: Int = ???
F.raiseUnless(x < tooMany)(new IllegalArgumentException("Too many"))
Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def raiseUnless(cond: Boolean)(e: => Throwable): F[Unit]
Implicitly added by asyncForOptionT

Returns raiseError when cond is false, otherwise F.unit

Returns raiseError when cond is false, otherwise F.unit

Attributes

Example:
val tooMany = 5
val x: Int = ???
F.raiseUnless(x < tooMany)(new IllegalArgumentException("Too many"))
Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def raiseUnless(cond: Boolean)(e: => Throwable): F[Unit]

Returns raiseError when cond is false, otherwise F.unit

Returns raiseError when cond is false, otherwise F.unit

Attributes

Example:
val tooMany = 5
val x: Int = ???
F.raiseUnless(x < tooMany)(new IllegalArgumentException("Too many"))
Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def raiseWhen(cond: Boolean)(e: => Throwable): F[Unit]
Implicitly added by asyncForEitherT

Returns raiseError when the cond is true, otherwise F.unit

Returns raiseError when the cond is true, otherwise F.unit

Attributes

Example:
val tooMany = 5
val x: Int = ???
F.raiseWhen(x >= tooMany)(new IllegalArgumentException("Too many"))
Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def raiseWhen(cond: Boolean)(e: => Throwable): F[Unit]
Implicitly added by asyncForKleisli

Returns raiseError when the cond is true, otherwise F.unit

Returns raiseError when the cond is true, otherwise F.unit

Attributes

Example:
val tooMany = 5
val x: Int = ???
F.raiseWhen(x >= tooMany)(new IllegalArgumentException("Too many"))
Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def raiseWhen(cond: Boolean)(e: => Throwable): F[Unit]
Implicitly added by asyncForOptionT

Returns raiseError when the cond is true, otherwise F.unit

Returns raiseError when the cond is true, otherwise F.unit

Attributes

Example:
val tooMany = 5
val x: Int = ???
F.raiseWhen(x >= tooMany)(new IllegalArgumentException("Too many"))
Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def raiseWhen(cond: Boolean)(e: => Throwable): F[Unit]

Returns raiseError when the cond is true, otherwise F.unit

Returns raiseError when the cond is true, otherwise F.unit

Attributes

Example:
val tooMany = 5
val x: Int = ???
F.raiseWhen(x >= tooMany)(new IllegalArgumentException("Too many"))
Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def realTime: F[FiniteDuration]
Implicitly added by asyncForEitherT

A representation of the current system time

A representation of the current system time

Analogous to java.lang.System.currentTimeMillis.

Attributes

Inherited from:
Clock
Source:
Clock.scala
def realTime: F[FiniteDuration]
Implicitly added by asyncForKleisli

A representation of the current system time

A representation of the current system time

Analogous to java.lang.System.currentTimeMillis.

Attributes

Inherited from:
Clock
Source:
Clock.scala
def realTime: F[FiniteDuration]
Implicitly added by asyncForOptionT

A representation of the current system time

A representation of the current system time

Analogous to java.lang.System.currentTimeMillis.

Attributes

Inherited from:
Clock
Source:
Clock.scala
def realTime: F[FiniteDuration]

A representation of the current system time

A representation of the current system time

Analogous to java.lang.System.currentTimeMillis.

Attributes

Inherited from:
Clock
Source:
Clock.scala
def realTimeInstant: F[Instant]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
ClockPlatform (hidden)
Source:
ClockPlatform.scala
def realTimeInstant: F[Instant]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
ClockPlatform (hidden)
Source:
ClockPlatform.scala
def realTimeInstant: F[Instant]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
ClockPlatform (hidden)
Source:
ClockPlatform.scala
def realTimeInstant: F[Instant]

Attributes

Inherited from:
ClockPlatform (hidden)
Source:
ClockPlatform.scala
def recover[A](fa: F[A])(pf: PartialFunction[Throwable, A]): F[A]
Implicitly added by asyncForEitherT

Recover from certain errors by mapping them to an A value.

Recover from certain errors by mapping them to an A value.

Attributes

See also:

handleError to handle any/all errors.

recoverWith to recover from certain errors by mapping them to F[A] values.

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def recover[A](fa: F[A])(pf: PartialFunction[Throwable, A]): F[A]
Implicitly added by asyncForKleisli

Recover from certain errors by mapping them to an A value.

Recover from certain errors by mapping them to an A value.

Attributes

See also:

handleError to handle any/all errors.

recoverWith to recover from certain errors by mapping them to F[A] values.

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def recover[A](fa: F[A])(pf: PartialFunction[Throwable, A]): F[A]
Implicitly added by asyncForOptionT

Recover from certain errors by mapping them to an A value.

Recover from certain errors by mapping them to an A value.

Attributes

See also:

handleError to handle any/all errors.

recoverWith to recover from certain errors by mapping them to F[A] values.

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def recover[A](fa: F[A])(pf: PartialFunction[Throwable, A]): F[A]

Recover from certain errors by mapping them to an A value.

Recover from certain errors by mapping them to an A value.

Attributes

See also:

handleError to handle any/all errors.

recoverWith to recover from certain errors by mapping them to F[A] values.

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def recoverWith[A](fa: F[A])(pf: PartialFunction[Throwable, F[A]]): F[A]
Implicitly added by asyncForEitherT

Recover from certain errors by mapping them to an F[A] value.

Recover from certain errors by mapping them to an F[A] value.

Attributes

See also:

handleErrorWith to handle any/all errors.

recover to recover from certain errors by mapping them to A values.

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def recoverWith[A](fa: F[A])(pf: PartialFunction[Throwable, F[A]]): F[A]
Implicitly added by asyncForKleisli

Recover from certain errors by mapping them to an F[A] value.

Recover from certain errors by mapping them to an F[A] value.

Attributes

See also:

handleErrorWith to handle any/all errors.

recover to recover from certain errors by mapping them to A values.

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def recoverWith[A](fa: F[A])(pf: PartialFunction[Throwable, F[A]]): F[A]
Implicitly added by asyncForOptionT

Recover from certain errors by mapping them to an F[A] value.

Recover from certain errors by mapping them to an F[A] value.

Attributes

See also:

handleErrorWith to handle any/all errors.

recover to recover from certain errors by mapping them to A values.

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def recoverWith[A](fa: F[A])(pf: PartialFunction[Throwable, F[A]]): F[A]

Recover from certain errors by mapping them to an F[A] value.

Recover from certain errors by mapping them to an F[A] value.

Attributes

See also:

handleErrorWith to handle any/all errors.

recover to recover from certain errors by mapping them to A values.

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def redeem[A, B](fa: F[A])(recover: Throwable => B, f: A => B): F[B]
Implicitly added by asyncForEitherT

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.

Attributes

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:
Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def redeem[A, B](fa: F[A])(recover: Throwable => B, f: A => B): F[B]
Implicitly added by asyncForKleisli

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.

Attributes

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:
Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def redeem[A, B](fa: F[A])(recover: Throwable => B, f: A => B): F[B]
Implicitly added by asyncForOptionT

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.

Attributes

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:
Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def redeem[A, B](fa: F[A])(recover: Throwable => B, f: A => B): F[B]

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.

Attributes

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:
Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def redeemWith[A, B](fa: F[A])(recover: Throwable => F[B], bind: A => F[B]): F[B]
Implicitly added by asyncForEitherT

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.

Attributes

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
Source:
MonadError.scala
def redeemWith[A, B](fa: F[A])(recover: Throwable => F[B], bind: A => F[B]): F[B]
Implicitly added by asyncForKleisli

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.

Attributes

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
Source:
MonadError.scala
def redeemWith[A, B](fa: F[A])(recover: Throwable => F[B], bind: A => F[B]): F[B]
Implicitly added by asyncForOptionT

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.

Attributes

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
Source:
MonadError.scala
def redeemWith[A, B](fa: F[A])(recover: Throwable => F[B], bind: A => F[B]): F[B]

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.

Attributes

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
Source:
MonadError.scala
def ref[A](a: A): F[Ref[F, A]]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def ref[A](a: A): F[Ref[F, A]]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def ref[A](a: A): F[Ref[F, A]]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def ref[A](a: A): F[Ref[F, A]]

Attributes

Inherited from:
GenConcurrent
Source:
GenConcurrent.scala
def replicateA[A](n: Int, fa: F[A]): F[List[A]]
Implicitly added by asyncForEitherT

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))

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def replicateA[A](n: Int, fa: F[A]): F[List[A]]
Implicitly added by asyncForKleisli

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))

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def replicateA[A](n: Int, fa: F[A]): F[List[A]]
Implicitly added by asyncForOptionT

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))

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
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.

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))

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def replicateA_[A](n: Int, fa: F[A]): F[Unit]
Implicitly added by asyncForEitherT

Given fa and n, apply fa n times discarding results to return F[Unit].

Given fa and n, apply fa n times discarding results to return F[Unit].

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[Unit] =
    | Applicative[Counter].replicateA_(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, Unit) = (5,())

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def replicateA_[A](n: Int, fa: F[A]): F[Unit]
Implicitly added by asyncForKleisli

Given fa and n, apply fa n times discarding results to return F[Unit].

Given fa and n, apply fa n times discarding results to return F[Unit].

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[Unit] =
    | Applicative[Counter].replicateA_(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, Unit) = (5,())

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def replicateA_[A](n: Int, fa: F[A]): F[Unit]
Implicitly added by asyncForOptionT

Given fa and n, apply fa n times discarding results to return F[Unit].

Given fa and n, apply fa n times discarding results to return F[Unit].

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[Unit] =
    | Applicative[Counter].replicateA_(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, Unit) = (5,())

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def replicateA_[A](n: Int, fa: F[A]): F[Unit]

Given fa and n, apply fa n times discarding results to return F[Unit].

Given fa and n, apply fa n times discarding results to return F[Unit].

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[Unit] =
    | Applicative[Counter].replicateA_(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, Unit) = (5,())

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def rethrow[A, EE <: Throwable](fa: F[Either[EE, A]]): F[A]
Implicitly added by asyncForEitherT

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)

Attributes

Inherited from:
MonadError
Source:
MonadError.scala
def rethrow[A, EE <: Throwable](fa: F[Either[EE, A]]): F[A]
Implicitly added by asyncForKleisli

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)

Attributes

Inherited from:
MonadError
Source:
MonadError.scala
def rethrow[A, EE <: Throwable](fa: F[Either[EE, A]]): F[A]
Implicitly added by asyncForOptionT

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)

Attributes

Inherited from:
MonadError
Source:
MonadError.scala
def rethrow[A, EE <: Throwable](fa: F[Either[EE, A]]): F[A]

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)

Attributes

Inherited from:
MonadError
Source:
MonadError.scala
final def rootCancelScope: CancelScope
Implicitly added by asyncForEitherT

Indicates the default "root scope" semantics of the F in question. For types which do ''not'' implement auto-cancelation, this value may be set to CancelScope.Uncancelable, which behaves as if all values F[A] are wrapped in an implicit "outer" uncancelable which cannot be polled. Most IO-like types will define this to be Cancelable.

Indicates the default "root scope" semantics of the F in question. For types which do ''not'' implement auto-cancelation, this value may be set to CancelScope.Uncancelable, which behaves as if all values F[A] are wrapped in an implicit "outer" uncancelable which cannot be polled. Most IO-like types will define this to be Cancelable.

Attributes

Inherited from:
GenSpawn
Source:
GenSpawn.scala
final def rootCancelScope: CancelScope
Implicitly added by asyncForKleisli

Indicates the default "root scope" semantics of the F in question. For types which do ''not'' implement auto-cancelation, this value may be set to CancelScope.Uncancelable, which behaves as if all values F[A] are wrapped in an implicit "outer" uncancelable which cannot be polled. Most IO-like types will define this to be Cancelable.

Indicates the default "root scope" semantics of the F in question. For types which do ''not'' implement auto-cancelation, this value may be set to CancelScope.Uncancelable, which behaves as if all values F[A] are wrapped in an implicit "outer" uncancelable which cannot be polled. Most IO-like types will define this to be Cancelable.

Attributes

Inherited from:
GenSpawn
Source:
GenSpawn.scala
final def rootCancelScope: CancelScope
Implicitly added by asyncForOptionT

Indicates the default "root scope" semantics of the F in question. For types which do ''not'' implement auto-cancelation, this value may be set to CancelScope.Uncancelable, which behaves as if all values F[A] are wrapped in an implicit "outer" uncancelable which cannot be polled. Most IO-like types will define this to be Cancelable.

Indicates the default "root scope" semantics of the F in question. For types which do ''not'' implement auto-cancelation, this value may be set to CancelScope.Uncancelable, which behaves as if all values F[A] are wrapped in an implicit "outer" uncancelable which cannot be polled. Most IO-like types will define this to be Cancelable.

Attributes

Inherited from:
GenSpawn
Source:
GenSpawn.scala
final def rootCancelScope: CancelScope

Indicates the default "root scope" semantics of the F in question. For types which do ''not'' implement auto-cancelation, this value may be set to CancelScope.Uncancelable, which behaves as if all values F[A] are wrapped in an implicit "outer" uncancelable which cannot be polled. Most IO-like types will define this to be Cancelable.

Indicates the default "root scope" semantics of the F in question. For types which do ''not'' implement auto-cancelation, this value may be set to CancelScope.Uncancelable, which behaves as if all values F[A] are wrapped in an implicit "outer" uncancelable which cannot be polled. Most IO-like types will define this to be Cancelable.

Attributes

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def sleep(time: Duration): F[Unit]
Implicitly added by asyncForEitherT

Semantically block the fiber for the specified duration.

Semantically block the fiber for the specified duration.

Attributes

time

The duration to semantically block for

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def sleep(time: Duration): F[Unit]
Implicitly added by asyncForKleisli

Semantically block the fiber for the specified duration.

Semantically block the fiber for the specified duration.

Attributes

time

The duration to semantically block for

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def sleep(time: Duration): F[Unit]
Implicitly added by asyncForOptionT

Semantically block the fiber for the specified duration.

Semantically block the fiber for the specified duration.

Attributes

time

The duration to semantically block for

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def sleep(time: Duration): F[Unit]

Semantically block the fiber for the specified duration.

Semantically block the fiber for the specified duration.

Attributes

time

The duration to semantically block for

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def start[A](fa: F[A]): F[Fiber[F, E, A]]
Implicitly added by asyncForEitherT

A low-level primitive for starting the concurrent evaluation of a fiber. Returns a Fiber that can be used to wait for a fiber or cancel it.

A low-level primitive for starting the concurrent evaluation of a fiber. Returns a Fiber that can be used to wait for a fiber or cancel it.

start is a cancelation-unsafe function; it is recommended to use the safer variant, background, to spawn fibers.

Attributes

fa

the effect for the fiber

See also:

background for the safer, recommended variant

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def start[A](fa: F[A]): F[Fiber[F, E, A]]
Implicitly added by asyncForKleisli

A low-level primitive for starting the concurrent evaluation of a fiber. Returns a Fiber that can be used to wait for a fiber or cancel it.

A low-level primitive for starting the concurrent evaluation of a fiber. Returns a Fiber that can be used to wait for a fiber or cancel it.

start is a cancelation-unsafe function; it is recommended to use the safer variant, background, to spawn fibers.

Attributes

fa

the effect for the fiber

See also:

background for the safer, recommended variant

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def start[A](fa: F[A]): F[Fiber[F, E, A]]
Implicitly added by asyncForOptionT

A low-level primitive for starting the concurrent evaluation of a fiber. Returns a Fiber that can be used to wait for a fiber or cancel it.

A low-level primitive for starting the concurrent evaluation of a fiber. Returns a Fiber that can be used to wait for a fiber or cancel it.

start is a cancelation-unsafe function; it is recommended to use the safer variant, background, to spawn fibers.

Attributes

fa

the effect for the fiber

See also:

background for the safer, recommended variant

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def start[A](fa: F[A]): F[Fiber[F, E, A]]

A low-level primitive for starting the concurrent evaluation of a fiber. Returns a Fiber that can be used to wait for a fiber or cancel it.

A low-level primitive for starting the concurrent evaluation of a fiber. Returns a Fiber that can be used to wait for a fiber or cancel it.

start is a cancelation-unsafe function; it is recommended to use the safer variant, background, to spawn fibers.

Attributes

fa

the effect for the fiber

See also:

background for the safer, recommended variant

Inherited from:
GenSpawn
Source:
GenSpawn.scala
def suspend[A](hint: Type)(thunk: => A): F[A]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
Sync
Source:
Sync.scala
def suspend[A](hint: Type)(thunk: => A): F[A]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
Sync
Source:
Sync.scala
def suspend[A](hint: Type)(thunk: => A): F[A]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
Sync
Source:
Sync.scala
def suspend[A](hint: Type)(thunk: => A): F[A]

Attributes

Inherited from:
Sync
Source:
Sync.scala
def tailRecM[A, B](a: A)(f: A => F[Either[A, B]]): F[B]
Implicitly added by asyncForEitherT

Keeps calling f until a scala.util.Right[B] is returned.

Keeps calling f until a scala.util.Right[B] is returned.

Based on Phil Freeman's Stack Safety for Free.

Implementations of this method should use constant stack space relative to f.

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def tailRecM[A, B](a: A)(f: A => F[Either[A, B]]): F[B]
Implicitly added by asyncForKleisli

Keeps calling f until a scala.util.Right[B] is returned.

Keeps calling f until a scala.util.Right[B] is returned.

Based on Phil Freeman's Stack Safety for Free.

Implementations of this method should use constant stack space relative to f.

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def tailRecM[A, B](a: A)(f: A => F[Either[A, B]]): F[B]
Implicitly added by asyncForOptionT

Keeps calling f until a scala.util.Right[B] is returned.

Keeps calling f until a scala.util.Right[B] is returned.

Based on Phil Freeman's Stack Safety for Free.

Implementations of this method should use constant stack space relative to f.

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
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.

Keeps calling f until a scala.util.Right[B] is returned.

Based on Phil Freeman's Stack Safety for Free.

Implementations of this method should use constant stack space relative to f.

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def timed[A](fa: F[A]): F[(FiniteDuration, A)]
Implicitly added by asyncForEitherT

Returns an effect that completes with the result of the source together with the duration that it took to complete.

Returns an effect that completes with the result of the source together with the duration that it took to complete.

Attributes

fa

The effect which we wish to time the execution of

Inherited from:
Clock
Source:
Clock.scala
def timed[A](fa: F[A]): F[(FiniteDuration, A)]
Implicitly added by asyncForKleisli

Returns an effect that completes with the result of the source together with the duration that it took to complete.

Returns an effect that completes with the result of the source together with the duration that it took to complete.

Attributes

fa

The effect which we wish to time the execution of

Inherited from:
Clock
Source:
Clock.scala
def timed[A](fa: F[A]): F[(FiniteDuration, A)]
Implicitly added by asyncForOptionT

Returns an effect that completes with the result of the source together with the duration that it took to complete.

Returns an effect that completes with the result of the source together with the duration that it took to complete.

Attributes

fa

The effect which we wish to time the execution of

Inherited from:
Clock
Source:
Clock.scala
def timed[A](fa: F[A]): F[(FiniteDuration, A)]

Returns an effect that completes with the result of the source together with the duration that it took to complete.

Returns an effect that completes with the result of the source together with the duration that it took to complete.

Attributes

fa

The effect which we wish to time the execution of

Inherited from:
Clock
Source:
Clock.scala
def timeout[A](fa: F[A], duration: Duration)(implicit ev: TimeoutException <:< Throwable): F[A]
Implicitly added by asyncForEitherT

Returns an effect that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

Returns an effect that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

The source is canceled in the event that it takes longer than the specified time duration to complete. Once the source has been successfully canceled (and has completed its finalizers), the TimeoutException will be raised. If the source is uncancelable, the resulting effect will wait for it to complete before raising the exception.

Attributes

duration

The time span for which we wait for the source to complete; in the event that the specified time has passed without the source completing, a TimeoutException is raised

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def timeout[A](fa: F[A], duration: Duration)(implicit ev: TimeoutException <:< Throwable): F[A]
Implicitly added by asyncForKleisli

Returns an effect that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

Returns an effect that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

The source is canceled in the event that it takes longer than the specified time duration to complete. Once the source has been successfully canceled (and has completed its finalizers), the TimeoutException will be raised. If the source is uncancelable, the resulting effect will wait for it to complete before raising the exception.

Attributes

duration

The time span for which we wait for the source to complete; in the event that the specified time has passed without the source completing, a TimeoutException is raised

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def timeout[A](fa: F[A], duration: Duration)(implicit ev: TimeoutException <:< Throwable): F[A]
Implicitly added by asyncForOptionT

Returns an effect that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

Returns an effect that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

The source is canceled in the event that it takes longer than the specified time duration to complete. Once the source has been successfully canceled (and has completed its finalizers), the TimeoutException will be raised. If the source is uncancelable, the resulting effect will wait for it to complete before raising the exception.

Attributes

duration

The time span for which we wait for the source to complete; in the event that the specified time has passed without the source completing, a TimeoutException is raised

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def timeout[A](fa: F[A], duration: Duration)(implicit ev: TimeoutException <:< Throwable): F[A]

Returns an effect that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

Returns an effect that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

The source is canceled in the event that it takes longer than the specified time duration to complete. Once the source has been successfully canceled (and has completed its finalizers), the TimeoutException will be raised. If the source is uncancelable, the resulting effect will wait for it to complete before raising the exception.

Attributes

duration

The time span for which we wait for the source to complete; in the event that the specified time has passed without the source completing, a TimeoutException is raised

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def timeoutAndForget[A](fa: F[A], duration: Duration)(implicit ev: TimeoutException <:< Throwable): F[A]
Implicitly added by asyncForEitherT

Returns an effect that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

Returns an effect that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

The source is canceled in the event that it takes longer than the specified time duration to complete. Unlike [[timeoutA* timeout]], the cancelation of the source will be ''requested'' but not awaited, and the exception will be raised immediately upon the completion of the timer. This may more closely match intuitions about timeouts, but it also violates backpressure guarantees and intentionally leaks fibers.

This combinator should be applied very carefully.

Attributes

duration

The time span for which we wait for the source to complete; in the event that the specified time has passed without the source completing, a TimeoutException is raised

See also:

[[timeoutA* timeout]] for a variant which respects backpressure and does not leak fibers

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def timeoutAndForget[A](fa: F[A], duration: Duration)(implicit ev: TimeoutException <:< Throwable): F[A]
Implicitly added by asyncForKleisli

Returns an effect that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

Returns an effect that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

The source is canceled in the event that it takes longer than the specified time duration to complete. Unlike [[timeoutA* timeout]], the cancelation of the source will be ''requested'' but not awaited, and the exception will be raised immediately upon the completion of the timer. This may more closely match intuitions about timeouts, but it also violates backpressure guarantees and intentionally leaks fibers.

This combinator should be applied very carefully.

Attributes

duration

The time span for which we wait for the source to complete; in the event that the specified time has passed without the source completing, a TimeoutException is raised

See also:

[[timeoutA* timeout]] for a variant which respects backpressure and does not leak fibers

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def timeoutAndForget[A](fa: F[A], duration: Duration)(implicit ev: TimeoutException <:< Throwable): F[A]
Implicitly added by asyncForOptionT

Returns an effect that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

Returns an effect that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

The source is canceled in the event that it takes longer than the specified time duration to complete. Unlike [[timeoutA* timeout]], the cancelation of the source will be ''requested'' but not awaited, and the exception will be raised immediately upon the completion of the timer. This may more closely match intuitions about timeouts, but it also violates backpressure guarantees and intentionally leaks fibers.

This combinator should be applied very carefully.

Attributes

duration

The time span for which we wait for the source to complete; in the event that the specified time has passed without the source completing, a TimeoutException is raised

See also:

[[timeoutA* timeout]] for a variant which respects backpressure and does not leak fibers

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def timeoutAndForget[A](fa: F[A], duration: Duration)(implicit ev: TimeoutException <:< Throwable): F[A]

Returns an effect that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

Returns an effect that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

The source is canceled in the event that it takes longer than the specified time duration to complete. Unlike [[timeoutA* timeout]], the cancelation of the source will be ''requested'' but not awaited, and the exception will be raised immediately upon the completion of the timer. This may more closely match intuitions about timeouts, but it also violates backpressure guarantees and intentionally leaks fibers.

This combinator should be applied very carefully.

Attributes

duration

The time span for which we wait for the source to complete; in the event that the specified time has passed without the source completing, a TimeoutException is raised

See also:

[[timeoutA* timeout]] for a variant which respects backpressure and does not leak fibers

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def timeoutTo[A](fa: F[A], duration: Duration, fallback: F[A]): F[A]
Implicitly added by asyncForEitherT

Returns an effect that either completes with the result of the source within the specified time duration or otherwise evaluates the fallback.

Returns an effect that either completes with the result of the source within the specified time duration or otherwise evaluates the fallback.

The source is canceled in the event that it takes longer than the specified time duration to complete. Once the source has been successfully canceled (and has completed its finalizers), the fallback will be sequenced. If the source is uncancelable, the resulting effect will wait for it to complete before evaluating the fallback.

Attributes

duration

The time span for which we wait for the source to complete; in the event that the specified time has passed without the source completing, the fallback gets evaluated

fallback

The task evaluated after the duration has passed and the source canceled

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def timeoutTo[A](fa: F[A], duration: Duration, fallback: F[A]): F[A]
Implicitly added by asyncForKleisli

Returns an effect that either completes with the result of the source within the specified time duration or otherwise evaluates the fallback.

Returns an effect that either completes with the result of the source within the specified time duration or otherwise evaluates the fallback.

The source is canceled in the event that it takes longer than the specified time duration to complete. Once the source has been successfully canceled (and has completed its finalizers), the fallback will be sequenced. If the source is uncancelable, the resulting effect will wait for it to complete before evaluating the fallback.

Attributes

duration

The time span for which we wait for the source to complete; in the event that the specified time has passed without the source completing, the fallback gets evaluated

fallback

The task evaluated after the duration has passed and the source canceled

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def timeoutTo[A](fa: F[A], duration: Duration, fallback: F[A]): F[A]
Implicitly added by asyncForOptionT

Returns an effect that either completes with the result of the source within the specified time duration or otherwise evaluates the fallback.

Returns an effect that either completes with the result of the source within the specified time duration or otherwise evaluates the fallback.

The source is canceled in the event that it takes longer than the specified time duration to complete. Once the source has been successfully canceled (and has completed its finalizers), the fallback will be sequenced. If the source is uncancelable, the resulting effect will wait for it to complete before evaluating the fallback.

Attributes

duration

The time span for which we wait for the source to complete; in the event that the specified time has passed without the source completing, the fallback gets evaluated

fallback

The task evaluated after the duration has passed and the source canceled

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def timeoutTo[A](fa: F[A], duration: Duration, fallback: F[A]): F[A]

Returns an effect that either completes with the result of the source within the specified time duration or otherwise evaluates the fallback.

Returns an effect that either completes with the result of the source within the specified time duration or otherwise evaluates the fallback.

The source is canceled in the event that it takes longer than the specified time duration to complete. Once the source has been successfully canceled (and has completed its finalizers), the fallback will be sequenced. If the source is uncancelable, the resulting effect will wait for it to complete before evaluating the fallback.

Attributes

duration

The time span for which we wait for the source to complete; in the event that the specified time has passed without the source completing, the fallback gets evaluated

fallback

The task evaluated after the duration has passed and the source canceled

Inherited from:
GenTemporal
Source:
GenTemporal.scala
def tuple10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9](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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9](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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9](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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9](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)]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](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)]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](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)]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](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)]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](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)]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](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)]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](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)]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](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)]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](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)]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](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)]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple2[A, B](f1: F[A], f2: F[B]): F[(A, B)]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple2[A, B](f1: F[A], f2: F[B]): F[(A, B)]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple2[A, B](f1: F[A], f2: F[B]): F[(A, B)]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple2[A, B](f1: F[A], f2: F[B]): F[(A, B)]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](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)]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](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)]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](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)]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple3[A0, A1, A2](f0: F[A0], f1: F[A1], f2: F[A2]): F[(A0, A1, A2)]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple3[A0, A1, A2](f0: F[A0], f1: F[A1], f2: F[A2]): F[(A0, A1, A2)]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple3[A0, A1, A2](f0: F[A0], f1: F[A1], f2: F[A2]): F[(A0, A1, A2)]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple3[A0, A1, A2](f0: F[A0], f1: F[A1], f2: F[A2]): F[(A0, A1, A2)]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple4[A0, A1, A2, A3](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[(A0, A1, A2, A3)]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple4[A0, A1, A2, A3](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[(A0, A1, A2, A3)]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple4[A0, A1, A2, A3](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[(A0, A1, A2, A3)]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple4[A0, A1, A2, A3](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[(A0, A1, A2, A3)]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple5[A0, A1, A2, A3, A4](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[(A0, A1, A2, A3, A4)]
Implicitly added by asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple5[A0, A1, A2, A3, A4](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[(A0, A1, A2, A3, A4)]
Implicitly added by asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple5[A0, A1, A2, A3, A4](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[(A0, A1, A2, A3, A4)]
Implicitly added by asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple5[A0, A1, A2, A3, A4](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[(A0, A1, A2, A3, A4)]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple6[A0, A1, A2, A3, A4, A5](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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple6[A0, A1, A2, A3, A4, A5](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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple6[A0, A1, A2, A3, A4, A5](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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple6[A0, A1, A2, A3, A4, A5](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)]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple7[A0, A1, A2, A3, A4, A5, A6](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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple7[A0, A1, A2, A3, A4, A5, A6](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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple7[A0, A1, A2, A3, A4, A5, A6](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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple7[A0, A1, A2, A3, A4, A5, A6](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)]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple8[A0, A1, A2, A3, A4, A5, A6, A7](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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple8[A0, A1, A2, A3, A4, A5, A6, A7](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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple8[A0, A1, A2, A3, A4, A5, A6, A7](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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple8[A0, A1, A2, A3, A4, A5, A6, A7](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)]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple9[A0, A1, A2, A3, A4, A5, A6, A7, A8](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 asyncForEitherT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple9[A0, A1, A2, A3, A4, A5, A6, A7, A8](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 asyncForKleisli

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple9[A0, A1, A2, A3, A4, A5, A6, A7, A8](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 asyncForOptionT

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tuple9[A0, A1, A2, A3, A4, A5, A6, A7, A8](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)]

Attributes

Inherited from:
ApplyArityFunctions
Source:
ApplyArityFunctions.scala
def tupleLeft[A, B](fa: F[A], b: B): F[(B, A)]
Implicitly added by asyncForEitherT

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))

Attributes

Inherited from:
Functor
Source:
Functor.scala
def tupleLeft[A, B](fa: F[A], b: B): F[(B, A)]
Implicitly added by asyncForKleisli

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))

Attributes

Inherited from:
Functor
Source:
Functor.scala
def tupleLeft[A, B](fa: F[A], b: B): F[(B, A)]
Implicitly added by asyncForOptionT

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))

Attributes

Inherited from:
Functor
Source:
Functor.scala
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.

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))

Attributes

Inherited from:
Functor
Source:
Functor.scala
def tupleRight[A, B](fa: F[A], b: B): F[(A, B)]
Implicitly added by asyncForEitherT

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))

Attributes

Inherited from:
Functor
Source:
Functor.scala
def tupleRight[A, B](fa: F[A], b: B): F[(A, B)]
Implicitly added by asyncForKleisli

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))

Attributes

Inherited from:
Functor
Source:
Functor.scala
def tupleRight[A, B](fa: F[A], b: B): F[(A, B)]
Implicitly added by asyncForOptionT

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))

Attributes

Inherited from:
Functor
Source:
Functor.scala
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.

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))

Attributes

Inherited from:
Functor
Source:
Functor.scala
def uncancelable[A](body: Poll[F] => F[A]): F[A]
Implicitly added by asyncForEitherT

Masks cancelation on the current fiber. The argument to body of type Poll[F] is a natural transformation F ~> F that enables polling. Polling causes a fiber to unmask within a masked region so that cancelation can be observed again.

Masks cancelation on the current fiber. The argument to body of type Poll[F] is a natural transformation F ~> F that enables polling. Polling causes a fiber to unmask within a masked region so that cancelation can be observed again.

In the following example, cancelation can be observed only within fb and nowhere else:


 F.uncancelable { poll =>
   fa *> poll(fb) *> fc
 }

If a fiber is canceled while it is masked, the cancelation is suppressed for as long as the fiber remains masked. Whenever the fiber is completely unmasked again, the cancelation will be respected.

Masks can also be stacked or nested within each other. If multiple masks are active, all masks must be undone so that cancelation can be observed. In order to completely unmask within a multi-masked region the poll corresponding to each mask must be applied to the effect, outermost-first.


 F.uncancelable { p1 =>
   F.uncancelable { p2 =>
     fa *> p2(p1(fb)) *> fc
   }
 }

The following operations are no-ops:

  1. Polling in the wrong order
  2. Subsequent polls when applying the same poll more than once: poll(poll(fa)) is equivalent to poll(fa)
  3. Applying a poll bound to one fiber within another fiber

Attributes

body

A function which takes a Poll and returns the effect that we wish to make uncancelable.

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def uncancelable[A](body: Poll[F] => F[A]): F[A]
Implicitly added by asyncForKleisli

Masks cancelation on the current fiber. The argument to body of type Poll[F] is a natural transformation F ~> F that enables polling. Polling causes a fiber to unmask within a masked region so that cancelation can be observed again.

Masks cancelation on the current fiber. The argument to body of type Poll[F] is a natural transformation F ~> F that enables polling. Polling causes a fiber to unmask within a masked region so that cancelation can be observed again.

In the following example, cancelation can be observed only within fb and nowhere else:


 F.uncancelable { poll =>
   fa *> poll(fb) *> fc
 }

If a fiber is canceled while it is masked, the cancelation is suppressed for as long as the fiber remains masked. Whenever the fiber is completely unmasked again, the cancelation will be respected.

Masks can also be stacked or nested within each other. If multiple masks are active, all masks must be undone so that cancelation can be observed. In order to completely unmask within a multi-masked region the poll corresponding to each mask must be applied to the effect, outermost-first.


 F.uncancelable { p1 =>
   F.uncancelable { p2 =>
     fa *> p2(p1(fb)) *> fc
   }
 }

The following operations are no-ops:

  1. Polling in the wrong order
  2. Subsequent polls when applying the same poll more than once: poll(poll(fa)) is equivalent to poll(fa)
  3. Applying a poll bound to one fiber within another fiber

Attributes

body

A function which takes a Poll and returns the effect that we wish to make uncancelable.

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def uncancelable[A](body: Poll[F] => F[A]): F[A]
Implicitly added by asyncForOptionT

Masks cancelation on the current fiber. The argument to body of type Poll[F] is a natural transformation F ~> F that enables polling. Polling causes a fiber to unmask within a masked region so that cancelation can be observed again.

Masks cancelation on the current fiber. The argument to body of type Poll[F] is a natural transformation F ~> F that enables polling. Polling causes a fiber to unmask within a masked region so that cancelation can be observed again.

In the following example, cancelation can be observed only within fb and nowhere else:


 F.uncancelable { poll =>
   fa *> poll(fb) *> fc
 }

If a fiber is canceled while it is masked, the cancelation is suppressed for as long as the fiber remains masked. Whenever the fiber is completely unmasked again, the cancelation will be respected.

Masks can also be stacked or nested within each other. If multiple masks are active, all masks must be undone so that cancelation can be observed. In order to completely unmask within a multi-masked region the poll corresponding to each mask must be applied to the effect, outermost-first.


 F.uncancelable { p1 =>
   F.uncancelable { p2 =>
     fa *> p2(p1(fb)) *> fc
   }
 }

The following operations are no-ops:

  1. Polling in the wrong order
  2. Subsequent polls when applying the same poll more than once: poll(poll(fa)) is equivalent to poll(fa)
  3. Applying a poll bound to one fiber within another fiber

Attributes

body

A function which takes a Poll and returns the effect that we wish to make uncancelable.

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def uncancelable[A](body: Poll[F] => F[A]): F[A]

Masks cancelation on the current fiber. The argument to body of type Poll[F] is a natural transformation F ~> F that enables polling. Polling causes a fiber to unmask within a masked region so that cancelation can be observed again.

Masks cancelation on the current fiber. The argument to body of type Poll[F] is a natural transformation F ~> F that enables polling. Polling causes a fiber to unmask within a masked region so that cancelation can be observed again.

In the following example, cancelation can be observed only within fb and nowhere else:


 F.uncancelable { poll =>
   fa *> poll(fb) *> fc
 }

If a fiber is canceled while it is masked, the cancelation is suppressed for as long as the fiber remains masked. Whenever the fiber is completely unmasked again, the cancelation will be respected.

Masks can also be stacked or nested within each other. If multiple masks are active, all masks must be undone so that cancelation can be observed. In order to completely unmask within a multi-masked region the poll corresponding to each mask must be applied to the effect, outermost-first.


 F.uncancelable { p1 =>
   F.uncancelable { p2 =>
     fa *> p2(p1(fb)) *> fc
   }
 }

The following operations are no-ops:

  1. Polling in the wrong order
  2. Subsequent polls when applying the same poll more than once: poll(poll(fa)) is equivalent to poll(fa)
  3. Applying a poll bound to one fiber within another fiber

Attributes

body

A function which takes a Poll and returns the effect that we wish to make uncancelable.

Inherited from:
MonadCancel
Source:
MonadCancel.scala
def unique: F[Token]
Implicitly added by asyncForEitherT

Yields a value that is guaranteed to be unique ie (F.unique, F.unique).mapN(_ =!= _)

Yields a value that is guaranteed to be unique ie (F.unique, F.unique).mapN(_ =!= _)

Attributes

Inherited from:
Sync
Source:
Sync.scala
def unique: F[Token]
Implicitly added by asyncForKleisli

Yields a value that is guaranteed to be unique ie (F.unique, F.unique).mapN(_ =!= _)

Yields a value that is guaranteed to be unique ie (F.unique, F.unique).mapN(_ =!= _)

Attributes

Inherited from:
Sync
Source:
Sync.scala
def unique: F[Token]
Implicitly added by asyncForOptionT

Yields a value that is guaranteed to be unique ie (F.unique, F.unique).mapN(_ =!= _)

Yields a value that is guaranteed to be unique ie (F.unique, F.unique).mapN(_ =!= _)

Attributes

Inherited from:
Sync
Source:
Sync.scala
def unique: F[Token]

Yields a value that is guaranteed to be unique ie (F.unique, F.unique).mapN(_ =!= _)

Yields a value that is guaranteed to be unique ie (F.unique, F.unique).mapN(_ =!= _)

Attributes

Inherited from:
Sync
Source:
Sync.scala
def unit: F[Unit]
Implicitly added by asyncForEitherT

Returns an F[Unit] value, equivalent with pure(()).

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 val).

Example:

scala> import cats.implicits._

scala> Applicative[Option].unit
res0: Option[Unit] = Some(())

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def unit: F[Unit]
Implicitly added by asyncForKleisli

Returns an F[Unit] value, equivalent with pure(()).

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 val).

Example:

scala> import cats.implicits._

scala> Applicative[Option].unit
res0: Option[Unit] = Some(())

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def unit: F[Unit]
Implicitly added by asyncForOptionT

Returns an F[Unit] value, equivalent with pure(()).

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 val).

Example:

scala> import cats.implicits._

scala> Applicative[Option].unit
res0: Option[Unit] = Some(())

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def unit: F[Unit]

Returns an F[Unit] value, equivalent with pure(()).

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 val).

Example:

scala> import cats.implicits._

scala> Applicative[Option].unit
res0: Option[Unit] = Some(())

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def unlessA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by asyncForEitherT

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()

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def unlessA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by asyncForKleisli

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()

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def unlessA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by asyncForOptionT

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()

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def unlessA[A](cond: Boolean)(f: => F[A]): F[Unit]

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()

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def untilDefinedM[A](foa: F[Option[A]]): F[A]
Implicitly added by asyncForEitherT

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.

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def untilDefinedM[A](foa: F[Option[A]]): F[A]
Implicitly added by asyncForKleisli

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.

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def untilDefinedM[A](foa: F[Option[A]]): F[A]
Implicitly added by asyncForOptionT

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.

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
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.

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.

Attributes

Inherited from:
FlatMap
Source:
FlatMap.scala
def untilM[G[_], A](f: F[A])(cond: => F[Boolean])(implicit G: Alternative[G]): F[G[A]]
Implicitly added by asyncForEitherT

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def untilM[G[_], A](f: F[A])(cond: => F[Boolean])(implicit G: Alternative[G]): F[G[A]]
Implicitly added by asyncForKleisli

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def untilM[G[_], A](f: F[A])(cond: => F[Boolean])(implicit G: Alternative[G]): F[G[A]]
Implicitly added by asyncForOptionT

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def untilM[G[_], A](f: F[A])(cond: => F[Boolean])(implicit G: Alternative[G]): F[G[A]]

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def untilM_[A](f: F[A])(cond: => F[Boolean]): F[Unit]
Implicitly added by asyncForEitherT

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def untilM_[A](f: F[A])(cond: => F[Boolean]): F[Unit]
Implicitly added by asyncForKleisli

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def untilM_[A](f: F[A])(cond: => F[Boolean]): F[Unit]
Implicitly added by asyncForOptionT

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def untilM_[A](f: F[A])(cond: => F[Boolean]): F[Unit]

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def unzip[A, B](fab: F[(A, B)]): (F[A], F[B])
Implicitly added by asyncForEitherT

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))

Attributes

Inherited from:
Functor
Source:
Functor.scala
def unzip[A, B](fab: F[(A, B)]): (F[A], F[B])
Implicitly added by asyncForKleisli

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))

Attributes

Inherited from:
Functor
Source:
Functor.scala
def unzip[A, B](fab: F[(A, B)]): (F[A], F[B])
Implicitly added by asyncForOptionT

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))

Attributes

Inherited from:
Functor
Source:
Functor.scala
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.

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))

Attributes

Inherited from:
Functor
Source:
Functor.scala
def void[A](fa: F[A]): F[Unit]
Implicitly added by asyncForEitherT

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((), (), ())

Attributes

Inherited from:
Functor
Source:
Functor.scala
def void[A](fa: F[A]): F[Unit]
Implicitly added by asyncForKleisli

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((), (), ())

Attributes

Inherited from:
Functor
Source:
Functor.scala
def void[A](fa: F[A]): F[Unit]
Implicitly added by asyncForOptionT

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((), (), ())

Attributes

Inherited from:
Functor
Source:
Functor.scala
def void[A](fa: F[A]): F[Unit]

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((), (), ())

Attributes

Inherited from:
Functor
Source:
Functor.scala
def voidError(fu: F[Unit]): F[Unit]
Implicitly added by asyncForEitherT

Void any error, by mapping it to Unit.

Void any error, by mapping it to Unit.

This is useful when errors are reported via a side-channel but not directly handled. For example in Cats Effect:

IO.deferred[OutcomeIO[A]].flatMap { oc =>
 ioa.guaranteeCase(oc.complete(_).void).void.voidError.start
 // ...
}

Without the .voidError, the Cats Effect runtime would consider an error in ioa to be unhandled and elevate it to ExecutionContext#reportFailure.

Attributes

See also:

handleError to map to an A value instead of Unit.

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def voidError(fu: F[Unit]): F[Unit]
Implicitly added by asyncForKleisli

Void any error, by mapping it to Unit.

Void any error, by mapping it to Unit.

This is useful when errors are reported via a side-channel but not directly handled. For example in Cats Effect:

IO.deferred[OutcomeIO[A]].flatMap { oc =>
 ioa.guaranteeCase(oc.complete(_).void).void.voidError.start
 // ...
}

Without the .voidError, the Cats Effect runtime would consider an error in ioa to be unhandled and elevate it to ExecutionContext#reportFailure.

Attributes

See also:

handleError to map to an A value instead of Unit.

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def voidError(fu: F[Unit]): F[Unit]
Implicitly added by asyncForOptionT

Void any error, by mapping it to Unit.

Void any error, by mapping it to Unit.

This is useful when errors are reported via a side-channel but not directly handled. For example in Cats Effect:

IO.deferred[OutcomeIO[A]].flatMap { oc =>
 ioa.guaranteeCase(oc.complete(_).void).void.voidError.start
 // ...
}

Without the .voidError, the Cats Effect runtime would consider an error in ioa to be unhandled and elevate it to ExecutionContext#reportFailure.

Attributes

See also:

handleError to map to an A value instead of Unit.

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def voidError(fu: F[Unit]): F[Unit]

Void any error, by mapping it to Unit.

Void any error, by mapping it to Unit.

This is useful when errors are reported via a side-channel but not directly handled. For example in Cats Effect:

IO.deferred[OutcomeIO[A]].flatMap { oc =>
 ioa.guaranteeCase(oc.complete(_).void).void.voidError.start
 // ...
}

Without the .voidError, the Cats Effect runtime would consider an error in ioa to be unhandled and elevate it to ExecutionContext#reportFailure.

Attributes

See also:

handleError to map to an A value instead of Unit.

Inherited from:
ApplicativeError
Source:
ApplicativeError.scala
def whenA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by asyncForEitherT

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(())

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def whenA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by asyncForKleisli

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(())

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def whenA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by asyncForOptionT

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(())

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def whenA[A](cond: Boolean)(f: => F[A]): F[Unit]

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(())

Attributes

Inherited from:
Applicative
Source:
Applicative.scala
def whileM[G[_], A](p: F[Boolean])(body: => F[A])(implicit G: Alternative[G]): F[G[A]]
Implicitly added by asyncForEitherT

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def whileM[G[_], A](p: F[Boolean])(body: => F[A])(implicit G: Alternative[G]): F[G[A]]
Implicitly added by asyncForKleisli

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def whileM[G[_], A](p: F[Boolean])(body: => F[A])(implicit G: Alternative[G]): F[G[A]]
Implicitly added by asyncForOptionT

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def whileM[G[_], A](p: F[Boolean])(body: => F[A])(implicit G: Alternative[G]): F[G[A]]

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def whileM_[A](p: F[Boolean])(body: => F[A]): F[Unit]
Implicitly added by asyncForEitherT

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def whileM_[A](p: F[Boolean])(body: => F[A]): F[Unit]
Implicitly added by asyncForKleisli

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def whileM_[A](p: F[Boolean])(body: => F[A]): F[Unit]
Implicitly added by asyncForOptionT

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def whileM_[A](p: F[Boolean])(body: => F[A]): F[Unit]

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.

Attributes

Inherited from:
Monad
Source:
Monad.scala
def widen[A, B >: A](fa: F[A]): F[B]
Implicitly added by asyncForEitherT

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)

Attributes

Inherited from:
Functor
Source:
Functor.scala
def widen[A, B >: A](fa: F[A]): F[B]
Implicitly added by asyncForKleisli

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)

Attributes

Inherited from:
Functor
Source:
Functor.scala
def widen[A, B >: A](fa: F[A]): F[B]
Implicitly added by asyncForOptionT

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)

Attributes

Inherited from:
Functor
Source:
Functor.scala
def widen[A, B >: A](fa: F[A]): F[B]

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)

Attributes

Inherited from:
Functor
Source:
Functor.scala

Deprecated and Inherited methods

def ifA[A](fcond: F[Boolean])(ifTrue: F[A], ifFalse: F[A]): F[A]
Implicitly added by asyncForEitherT

Attributes

Deprecated
true
Inherited from:
Apply
Source:
Apply.scala
def ifA[A](fcond: F[Boolean])(ifTrue: F[A], ifFalse: F[A]): F[A]
Implicitly added by asyncForKleisli

Attributes

Deprecated
true
Inherited from:
Apply
Source:
Apply.scala
def ifA[A](fcond: F[Boolean])(ifTrue: F[A], ifFalse: F[A]): F[A]
Implicitly added by asyncForOptionT

Attributes

Deprecated
true
Inherited from:
Apply
Source:
Apply.scala
def ifA[A](fcond: F[Boolean])(ifTrue: F[A], ifFalse: F[A]): F[A]

Attributes

Deprecated
true
Inherited from:
Apply
Source:
Apply.scala
Generated with
© 2002-2021 · LAMP/EPFL
© 2002-2021 · LAMP/EPFL