cats-effect-kernel/cats.effect.kernel/MonadCancel

MonadCancel

trait MonadCancel[F[_], E] extends MonadError[F, E]

A typeclass that characterizes monads which support safe cancelation, masking, and finalization. MonadCancel extends the capabilities of cats.MonadError, so an instance of this typeclass must also provide a lawful instance for cats.MonadError.

==Fibers==

A fiber is a sequence of effects which are bound together by flatMap. The execution of a fiber of an effect F[E, A] terminates with one of three outcomes, which are encoded by the datatype Outcome:

  1. Outcome.Succeeded: indicates success with a value of type A
  2. Outcome.Errored: indicates failure with a value of type E
  3. Outcome.Canceled: indicates abnormal termination

Additionally, a fiber may never produce an outcome, in which case it is said to be non-terminating.

==Cancelation==

Cancelation refers to the act of requesting that the execution of a fiber be abnormally terminated. MonadCancel exposes a means of self-cancelation, with which a fiber can request that its own execution be terminated. Self-cancelation is achieved via canceled.

Cancelation is vaguely similar to the short-circuiting behavior introduced by cats.MonadError, but there are several key differences:

  1. Cancelation is effective; if it is observed it must be respected, and it cannot be reversed. In contrast, handleError exposes the ability to catch and recover from errors, and then proceed with normal execution.
  2. Cancelation can be masked via MonadCancel!.uncancelable. Masking is discussed in the next section.
  3. GenSpawn introduces external cancelation, another cancelation mechanism by which fibers can be canceled by external parties.

==Masking==

Masking allows a fiber to suppress cancelation for a period of time, which is achieved via uncancelable. If a fiber is canceled while it is masked, the cancelation is suppressed for as long as the fiber remains masked. Once the fiber reaches a completely unmasked state, it responds to the cancelation.

While a fiber is masked, it may optionally unmask by "polling", rendering itself cancelable again.


 F.uncancelable { poll =>
   // can only observe cancelation within `fb`
   fa *> poll(fb) *> fc
 }

These semantics allow users to precisely mark what regions of code are cancelable within a larger code block.

==Cancelation Boundaries===

A boundary corresponds to an iteration of the internal runloop. In general they are introduced by any of the combinators from the cats/cats effect hierarchy (map, flatMap, handleErrorWith, attempt, etc).

A cancelation boundary is a boundary where the cancelation status of a fiber may be checked and hence cancelation observed. Note that in general you cannot guarantee that cancelation will be observed at a given boundary. However, in the absence of masking it will be observed eventually.

With a small number of exceptions covered below, all boundaries are cancelable boundaries ie cancelation may be observed before the invocation of any combinator.

 fa
   .flatMap(f)
   .handleErrorWith(g)
   .map(h)

If the fiber above is canceled then the cancelation status may be checked and the execution terminated between any of the combinators.

As noted above, there are some boundaries which are not cancelable boundaries:

  1. Any boundary inside uncancelable and not inside poll. This is the definition of masking as above.
 F.uncancelable( _ =>
   fa
     .flatMap(f)
     .handleErrorWith(g)
     .map(h)
 )

None of the boundaries above are cancelation boundaries as cancelation is masked.

  1. The boundary after uncancelable
 F.uncancelable(poll => foo(poll)).flatMap(f)

It is guaranteed that we will not observe cancelation after uncancelable and hence flatMap(f) will be invoked. This is necessary for uncancelable to compose. Consider for example Resource#allocated

 def allocated[B >: A](implicit F: MonadCancel[F, Throwable]): F[(B, F[Unit])]

which returns a tuple of the resource and a finalizer which needs to be invoked to clean-up once the resource is no longer needed. The implementation of allocated can make sure it is safe by appropriate use of uncancelable. However, if it were possible to observe cancelation on the boundary directly after allocated then we would have a leak as the caller would be unable to ensure that the finalizer is invoked. In other words, the safety of allocated and the safety of f would not guarantee the safety of the composition allocated.flatMap(f).

This does however mean that we violate the functor law that fa.map(identity) <-> fa as

 F.uncancelable(_ => fa).onCancel(fin)  <-!-> F.uncancelable(_ => fa).map(identity).onCancel(fin)

as cancelation may be observed before the onCancel on the RHS. The justification is that cancelation is a hint rather than a mandate and so enshrining its behaviour in laws will always be awkward. Given this, it is better to pick a semantic that allows safe composition of regions.

  1. The boundary after poll
 F.uncancelable(poll => poll(fa).flatMap(f))

If fa completes successfully then cancelation may not be observed after poll but before flatMap. The reasoning is similar to above - if fa has successfully produced a value then the caller should have the opportunity to observe the value and ensure finalizers are in-place, etc.

==Finalization==

Finalization refers to the act of running finalizers in response to a cancelation. Finalizers are those effects whose evaluation is guaranteed in the event of cancelation. After a fiber has completed finalization, it terminates with an outcome of Canceled.

Finalizers can be registered to a fiber for the duration of some effect via onCancel. If a fiber is canceled while running that effect, the registered finalizer is guaranteed to be run before terminating.

==Bracket pattern==

The aforementioned concepts work together to unlock a powerful pattern for safely interacting with effectful lifecycles: the bracket pattern. This is analogous to the try-with-resources/finally construct in Java.

A lifecycle refers to a pair of actions, which are called the acquisition action and the release action respectively. The relationship between these two actions is that if the former completes successfully, then the latter is guaranteed to be run eventually, even in the presence of errors and cancelation. While the lifecycle is active, other work can be performed, but this invariant is always respected.

The bracket pattern is an invaluable tool for safely handling resource lifecycles. Imagine an application that opens network connections to a database server to do work. If a task in the application is canceled while it holds an open database connection, the connection would never be released or returned to a pool, causing a resource leak.

To illustrate the compositional nature of MonadCancel and its combinators, the implementation of bracket is shown below:


 def bracket[A, B](acquire: F[A])(use: A => F[B])(release: A => F[Unit]): F[B] =
   uncancelable { poll =>
     flatMap(acquire) { a =>
       val finalized = onCancel(poll(use(a)), release(a).uncancelable)
       val handled = onError(finalized) { case e => void(attempt(release(a).uncancelable)) }
       flatMap(handled)(b => as(attempt(release(a).uncancelable), b))
     }
   }

See bracketCase and bracketFull for other variants of the bracket pattern. If more specialized behavior is necessary, it is recommended to use uncancelable and onCancel directly.

Companion
object
trait MonadError[F, E]
trait Monad[F]
trait FlatMap[F]
trait ApplicativeError[F, E]
trait Applicative[F]
trait InvariantMonoidal[F]
trait Apply[F]
trait ApplyArityFunctions[F]
trait InvariantSemigroupal[F]
trait Semigroupal[F]
trait Functor[F]
trait Invariant[F]
trait Serializable
class Object
trait Matchable
class Any
trait GenSpawn[F, E]
trait GenConcurrent[F, E]
trait GenTemporal[F, E]
trait Sync[F]
trait Async[F]

Value members

Abstract methods

def canceled: F[Unit]
Implicitly added by monadCancelForOptionT

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

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

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.


 F.uncancelable { _ =>
   F.canceled *> fa
 } *> fb
def canceled: F[Unit]
Implicitly added by monadCancelForEitherT

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

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

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.


 F.uncancelable { _ =>
   F.canceled *> fa
 } *> fb
def canceled: F[Unit]
Implicitly added by monadCancelForKleisli

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

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

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.


 F.uncancelable { _ =>
   F.canceled *> fa
 } *> fb
def canceled: F[Unit]
Implicitly added by monadCancelForStateT

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

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

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.


 F.uncancelable { _ =>
   F.canceled *> fa
 } *> fb
def canceled: F[Unit]

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

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

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.


 F.uncancelable { _ =>
   F.canceled *> fa
 } *> fb
def forceR[A, B](fa: F[A])(fb: F[B]): F[B]
Implicitly added by monadCancelForOptionT

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

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

def forceR[A, B](fa: F[A])(fb: F[B]): F[B]
Implicitly added by monadCancelForEitherT

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

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

def forceR[A, B](fa: F[A])(fb: F[B]): F[B]
Implicitly added by monadCancelForKleisli

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

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

def forceR[A, B](fa: F[A])(fb: F[B]): F[B]
Implicitly added by monadCancelForStateT

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

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

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.

def onCancel[A](fa: F[A], fin: F[Unit]): F[A]
Implicitly added by monadCancelForOptionT

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.

Value Params
fa

The effect that is evaluated after fin is registered.

fin

The finalizer to register before evaluating fa.

def onCancel[A](fa: F[A], fin: F[Unit]): F[A]
Implicitly added by monadCancelForEitherT

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.

Value Params
fa

The effect that is evaluated after fin is registered.

fin

The finalizer to register before evaluating fa.

def onCancel[A](fa: F[A], fin: F[Unit]): F[A]
Implicitly added by monadCancelForKleisli

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.

Value Params
fa

The effect that is evaluated after fin is registered.

fin

The finalizer to register before evaluating fa.

def onCancel[A](fa: F[A], fin: F[Unit]): F[A]
Implicitly added by monadCancelForStateT

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.

Value Params
fa

The effect that is evaluated after fin is registered.

fin

The finalizer to register before evaluating fa.

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.

Value Params
fa

The effect that is evaluated after fin is registered.

fin

The finalizer to register before evaluating fa.

def rootCancelScope: CancelScope
Implicitly added by monadCancelForOptionT

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.

def rootCancelScope: CancelScope
Implicitly added by monadCancelForEitherT

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.

def rootCancelScope: CancelScope
Implicitly added by monadCancelForKleisli

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.

def rootCancelScope: CancelScope
Implicitly added by monadCancelForStateT

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.

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.

def uncancelable[A](body: Poll[F] => F[A]): F[A]
Implicitly added by monadCancelForOptionT

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, innermost-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. Applying the same poll more than once: poll(poll(fa))
  3. Applying a poll bound to one fiber within another fiber
Value Params
body

A function which takes a Poll and returns the effect that we wish to make uncancelable.

def uncancelable[A](body: Poll[F] => F[A]): F[A]
Implicitly added by monadCancelForEitherT

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, innermost-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. Applying the same poll more than once: poll(poll(fa))
  3. Applying a poll bound to one fiber within another fiber
Value Params
body

A function which takes a Poll and returns the effect that we wish to make uncancelable.

def uncancelable[A](body: Poll[F] => F[A]): F[A]
Implicitly added by monadCancelForKleisli

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, innermost-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. Applying the same poll more than once: poll(poll(fa))
  3. Applying a poll bound to one fiber within another fiber
Value Params
body

A function which takes a Poll and returns the effect that we wish to make uncancelable.

def uncancelable[A](body: Poll[F] => F[A]): F[A]
Implicitly added by monadCancelForStateT

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, innermost-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. Applying the same poll more than once: poll(poll(fa))
  3. Applying a poll bound to one fiber within another fiber
Value Params
body

A function which takes a Poll and returns the effect that we wish to make uncancelable.

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, innermost-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. Applying the same poll more than once: poll(poll(fa))
  3. Applying a poll bound to one fiber within another fiber
Value Params
body

A function which takes a Poll and returns the effect that we wish to make uncancelable.

Concrete methods

def bracket[A, B](acquire: F[A])(use: A => F[B])(release: A => F[Unit]): F[B]
Implicitly added by monadCancelForOptionT

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.

Value Params
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

def bracket[A, B](acquire: F[A])(use: A => F[B])(release: A => F[Unit]): F[B]
Implicitly added by monadCancelForEitherT

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.

Value Params
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

def bracket[A, B](acquire: F[A])(use: A => F[B])(release: A => F[Unit]): F[B]
Implicitly added by monadCancelForKleisli

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.

Value Params
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

def bracket[A, B](acquire: F[A])(use: A => F[B])(release: A => F[Unit]): F[B]
Implicitly added by monadCancelForStateT

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.

Value Params
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

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.

Value Params
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

def bracketCase[A, B](acquire: F[A])(use: A => F[B])(release: (A, Outcome[F, E, B]) => F[Unit]): F[B]
Implicitly added by monadCancelForOptionT

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.

Value Params
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

def bracketCase[A, B](acquire: F[A])(use: A => F[B])(release: (A, Outcome[F, E, B]) => F[Unit]): F[B]
Implicitly added by monadCancelForEitherT

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.

Value Params
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

def bracketCase[A, B](acquire: F[A])(use: A => F[B])(release: (A, Outcome[F, E, B]) => F[Unit]): F[B]
Implicitly added by monadCancelForKleisli

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.

Value Params
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

def bracketCase[A, B](acquire: F[A])(use: A => F[B])(release: (A, Outcome[F, E, B]) => F[Unit]): F[B]
Implicitly added by monadCancelForStateT

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.

Value Params
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

def bracketCase[A, B](acquire: F[A])(use: A => F[B])(release: (A, Outcome[F, E, 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.

Value Params
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

def bracketFull[A, B](acquire: Poll[F] => F[A])(use: A => F[B])(release: (A, Outcome[F, E, B]) => F[Unit]): F[B]
Implicitly added by monadCancelForOptionT

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.

Value Params
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

def bracketFull[A, B](acquire: Poll[F] => F[A])(use: A => F[B])(release: (A, Outcome[F, E, B]) => F[Unit]): F[B]
Implicitly added by monadCancelForEitherT

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.

Value Params
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

def bracketFull[A, B](acquire: Poll[F] => F[A])(use: A => F[B])(release: (A, Outcome[F, E, B]) => F[Unit]): F[B]
Implicitly added by monadCancelForKleisli

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.

Value Params
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

def bracketFull[A, B](acquire: Poll[F] => F[A])(use: A => F[B])(release: (A, Outcome[F, E, B]) => F[Unit]): F[B]
Implicitly added by monadCancelForStateT

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.

Value Params
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

def bracketFull[A, B](acquire: Poll[F] => F[A])(use: A => F[B])(release: (A, Outcome[F, E, 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.

Value Params
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

def guarantee[A](fa: F[A], fin: F[Unit]): F[A]
Implicitly added by monadCancelForOptionT

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.

Value Params
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

def guarantee[A](fa: F[A], fin: F[Unit]): F[A]
Implicitly added by monadCancelForEitherT

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.

Value Params
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

def guarantee[A](fa: F[A], fin: F[Unit]): F[A]
Implicitly added by monadCancelForKleisli

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.

Value Params
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

def guarantee[A](fa: F[A], fin: F[Unit]): F[A]
Implicitly added by monadCancelForStateT

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.

Value Params
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

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.

Value Params
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

def guaranteeCase[A](fa: F[A])(fin: Outcome[F, E, A] => F[Unit]): F[A]
Implicitly added by monadCancelForOptionT

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.

Value Params
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

def guaranteeCase[A](fa: F[A])(fin: Outcome[F, E, A] => F[Unit]): F[A]
Implicitly added by monadCancelForEitherT

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.

Value Params
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

def guaranteeCase[A](fa: F[A])(fin: Outcome[F, E, A] => F[Unit]): F[A]
Implicitly added by monadCancelForKleisli

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.

Value Params
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

def guaranteeCase[A](fa: F[A])(fin: Outcome[F, E, A] => F[Unit]): F[A]
Implicitly added by monadCancelForStateT

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.

Value Params
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

def guaranteeCase[A](fa: F[A])(fin: Outcome[F, E, 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.

Value Params
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 methods

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

Alias for productR.

Alias for productR.

Inherited from
Apply
@inline
final def *>[A, B](fa: F[A])(fb: F[B]): F[B]
Implicitly added by monadCancelForEitherT

Alias for productR.

Alias for productR.

Inherited from
Apply
@inline
final def *>[A, B](fa: F[A])(fb: F[B]): F[B]
Implicitly added by monadCancelForKleisli

Alias for productR.

Alias for productR.

Inherited from
Apply
@inline
final def *>[A, B](fa: F[A])(fb: F[B]): F[B]
Implicitly added by monadCancelForStateT

Alias for productR.

Alias for productR.

Inherited from
Apply
@inline
final def *>[A, B](fa: F[A])(fb: F[B]): F[B]

Alias for productR.

Alias for productR.

Inherited from
Apply
@inline
final def <*[A, B](fa: F[A])(fb: F[B]): F[A]
Implicitly added by monadCancelForOptionT

Alias for productL.

Alias for productL.

Inherited from
Apply
@inline
final def <*[A, B](fa: F[A])(fb: F[B]): F[A]
Implicitly added by monadCancelForEitherT

Alias for productL.

Alias for productL.

Inherited from
Apply
@inline
final def <*[A, B](fa: F[A])(fb: F[B]): F[A]
Implicitly added by monadCancelForKleisli

Alias for productL.

Alias for productL.

Inherited from
Apply
@inline
final def <*[A, B](fa: F[A])(fb: F[B]): F[A]
Implicitly added by monadCancelForStateT

Alias for productL.

Alias for productL.

Inherited from
Apply
@inline
final def <*[A, B](fa: F[A])(fb: F[B]): F[A]

Alias for productL.

Alias for productL.

Inherited from
Apply
@inline
final def <*>[A, B](ff: F[A => B])(fa: F[A]): F[B]
Implicitly added by monadCancelForOptionT

Alias for ap.

Alias for ap.

Inherited from
Apply
@inline
final def <*>[A, B](ff: F[A => B])(fa: F[A]): F[B]
Implicitly added by monadCancelForEitherT

Alias for ap.

Alias for ap.

Inherited from
Apply
@inline
final def <*>[A, B](ff: F[A => B])(fa: F[A]): F[B]
Implicitly added by monadCancelForKleisli

Alias for ap.

Alias for ap.

Inherited from
Apply
@inline
final def <*>[A, B](ff: F[A => B])(fa: F[A]): F[B]
Implicitly added by monadCancelForStateT

Alias for ap.

Alias for ap.

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

Alias for ap.

Alias for ap.

Inherited from
Apply
override def adaptError[A](fa: F[A])(pf: PartialFunction[E, E]): F[A]
Definition Classes
MonadError -> ApplicativeError
Inherited from
MonadError
override def ap[A, B](ff: F[A => B])(fa: F[A]): F[B]
Definition Classes
FlatMap -> Apply
Inherited from
FlatMap
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 monadCancelForOptionT
Inherited from
ApplyArityFunctions
def ap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def ap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def ap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def ap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[Z]
Inherited from
ApplyArityFunctions
def ap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def ap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def ap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def ap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def ap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[Z]
Inherited from
ApplyArityFunctions
def ap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def ap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def ap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def ap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def ap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[Z]
Inherited from
ApplyArityFunctions
def ap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def ap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def ap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def ap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def ap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[Z]
Inherited from
ApplyArityFunctions
def ap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def ap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def ap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def ap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def ap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[Z]
Inherited from
ApplyArityFunctions
def ap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def ap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def ap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def ap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def ap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[Z]
Inherited from
ApplyArityFunctions
def ap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def ap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def ap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def ap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def ap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[Z]
Inherited from
ApplyArityFunctions
def ap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def ap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def ap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def ap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def ap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[Z]
Inherited from
ApplyArityFunctions
def ap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def ap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def ap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def ap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def ap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[Z]
Inherited from
ApplyArityFunctions
def ap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def ap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def ap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def ap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def ap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[Z]
Inherited from
ApplyArityFunctions
override def ap2[A, B, Z](ff: F[(A, B) => Z])(fa: F[A], fb: F[B]): F[Z]
Definition Classes
FlatMap -> Apply
Inherited from
FlatMap
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 monadCancelForOptionT
Inherited from
ApplyArityFunctions
def ap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def ap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def ap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def ap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[Z]
Inherited from
ApplyArityFunctions
def ap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def ap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def ap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def ap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def ap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[Z]
Inherited from
ApplyArityFunctions
def ap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def ap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def ap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def ap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def ap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[Z]
Inherited from
ApplyArityFunctions
def ap3[A0, A1, A2, Z](f: F[(A0, A1, A2) => Z])(f0: F[A0], f1: F[A1], f2: F[A2]): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def ap3[A0, A1, A2, Z](f: F[(A0, A1, A2) => Z])(f0: F[A0], f1: F[A1], f2: F[A2]): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def ap3[A0, A1, A2, Z](f: F[(A0, A1, A2) => Z])(f0: F[A0], f1: F[A1], f2: F[A2]): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def ap3[A0, A1, A2, Z](f: F[(A0, A1, A2) => Z])(f0: F[A0], f1: F[A1], f2: F[A2]): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def ap3[A0, A1, A2, Z](f: F[(A0, A1, A2) => Z])(f0: F[A0], f1: F[A1], f2: F[A2]): F[Z]
Inherited from
ApplyArityFunctions
def ap4[A0, A1, A2, A3, Z](f: F[(A0, A1, A2, A3) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def ap4[A0, A1, A2, A3, Z](f: F[(A0, A1, A2, A3) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def ap4[A0, A1, A2, A3, Z](f: F[(A0, A1, A2, A3) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def ap4[A0, A1, A2, A3, Z](f: F[(A0, A1, A2, A3) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def ap4[A0, A1, A2, A3, Z](f: F[(A0, A1, A2, A3) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[Z]
Inherited from
ApplyArityFunctions
def ap5[A0, A1, A2, A3, A4, Z](f: F[(A0, A1, A2, A3, A4) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def ap5[A0, A1, A2, A3, A4, Z](f: F[(A0, A1, A2, A3, A4) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def ap5[A0, A1, A2, A3, A4, Z](f: F[(A0, A1, A2, A3, A4) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def ap5[A0, A1, A2, A3, A4, Z](f: F[(A0, A1, A2, A3, A4) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def ap5[A0, A1, A2, A3, A4, Z](f: F[(A0, A1, A2, A3, A4) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[Z]
Inherited from
ApplyArityFunctions
def ap6[A0, A1, A2, A3, A4, A5, Z](f: F[(A0, A1, A2, A3, A4, A5) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def ap6[A0, A1, A2, A3, A4, A5, Z](f: F[(A0, A1, A2, A3, A4, A5) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def ap6[A0, A1, A2, A3, A4, A5, Z](f: F[(A0, A1, A2, A3, A4, A5) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def ap6[A0, A1, A2, A3, A4, A5, Z](f: F[(A0, A1, A2, A3, A4, A5) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def ap6[A0, A1, A2, A3, A4, A5, Z](f: F[(A0, A1, A2, A3, A4, A5) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[Z]
Inherited from
ApplyArityFunctions
def ap7[A0, A1, A2, A3, A4, A5, A6, Z](f: F[(A0, A1, A2, A3, A4, A5, A6) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def ap7[A0, A1, A2, A3, A4, A5, A6, Z](f: F[(A0, A1, A2, A3, A4, A5, A6) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def ap7[A0, A1, A2, A3, A4, A5, A6, Z](f: F[(A0, A1, A2, A3, A4, A5, A6) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def ap7[A0, A1, A2, A3, A4, A5, A6, Z](f: F[(A0, A1, A2, A3, A4, A5, A6) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def ap7[A0, A1, A2, A3, A4, A5, A6, Z](f: F[(A0, A1, A2, A3, A4, A5, A6) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[Z]
Inherited from
ApplyArityFunctions
def ap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def ap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def ap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def ap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def ap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[Z]
Inherited from
ApplyArityFunctions
def ap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def ap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def ap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def ap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def ap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[Z]
Inherited from
ApplyArityFunctions
def as[A, B](fa: F[A], b: B): F[B]
Implicitly added by monadCancelForOptionT

Replaces the A value in F[A] with the supplied value.

Replaces the A value in F[A] with the supplied value.

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList

scala> Functor[List].as(List(1,2,3), "hello")
res0: List[String] = List(hello, hello, hello)
Inherited from
Functor
def as[A, B](fa: F[A], b: B): F[B]
Implicitly added by monadCancelForEitherT

Replaces the A value in F[A] with the supplied value.

Replaces the A value in F[A] with the supplied value.

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList

scala> Functor[List].as(List(1,2,3), "hello")
res0: List[String] = List(hello, hello, hello)
Inherited from
Functor
def as[A, B](fa: F[A], b: B): F[B]
Implicitly added by monadCancelForKleisli

Replaces the A value in F[A] with the supplied value.

Replaces the A value in F[A] with the supplied value.

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList

scala> Functor[List].as(List(1,2,3), "hello")
res0: List[String] = List(hello, hello, hello)
Inherited from
Functor
def as[A, B](fa: F[A], b: B): F[B]
Implicitly added by monadCancelForStateT

Replaces the A value in F[A] with the supplied value.

Replaces the A value in F[A] with the supplied value.

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList

scala> Functor[List].as(List(1,2,3), "hello")
res0: List[String] = List(hello, hello, hello)
Inherited from
Functor
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)
Inherited from
Functor
def attempt[A](fa: F[A]): F[Either[E, A]]
Implicitly added by monadCancelForOptionT

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.

Inherited from
ApplicativeError
def attempt[A](fa: F[A]): F[Either[E, A]]
Implicitly added by monadCancelForEitherT

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.

Inherited from
ApplicativeError
def attempt[A](fa: F[A]): F[Either[E, A]]
Implicitly added by monadCancelForKleisli

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.

Inherited from
ApplicativeError
def attempt[A](fa: F[A]): F[Either[E, A]]
Implicitly added by monadCancelForStateT

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.

Inherited from
ApplicativeError
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.

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

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

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

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

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

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

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

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

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

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

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

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

Inherited from
ApplicativeError
def attemptNarrow[EE <: Throwable, A](fa: F[A])(implicit tag: ClassTag[EE], ev: EE <:< E): 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.

Inherited from
ApplicativeError
def attemptT[A](fa: F[A]): EitherT[F, E, A]
Implicitly added by monadCancelForOptionT

Similar to attempt, but wraps the result in a cats.data.EitherT for convenience.

Similar to attempt, but wraps the result in a cats.data.EitherT for convenience.

Inherited from
ApplicativeError
def attemptT[A](fa: F[A]): EitherT[F, E, A]
Implicitly added by monadCancelForEitherT

Similar to attempt, but wraps the result in a cats.data.EitherT for convenience.

Similar to attempt, but wraps the result in a cats.data.EitherT for convenience.

Inherited from
ApplicativeError
def attemptT[A](fa: F[A]): EitherT[F, E, A]
Implicitly added by monadCancelForKleisli

Similar to attempt, but wraps the result in a cats.data.EitherT for convenience.

Similar to attempt, but wraps the result in a cats.data.EitherT for convenience.

Inherited from
ApplicativeError
def attemptT[A](fa: F[A]): EitherT[F, E, A]
Implicitly added by monadCancelForStateT

Similar to attempt, but wraps the result in a cats.data.EitherT for convenience.

Similar to attempt, but wraps the result in a cats.data.EitherT for convenience.

Inherited from
ApplicativeError
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.

Inherited from
ApplicativeError
def attemptTap[A, B](fa: F[A])(f: Either[E, A] => F[B]): F[A]
Implicitly added by monadCancelForOptionT

Reifies the value or error of the source and performs an effect on the result, then recovers the original value or error back into F.

Reifies the value or error of the source and performs an effect on the result, then recovers the original value or error back into F.

Note that if the effect returned by f fails, the resulting effect will fail too.

Alias for fa.attempt.flatTap(f).rethrow for convenience.

Example:

scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}

scala> def checkError(result: Either[Throwable, Int]): Try[String] = result.fold(_ => Failure(new java.lang.Exception), _ => Success("success"))

scala> val a: Try[Int] = Failure(new Throwable("failed"))
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)

scala> val b: Try[Int] = Success(1)
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
Inherited from
MonadError
def attemptTap[A, B](fa: F[A])(f: Either[E, A] => F[B]): F[A]
Implicitly added by monadCancelForEitherT

Reifies the value or error of the source and performs an effect on the result, then recovers the original value or error back into F.

Reifies the value or error of the source and performs an effect on the result, then recovers the original value or error back into F.

Note that if the effect returned by f fails, the resulting effect will fail too.

Alias for fa.attempt.flatTap(f).rethrow for convenience.

Example:

scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}

scala> def checkError(result: Either[Throwable, Int]): Try[String] = result.fold(_ => Failure(new java.lang.Exception), _ => Success("success"))

scala> val a: Try[Int] = Failure(new Throwable("failed"))
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)

scala> val b: Try[Int] = Success(1)
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
Inherited from
MonadError
def attemptTap[A, B](fa: F[A])(f: Either[E, A] => F[B]): F[A]
Implicitly added by monadCancelForKleisli

Reifies the value or error of the source and performs an effect on the result, then recovers the original value or error back into F.

Reifies the value or error of the source and performs an effect on the result, then recovers the original value or error back into F.

Note that if the effect returned by f fails, the resulting effect will fail too.

Alias for fa.attempt.flatTap(f).rethrow for convenience.

Example:

scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}

scala> def checkError(result: Either[Throwable, Int]): Try[String] = result.fold(_ => Failure(new java.lang.Exception), _ => Success("success"))

scala> val a: Try[Int] = Failure(new Throwable("failed"))
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)

scala> val b: Try[Int] = Success(1)
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
Inherited from
MonadError
def attemptTap[A, B](fa: F[A])(f: Either[E, A] => F[B]): F[A]
Implicitly added by monadCancelForStateT

Reifies the value or error of the source and performs an effect on the result, then recovers the original value or error back into F.

Reifies the value or error of the source and performs an effect on the result, then recovers the original value or error back into F.

Note that if the effect returned by f fails, the resulting effect will fail too.

Alias for fa.attempt.flatTap(f).rethrow for convenience.

Example:

scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}

scala> def checkError(result: Either[Throwable, Int]): Try[String] = result.fold(_ => Failure(new java.lang.Exception), _ => Success("success"))

scala> val a: Try[Int] = Failure(new Throwable("failed"))
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)

scala> val b: Try[Int] = Success(1)
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
Inherited from
MonadError
def attemptTap[A, B](fa: F[A])(f: Either[E, A] => F[B]): F[A]

Reifies the value or error of the source and performs an effect on the result, then recovers the original value or error back into F.

Reifies the value or error of the source and performs an effect on the result, then recovers the original value or error back into F.

Note that if the effect returned by f fails, the resulting effect will fail too.

Alias for fa.attempt.flatTap(f).rethrow for convenience.

Example:

scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}

scala> def checkError(result: Either[Throwable, Int]): Try[String] = result.fold(_ => Failure(new java.lang.Exception), _ => Success("success"))

scala> val a: Try[Int] = Failure(new Throwable("failed"))
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)

scala> val b: Try[Int] = Success(1)
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
Inherited from
MonadError
def catchNonFatal[A](a: => A)(implicit ev: Throwable <:< E): F[A]
Implicitly added by monadCancelForOptionT

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.

Inherited from
ApplicativeError
def catchNonFatal[A](a: => A)(implicit ev: Throwable <:< E): F[A]
Implicitly added by monadCancelForEitherT

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.

Inherited from
ApplicativeError
def catchNonFatal[A](a: => A)(implicit ev: Throwable <:< E): F[A]
Implicitly added by monadCancelForKleisli

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.

Inherited from
ApplicativeError
def catchNonFatal[A](a: => A)(implicit ev: Throwable <:< E): F[A]
Implicitly added by monadCancelForStateT

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.

Inherited from
ApplicativeError
def catchNonFatal[A](a: => A)(implicit ev: Throwable <:< E): 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.

Inherited from
ApplicativeError
def catchNonFatalEval[A](a: Eval[A])(implicit ev: Throwable <:< E): F[A]
Implicitly added by monadCancelForOptionT

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

Inherited from
ApplicativeError
def catchNonFatalEval[A](a: Eval[A])(implicit ev: Throwable <:< E): F[A]
Implicitly added by monadCancelForEitherT

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

Inherited from
ApplicativeError
def catchNonFatalEval[A](a: Eval[A])(implicit ev: Throwable <:< E): F[A]
Implicitly added by monadCancelForKleisli

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

Inherited from
ApplicativeError
def catchNonFatalEval[A](a: Eval[A])(implicit ev: Throwable <:< E): F[A]
Implicitly added by monadCancelForStateT

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

Inherited from
ApplicativeError
def catchNonFatalEval[A](a: Eval[A])(implicit ev: Throwable <:< E): 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

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

Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.

Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.

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

Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.

Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.

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

Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.

Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.

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

Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.

Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.

Inherited from
ApplicativeError
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.

Inherited from
ApplicativeError
def compose[G[_]](implicit evidence$1: Applicative[G]): Applicative[[α] =>> F[G[α]]]
Implicitly added by monadCancelForOptionT

Compose an Applicative[F] and an Applicative[G] into an Applicative[λ[α => F[G[α]]]].

Compose an Applicative[F] and an Applicative[G] into an Applicative[λ[α => F[G[α]]]].

Example:

scala> import cats.implicits._

scala> val alo = Applicative[List].compose[Option]

scala> alo.pure(3)
res0: List[Option[Int]] = List(Some(3))

scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)]] = List(None, None, Some((true,2)), None, Some((false,2)), None)
Inherited from
Applicative
def compose[G[_]](implicit evidence$1: Invariant[G]): Invariant[[α] =>> F[G[α]]]
Implicitly added by monadCancelForOptionT

Compose Invariant F[_] and G[_] then produce Invariant[F[G[_]]] using their imap.

Compose Invariant F[_] and G[_] then produce Invariant[F[G[_]]] using their imap.

Example:

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

scala> val durSemigroupList: Semigroup[List[FiniteDuration]] =
    | Invariant[Semigroup].compose[List].imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
Inherited from
Invariant
def compose[G[_]](implicit evidence$1: Apply[G]): Apply[[α] =>> F[G[α]]]
Implicitly added by monadCancelForOptionT

Compose an Apply[F] and an Apply[G] into an Apply[λ[α => F[G[α]]]].

Compose an Apply[F] and an Apply[G] into an Apply[λ[α => F[G[α]]]].

Example:

scala> import cats.implicits._

scala> val alo = Apply[List].compose[Option]

scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)]] = List(None, None, Some((true,2)), None, Some((false,2)), None)
Inherited from
Apply
def compose[G[_]](implicit evidence$1: Functor[G]): Functor[[α] =>> F[G[α]]]
Implicitly added by monadCancelForOptionT
Inherited from
Functor
def compose[G[_]](implicit evidence$1: Applicative[G]): Applicative[[α] =>> F[G[α]]]
Implicitly added by monadCancelForEitherT

Compose an Applicative[F] and an Applicative[G] into an Applicative[λ[α => F[G[α]]]].

Compose an Applicative[F] and an Applicative[G] into an Applicative[λ[α => F[G[α]]]].

Example:

scala> import cats.implicits._

scala> val alo = Applicative[List].compose[Option]

scala> alo.pure(3)
res0: List[Option[Int]] = List(Some(3))

scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)]] = List(None, None, Some((true,2)), None, Some((false,2)), None)
Inherited from
Applicative
def compose[G[_]](implicit evidence$1: Invariant[G]): Invariant[[α] =>> F[G[α]]]
Implicitly added by monadCancelForEitherT

Compose Invariant F[_] and G[_] then produce Invariant[F[G[_]]] using their imap.

Compose Invariant F[_] and G[_] then produce Invariant[F[G[_]]] using their imap.

Example:

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

scala> val durSemigroupList: Semigroup[List[FiniteDuration]] =
    | Invariant[Semigroup].compose[List].imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
Inherited from
Invariant
def compose[G[_]](implicit evidence$1: Apply[G]): Apply[[α] =>> F[G[α]]]
Implicitly added by monadCancelForEitherT

Compose an Apply[F] and an Apply[G] into an Apply[λ[α => F[G[α]]]].

Compose an Apply[F] and an Apply[G] into an Apply[λ[α => F[G[α]]]].

Example:

scala> import cats.implicits._

scala> val alo = Apply[List].compose[Option]

scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)]] = List(None, None, Some((true,2)), None, Some((false,2)), None)
Inherited from
Apply
def compose[G[_]](implicit evidence$1: Functor[G]): Functor[[α] =>> F[G[α]]]
Implicitly added by monadCancelForEitherT
Inherited from
Functor
def compose[G[_]](implicit evidence$1: Applicative[G]): Applicative[[α] =>> F[G[α]]]
Implicitly added by monadCancelForKleisli

Compose an Applicative[F] and an Applicative[G] into an Applicative[λ[α => F[G[α]]]].

Compose an Applicative[F] and an Applicative[G] into an Applicative[λ[α => F[G[α]]]].

Example:

scala> import cats.implicits._

scala> val alo = Applicative[List].compose[Option]

scala> alo.pure(3)
res0: List[Option[Int]] = List(Some(3))

scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)]] = List(None, None, Some((true,2)), None, Some((false,2)), None)
Inherited from
Applicative
def compose[G[_]](implicit evidence$1: Invariant[G]): Invariant[[α] =>> F[G[α]]]
Implicitly added by monadCancelForKleisli

Compose Invariant F[_] and G[_] then produce Invariant[F[G[_]]] using their imap.

Compose Invariant F[_] and G[_] then produce Invariant[F[G[_]]] using their imap.

Example:

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

scala> val durSemigroupList: Semigroup[List[FiniteDuration]] =
    | Invariant[Semigroup].compose[List].imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
Inherited from
Invariant
def compose[G[_]](implicit evidence$1: Apply[G]): Apply[[α] =>> F[G[α]]]
Implicitly added by monadCancelForKleisli

Compose an Apply[F] and an Apply[G] into an Apply[λ[α => F[G[α]]]].

Compose an Apply[F] and an Apply[G] into an Apply[λ[α => F[G[α]]]].

Example:

scala> import cats.implicits._

scala> val alo = Apply[List].compose[Option]

scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)]] = List(None, None, Some((true,2)), None, Some((false,2)), None)
Inherited from
Apply
def compose[G[_]](implicit evidence$1: Functor[G]): Functor[[α] =>> F[G[α]]]
Implicitly added by monadCancelForKleisli
Inherited from
Functor
def compose[G[_]](implicit evidence$1: Applicative[G]): Applicative[[α] =>> F[G[α]]]
Implicitly added by monadCancelForStateT

Compose an Applicative[F] and an Applicative[G] into an Applicative[λ[α => F[G[α]]]].

Compose an Applicative[F] and an Applicative[G] into an Applicative[λ[α => F[G[α]]]].

Example:

scala> import cats.implicits._

scala> val alo = Applicative[List].compose[Option]

scala> alo.pure(3)
res0: List[Option[Int]] = List(Some(3))

scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)]] = List(None, None, Some((true,2)), None, Some((false,2)), None)
Inherited from
Applicative
def compose[G[_]](implicit evidence$1: Invariant[G]): Invariant[[α] =>> F[G[α]]]
Implicitly added by monadCancelForStateT

Compose Invariant F[_] and G[_] then produce Invariant[F[G[_]]] using their imap.

Compose Invariant F[_] and G[_] then produce Invariant[F[G[_]]] using their imap.

Example:

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

scala> val durSemigroupList: Semigroup[List[FiniteDuration]] =
    | Invariant[Semigroup].compose[List].imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
Inherited from
Invariant
def compose[G[_]](implicit evidence$1: Apply[G]): Apply[[α] =>> F[G[α]]]
Implicitly added by monadCancelForStateT

Compose an Apply[F] and an Apply[G] into an Apply[λ[α => F[G[α]]]].

Compose an Apply[F] and an Apply[G] into an Apply[λ[α => F[G[α]]]].

Example:

scala> import cats.implicits._

scala> val alo = Apply[List].compose[Option]

scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)]] = List(None, None, Some((true,2)), None, Some((false,2)), None)
Inherited from
Apply
def compose[G[_]](implicit evidence$1: Functor[G]): Functor[[α] =>> F[G[α]]]
Implicitly added by monadCancelForStateT
Inherited from
Functor
def compose[G[_]](implicit evidence$1: Applicative[G]): 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)
Inherited from
Applicative
def compose[G[_]](implicit evidence$1: Invariant[G]): 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)
Inherited from
Invariant
def compose[G[_]](implicit evidence$1: Apply[G]): 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)
Inherited from
Apply
def compose[G[_]](implicit evidence$1: Functor[G]): Functor[[α] =>> F[G[α]]]
Inherited from
Functor
def composeApply[G[_]](implicit evidence$1: Apply[G]): InvariantSemigroupal[[α] =>> F[G[α]]]
Implicitly added by monadCancelForOptionT
Inherited from
InvariantSemigroupal
def composeApply[G[_]](implicit evidence$1: Apply[G]): InvariantSemigroupal[[α] =>> F[G[α]]]
Implicitly added by monadCancelForEitherT
Inherited from
InvariantSemigroupal
def composeApply[G[_]](implicit evidence$1: Apply[G]): InvariantSemigroupal[[α] =>> F[G[α]]]
Implicitly added by monadCancelForKleisli
Inherited from
InvariantSemigroupal
def composeApply[G[_]](implicit evidence$1: Apply[G]): InvariantSemigroupal[[α] =>> F[G[α]]]
Implicitly added by monadCancelForStateT
Inherited from
InvariantSemigroupal
def composeApply[G[_]](implicit evidence$1: Apply[G]): InvariantSemigroupal[[α] =>> F[G[α]]]
Inherited from
InvariantSemigroupal
override def composeContravariant[G[_]](implicit evidence$2: Contravariant[G]): Contravariant[[α] =>> F[G[α]]]
Definition Classes
Functor -> Invariant
Inherited from
Functor
def composeContravariantMonoidal[G[_]](implicit evidence$2: ContravariantMonoidal[G]): ContravariantMonoidal[[α] =>> F[G[α]]]
Implicitly added by monadCancelForOptionT

Compose an Applicative[F] and a ContravariantMonoidal[G] into a ContravariantMonoidal[λ[α => F[G[α]]]].

Compose an Applicative[F] and a ContravariantMonoidal[G] into a ContravariantMonoidal[λ[α => F[G[α]]]].

Example:

scala> import cats.kernel.Comparison
scala> import cats.implicits._

// compares strings by alphabetical order
scala> val alpha: Order[String] = Order[String]

// compares strings by their length
scala> val strLength: Order[String] = Order.by[String, Int](_.length)

scala> val stringOrders: List[Order[String]] = List(alpha, strLength)

// first comparison is with alpha order, second is with string length
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)

scala> val le = Applicative[List].composeContravariantMonoidal[Order]

// create Int orders that convert ints to strings and then use the string orders
scala> val intOrders: List[Order[Int]] = le.contramap(stringOrders)(_.toString)

// first comparison is with alpha order, second is with string length
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)

// create the `product` of the string order list and the int order list
// `p` contains a list of the following orders:
// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)]] = le.product(stringOrders, intOrders)

scala> p.map(o => o.comparison(("abc", 12), ("def", 3)))
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
Inherited from
Applicative
def composeContravariantMonoidal[G[_]](implicit evidence$2: ContravariantMonoidal[G]): ContravariantMonoidal[[α] =>> F[G[α]]]
Implicitly added by monadCancelForEitherT

Compose an Applicative[F] and a ContravariantMonoidal[G] into a ContravariantMonoidal[λ[α => F[G[α]]]].

Compose an Applicative[F] and a ContravariantMonoidal[G] into a ContravariantMonoidal[λ[α => F[G[α]]]].

Example:

scala> import cats.kernel.Comparison
scala> import cats.implicits._

// compares strings by alphabetical order
scala> val alpha: Order[String] = Order[String]

// compares strings by their length
scala> val strLength: Order[String] = Order.by[String, Int](_.length)

scala> val stringOrders: List[Order[String]] = List(alpha, strLength)

// first comparison is with alpha order, second is with string length
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)

scala> val le = Applicative[List].composeContravariantMonoidal[Order]

// create Int orders that convert ints to strings and then use the string orders
scala> val intOrders: List[Order[Int]] = le.contramap(stringOrders)(_.toString)

// first comparison is with alpha order, second is with string length
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)

// create the `product` of the string order list and the int order list
// `p` contains a list of the following orders:
// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)]] = le.product(stringOrders, intOrders)

scala> p.map(o => o.comparison(("abc", 12), ("def", 3)))
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
Inherited from
Applicative
def composeContravariantMonoidal[G[_]](implicit evidence$2: ContravariantMonoidal[G]): ContravariantMonoidal[[α] =>> F[G[α]]]
Implicitly added by monadCancelForKleisli

Compose an Applicative[F] and a ContravariantMonoidal[G] into a ContravariantMonoidal[λ[α => F[G[α]]]].

Compose an Applicative[F] and a ContravariantMonoidal[G] into a ContravariantMonoidal[λ[α => F[G[α]]]].

Example:

scala> import cats.kernel.Comparison
scala> import cats.implicits._

// compares strings by alphabetical order
scala> val alpha: Order[String] = Order[String]

// compares strings by their length
scala> val strLength: Order[String] = Order.by[String, Int](_.length)

scala> val stringOrders: List[Order[String]] = List(alpha, strLength)

// first comparison is with alpha order, second is with string length
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)

scala> val le = Applicative[List].composeContravariantMonoidal[Order]

// create Int orders that convert ints to strings and then use the string orders
scala> val intOrders: List[Order[Int]] = le.contramap(stringOrders)(_.toString)

// first comparison is with alpha order, second is with string length
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)

// create the `product` of the string order list and the int order list
// `p` contains a list of the following orders:
// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)]] = le.product(stringOrders, intOrders)

scala> p.map(o => o.comparison(("abc", 12), ("def", 3)))
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
Inherited from
Applicative
def composeContravariantMonoidal[G[_]](implicit evidence$2: ContravariantMonoidal[G]): ContravariantMonoidal[[α] =>> F[G[α]]]
Implicitly added by monadCancelForStateT

Compose an Applicative[F] and a ContravariantMonoidal[G] into a ContravariantMonoidal[λ[α => F[G[α]]]].

Compose an Applicative[F] and a ContravariantMonoidal[G] into a ContravariantMonoidal[λ[α => F[G[α]]]].

Example:

scala> import cats.kernel.Comparison
scala> import cats.implicits._

// compares strings by alphabetical order
scala> val alpha: Order[String] = Order[String]

// compares strings by their length
scala> val strLength: Order[String] = Order.by[String, Int](_.length)

scala> val stringOrders: List[Order[String]] = List(alpha, strLength)

// first comparison is with alpha order, second is with string length
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)

scala> val le = Applicative[List].composeContravariantMonoidal[Order]

// create Int orders that convert ints to strings and then use the string orders
scala> val intOrders: List[Order[Int]] = le.contramap(stringOrders)(_.toString)

// first comparison is with alpha order, second is with string length
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)

// create the `product` of the string order list and the int order list
// `p` contains a list of the following orders:
// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)]] = le.product(stringOrders, intOrders)

scala> p.map(o => o.comparison(("abc", 12), ("def", 3)))
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
Inherited from
Applicative
def composeContravariantMonoidal[G[_]](implicit evidence$2: ContravariantMonoidal[G]): 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)
Inherited from
Applicative
def composeFunctor[G[_]](implicit evidence$2: Functor[G]): Invariant[[α] =>> F[G[α]]]
Implicitly added by monadCancelForOptionT

Compose Invariant F[_] and Functor G[_] then produce Invariant[F[G[_]]] using F's imap and G's map.

Compose Invariant F[_] and Functor G[_] then produce Invariant[F[G[_]]] using F's imap and G's map.

Example:

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

scala> val durSemigroupList: Semigroup[List[FiniteDuration]] =
    | Invariant[Semigroup]
    |   .composeFunctor[List]
    |   .imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
Inherited from
Invariant
def composeFunctor[G[_]](implicit evidence$2: Functor[G]): Invariant[[α] =>> F[G[α]]]
Implicitly added by monadCancelForEitherT

Compose Invariant F[_] and Functor G[_] then produce Invariant[F[G[_]]] using F's imap and G's map.

Compose Invariant F[_] and Functor G[_] then produce Invariant[F[G[_]]] using F's imap and G's map.

Example:

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

scala> val durSemigroupList: Semigroup[List[FiniteDuration]] =
    | Invariant[Semigroup]
    |   .composeFunctor[List]
    |   .imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
Inherited from
Invariant
def composeFunctor[G[_]](implicit evidence$2: Functor[G]): Invariant[[α] =>> F[G[α]]]
Implicitly added by monadCancelForKleisli

Compose Invariant F[_] and Functor G[_] then produce Invariant[F[G[_]]] using F's imap and G's map.

Compose Invariant F[_] and Functor G[_] then produce Invariant[F[G[_]]] using F's imap and G's map.

Example:

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

scala> val durSemigroupList: Semigroup[List[FiniteDuration]] =
    | Invariant[Semigroup]
    |   .composeFunctor[List]
    |   .imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
Inherited from
Invariant
def composeFunctor[G[_]](implicit evidence$2: Functor[G]): Invariant[[α] =>> F[G[α]]]
Implicitly added by monadCancelForStateT

Compose Invariant F[_] and Functor G[_] then produce Invariant[F[G[_]]] using F's imap and G's map.

Compose Invariant F[_] and Functor G[_] then produce Invariant[F[G[_]]] using F's imap and G's map.

Example:

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

scala> val durSemigroupList: Semigroup[List[FiniteDuration]] =
    | Invariant[Semigroup]
    |   .composeFunctor[List]
    |   .imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
Inherited from
Invariant
def composeFunctor[G[_]](implicit evidence$2: Functor[G]): 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)
Inherited from
Invariant
def ensure[A](fa: F[A])(error: => E)(predicate: A => Boolean): F[A]
Implicitly added by monadCancelForOptionT

Turns a successful value into an error if it does not satisfy a given predicate.

Turns a successful value into an error if it does not satisfy a given predicate.

Inherited from
MonadError
def ensure[A](fa: F[A])(error: => E)(predicate: A => Boolean): F[A]
Implicitly added by monadCancelForEitherT

Turns a successful value into an error if it does not satisfy a given predicate.

Turns a successful value into an error if it does not satisfy a given predicate.

Inherited from
MonadError
def ensure[A](fa: F[A])(error: => E)(predicate: A => Boolean): F[A]
Implicitly added by monadCancelForKleisli

Turns a successful value into an error if it does not satisfy a given predicate.

Turns a successful value into an error if it does not satisfy a given predicate.

Inherited from
MonadError
def ensure[A](fa: F[A])(error: => E)(predicate: A => Boolean): F[A]
Implicitly added by monadCancelForStateT

Turns a successful value into an error if it does not satisfy a given predicate.

Turns a successful value into an error if it does not satisfy a given predicate.

Inherited from
MonadError
def ensure[A](fa: F[A])(error: => E)(predicate: A => Boolean): F[A]

Turns a successful value into an error if it does not satisfy a given predicate.

Turns a successful value into an error if it does not satisfy a given predicate.

Inherited from
MonadError
def ensureOr[A](fa: F[A])(error: A => E)(predicate: A => Boolean): F[A]
Implicitly added by monadCancelForOptionT

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

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

Inherited from
MonadError
def ensureOr[A](fa: F[A])(error: A => E)(predicate: A => Boolean): F[A]
Implicitly added by monadCancelForEitherT

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

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

Inherited from
MonadError
def ensureOr[A](fa: F[A])(error: A => E)(predicate: A => Boolean): F[A]
Implicitly added by monadCancelForKleisli

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

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

Inherited from
MonadError
def ensureOr[A](fa: F[A])(error: A => E)(predicate: A => Boolean): F[A]
Implicitly added by monadCancelForStateT

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

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

Inherited from
MonadError
def ensureOr[A](fa: F[A])(error: A => E)(predicate: A => Boolean): F[A]

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

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

Inherited from
MonadError
def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B]
Implicitly added by monadCancelForOptionT
Inherited from
FlatMap
def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B]
Implicitly added by monadCancelForEitherT
Inherited from
FlatMap
def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B]
Implicitly added by monadCancelForKleisli
Inherited from
FlatMap
def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B]
Implicitly added by monadCancelForStateT
Inherited from
FlatMap
def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B]
Inherited from
FlatMap
def flatTap[A, B](fa: F[A])(f: A => F[B]): F[A]
Implicitly added by monadCancelForOptionT

Apply a monadic function and discard the result while keeping the effect.

Apply a monadic function and discard the result while keeping the effect.

scala> import cats._, implicits._
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> List[Int](0).flatTap(nCats)
res2: List[Int] = List()
scala> List[Int](4).flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
Inherited from
FlatMap
def flatTap[A, B](fa: F[A])(f: A => F[B]): F[A]
Implicitly added by monadCancelForEitherT

Apply a monadic function and discard the result while keeping the effect.

Apply a monadic function and discard the result while keeping the effect.

scala> import cats._, implicits._
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> List[Int](0).flatTap(nCats)
res2: List[Int] = List()
scala> List[Int](4).flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
Inherited from
FlatMap
def flatTap[A, B](fa: F[A])(f: A => F[B]): F[A]
Implicitly added by monadCancelForKleisli

Apply a monadic function and discard the result while keeping the effect.

Apply a monadic function and discard the result while keeping the effect.

scala> import cats._, implicits._
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> List[Int](0).flatTap(nCats)
res2: List[Int] = List()
scala> List[Int](4).flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
Inherited from
FlatMap
def flatTap[A, B](fa: F[A])(f: A => F[B]): F[A]
Implicitly added by monadCancelForStateT

Apply a monadic function and discard the result while keeping the effect.

Apply a monadic function and discard the result while keeping the effect.

scala> import cats._, implicits._
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> List[Int](0).flatTap(nCats)
res2: List[Int] = List()
scala> List[Int](4).flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
Inherited from
FlatMap
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)
Inherited from
FlatMap
def flatten[A](ffa: F[F[A]]): F[A]
Implicitly added by monadCancelForOptionT

"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
Inherited from
FlatMap
def flatten[A](ffa: F[F[A]]): F[A]
Implicitly added by monadCancelForEitherT

"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
Inherited from
FlatMap
def flatten[A](ffa: F[F[A]]): F[A]
Implicitly added by monadCancelForKleisli

"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
Inherited from
FlatMap
def flatten[A](ffa: F[F[A]]): F[A]
Implicitly added by monadCancelForStateT

"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
Inherited from
FlatMap
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
Inherited from
FlatMap
final def fmap[A, B](fa: F[A])(f: A => B): F[B]
Implicitly added by monadCancelForOptionT

Alias for map, since map can't be injected as syntax if the implementing type already had a built-in .map method.

Alias for map, since map can't be injected as syntax if the implementing type already had a built-in .map method.

Example:

scala> import cats.implicits._

scala> val m: Map[Int, String] = Map(1 -> "hi", 2 -> "there", 3 -> "you")

scala> m.fmap(_ ++ "!")
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
Inherited from
Functor
final def fmap[A, B](fa: F[A])(f: A => B): F[B]
Implicitly added by monadCancelForEitherT

Alias for map, since map can't be injected as syntax if the implementing type already had a built-in .map method.

Alias for map, since map can't be injected as syntax if the implementing type already had a built-in .map method.

Example:

scala> import cats.implicits._

scala> val m: Map[Int, String] = Map(1 -> "hi", 2 -> "there", 3 -> "you")

scala> m.fmap(_ ++ "!")
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
Inherited from
Functor
final def fmap[A, B](fa: F[A])(f: A => B): F[B]
Implicitly added by monadCancelForKleisli

Alias for map, since map can't be injected as syntax if the implementing type already had a built-in .map method.

Alias for map, since map can't be injected as syntax if the implementing type already had a built-in .map method.

Example:

scala> import cats.implicits._

scala> val m: Map[Int, String] = Map(1 -> "hi", 2 -> "there", 3 -> "you")

scala> m.fmap(_ ++ "!")
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
Inherited from
Functor
final def fmap[A, B](fa: F[A])(f: A => B): F[B]
Implicitly added by monadCancelForStateT

Alias for map, since map can't be injected as syntax if the implementing type already had a built-in .map method.

Alias for map, since map can't be injected as syntax if the implementing type already had a built-in .map method.

Example:

scala> import cats.implicits._

scala> val m: Map[Int, String] = Map(1 -> "hi", 2 -> "there", 3 -> "you")

scala> m.fmap(_ ++ "!")
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
Inherited from
Functor
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!)
Inherited from
Functor
@noop
def foreverM[A, B](fa: F[A]): F[B]
Implicitly added by monadCancelForOptionT

Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.

Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.

This will be an infinite loop, or it will return an F[Nothing].

Be careful using this. For instance, a List of length k will produce a list of length k^n at iteration n. This means if k = 0, we return an empty list, if k = 1, we loop forever allocating single element lists, but if we have a k > 1, we will allocate exponentially increasing memory and very quickly OOM.

Inherited from
FlatMap
@noop
def foreverM[A, B](fa: F[A]): F[B]
Implicitly added by monadCancelForEitherT

Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.

Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.

This will be an infinite loop, or it will return an F[Nothing].

Be careful using this. For instance, a List of length k will produce a list of length k^n at iteration n. This means if k = 0, we return an empty list, if k = 1, we loop forever allocating single element lists, but if we have a k > 1, we will allocate exponentially increasing memory and very quickly OOM.

Inherited from
FlatMap
@noop
def foreverM[A, B](fa: F[A]): F[B]
Implicitly added by monadCancelForKleisli

Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.

Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.

This will be an infinite loop, or it will return an F[Nothing].

Be careful using this. For instance, a List of length k will produce a list of length k^n at iteration n. This means if k = 0, we return an empty list, if k = 1, we loop forever allocating single element lists, but if we have a k > 1, we will allocate exponentially increasing memory and very quickly OOM.

Inherited from
FlatMap
@noop
def foreverM[A, B](fa: F[A]): F[B]
Implicitly added by monadCancelForStateT

Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.

Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.

This will be an infinite loop, or it will return an F[Nothing].

Be careful using this. For instance, a List of length k will produce a list of length k^n at iteration n. This means if k = 0, we return an empty list, if k = 1, we loop forever allocating single element lists, but if we have a k > 1, we will allocate exponentially increasing memory and very quickly OOM.

Inherited from
FlatMap
@noop
def foreverM[A, B](fa: F[A]): F[B]

Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.

Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.

This will be an infinite loop, or it will return an F[Nothing].

Be careful using this. For instance, a List of length k will produce a list of length k^n at iteration n. This means if k = 0, we return an empty list, if k = 1, we loop forever allocating single element lists, but if we have a k > 1, we will allocate exponentially increasing memory and very quickly OOM.

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

Tuple the values in fa with the result of applying a function with the value

Tuple the values in fa with the result of applying a function with the value

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption

scala> Functor[Option].fproduct(Option(42))(_.toString)
res0: Option[(Int, String)] = Some((42,42))
Inherited from
Functor
def fproduct[A, B](fa: F[A])(f: A => B): F[(A, B)]
Implicitly added by monadCancelForEitherT

Tuple the values in fa with the result of applying a function with the value

Tuple the values in fa with the result of applying a function with the value

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption

scala> Functor[Option].fproduct(Option(42))(_.toString)
res0: Option[(Int, String)] = Some((42,42))
Inherited from
Functor
def fproduct[A, B](fa: F[A])(f: A => B): F[(A, B)]
Implicitly added by monadCancelForKleisli

Tuple the values in fa with the result of applying a function with the value

Tuple the values in fa with the result of applying a function with the value

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption

scala> Functor[Option].fproduct(Option(42))(_.toString)
res0: Option[(Int, String)] = Some((42,42))
Inherited from
Functor
def fproduct[A, B](fa: F[A])(f: A => B): F[(A, B)]
Implicitly added by monadCancelForStateT

Tuple the values in fa with the result of applying a function with the value

Tuple the values in fa with the result of applying a function with the value

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption

scala> Functor[Option].fproduct(Option(42))(_.toString)
res0: Option[(Int, String)] = Some((42,42))
Inherited from
Functor
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))
Inherited from
Functor
def fproductLeft[A, B](fa: F[A])(f: A => B): F[(B, A)]
Implicitly added by monadCancelForOptionT

Pair the result of function application with A.

Pair the result of function application with A.

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption

scala> Functor[Option].fproductLeft(Option(42))(_.toString)
res0: Option[(String, Int)] = Some((42,42))
Inherited from
Functor
def fproductLeft[A, B](fa: F[A])(f: A => B): F[(B, A)]
Implicitly added by monadCancelForEitherT

Pair the result of function application with A.

Pair the result of function application with A.

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption

scala> Functor[Option].fproductLeft(Option(42))(_.toString)
res0: Option[(String, Int)] = Some((42,42))
Inherited from
Functor
def fproductLeft[A, B](fa: F[A])(f: A => B): F[(B, A)]
Implicitly added by monadCancelForKleisli

Pair the result of function application with A.

Pair the result of function application with A.

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption

scala> Functor[Option].fproductLeft(Option(42))(_.toString)
res0: Option[(String, Int)] = Some((42,42))
Inherited from
Functor
def fproductLeft[A, B](fa: F[A])(f: A => B): F[(B, A)]
Implicitly added by monadCancelForStateT

Pair the result of function application with A.

Pair the result of function application with A.

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption

scala> Functor[Option].fproductLeft(Option(42))(_.toString)
res0: Option[(String, Int)] = Some((42,42))
Inherited from
Functor
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))
Inherited from
Functor
def fromEither[A](x: Either[E, A]): F[A]
Implicitly added by monadCancelForOptionT

Convert from scala.Either

Convert from scala.Either

Example:

scala> import cats.ApplicativeError
scala> import cats.instances.option._

scala> ApplicativeError[Option, Unit].fromEither(Right(1))
res0: scala.Option[Int] = Some(1)

scala> ApplicativeError[Option, Unit].fromEither(Left(()))
res1: scala.Option[Nothing] = None
Inherited from
ApplicativeError
def fromEither[A](x: Either[E, A]): F[A]
Implicitly added by monadCancelForEitherT

Convert from scala.Either

Convert from scala.Either

Example:

scala> import cats.ApplicativeError
scala> import cats.instances.option._

scala> ApplicativeError[Option, Unit].fromEither(Right(1))
res0: scala.Option[Int] = Some(1)

scala> ApplicativeError[Option, Unit].fromEither(Left(()))
res1: scala.Option[Nothing] = None
Inherited from
ApplicativeError
def fromEither[A](x: Either[E, A]): F[A]
Implicitly added by monadCancelForKleisli

Convert from scala.Either

Convert from scala.Either

Example:

scala> import cats.ApplicativeError
scala> import cats.instances.option._

scala> ApplicativeError[Option, Unit].fromEither(Right(1))
res0: scala.Option[Int] = Some(1)

scala> ApplicativeError[Option, Unit].fromEither(Left(()))
res1: scala.Option[Nothing] = None
Inherited from
ApplicativeError
def fromEither[A](x: Either[E, A]): F[A]
Implicitly added by monadCancelForStateT

Convert from scala.Either

Convert from scala.Either

Example:

scala> import cats.ApplicativeError
scala> import cats.instances.option._

scala> ApplicativeError[Option, Unit].fromEither(Right(1))
res0: scala.Option[Int] = Some(1)

scala> ApplicativeError[Option, Unit].fromEither(Left(()))
res1: scala.Option[Nothing] = None
Inherited from
ApplicativeError
def fromEither[A](x: Either[E, 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
Inherited from
ApplicativeError
def fromOption[A](oa: Option[A], ifEmpty: => E): F[A]
Implicitly added by monadCancelForOptionT

Convert from scala.Option

Convert from scala.Option

Example:

scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *], String]

scala> F.fromOption(Some(1), "Empty")
res0: scala.Either[String, Int] = Right(1)

scala> F.fromOption(Option.empty[Int], "Empty")
res1: scala.Either[String, Int] = Left(Empty)
Inherited from
ApplicativeError
def fromOption[A](oa: Option[A], ifEmpty: => E): F[A]
Implicitly added by monadCancelForEitherT

Convert from scala.Option

Convert from scala.Option

Example:

scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *], String]

scala> F.fromOption(Some(1), "Empty")
res0: scala.Either[String, Int] = Right(1)

scala> F.fromOption(Option.empty[Int], "Empty")
res1: scala.Either[String, Int] = Left(Empty)
Inherited from
ApplicativeError
def fromOption[A](oa: Option[A], ifEmpty: => E): F[A]
Implicitly added by monadCancelForKleisli

Convert from scala.Option

Convert from scala.Option

Example:

scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *], String]

scala> F.fromOption(Some(1), "Empty")
res0: scala.Either[String, Int] = Right(1)

scala> F.fromOption(Option.empty[Int], "Empty")
res1: scala.Either[String, Int] = Left(Empty)
Inherited from
ApplicativeError
def fromOption[A](oa: Option[A], ifEmpty: => E): F[A]
Implicitly added by monadCancelForStateT

Convert from scala.Option

Convert from scala.Option

Example:

scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *], String]

scala> F.fromOption(Some(1), "Empty")
res0: scala.Either[String, Int] = Right(1)

scala> F.fromOption(Option.empty[Int], "Empty")
res1: scala.Either[String, Int] = Left(Empty)
Inherited from
ApplicativeError
def fromOption[A](oa: Option[A], ifEmpty: => E): 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)
Inherited from
ApplicativeError
def fromTry[A](t: Try[A])(implicit ev: Throwable <:< E): F[A]
Implicitly added by monadCancelForOptionT

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

Inherited from
ApplicativeError
def fromTry[A](t: Try[A])(implicit ev: Throwable <:< E): F[A]
Implicitly added by monadCancelForEitherT

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

Inherited from
ApplicativeError
def fromTry[A](t: Try[A])(implicit ev: Throwable <:< E): F[A]
Implicitly added by monadCancelForKleisli

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

Inherited from
ApplicativeError
def fromTry[A](t: Try[A])(implicit ev: Throwable <:< E): F[A]
Implicitly added by monadCancelForStateT

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

Inherited from
ApplicativeError
def fromTry[A](t: Try[A])(implicit ev: Throwable <:< E): 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

Inherited from
ApplicativeError
def fromValidated[A](x: Validated[E, A]): F[A]
Implicitly added by monadCancelForOptionT

Convert from cats.data.Validated

Convert from cats.data.Validated

Example:

scala> import cats.implicits._
scala> import cats.ApplicativeError

scala> ApplicativeError[Option, Unit].fromValidated(1.valid[Unit])
res0: scala.Option[Int] = Some(1)

scala> ApplicativeError[Option, Unit].fromValidated(().invalid[Int])
res1: scala.Option[Int] = None
Inherited from
ApplicativeError
def fromValidated[A](x: Validated[E, A]): F[A]
Implicitly added by monadCancelForEitherT

Convert from cats.data.Validated

Convert from cats.data.Validated

Example:

scala> import cats.implicits._
scala> import cats.ApplicativeError

scala> ApplicativeError[Option, Unit].fromValidated(1.valid[Unit])
res0: scala.Option[Int] = Some(1)

scala> ApplicativeError[Option, Unit].fromValidated(().invalid[Int])
res1: scala.Option[Int] = None
Inherited from
ApplicativeError
def fromValidated[A](x: Validated[E, A]): F[A]
Implicitly added by monadCancelForKleisli

Convert from cats.data.Validated

Convert from cats.data.Validated

Example:

scala> import cats.implicits._
scala> import cats.ApplicativeError

scala> ApplicativeError[Option, Unit].fromValidated(1.valid[Unit])
res0: scala.Option[Int] = Some(1)

scala> ApplicativeError[Option, Unit].fromValidated(().invalid[Int])
res1: scala.Option[Int] = None
Inherited from
ApplicativeError
def fromValidated[A](x: Validated[E, A]): F[A]
Implicitly added by monadCancelForStateT

Convert from cats.data.Validated

Convert from cats.data.Validated

Example:

scala> import cats.implicits._
scala> import cats.ApplicativeError

scala> ApplicativeError[Option, Unit].fromValidated(1.valid[Unit])
res0: scala.Option[Int] = Some(1)

scala> ApplicativeError[Option, Unit].fromValidated(().invalid[Int])
res1: scala.Option[Int] = None
Inherited from
ApplicativeError
def fromValidated[A](x: Validated[E, 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
Inherited from
ApplicativeError
def handleError[A](fa: F[A])(f: E => A): F[A]
Implicitly added by monadCancelForOptionT

Handle any error, by mapping it to an A value.

Handle any error, by mapping it to an A value.

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
def handleError[A](fa: F[A])(f: E => A): F[A]
Implicitly added by monadCancelForEitherT

Handle any error, by mapping it to an A value.

Handle any error, by mapping it to an A value.

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
def handleError[A](fa: F[A])(f: E => A): F[A]
Implicitly added by monadCancelForKleisli

Handle any error, by mapping it to an A value.

Handle any error, by mapping it to an A value.

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
def handleError[A](fa: F[A])(f: E => A): F[A]
Implicitly added by monadCancelForStateT

Handle any error, by mapping it to an A value.

Handle any error, by mapping it to an A value.

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
def handleError[A](fa: F[A])(f: E => A): F[A]

Handle any error, by mapping it to an A value.

Handle any error, by mapping it to an A value.

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
def handleErrorWith[A](fa: F[A])(f: E => F[A]): F[A]
Implicitly added by monadCancelForOptionT

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.

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
def handleErrorWith[A](fa: F[A])(f: E => F[A]): F[A]
Implicitly added by monadCancelForEitherT

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.

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
def handleErrorWith[A](fa: F[A])(f: E => F[A]): F[A]
Implicitly added by monadCancelForKleisli

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.

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
def handleErrorWith[A](fa: F[A])(f: E => F[A]): F[A]
Implicitly added by monadCancelForStateT

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.

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
def handleErrorWith[A](fa: F[A])(f: E => F[A]): F[A]

Handle any error, potentially recovering from it, by mapping it to an F[A] value.

Handle any error, potentially recovering from it, by mapping it to an F[A] value.

See also

handleError to handle any error by simply mapping it to an A value instead of an F[A].

recoverWith to recover from only certain errors.

Inherited from
ApplicativeError
@noop
def ifA[A](fcond: F[Boolean])(ifTrue: F[A], ifFalse: F[A]): F[A]
Implicitly added by monadCancelForOptionT

An if-then-else lifted into the F context. This function combines the effects of the fcond condition and of the two branches, in the order in which they are given.

An if-then-else lifted into the F context. This function combines the effects of the fcond condition and of the two branches, in the order in which they are given.

The value of the result is, depending on the value of the condition, the value of the first argument, or the value of the second argument.

Example:

scala> import cats.implicits._

scala> val b1: Option[Boolean] = Some(true)
scala> val asInt1: Option[Int] = Apply[Option].ifA(b1)(Some(1), Some(0))
scala> asInt1.get
res0: Int = 1

scala> val b2: Option[Boolean] = Some(false)
scala> val asInt2: Option[Int] = Apply[Option].ifA(b2)(Some(1), Some(0))
scala> asInt2.get
res1: Int = 0

scala> val b3: Option[Boolean] = Some(true)
scala> val asInt3: Option[Int] = Apply[Option].ifA(b3)(Some(1), None)
asInt2: Option[Int] = None
Inherited from
Apply
@noop
def ifA[A](fcond: F[Boolean])(ifTrue: F[A], ifFalse: F[A]): F[A]
Implicitly added by monadCancelForEitherT

An if-then-else lifted into the F context. This function combines the effects of the fcond condition and of the two branches, in the order in which they are given.

An if-then-else lifted into the F context. This function combines the effects of the fcond condition and of the two branches, in the order in which they are given.

The value of the result is, depending on the value of the condition, the value of the first argument, or the value of the second argument.

Example:

scala> import cats.implicits._

scala> val b1: Option[Boolean] = Some(true)
scala> val asInt1: Option[Int] = Apply[Option].ifA(b1)(Some(1), Some(0))
scala> asInt1.get
res0: Int = 1

scala> val b2: Option[Boolean] = Some(false)
scala> val asInt2: Option[Int] = Apply[Option].ifA(b2)(Some(1), Some(0))
scala> asInt2.get
res1: Int = 0

scala> val b3: Option[Boolean] = Some(true)
scala> val asInt3: Option[Int] = Apply[Option].ifA(b3)(Some(1), None)
asInt2: Option[Int] = None
Inherited from
Apply
@noop
def ifA[A](fcond: F[Boolean])(ifTrue: F[A], ifFalse: F[A]): F[A]
Implicitly added by monadCancelForKleisli

An if-then-else lifted into the F context. This function combines the effects of the fcond condition and of the two branches, in the order in which they are given.

An if-then-else lifted into the F context. This function combines the effects of the fcond condition and of the two branches, in the order in which they are given.

The value of the result is, depending on the value of the condition, the value of the first argument, or the value of the second argument.

Example:

scala> import cats.implicits._

scala> val b1: Option[Boolean] = Some(true)
scala> val asInt1: Option[Int] = Apply[Option].ifA(b1)(Some(1), Some(0))
scala> asInt1.get
res0: Int = 1

scala> val b2: Option[Boolean] = Some(false)
scala> val asInt2: Option[Int] = Apply[Option].ifA(b2)(Some(1), Some(0))
scala> asInt2.get
res1: Int = 0

scala> val b3: Option[Boolean] = Some(true)
scala> val asInt3: Option[Int] = Apply[Option].ifA(b3)(Some(1), None)
asInt2: Option[Int] = None
Inherited from
Apply
@noop
def ifA[A](fcond: F[Boolean])(ifTrue: F[A], ifFalse: F[A]): F[A]
Implicitly added by monadCancelForStateT

An if-then-else lifted into the F context. This function combines the effects of the fcond condition and of the two branches, in the order in which they are given.

An if-then-else lifted into the F context. This function combines the effects of the fcond condition and of the two branches, in the order in which they are given.

The value of the result is, depending on the value of the condition, the value of the first argument, or the value of the second argument.

Example:

scala> import cats.implicits._

scala> val b1: Option[Boolean] = Some(true)
scala> val asInt1: Option[Int] = Apply[Option].ifA(b1)(Some(1), Some(0))
scala> asInt1.get
res0: Int = 1

scala> val b2: Option[Boolean] = Some(false)
scala> val asInt2: Option[Int] = Apply[Option].ifA(b2)(Some(1), Some(0))
scala> asInt2.get
res1: Int = 0

scala> val b3: Option[Boolean] = Some(true)
scala> val asInt3: Option[Int] = Apply[Option].ifA(b3)(Some(1), None)
asInt2: Option[Int] = None
Inherited from
Apply
@noop
def ifA[A](fcond: F[Boolean])(ifTrue: F[A], ifFalse: F[A]): F[A]

An if-then-else lifted into the F context. This function combines the effects of the fcond condition and of the two branches, in the order in which they are given.

An if-then-else lifted into the F context. This function combines the effects of the fcond condition and of the two branches, in the order in which they are given.

The value of the result is, depending on the value of the condition, the value of the first argument, or the value of the second argument.

Example:

scala> import cats.implicits._

scala> val b1: Option[Boolean] = Some(true)
scala> val asInt1: Option[Int] = Apply[Option].ifA(b1)(Some(1), Some(0))
scala> asInt1.get
res0: Int = 1

scala> val b2: Option[Boolean] = Some(false)
scala> val asInt2: Option[Int] = Apply[Option].ifA(b2)(Some(1), Some(0))
scala> asInt2.get
res1: Int = 0

scala> val b3: Option[Boolean] = Some(true)
scala> val asInt3: Option[Int] = Apply[Option].ifA(b3)(Some(1), None)
asInt2: Option[Int] = None
Inherited from
Apply
@noop
def ifElseM[A](branches: (F[Boolean], F[A])*)(els: F[A]): F[A]
Implicitly added by monadCancelForOptionT

Simulates an if/else-if/else in the context of an F. It evaluates conditions until one evaluates to true, and returns the associated F[A]. If no condition is true, returns els.

Simulates an if/else-if/else in the context of an F. It evaluates conditions until one evaluates to true, and returns the associated F[A]. If no condition is true, returns els.

scala> import cats._
scala> Monad[Eval].ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2

Based on a gist by Daniel Spiewak with a stack-safe implementation due to P. Oscar Boykin

See also
Inherited from
Monad
@noop
def ifElseM[A](branches: (F[Boolean], F[A])*)(els: F[A]): F[A]
Implicitly added by monadCancelForEitherT

Simulates an if/else-if/else in the context of an F. It evaluates conditions until one evaluates to true, and returns the associated F[A]. If no condition is true, returns els.

Simulates an if/else-if/else in the context of an F. It evaluates conditions until one evaluates to true, and returns the associated F[A]. If no condition is true, returns els.

scala> import cats._
scala> Monad[Eval].ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2

Based on a gist by Daniel Spiewak with a stack-safe implementation due to P. Oscar Boykin

See also
Inherited from
Monad
@noop
def ifElseM[A](branches: (F[Boolean], F[A])*)(els: F[A]): F[A]
Implicitly added by monadCancelForKleisli

Simulates an if/else-if/else in the context of an F. It evaluates conditions until one evaluates to true, and returns the associated F[A]. If no condition is true, returns els.

Simulates an if/else-if/else in the context of an F. It evaluates conditions until one evaluates to true, and returns the associated F[A]. If no condition is true, returns els.

scala> import cats._
scala> Monad[Eval].ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2

Based on a gist by Daniel Spiewak with a stack-safe implementation due to P. Oscar Boykin

See also
Inherited from
Monad
@noop
def ifElseM[A](branches: (F[Boolean], F[A])*)(els: F[A]): F[A]
Implicitly added by monadCancelForStateT

Simulates an if/else-if/else in the context of an F. It evaluates conditions until one evaluates to true, and returns the associated F[A]. If no condition is true, returns els.

Simulates an if/else-if/else in the context of an F. It evaluates conditions until one evaluates to true, and returns the associated F[A]. If no condition is true, returns els.

scala> import cats._
scala> Monad[Eval].ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2

Based on a gist by Daniel Spiewak with a stack-safe implementation due to P. Oscar Boykin

See also
Inherited from
Monad
@noop
def ifElseM[A](branches: (F[Boolean], F[A])*)(els: F[A]): F[A]

Simulates an if/else-if/else in the context of an F. It evaluates conditions until one evaluates to true, and returns the associated F[A]. If no condition is true, returns els.

Simulates an if/else-if/else in the context of an F. It evaluates conditions until one evaluates to true, and returns the associated F[A]. If no condition is true, returns els.

scala> import cats._
scala> Monad[Eval].ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2

Based on a gist by Daniel Spiewak with a stack-safe implementation due to P. Oscar Boykin

See also
Inherited from
Monad
@noop
def ifF[A](fb: F[Boolean])(ifTrue: => A, ifFalse: => A): F[A]
Implicitly added by monadCancelForOptionT

Lifts if to Functor

Lifts if to Functor

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList

scala> Functor[List].ifF(List(true, false, false))(1, 0)
res0: List[Int] = List(1, 0, 0)
Inherited from
Functor
@noop
def ifF[A](fb: F[Boolean])(ifTrue: => A, ifFalse: => A): F[A]
Implicitly added by monadCancelForEitherT

Lifts if to Functor

Lifts if to Functor

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList

scala> Functor[List].ifF(List(true, false, false))(1, 0)
res0: List[Int] = List(1, 0, 0)
Inherited from
Functor
@noop
def ifF[A](fb: F[Boolean])(ifTrue: => A, ifFalse: => A): F[A]
Implicitly added by monadCancelForKleisli

Lifts if to Functor

Lifts if to Functor

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList

scala> Functor[List].ifF(List(true, false, false))(1, 0)
res0: List[Int] = List(1, 0, 0)
Inherited from
Functor
@noop
def ifF[A](fb: F[Boolean])(ifTrue: => A, ifFalse: => A): F[A]
Implicitly added by monadCancelForStateT

Lifts if to Functor

Lifts if to Functor

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList

scala> Functor[List].ifF(List(true, false, false))(1, 0)
res0: List[Int] = List(1, 0, 0)
Inherited from
Functor
@noop
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)
Inherited from
Functor
@noop
def ifM[B](fa: F[Boolean])(ifTrue: => F[B], ifFalse: => F[B]): F[B]
Implicitly added by monadCancelForOptionT

if lifted into monad.

if lifted into monad.

Inherited from
FlatMap
@noop
def ifM[B](fa: F[Boolean])(ifTrue: => F[B], ifFalse: => F[B]): F[B]
Implicitly added by monadCancelForEitherT

if lifted into monad.

if lifted into monad.

Inherited from
FlatMap
@noop
def ifM[B](fa: F[Boolean])(ifTrue: => F[B], ifFalse: => F[B]): F[B]
Implicitly added by monadCancelForKleisli

if lifted into monad.

if lifted into monad.

Inherited from
FlatMap
@noop
def ifM[B](fa: F[Boolean])(ifTrue: => F[B], ifFalse: => F[B]): F[B]
Implicitly added by monadCancelForStateT

if lifted into monad.

if lifted into monad.

Inherited from
FlatMap
@noop
def ifM[B](fa: F[Boolean])(ifTrue: => F[B], ifFalse: => F[B]): F[B]

if lifted into monad.

if lifted into monad.

Inherited from
FlatMap
override def imap[A, B](fa: F[A])(f: A => B)(g: B => A): F[B]
Definition Classes
Functor -> Invariant
Inherited from
Functor
@noop
def iterateForeverM[A, B](a: A)(f: A => F[A]): F[B]
Implicitly added by monadCancelForOptionT

iterateForeverM is almost exclusively useful for effect types. For instance, A may be some state, we may take the current state, run some effect to get a new state and repeat.

iterateForeverM is almost exclusively useful for effect types. For instance, A may be some state, we may take the current state, run some effect to get a new state and repeat.

Inherited from
FlatMap
@noop
def iterateForeverM[A, B](a: A)(f: A => F[A]): F[B]
Implicitly added by monadCancelForEitherT

iterateForeverM is almost exclusively useful for effect types. For instance, A may be some state, we may take the current state, run some effect to get a new state and repeat.

iterateForeverM is almost exclusively useful for effect types. For instance, A may be some state, we may take the current state, run some effect to get a new state and repeat.

Inherited from
FlatMap
@noop
def iterateForeverM[A, B](a: A)(f: A => F[A]): F[B]
Implicitly added by monadCancelForKleisli

iterateForeverM is almost exclusively useful for effect types. For instance, A may be some state, we may take the current state, run some effect to get a new state and repeat.

iterateForeverM is almost exclusively useful for effect types. For instance, A may be some state, we may take the current state, run some effect to get a new state and repeat.

Inherited from
FlatMap
@noop
def iterateForeverM[A, B](a: A)(f: A => F[A]): F[B]
Implicitly added by monadCancelForStateT

iterateForeverM is almost exclusively useful for effect types. For instance, A may be some state, we may take the current state, run some effect to get a new state and repeat.

iterateForeverM is almost exclusively useful for effect types. For instance, A may be some state, we may take the current state, run some effect to get a new state and repeat.

Inherited from
FlatMap
@noop
def iterateForeverM[A, B](a: A)(f: A => F[A]): F[B]

iterateForeverM is almost exclusively useful for effect types. For instance, A may be some state, we may take the current state, run some effect to get a new state and repeat.

iterateForeverM is almost exclusively useful for effect types. For instance, A may be some state, we may take the current state, run some effect to get a new state and repeat.

Inherited from
FlatMap
def iterateUntil[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by monadCancelForOptionT

Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.

Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.

Inherited from
Monad
def iterateUntil[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by monadCancelForEitherT

Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.

Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.

Inherited from
Monad
def iterateUntil[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by monadCancelForKleisli

Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.

Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.

Inherited from
Monad
def iterateUntil[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by monadCancelForStateT

Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.

Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.

Inherited from
Monad
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.

Inherited from
Monad
def iterateUntilM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by monadCancelForOptionT

Apply a monadic function iteratively until its result satisfies the given predicate and return that result.

Apply a monadic function iteratively until its result satisfies the given predicate and return that result.

Inherited from
Monad
def iterateUntilM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by monadCancelForEitherT

Apply a monadic function iteratively until its result satisfies the given predicate and return that result.

Apply a monadic function iteratively until its result satisfies the given predicate and return that result.

Inherited from
Monad
def iterateUntilM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by monadCancelForKleisli

Apply a monadic function iteratively until its result satisfies the given predicate and return that result.

Apply a monadic function iteratively until its result satisfies the given predicate and return that result.

Inherited from
Monad
def iterateUntilM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by monadCancelForStateT

Apply a monadic function iteratively until its result satisfies the given predicate and return that result.

Apply a monadic function iteratively until its result satisfies the given predicate and return that result.

Inherited from
Monad
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.

Inherited from
Monad
def iterateWhile[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by monadCancelForOptionT

Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.

Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.

Inherited from
Monad
def iterateWhile[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by monadCancelForEitherT

Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.

Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.

Inherited from
Monad
def iterateWhile[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by monadCancelForKleisli

Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.

Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.

Inherited from
Monad
def iterateWhile[A](f: F[A])(p: A => Boolean): F[A]
Implicitly added by monadCancelForStateT

Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.

Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.

Inherited from
Monad
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.

Inherited from
Monad
def iterateWhileM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by monadCancelForOptionT

Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.

Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.

Inherited from
Monad
def iterateWhileM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by monadCancelForEitherT

Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.

Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.

Inherited from
Monad
def iterateWhileM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by monadCancelForKleisli

Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.

Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.

Inherited from
Monad
def iterateWhileM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
Implicitly added by monadCancelForStateT

Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.

Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.

Inherited from
Monad
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.

Inherited from
Monad
def lift[A, B](f: A => B): F[A] => F[B]
Implicitly added by monadCancelForOptionT

Lift a function f to operate on Functors

Lift a function f to operate on Functors

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption

scala> val o = Option(42)
scala> Functor[Option].lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
Inherited from
Functor
def lift[A, B](f: A => B): F[A] => F[B]
Implicitly added by monadCancelForEitherT

Lift a function f to operate on Functors

Lift a function f to operate on Functors

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption

scala> val o = Option(42)
scala> Functor[Option].lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
Inherited from
Functor
def lift[A, B](f: A => B): F[A] => F[B]
Implicitly added by monadCancelForKleisli

Lift a function f to operate on Functors

Lift a function f to operate on Functors

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption

scala> val o = Option(42)
scala> Functor[Option].lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
Inherited from
Functor
def lift[A, B](f: A => B): F[A] => F[B]
Implicitly added by monadCancelForStateT

Lift a function f to operate on Functors

Lift a function f to operate on Functors

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption

scala> val o = Option(42)
scala> Functor[Option].lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
Inherited from
Functor
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)
Inherited from
Functor
override def map[A, B](fa: F[A])(f: A => B): F[B]
Definition Classes
Monad -> Applicative -> Functor
Inherited from
Monad
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 monadCancelForOptionT
Inherited from
ApplyArityFunctions
def map10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def map10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def map10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def map10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z): F[Z]
Inherited from
ApplyArityFunctions
def map11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def map11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def map11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def map11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def map11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z): F[Z]
Inherited from
ApplyArityFunctions
def map12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def map12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def map12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def map12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def map12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z): F[Z]
Inherited from
ApplyArityFunctions
def map13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def map13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def map13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def map13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def map13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z): F[Z]
Inherited from
ApplyArityFunctions
def map14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def map14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def map14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def map14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def map14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z): F[Z]
Inherited from
ApplyArityFunctions
def map15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def map15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def map15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def map15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def map15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z): F[Z]
Inherited from
ApplyArityFunctions
def map16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def map16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def map16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def map16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def map16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z): F[Z]
Inherited from
ApplyArityFunctions
def map17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def map17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def map17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def map17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def map17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z): F[Z]
Inherited from
ApplyArityFunctions
def map18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def map18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def map18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def map18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def map18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z): F[Z]
Inherited from
ApplyArityFunctions
def map19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def map19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def map19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def map19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def map19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z): F[Z]
Inherited from
ApplyArityFunctions
override def map2[A, B, Z](fa: F[A], fb: F[B])(f: (A, B) => Z): F[Z]
Definition Classes
FlatMap -> Apply
Inherited from
FlatMap
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 monadCancelForOptionT
Inherited from
ApplyArityFunctions
def map20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def map20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def map20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def map20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z): F[Z]
Inherited from
ApplyArityFunctions
def map21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def map21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def map21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def map21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def map21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z): F[Z]
Inherited from
ApplyArityFunctions
def map22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def map22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def map22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def map22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def map22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z): F[Z]
Inherited from
ApplyArityFunctions
def map2Eval[A, B, Z](fa: F[A], fb: Eval[F[B]])(f: (A, B) => Z): Eval[F[Z]]
Implicitly added by monadCancelForOptionT

Similar to map2 but uses Eval to allow for laziness in the F[B] argument. This can allow for "short-circuiting" of computations.

Similar to map2 but uses Eval to allow for laziness in the F[B] argument. This can allow for "short-circuiting" of computations.

NOTE: the default implementation of map2Eval does not short-circuit computations. For data structures that can benefit from laziness, Apply instances should override this method.

In the following example, x.map2(bomb)(_ + _) would result in an error, but map2Eval "short-circuits" the computation. x is None and thus the result of bomb doesn't even need to be evaluated in order to determine that the result of map2Eval should be None.

scala> import cats.{Eval, Later}
scala> import cats.implicits._
scala> val bomb: Eval[Option[Int]] = Later(sys.error("boom"))
scala> val x: Option[Int] = None
scala> x.map2Eval(bomb)(_ + _).value
res0: Option[Int] = None
Inherited from
Apply
def map2Eval[A, B, Z](fa: F[A], fb: Eval[F[B]])(f: (A, B) => Z): Eval[F[Z]]
Implicitly added by monadCancelForEitherT

Similar to map2 but uses Eval to allow for laziness in the F[B] argument. This can allow for "short-circuiting" of computations.

Similar to map2 but uses Eval to allow for laziness in the F[B] argument. This can allow for "short-circuiting" of computations.

NOTE: the default implementation of map2Eval does not short-circuit computations. For data structures that can benefit from laziness, Apply instances should override this method.

In the following example, x.map2(bomb)(_ + _) would result in an error, but map2Eval "short-circuits" the computation. x is None and thus the result of bomb doesn't even need to be evaluated in order to determine that the result of map2Eval should be None.

scala> import cats.{Eval, Later}
scala> import cats.implicits._
scala> val bomb: Eval[Option[Int]] = Later(sys.error("boom"))
scala> val x: Option[Int] = None
scala> x.map2Eval(bomb)(_ + _).value
res0: Option[Int] = None
Inherited from
Apply
def map2Eval[A, B, Z](fa: F[A], fb: Eval[F[B]])(f: (A, B) => Z): Eval[F[Z]]
Implicitly added by monadCancelForKleisli

Similar to map2 but uses Eval to allow for laziness in the F[B] argument. This can allow for "short-circuiting" of computations.

Similar to map2 but uses Eval to allow for laziness in the F[B] argument. This can allow for "short-circuiting" of computations.

NOTE: the default implementation of map2Eval does not short-circuit computations. For data structures that can benefit from laziness, Apply instances should override this method.

In the following example, x.map2(bomb)(_ + _) would result in an error, but map2Eval "short-circuits" the computation. x is None and thus the result of bomb doesn't even need to be evaluated in order to determine that the result of map2Eval should be None.

scala> import cats.{Eval, Later}
scala> import cats.implicits._
scala> val bomb: Eval[Option[Int]] = Later(sys.error("boom"))
scala> val x: Option[Int] = None
scala> x.map2Eval(bomb)(_ + _).value
res0: Option[Int] = None
Inherited from
Apply
def map2Eval[A, B, Z](fa: F[A], fb: Eval[F[B]])(f: (A, B) => Z): Eval[F[Z]]
Implicitly added by monadCancelForStateT

Similar to map2 but uses Eval to allow for laziness in the F[B] argument. This can allow for "short-circuiting" of computations.

Similar to map2 but uses Eval to allow for laziness in the F[B] argument. This can allow for "short-circuiting" of computations.

NOTE: the default implementation of map2Eval does not short-circuit computations. For data structures that can benefit from laziness, Apply instances should override this method.

In the following example, x.map2(bomb)(_ + _) would result in an error, but map2Eval "short-circuits" the computation. x is None and thus the result of bomb doesn't even need to be evaluated in order to determine that the result of map2Eval should be None.

scala> import cats.{Eval, Later}
scala> import cats.implicits._
scala> val bomb: Eval[Option[Int]] = Later(sys.error("boom"))
scala> val x: Option[Int] = None
scala> x.map2Eval(bomb)(_ + _).value
res0: Option[Int] = None
Inherited from
Apply
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
Inherited from
Apply
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 monadCancelForOptionT
Inherited from
ApplyArityFunctions
def map3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2])(f: (A0, A1, A2) => Z): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def map3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2])(f: (A0, A1, A2) => Z): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def map3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2])(f: (A0, A1, A2) => Z): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def map3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2])(f: (A0, A1, A2) => Z): F[Z]
Inherited from
ApplyArityFunctions
def map4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3])(f: (A0, A1, A2, A3) => Z): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def map4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3])(f: (A0, A1, A2, A3) => Z): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def map4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3])(f: (A0, A1, A2, A3) => Z): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def map4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3])(f: (A0, A1, A2, A3) => Z): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def map4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3])(f: (A0, A1, A2, A3) => Z): F[Z]
Inherited from
ApplyArityFunctions
def map5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4])(f: (A0, A1, A2, A3, A4) => Z): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def map5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4])(f: (A0, A1, A2, A3, A4) => Z): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def map5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4])(f: (A0, A1, A2, A3, A4) => Z): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def map5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4])(f: (A0, A1, A2, A3, A4) => Z): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def map5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4])(f: (A0, A1, A2, A3, A4) => Z): F[Z]
Inherited from
ApplyArityFunctions
def map6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5])(f: (A0, A1, A2, A3, A4, A5) => Z): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def map6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5])(f: (A0, A1, A2, A3, A4, A5) => Z): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def map6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5])(f: (A0, A1, A2, A3, A4, A5) => Z): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def map6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5])(f: (A0, A1, A2, A3, A4, A5) => Z): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def map6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5])(f: (A0, A1, A2, A3, A4, A5) => Z): F[Z]
Inherited from
ApplyArityFunctions
def map7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => Z): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def map7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => Z): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def map7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => Z): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def map7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => Z): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def map7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => Z): F[Z]
Inherited from
ApplyArityFunctions
def map8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def map8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def map8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def map8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def map8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z): F[Z]
Inherited from
ApplyArityFunctions
def map9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z): F[Z]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def map9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z): F[Z]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def map9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z): F[Z]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def map9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z): F[Z]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def map9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z): F[Z]
Inherited from
ApplyArityFunctions
def mproduct[A, B](fa: F[A])(f: A => F[B]): F[(A, B)]
Implicitly added by monadCancelForOptionT

Pair A with the result of function application.

Pair A with the result of function application.

Example:

scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
Inherited from
FlatMap
def mproduct[A, B](fa: F[A])(f: A => F[B]): F[(A, B)]
Implicitly added by monadCancelForEitherT

Pair A with the result of function application.

Pair A with the result of function application.

Example:

scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
Inherited from
FlatMap
def mproduct[A, B](fa: F[A])(f: A => F[B]): F[(A, B)]
Implicitly added by monadCancelForKleisli

Pair A with the result of function application.

Pair A with the result of function application.

Example:

scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
Inherited from
FlatMap
def mproduct[A, B](fa: F[A])(f: A => F[B]): F[(A, B)]
Implicitly added by monadCancelForStateT

Pair A with the result of function application.

Pair A with the result of function application.

Example:

scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
Inherited from
FlatMap
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))
Inherited from
FlatMap
def onError[A](fa: F[A])(pf: PartialFunction[E, F[Unit]]): F[A]
Implicitly added by monadCancelForOptionT

Execute a callback on certain errors, then rethrow them. Any non matching error is rethrown as well.

Execute a callback on certain errors, then rethrow them. Any non matching error is rethrown as well.

In the following example, only one of the errors is logged, but they are both rethrown, to be possibly handled by another layer of the program:

scala> import cats._, data._, implicits._

scala> case class Err(msg: String)

scala> type F[A] = EitherT[State[String, *], Err, A]

scala> val action: PartialFunction[Err, F[Unit]] = {
    |   case Err("one") => EitherT.liftF(State.set("one"))
    | }

scala> val prog1: F[Int] = (Err("one")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]

scala> prog1.onError(action).value.run("").value

res0: (String, Either[Err,Int]) = (one,Left(Err(one)))

scala> prog2.onError(action).value.run("").value
res1: (String, Either[Err,Int]) = ("",Left(Err(two)))
Inherited from
ApplicativeError
def onError[A](fa: F[A])(pf: PartialFunction[E, F[Unit]]): F[A]
Implicitly added by monadCancelForEitherT

Execute a callback on certain errors, then rethrow them. Any non matching error is rethrown as well.

Execute a callback on certain errors, then rethrow them. Any non matching error is rethrown as well.

In the following example, only one of the errors is logged, but they are both rethrown, to be possibly handled by another layer of the program:

scala> import cats._, data._, implicits._

scala> case class Err(msg: String)

scala> type F[A] = EitherT[State[String, *], Err, A]

scala> val action: PartialFunction[Err, F[Unit]] = {
    |   case Err("one") => EitherT.liftF(State.set("one"))
    | }

scala> val prog1: F[Int] = (Err("one")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]

scala> prog1.onError(action).value.run("").value

res0: (String, Either[Err,Int]) = (one,Left(Err(one)))

scala> prog2.onError(action).value.run("").value
res1: (String, Either[Err,Int]) = ("",Left(Err(two)))
Inherited from
ApplicativeError
def onError[A](fa: F[A])(pf: PartialFunction[E, F[Unit]]): F[A]
Implicitly added by monadCancelForKleisli

Execute a callback on certain errors, then rethrow them. Any non matching error is rethrown as well.

Execute a callback on certain errors, then rethrow them. Any non matching error is rethrown as well.

In the following example, only one of the errors is logged, but they are both rethrown, to be possibly handled by another layer of the program:

scala> import cats._, data._, implicits._

scala> case class Err(msg: String)

scala> type F[A] = EitherT[State[String, *], Err, A]

scala> val action: PartialFunction[Err, F[Unit]] = {
    |   case Err("one") => EitherT.liftF(State.set("one"))
    | }

scala> val prog1: F[Int] = (Err("one")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]

scala> prog1.onError(action).value.run("").value

res0: (String, Either[Err,Int]) = (one,Left(Err(one)))

scala> prog2.onError(action).value.run("").value
res1: (String, Either[Err,Int]) = ("",Left(Err(two)))
Inherited from
ApplicativeError
def onError[A](fa: F[A])(pf: PartialFunction[E, F[Unit]]): F[A]
Implicitly added by monadCancelForStateT

Execute a callback on certain errors, then rethrow them. Any non matching error is rethrown as well.

Execute a callback on certain errors, then rethrow them. Any non matching error is rethrown as well.

In the following example, only one of the errors is logged, but they are both rethrown, to be possibly handled by another layer of the program:

scala> import cats._, data._, implicits._

scala> case class Err(msg: String)

scala> type F[A] = EitherT[State[String, *], Err, A]

scala> val action: PartialFunction[Err, F[Unit]] = {
    |   case Err("one") => EitherT.liftF(State.set("one"))
    | }

scala> val prog1: F[Int] = (Err("one")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]

scala> prog1.onError(action).value.run("").value

res0: (String, Either[Err,Int]) = (one,Left(Err(one)))

scala> prog2.onError(action).value.run("").value
res1: (String, Either[Err,Int]) = ("",Left(Err(two)))
Inherited from
ApplicativeError
def onError[A](fa: F[A])(pf: PartialFunction[E, F[Unit]]): F[A]

Execute a callback on certain errors, then rethrow them. Any non matching error is rethrown as well.

Execute a callback on certain errors, then rethrow them. Any non matching error is rethrown as well.

In the following example, only one of the errors is logged, but they are both rethrown, to be possibly handled by another layer of the program:

scala> import cats._, data._, implicits._

scala> case class Err(msg: String)

scala> type F[A] = EitherT[State[String, *], Err, A]

scala> val action: PartialFunction[Err, F[Unit]] = {
    |   case Err("one") => EitherT.liftF(State.set("one"))
    | }

scala> val prog1: F[Int] = (Err("one")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]

scala> prog1.onError(action).value.run("").value

res0: (String, Either[Err,Int]) = (one,Left(Err(one)))

scala> prog2.onError(action).value.run("").value
res1: (String, Either[Err,Int]) = ("",Left(Err(two)))
Inherited from
ApplicativeError
def point[A](a: A): F[A]
Implicitly added by monadCancelForOptionT

point lifts any value into a Monoidal Functor.

point lifts any value into a Monoidal Functor.

Example:

scala> import cats.implicits._

scala> InvariantMonoidal[Option].point(10)
res0: Option[Int] = Some(10)
Inherited from
InvariantMonoidal
def point[A](a: A): F[A]
Implicitly added by monadCancelForEitherT

point lifts any value into a Monoidal Functor.

point lifts any value into a Monoidal Functor.

Example:

scala> import cats.implicits._

scala> InvariantMonoidal[Option].point(10)
res0: Option[Int] = Some(10)
Inherited from
InvariantMonoidal
def point[A](a: A): F[A]
Implicitly added by monadCancelForKleisli

point lifts any value into a Monoidal Functor.

point lifts any value into a Monoidal Functor.

Example:

scala> import cats.implicits._

scala> InvariantMonoidal[Option].point(10)
res0: Option[Int] = Some(10)
Inherited from
InvariantMonoidal
def point[A](a: A): F[A]
Implicitly added by monadCancelForStateT

point lifts any value into a Monoidal Functor.

point lifts any value into a Monoidal Functor.

Example:

scala> import cats.implicits._

scala> InvariantMonoidal[Option].point(10)
res0: Option[Int] = Some(10)
Inherited from
InvariantMonoidal
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)
Inherited from
InvariantMonoidal
override def product[A, B](fa: F[A], fb: F[B]): F[(A, B)]
Definition Classes
FlatMap -> Apply -> Semigroupal
Inherited from
FlatMap
override def productL[A, B](fa: F[A])(fb: F[B]): F[A]
Definition Classes
FlatMap -> Apply
Inherited from
FlatMap
def productLEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[A]
Implicitly added by monadCancelForOptionT

Sequentially compose two actions, discarding any value produced by the second. This variant of productL also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:

Sequentially compose two actions, discarding any value produced by the second. This variant of productL also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:

scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int].productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
Inherited from
FlatMap
def productLEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[A]
Implicitly added by monadCancelForEitherT

Sequentially compose two actions, discarding any value produced by the second. This variant of productL also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:

Sequentially compose two actions, discarding any value produced by the second. This variant of productL also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:

scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int].productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
Inherited from
FlatMap
def productLEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[A]
Implicitly added by monadCancelForKleisli

Sequentially compose two actions, discarding any value produced by the second. This variant of productL also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:

Sequentially compose two actions, discarding any value produced by the second. This variant of productL also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:

scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int].productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
Inherited from
FlatMap
def productLEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[A]
Implicitly added by monadCancelForStateT

Sequentially compose two actions, discarding any value produced by the second. This variant of productL also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:

Sequentially compose two actions, discarding any value produced by the second. This variant of productL also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:

scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int].productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
Inherited from
FlatMap
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)
Inherited from
FlatMap
override def productR[A, B](fa: F[A])(fb: F[B]): F[B]
Definition Classes
FlatMap -> Apply
Inherited from
FlatMap
def productREval[A, B](fa: F[A])(fb: Eval[F[B]]): F[B]
Implicitly added by monadCancelForOptionT

Sequentially compose two actions, discarding any value produced by the first. This variant of productR also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:

Sequentially compose two actions, discarding any value produced by the first. This variant of productR also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:

scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
Inherited from
FlatMap
def productREval[A, B](fa: F[A])(fb: Eval[F[B]]): F[B]
Implicitly added by monadCancelForEitherT

Sequentially compose two actions, discarding any value produced by the first. This variant of productR also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:

Sequentially compose two actions, discarding any value produced by the first. This variant of productR also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:

scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
Inherited from
FlatMap
def productREval[A, B](fa: F[A])(fb: Eval[F[B]]): F[B]
Implicitly added by monadCancelForKleisli

Sequentially compose two actions, discarding any value produced by the first. This variant of productR also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:

Sequentially compose two actions, discarding any value produced by the first. This variant of productR also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:

scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
Inherited from
FlatMap
def productREval[A, B](fa: F[A])(fb: Eval[F[B]]): F[B]
Implicitly added by monadCancelForStateT

Sequentially compose two actions, discarding any value produced by the first. This variant of productR also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:

Sequentially compose two actions, discarding any value produced by the first. This variant of productR also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:

scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
Inherited from
FlatMap
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)
Inherited from
FlatMap
def pure[A](x: A): F[A]
Implicitly added by monadCancelForOptionT

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)
Inherited from
Applicative
def pure[A](x: A): F[A]
Implicitly added by monadCancelForEitherT

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)
Inherited from
Applicative
def pure[A](x: A): F[A]
Implicitly added by monadCancelForKleisli

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)
Inherited from
Applicative
def pure[A](x: A): F[A]
Implicitly added by monadCancelForStateT

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)
Inherited from
Applicative
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)
Inherited from
Applicative
def raiseError[A](e: E): F[A]
Implicitly added by monadCancelForOptionT

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)
Inherited from
ApplicativeError
def raiseError[A](e: E): F[A]
Implicitly added by monadCancelForEitherT

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)
Inherited from
ApplicativeError
def raiseError[A](e: E): F[A]
Implicitly added by monadCancelForKleisli

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)
Inherited from
ApplicativeError
def raiseError[A](e: E): F[A]
Implicitly added by monadCancelForStateT

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)
Inherited from
ApplicativeError
def raiseError[A](e: E): 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)
Inherited from
ApplicativeError
def recover[A](fa: F[A])(pf: PartialFunction[E, A]): F[A]
Implicitly added by monadCancelForOptionT

Recover from certain errors by mapping them to an A value.

Recover from certain errors by mapping them to an A value.

See also

handleError to handle any/all errors.

recoverWith to recover from certain errors by mapping them to F[A] values.

Inherited from
ApplicativeError
def recover[A](fa: F[A])(pf: PartialFunction[E, A]): F[A]
Implicitly added by monadCancelForEitherT

Recover from certain errors by mapping them to an A value.

Recover from certain errors by mapping them to an A value.

See also

handleError to handle any/all errors.

recoverWith to recover from certain errors by mapping them to F[A] values.

Inherited from
ApplicativeError
def recover[A](fa: F[A])(pf: PartialFunction[E, A]): F[A]
Implicitly added by monadCancelForKleisli

Recover from certain errors by mapping them to an A value.

Recover from certain errors by mapping them to an A value.

See also

handleError to handle any/all errors.

recoverWith to recover from certain errors by mapping them to F[A] values.

Inherited from
ApplicativeError
def recover[A](fa: F[A])(pf: PartialFunction[E, A]): F[A]
Implicitly added by monadCancelForStateT

Recover from certain errors by mapping them to an A value.

Recover from certain errors by mapping them to an A value.

See also

handleError to handle any/all errors.

recoverWith to recover from certain errors by mapping them to F[A] values.

Inherited from
ApplicativeError
def recover[A](fa: F[A])(pf: PartialFunction[E, 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.

See also

handleError to handle any/all errors.

recoverWith to recover from certain errors by mapping them to F[A] values.

Inherited from
ApplicativeError
def recoverWith[A](fa: F[A])(pf: PartialFunction[E, F[A]]): F[A]
Implicitly added by monadCancelForOptionT

Recover from certain errors by mapping them to an F[A] value.

Recover from certain errors by mapping them to an F[A] value.

See also

handleErrorWith to handle any/all errors.

recover to recover from certain errors by mapping them to A values.

Inherited from
ApplicativeError
def recoverWith[A](fa: F[A])(pf: PartialFunction[E, F[A]]): F[A]
Implicitly added by monadCancelForEitherT

Recover from certain errors by mapping them to an F[A] value.

Recover from certain errors by mapping them to an F[A] value.

See also

handleErrorWith to handle any/all errors.

recover to recover from certain errors by mapping them to A values.

Inherited from
ApplicativeError
def recoverWith[A](fa: F[A])(pf: PartialFunction[E, F[A]]): F[A]
Implicitly added by monadCancelForKleisli

Recover from certain errors by mapping them to an F[A] value.

Recover from certain errors by mapping them to an F[A] value.

See also

handleErrorWith to handle any/all errors.

recover to recover from certain errors by mapping them to A values.

Inherited from
ApplicativeError
def recoverWith[A](fa: F[A])(pf: PartialFunction[E, F[A]]): F[A]
Implicitly added by monadCancelForStateT

Recover from certain errors by mapping them to an F[A] value.

Recover from certain errors by mapping them to an F[A] value.

See also

handleErrorWith to handle any/all errors.

recover to recover from certain errors by mapping them to A values.

Inherited from
ApplicativeError
def recoverWith[A](fa: F[A])(pf: PartialFunction[E, F[A]]): F[A]

Recover from certain errors by mapping them to an F[A] value.

Recover from certain errors by mapping them to an F[A] value.

See also

handleErrorWith to handle any/all errors.

recover to recover from certain errors by mapping them to A values.

Inherited from
ApplicativeError
def redeem[A, B](fa: F[A])(recover: E => B, f: A => B): F[B]
Implicitly added by monadCancelForOptionT

Returns a new value that transforms the result of the source, given the recover or map functions, which get executed depending on whether the result is successful or if it ends in error.

Returns a new value that transforms the result of the source, given the recover or map functions, which get executed depending on whether the result is successful or if it ends in error.

This is an optimization on usage of attempt and map, this equivalence being available:

 fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))

Usage of redeem subsumes handleError because:

 fa.redeem(fe, id) <-> fa.handleError(fe)

Implementations are free to override it in order to optimize error recovery.

Value Params
fa

is the source whose result is going to get transformed

recover

is the function that gets called to recover the source in case of error

See also

MonadError.redeemWith, attempt and handleError

Inherited from
ApplicativeError
def redeem[A, B](fa: F[A])(recover: E => B, f: A => B): F[B]
Implicitly added by monadCancelForEitherT

Returns a new value that transforms the result of the source, given the recover or map functions, which get executed depending on whether the result is successful or if it ends in error.

Returns a new value that transforms the result of the source, given the recover or map functions, which get executed depending on whether the result is successful or if it ends in error.

This is an optimization on usage of attempt and map, this equivalence being available:

 fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))

Usage of redeem subsumes handleError because:

 fa.redeem(fe, id) <-> fa.handleError(fe)

Implementations are free to override it in order to optimize error recovery.

Value Params
fa

is the source whose result is going to get transformed

recover

is the function that gets called to recover the source in case of error

See also

MonadError.redeemWith, attempt and handleError

Inherited from
ApplicativeError
def redeem[A, B](fa: F[A])(recover: E => B, f: A => B): F[B]
Implicitly added by monadCancelForKleisli

Returns a new value that transforms the result of the source, given the recover or map functions, which get executed depending on whether the result is successful or if it ends in error.

Returns a new value that transforms the result of the source, given the recover or map functions, which get executed depending on whether the result is successful or if it ends in error.

This is an optimization on usage of attempt and map, this equivalence being available:

 fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))

Usage of redeem subsumes handleError because:

 fa.redeem(fe, id) <-> fa.handleError(fe)

Implementations are free to override it in order to optimize error recovery.

Value Params
fa

is the source whose result is going to get transformed

recover

is the function that gets called to recover the source in case of error

See also

MonadError.redeemWith, attempt and handleError

Inherited from
ApplicativeError
def redeem[A, B](fa: F[A])(recover: E => B, f: A => B): F[B]
Implicitly added by monadCancelForStateT

Returns a new value that transforms the result of the source, given the recover or map functions, which get executed depending on whether the result is successful or if it ends in error.

Returns a new value that transforms the result of the source, given the recover or map functions, which get executed depending on whether the result is successful or if it ends in error.

This is an optimization on usage of attempt and map, this equivalence being available:

 fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))

Usage of redeem subsumes handleError because:

 fa.redeem(fe, id) <-> fa.handleError(fe)

Implementations are free to override it in order to optimize error recovery.

Value Params
fa

is the source whose result is going to get transformed

recover

is the function that gets called to recover the source in case of error

See also

MonadError.redeemWith, attempt and handleError

Inherited from
ApplicativeError
def redeem[A, B](fa: F[A])(recover: E => B, f: A => B): F[B]

Returns a new value that transforms the result of the source, given the recover or map functions, which get executed depending on whether the result is successful or if it ends in error.

Returns a new value that transforms the result of the source, given the recover or map functions, which get executed depending on whether the result is successful or if it ends in error.

This is an optimization on usage of attempt and map, this equivalence being available:

 fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))

Usage of redeem subsumes handleError because:

 fa.redeem(fe, id) <-> fa.handleError(fe)

Implementations are free to override it in order to optimize error recovery.

Value Params
fa

is the source whose result is going to get transformed

recover

is the function that gets called to recover the source in case of error

See also

MonadError.redeemWith, attempt and handleError

Inherited from
ApplicativeError
def redeemWith[A, B](fa: F[A])(recover: E => F[B], bind: A => F[B]): F[B]
Implicitly added by monadCancelForOptionT

Returns a new value that transforms the result of the source, given the recover or bind functions, which get executed depending on whether the result is successful or if it ends in error.

Returns a new value that transforms the result of the source, given the recover or bind functions, which get executed depending on whether the result is successful or if it ends in error.

This is an optimization on usage of attempt and flatMap, this equivalence being available:

 fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))

Usage of redeemWith subsumes handleErrorWith because:

 fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)

Usage of redeemWith also subsumes flatMap because:

 fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)

Implementations are free to override it in order to optimize error recovery.

Value Params
bind

is the function that gets to transform the source in case of success

fa

is the source whose result is going to get transformed

recover

is the function that gets called to recover the source in case of error

See also

redeem, attempt and handleErrorWith

Inherited from
MonadError
def redeemWith[A, B](fa: F[A])(recover: E => F[B], bind: A => F[B]): F[B]
Implicitly added by monadCancelForEitherT

Returns a new value that transforms the result of the source, given the recover or bind functions, which get executed depending on whether the result is successful or if it ends in error.

Returns a new value that transforms the result of the source, given the recover or bind functions, which get executed depending on whether the result is successful or if it ends in error.

This is an optimization on usage of attempt and flatMap, this equivalence being available:

 fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))

Usage of redeemWith subsumes handleErrorWith because:

 fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)

Usage of redeemWith also subsumes flatMap because:

 fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)

Implementations are free to override it in order to optimize error recovery.

Value Params
bind

is the function that gets to transform the source in case of success

fa

is the source whose result is going to get transformed

recover

is the function that gets called to recover the source in case of error

See also

redeem, attempt and handleErrorWith

Inherited from
MonadError
def redeemWith[A, B](fa: F[A])(recover: E => F[B], bind: A => F[B]): F[B]
Implicitly added by monadCancelForKleisli

Returns a new value that transforms the result of the source, given the recover or bind functions, which get executed depending on whether the result is successful or if it ends in error.

Returns a new value that transforms the result of the source, given the recover or bind functions, which get executed depending on whether the result is successful or if it ends in error.

This is an optimization on usage of attempt and flatMap, this equivalence being available:

 fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))

Usage of redeemWith subsumes handleErrorWith because:

 fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)

Usage of redeemWith also subsumes flatMap because:

 fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)

Implementations are free to override it in order to optimize error recovery.

Value Params
bind

is the function that gets to transform the source in case of success

fa

is the source whose result is going to get transformed

recover

is the function that gets called to recover the source in case of error

See also

redeem, attempt and handleErrorWith

Inherited from
MonadError
def redeemWith[A, B](fa: F[A])(recover: E => F[B], bind: A => F[B]): F[B]
Implicitly added by monadCancelForStateT

Returns a new value that transforms the result of the source, given the recover or bind functions, which get executed depending on whether the result is successful or if it ends in error.

Returns a new value that transforms the result of the source, given the recover or bind functions, which get executed depending on whether the result is successful or if it ends in error.

This is an optimization on usage of attempt and flatMap, this equivalence being available:

 fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))

Usage of redeemWith subsumes handleErrorWith because:

 fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)

Usage of redeemWith also subsumes flatMap because:

 fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)

Implementations are free to override it in order to optimize error recovery.

Value Params
bind

is the function that gets to transform the source in case of success

fa

is the source whose result is going to get transformed

recover

is the function that gets called to recover the source in case of error

See also

redeem, attempt and handleErrorWith

Inherited from
MonadError
def redeemWith[A, B](fa: F[A])(recover: E => F[B], bind: A => F[B]): F[B]

Returns a new value that transforms the result of the source, given the recover or bind functions, which get executed depending on whether the result is successful or if it ends in error.

Returns a new value that transforms the result of the source, given the recover or bind functions, which get executed depending on whether the result is successful or if it ends in error.

This is an optimization on usage of attempt and flatMap, this equivalence being available:

 fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))

Usage of redeemWith subsumes handleErrorWith because:

 fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)

Usage of redeemWith also subsumes flatMap because:

 fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)

Implementations are free to override it in order to optimize error recovery.

Value Params
bind

is the function that gets to transform the source in case of success

fa

is the source whose result is going to get transformed

recover

is the function that gets called to recover the source in case of error

See also

redeem, attempt and handleErrorWith

Inherited from
MonadError
def replicateA[A](n: Int, fa: F[A]): F[List[A]]
Implicitly added by monadCancelForOptionT

Given fa and n, apply fa n times to construct an F[List[A]] value.

Given fa and n, apply fa n times to construct an F[List[A]] value.

Example:

scala> import cats.data.State

scala> type Counter[A] = State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int]] =
    | Applicative[Counter].replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int]) = (5,List(0, 1, 2, 3, 4))
Inherited from
Applicative
def replicateA[A](n: Int, fa: F[A]): F[List[A]]
Implicitly added by monadCancelForEitherT

Given fa and n, apply fa n times to construct an F[List[A]] value.

Given fa and n, apply fa n times to construct an F[List[A]] value.

Example:

scala> import cats.data.State

scala> type Counter[A] = State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int]] =
    | Applicative[Counter].replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int]) = (5,List(0, 1, 2, 3, 4))
Inherited from
Applicative
def replicateA[A](n: Int, fa: F[A]): F[List[A]]
Implicitly added by monadCancelForKleisli

Given fa and n, apply fa n times to construct an F[List[A]] value.

Given fa and n, apply fa n times to construct an F[List[A]] value.

Example:

scala> import cats.data.State

scala> type Counter[A] = State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int]] =
    | Applicative[Counter].replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int]) = (5,List(0, 1, 2, 3, 4))
Inherited from
Applicative
def replicateA[A](n: Int, fa: F[A]): F[List[A]]
Implicitly added by monadCancelForStateT

Given fa and n, apply fa n times to construct an F[List[A]] value.

Given fa and n, apply fa n times to construct an F[List[A]] value.

Example:

scala> import cats.data.State

scala> type Counter[A] = State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int]] =
    | Applicative[Counter].replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int]) = (5,List(0, 1, 2, 3, 4))
Inherited from
Applicative
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))
Inherited from
Applicative
def rethrow[A, EE <: E](fa: F[Either[EE, A]]): F[A]
Implicitly added by monadCancelForOptionT

Inverse of attempt

Inverse of attempt

Example:

scala> import cats.implicits._
scala> import scala.util.{Try, Success}

scala> val a: Try[Either[Throwable, Int]] = Success(Left(new java.lang.Exception))
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)

scala> val b: Try[Either[Throwable, Int]] = Success(Right(1))
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
Inherited from
MonadError
def rethrow[A, EE <: E](fa: F[Either[EE, A]]): F[A]
Implicitly added by monadCancelForEitherT

Inverse of attempt

Inverse of attempt

Example:

scala> import cats.implicits._
scala> import scala.util.{Try, Success}

scala> val a: Try[Either[Throwable, Int]] = Success(Left(new java.lang.Exception))
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)

scala> val b: Try[Either[Throwable, Int]] = Success(Right(1))
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
Inherited from
MonadError
def rethrow[A, EE <: E](fa: F[Either[EE, A]]): F[A]
Implicitly added by monadCancelForKleisli

Inverse of attempt

Inverse of attempt

Example:

scala> import cats.implicits._
scala> import scala.util.{Try, Success}

scala> val a: Try[Either[Throwable, Int]] = Success(Left(new java.lang.Exception))
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)

scala> val b: Try[Either[Throwable, Int]] = Success(Right(1))
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
Inherited from
MonadError
def rethrow[A, EE <: E](fa: F[Either[EE, A]]): F[A]
Implicitly added by monadCancelForStateT

Inverse of attempt

Inverse of attempt

Example:

scala> import cats.implicits._
scala> import scala.util.{Try, Success}

scala> val a: Try[Either[Throwable, Int]] = Success(Left(new java.lang.Exception))
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)

scala> val b: Try[Either[Throwable, Int]] = Success(Right(1))
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
Inherited from
MonadError
def rethrow[A, EE <: E](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)
Inherited from
MonadError
def tailRecM[A, B](a: A)(f: A => F[Either[A, B]]): F[B]
Implicitly added by monadCancelForOptionT

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.

Inherited from
FlatMap
def tailRecM[A, B](a: A)(f: A => F[Either[A, B]]): F[B]
Implicitly added by monadCancelForEitherT

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.

Inherited from
FlatMap
def tailRecM[A, B](a: A)(f: A => F[Either[A, B]]): F[B]
Implicitly added by monadCancelForKleisli

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.

Inherited from
FlatMap
def tailRecM[A, B](a: A)(f: A => F[Either[A, B]]): F[B]
Implicitly added by monadCancelForStateT

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.

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

Inherited from
FlatMap
def tuple10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def tuple10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def tuple10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def tuple10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def tuple10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)]
Inherited from
ApplyArityFunctions
def tuple11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def tuple11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def tuple11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def tuple11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def tuple11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]
Inherited from
ApplyArityFunctions
def tuple12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def tuple12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def tuple12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def tuple12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def tuple12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]
Inherited from
ApplyArityFunctions
def tuple13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def tuple13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def tuple13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def tuple13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def tuple13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]
Inherited from
ApplyArityFunctions
def tuple14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def tuple14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def tuple14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def tuple14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def tuple14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]
Inherited from
ApplyArityFunctions
def tuple15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def tuple15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def tuple15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def tuple15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def tuple15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]
Inherited from
ApplyArityFunctions
def tuple16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def tuple16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def tuple16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def tuple16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def tuple16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]
Inherited from
ApplyArityFunctions
def tuple17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def tuple17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def tuple17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def tuple17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def tuple17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]
Inherited from
ApplyArityFunctions
def tuple18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def tuple18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def tuple18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def tuple18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def tuple18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]
Inherited from
ApplyArityFunctions
def tuple19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def tuple19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def tuple19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def tuple19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def tuple19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]
Inherited from
ApplyArityFunctions
def tuple2[A, B](f1: F[A], f2: F[B]): F[(A, B)]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def tuple2[A, B](f1: F[A], f2: F[B]): F[(A, B)]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def tuple2[A, B](f1: F[A], f2: F[B]): F[(A, B)]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def tuple2[A, B](f1: F[A], f2: F[B]): F[(A, B)]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def tuple2[A, B](f1: F[A], f2: F[B]): F[(A, B)]
Inherited from
ApplyArityFunctions
def tuple20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def tuple20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def tuple20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def tuple20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def tuple20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]
Inherited from
ApplyArityFunctions
def tuple21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def tuple21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def tuple21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def tuple21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def tuple21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]
Inherited from
ApplyArityFunctions
def tuple22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def tuple22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def tuple22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def tuple22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def tuple22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)]
Inherited from
ApplyArityFunctions
def tuple3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2]): F[(A0, A1, A2)]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def tuple3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2]): F[(A0, A1, A2)]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def tuple3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2]): F[(A0, A1, A2)]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def tuple3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2]): F[(A0, A1, A2)]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def tuple3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2]): F[(A0, A1, A2)]
Inherited from
ApplyArityFunctions
def tuple4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[(A0, A1, A2, A3)]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def tuple4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[(A0, A1, A2, A3)]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def tuple4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[(A0, A1, A2, A3)]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def tuple4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[(A0, A1, A2, A3)]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def tuple4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[(A0, A1, A2, A3)]
Inherited from
ApplyArityFunctions
def tuple5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[(A0, A1, A2, A3, A4)]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def tuple5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[(A0, A1, A2, A3, A4)]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def tuple5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[(A0, A1, A2, A3, A4)]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def tuple5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[(A0, A1, A2, A3, A4)]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def tuple5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[(A0, A1, A2, A3, A4)]
Inherited from
ApplyArityFunctions
def tuple6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[(A0, A1, A2, A3, A4, A5)]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def tuple6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[(A0, A1, A2, A3, A4, A5)]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def tuple6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[(A0, A1, A2, A3, A4, A5)]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def tuple6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[(A0, A1, A2, A3, A4, A5)]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def tuple6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[(A0, A1, A2, A3, A4, A5)]
Inherited from
ApplyArityFunctions
def tuple7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[(A0, A1, A2, A3, A4, A5, A6)]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def tuple7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[(A0, A1, A2, A3, A4, A5, A6)]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def tuple7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[(A0, A1, A2, A3, A4, A5, A6)]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def tuple7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[(A0, A1, A2, A3, A4, A5, A6)]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def tuple7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[(A0, A1, A2, A3, A4, A5, A6)]
Inherited from
ApplyArityFunctions
def tuple8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[(A0, A1, A2, A3, A4, A5, A6, A7)]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def tuple8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[(A0, A1, A2, A3, A4, A5, A6, A7)]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def tuple8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[(A0, A1, A2, A3, A4, A5, A6, A7)]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def tuple8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[(A0, A1, A2, A3, A4, A5, A6, A7)]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def tuple8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[(A0, A1, A2, A3, A4, A5, A6, A7)]
Inherited from
ApplyArityFunctions
def tuple9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8)]
Implicitly added by monadCancelForOptionT
Inherited from
ApplyArityFunctions
def tuple9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8)]
Implicitly added by monadCancelForEitherT
Inherited from
ApplyArityFunctions
def tuple9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8)]
Implicitly added by monadCancelForKleisli
Inherited from
ApplyArityFunctions
def tuple9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8)]
Implicitly added by monadCancelForStateT
Inherited from
ApplyArityFunctions
def tuple9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8)]
Inherited from
ApplyArityFunctions
def tupleLeft[A, B](fa: F[A], b: B): F[(B, A)]
Implicitly added by monadCancelForOptionT

Tuples the A value in F[A] with the supplied B value, with the B value on the left.

Tuples the A value in F[A] with the supplied B value, with the B value on the left.

Example:

scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue

scala> Functor[Queue].tupleLeft(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
Inherited from
Functor
def tupleLeft[A, B](fa: F[A], b: B): F[(B, A)]
Implicitly added by monadCancelForEitherT

Tuples the A value in F[A] with the supplied B value, with the B value on the left.

Tuples the A value in F[A] with the supplied B value, with the B value on the left.

Example:

scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue

scala> Functor[Queue].tupleLeft(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
Inherited from
Functor
def tupleLeft[A, B](fa: F[A], b: B): F[(B, A)]
Implicitly added by monadCancelForKleisli

Tuples the A value in F[A] with the supplied B value, with the B value on the left.

Tuples the A value in F[A] with the supplied B value, with the B value on the left.

Example:

scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue

scala> Functor[Queue].tupleLeft(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
Inherited from
Functor
def tupleLeft[A, B](fa: F[A], b: B): F[(B, A)]
Implicitly added by monadCancelForStateT

Tuples the A value in F[A] with the supplied B value, with the B value on the left.

Tuples the A value in F[A] with the supplied B value, with the B value on the left.

Example:

scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue

scala> Functor[Queue].tupleLeft(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
Inherited from
Functor
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))
Inherited from
Functor
def tupleRight[A, B](fa: F[A], b: B): F[(A, B)]
Implicitly added by monadCancelForOptionT

Tuples the A value in F[A] with the supplied B value, with the B value on the right.

Tuples the A value in F[A] with the supplied B value, with the B value on the right.

Example:

scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue

scala> Functor[Queue].tupleRight(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
Inherited from
Functor
def tupleRight[A, B](fa: F[A], b: B): F[(A, B)]
Implicitly added by monadCancelForEitherT

Tuples the A value in F[A] with the supplied B value, with the B value on the right.

Tuples the A value in F[A] with the supplied B value, with the B value on the right.

Example:

scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue

scala> Functor[Queue].tupleRight(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
Inherited from
Functor
def tupleRight[A, B](fa: F[A], b: B): F[(A, B)]
Implicitly added by monadCancelForKleisli

Tuples the A value in F[A] with the supplied B value, with the B value on the right.

Tuples the A value in F[A] with the supplied B value, with the B value on the right.

Example:

scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue

scala> Functor[Queue].tupleRight(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
Inherited from
Functor
def tupleRight[A, B](fa: F[A], b: B): F[(A, B)]
Implicitly added by monadCancelForStateT

Tuples the A value in F[A] with the supplied B value, with the B value on the right.

Tuples the A value in F[A] with the supplied B value, with the B value on the right.

Example:

scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue

scala> Functor[Queue].tupleRight(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
Inherited from
Functor
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))
Inherited from
Functor
def unit: F[Unit]
Implicitly added by monadCancelForOptionT

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(())
Inherited from
Applicative
def unit: F[Unit]
Implicitly added by monadCancelForEitherT

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(())
Inherited from
Applicative
def unit: F[Unit]
Implicitly added by monadCancelForKleisli

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(())
Inherited from
Applicative
def unit: F[Unit]
Implicitly added by monadCancelForStateT

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(())
Inherited from
Applicative
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(())
Inherited from
Applicative
def unlessA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by monadCancelForOptionT

Returns the given argument (mapped to Unit) if cond is false, otherwise, unit lifted into F.

Returns the given argument (mapped to Unit) if cond is false, otherwise, unit lifted into F.

Example:

scala> import cats.implicits._

scala> Applicative[List].unlessA(true)(List(1, 2, 3))
res0: List[Unit] = List(())

scala> Applicative[List].unlessA(false)(List(1, 2, 3))
res1: List[Unit] = List((), (), ())

scala> Applicative[List].unlessA(true)(List.empty[Int])
res2: List[Unit] = List(())

scala> Applicative[List].unlessA(false)(List.empty[Int])
res3: List[Unit] = List()
Inherited from
Applicative
def unlessA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by monadCancelForEitherT

Returns the given argument (mapped to Unit) if cond is false, otherwise, unit lifted into F.

Returns the given argument (mapped to Unit) if cond is false, otherwise, unit lifted into F.

Example:

scala> import cats.implicits._

scala> Applicative[List].unlessA(true)(List(1, 2, 3))
res0: List[Unit] = List(())

scala> Applicative[List].unlessA(false)(List(1, 2, 3))
res1: List[Unit] = List((), (), ())

scala> Applicative[List].unlessA(true)(List.empty[Int])
res2: List[Unit] = List(())

scala> Applicative[List].unlessA(false)(List.empty[Int])
res3: List[Unit] = List()
Inherited from
Applicative
def unlessA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by monadCancelForKleisli

Returns the given argument (mapped to Unit) if cond is false, otherwise, unit lifted into F.

Returns the given argument (mapped to Unit) if cond is false, otherwise, unit lifted into F.

Example:

scala> import cats.implicits._

scala> Applicative[List].unlessA(true)(List(1, 2, 3))
res0: List[Unit] = List(())

scala> Applicative[List].unlessA(false)(List(1, 2, 3))
res1: List[Unit] = List((), (), ())

scala> Applicative[List].unlessA(true)(List.empty[Int])
res2: List[Unit] = List(())

scala> Applicative[List].unlessA(false)(List.empty[Int])
res3: List[Unit] = List()
Inherited from
Applicative
def unlessA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by monadCancelForStateT

Returns the given argument (mapped to Unit) if cond is false, otherwise, unit lifted into F.

Returns the given argument (mapped to Unit) if cond is false, otherwise, unit lifted into F.

Example:

scala> import cats.implicits._

scala> Applicative[List].unlessA(true)(List(1, 2, 3))
res0: List[Unit] = List(())

scala> Applicative[List].unlessA(false)(List(1, 2, 3))
res1: List[Unit] = List((), (), ())

scala> Applicative[List].unlessA(true)(List.empty[Int])
res2: List[Unit] = List(())

scala> Applicative[List].unlessA(false)(List.empty[Int])
res3: List[Unit] = List()
Inherited from
Applicative
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()
Inherited from
Applicative
@noop
def untilDefinedM[A](foa: F[Option[A]]): F[A]
Implicitly added by monadCancelForOptionT

This repeats an F until we get defined values. This can be useful for polling type operations on State (or RNG) Monads, or in effect monads.

This repeats an F until we get defined values. This can be useful for polling type operations on State (or RNG) Monads, or in effect monads.

Inherited from
FlatMap
@noop
def untilDefinedM[A](foa: F[Option[A]]): F[A]
Implicitly added by monadCancelForEitherT

This repeats an F until we get defined values. This can be useful for polling type operations on State (or RNG) Monads, or in effect monads.

This repeats an F until we get defined values. This can be useful for polling type operations on State (or RNG) Monads, or in effect monads.

Inherited from
FlatMap
@noop
def untilDefinedM[A](foa: F[Option[A]]): F[A]
Implicitly added by monadCancelForKleisli

This repeats an F until we get defined values. This can be useful for polling type operations on State (or RNG) Monads, or in effect monads.

This repeats an F until we get defined values. This can be useful for polling type operations on State (or RNG) Monads, or in effect monads.

Inherited from
FlatMap
@noop
def untilDefinedM[A](foa: F[Option[A]]): F[A]
Implicitly added by monadCancelForStateT

This repeats an F until we get defined values. This can be useful for polling type operations on State (or RNG) Monads, or in effect monads.

This repeats an F until we get defined values. This can be useful for polling type operations on State (or RNG) Monads, or in effect monads.

Inherited from
FlatMap
@noop
def untilDefinedM[A](foa: F[Option[A]]): F[A]

This repeats an F until we get defined values. This can be useful for polling type operations on State (or RNG) Monads, or in effect monads.

This repeats an F until we get defined values. This can be useful for polling type operations on State (or RNG) Monads, or in effect monads.

Inherited from
FlatMap
def untilM[G[_], A](f: F[A])(cond: => F[Boolean])(implicit G: Alternative[G]): F[G[A]]
Implicitly added by monadCancelForOptionT

Execute an action repeatedly until the Boolean condition returns true. The condition is evaluated after the loop body. Collects results into an arbitrary Alternative value, such as a Vector. This implementation uses append on each evaluation result, so avoid data structures with non-constant append performance, e.g. List.

Execute an action repeatedly until the Boolean condition returns true. The condition is evaluated after the loop body. Collects results into an arbitrary Alternative value, such as a Vector. This implementation uses append on each evaluation result, so avoid data structures with non-constant append performance, e.g. List.

Inherited from
Monad
def untilM[G[_], A](f: F[A])(cond: => F[Boolean])(implicit G: Alternative[G]): F[G[A]]
Implicitly added by monadCancelForEitherT

Execute an action repeatedly until the Boolean condition returns true. The condition is evaluated after the loop body. Collects results into an arbitrary Alternative value, such as a Vector. This implementation uses append on each evaluation result, so avoid data structures with non-constant append performance, e.g. List.

Execute an action repeatedly until the Boolean condition returns true. The condition is evaluated after the loop body. Collects results into an arbitrary Alternative value, such as a Vector. This implementation uses append on each evaluation result, so avoid data structures with non-constant append performance, e.g. List.

Inherited from
Monad
def untilM[G[_], A](f: F[A])(cond: => F[Boolean])(implicit G: Alternative[G]): F[G[A]]
Implicitly added by monadCancelForKleisli

Execute an action repeatedly until the Boolean condition returns true. The condition is evaluated after the loop body. Collects results into an arbitrary Alternative value, such as a Vector. This implementation uses append on each evaluation result, so avoid data structures with non-constant append performance, e.g. List.

Execute an action repeatedly until the Boolean condition returns true. The condition is evaluated after the loop body. Collects results into an arbitrary Alternative value, such as a Vector. This implementation uses append on each evaluation result, so avoid data structures with non-constant append performance, e.g. List.

Inherited from
Monad
def untilM[G[_], A](f: F[A])(cond: => F[Boolean])(implicit G: Alternative[G]): F[G[A]]
Implicitly added by monadCancelForStateT

Execute an action repeatedly until the Boolean condition returns true. The condition is evaluated after the loop body. Collects results into an arbitrary Alternative value, such as a Vector. This implementation uses append on each evaluation result, so avoid data structures with non-constant append performance, e.g. List.

Execute an action repeatedly until the Boolean condition returns true. The condition is evaluated after the loop body. Collects results into an arbitrary Alternative value, such as a Vector. This implementation uses append on each evaluation result, so avoid data structures with non-constant append performance, e.g. List.

Inherited from
Monad
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.

Inherited from
Monad
def untilM_[A](f: F[A])(cond: => F[Boolean]): F[Unit]
Implicitly added by monadCancelForOptionT

Execute an action repeatedly until the Boolean condition returns true. The condition is evaluated after the loop body. Discards results.

Execute an action repeatedly until the Boolean condition returns true. The condition is evaluated after the loop body. Discards results.

Inherited from
Monad
def untilM_[A](f: F[A])(cond: => F[Boolean]): F[Unit]
Implicitly added by monadCancelForEitherT

Execute an action repeatedly until the Boolean condition returns true. The condition is evaluated after the loop body. Discards results.

Execute an action repeatedly until the Boolean condition returns true. The condition is evaluated after the loop body. Discards results.

Inherited from
Monad
def untilM_[A](f: F[A])(cond: => F[Boolean]): F[Unit]
Implicitly added by monadCancelForKleisli

Execute an action repeatedly until the Boolean condition returns true. The condition is evaluated after the loop body. Discards results.

Execute an action repeatedly until the Boolean condition returns true. The condition is evaluated after the loop body. Discards results.

Inherited from
Monad
def untilM_[A](f: F[A])(cond: => F[Boolean]): F[Unit]
Implicitly added by monadCancelForStateT

Execute an action repeatedly until the Boolean condition returns true. The condition is evaluated after the loop body. Discards results.

Execute an action repeatedly until the Boolean condition returns true. The condition is evaluated after the loop body. Discards results.

Inherited from
Monad
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.

Inherited from
Monad
@noop
def unzip[A, B](fab: F[(A, B)]): (F[A], F[B])
Implicitly added by monadCancelForOptionT

Un-zips an F[(A, B)] consisting of element pairs or Tuple2 into two separate F's tupled.

Un-zips an F[(A, B)] consisting of element pairs or Tuple2 into two separate F's tupled.

NOTE: Check for effect duplication, possibly memoize before

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList

scala> Functor[List].unzip(List((1,2), (3, 4)))
res0: (List[Int], List[Int]) = (List(1, 3),List(2, 4))
Inherited from
Functor
@noop
def unzip[A, B](fab: F[(A, B)]): (F[A], F[B])
Implicitly added by monadCancelForEitherT

Un-zips an F[(A, B)] consisting of element pairs or Tuple2 into two separate F's tupled.

Un-zips an F[(A, B)] consisting of element pairs or Tuple2 into two separate F's tupled.

NOTE: Check for effect duplication, possibly memoize before

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList

scala> Functor[List].unzip(List((1,2), (3, 4)))
res0: (List[Int], List[Int]) = (List(1, 3),List(2, 4))
Inherited from
Functor
@noop
def unzip[A, B](fab: F[(A, B)]): (F[A], F[B])
Implicitly added by monadCancelForKleisli

Un-zips an F[(A, B)] consisting of element pairs or Tuple2 into two separate F's tupled.

Un-zips an F[(A, B)] consisting of element pairs or Tuple2 into two separate F's tupled.

NOTE: Check for effect duplication, possibly memoize before

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList

scala> Functor[List].unzip(List((1,2), (3, 4)))
res0: (List[Int], List[Int]) = (List(1, 3),List(2, 4))
Inherited from
Functor
@noop
def unzip[A, B](fab: F[(A, B)]): (F[A], F[B])
Implicitly added by monadCancelForStateT

Un-zips an F[(A, B)] consisting of element pairs or Tuple2 into two separate F's tupled.

Un-zips an F[(A, B)] consisting of element pairs or Tuple2 into two separate F's tupled.

NOTE: Check for effect duplication, possibly memoize before

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList

scala> Functor[List].unzip(List((1,2), (3, 4)))
res0: (List[Int], List[Int]) = (List(1, 3),List(2, 4))
Inherited from
Functor
@noop
def unzip[A, B](fab: F[(A, B)]): (F[A], F[B])

Un-zips an F[(A, B)] consisting of element pairs or Tuple2 into two separate F's tupled.

Un-zips an F[(A, B)] consisting of element pairs or Tuple2 into two separate F's tupled.

NOTE: Check for effect duplication, possibly memoize before

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList

scala> Functor[List].unzip(List((1,2), (3, 4)))
res0: (List[Int], List[Int]) = (List(1, 3),List(2, 4))
Inherited from
Functor
def void[A](fa: F[A]): F[Unit]
Implicitly added by monadCancelForOptionT

Empty the fa of the values, preserving the structure

Empty the fa of the values, preserving the structure

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList

scala> Functor[List].void(List(1,2,3))
res0: List[Unit] = List((), (), ())
Inherited from
Functor
def void[A](fa: F[A]): F[Unit]
Implicitly added by monadCancelForEitherT

Empty the fa of the values, preserving the structure

Empty the fa of the values, preserving the structure

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList

scala> Functor[List].void(List(1,2,3))
res0: List[Unit] = List((), (), ())
Inherited from
Functor
def void[A](fa: F[A]): F[Unit]
Implicitly added by monadCancelForKleisli

Empty the fa of the values, preserving the structure

Empty the fa of the values, preserving the structure

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList

scala> Functor[List].void(List(1,2,3))
res0: List[Unit] = List((), (), ())
Inherited from
Functor
def void[A](fa: F[A]): F[Unit]
Implicitly added by monadCancelForStateT

Empty the fa of the values, preserving the structure

Empty the fa of the values, preserving the structure

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList

scala> Functor[List].void(List(1,2,3))
res0: List[Unit] = List((), (), ())
Inherited from
Functor
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((), (), ())
Inherited from
Functor
def whenA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by monadCancelForOptionT

Returns the given argument (mapped to Unit) if cond is true, otherwise, unit lifted into F.

Returns the given argument (mapped to Unit) if cond is true, otherwise, unit lifted into F.

Example:

scala> import cats.implicits._

scala> Applicative[List].whenA(true)(List(1, 2, 3))
res0: List[Unit] = List((), (), ())

scala> Applicative[List].whenA(false)(List(1, 2, 3))
res1: List[Unit] = List(())

scala> Applicative[List].whenA(true)(List.empty[Int])
res2: List[Unit] = List()

scala> Applicative[List].whenA(false)(List.empty[Int])
res3: List[Unit] = List(())
Inherited from
Applicative
def whenA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by monadCancelForEitherT

Returns the given argument (mapped to Unit) if cond is true, otherwise, unit lifted into F.

Returns the given argument (mapped to Unit) if cond is true, otherwise, unit lifted into F.

Example:

scala> import cats.implicits._

scala> Applicative[List].whenA(true)(List(1, 2, 3))
res0: List[Unit] = List((), (), ())

scala> Applicative[List].whenA(false)(List(1, 2, 3))
res1: List[Unit] = List(())

scala> Applicative[List].whenA(true)(List.empty[Int])
res2: List[Unit] = List()

scala> Applicative[List].whenA(false)(List.empty[Int])
res3: List[Unit] = List(())
Inherited from
Applicative
def whenA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by monadCancelForKleisli

Returns the given argument (mapped to Unit) if cond is true, otherwise, unit lifted into F.

Returns the given argument (mapped to Unit) if cond is true, otherwise, unit lifted into F.

Example:

scala> import cats.implicits._

scala> Applicative[List].whenA(true)(List(1, 2, 3))
res0: List[Unit] = List((), (), ())

scala> Applicative[List].whenA(false)(List(1, 2, 3))
res1: List[Unit] = List(())

scala> Applicative[List].whenA(true)(List.empty[Int])
res2: List[Unit] = List()

scala> Applicative[List].whenA(false)(List.empty[Int])
res3: List[Unit] = List(())
Inherited from
Applicative
def whenA[A](cond: Boolean)(f: => F[A]): F[Unit]
Implicitly added by monadCancelForStateT

Returns the given argument (mapped to Unit) if cond is true, otherwise, unit lifted into F.

Returns the given argument (mapped to Unit) if cond is true, otherwise, unit lifted into F.

Example:

scala> import cats.implicits._

scala> Applicative[List].whenA(true)(List(1, 2, 3))
res0: List[Unit] = List((), (), ())

scala> Applicative[List].whenA(false)(List(1, 2, 3))
res1: List[Unit] = List(())

scala> Applicative[List].whenA(true)(List.empty[Int])
res2: List[Unit] = List()

scala> Applicative[List].whenA(false)(List.empty[Int])
res3: List[Unit] = List(())
Inherited from
Applicative
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(())
Inherited from
Applicative
@noop
def whileM[G[_], A](p: F[Boolean])(body: => F[A])(implicit G: Alternative[G]): F[G[A]]
Implicitly added by monadCancelForOptionT

Execute an action repeatedly as long as the given Boolean expression returns true. The condition is evaluated before the loop body. Collects the results into an arbitrary Alternative value, such as a Vector. This implementation uses append on each evaluation result, so avoid data structures with non-constant append performance, e.g. List.

Execute an action repeatedly as long as the given Boolean expression returns true. The condition is evaluated before the loop body. Collects the results into an arbitrary Alternative value, such as a Vector. This implementation uses append on each evaluation result, so avoid data structures with non-constant append performance, e.g. List.

Inherited from
Monad
@noop
def whileM[G[_], A](p: F[Boolean])(body: => F[A])(implicit G: Alternative[G]): F[G[A]]
Implicitly added by monadCancelForEitherT

Execute an action repeatedly as long as the given Boolean expression returns true. The condition is evaluated before the loop body. Collects the results into an arbitrary Alternative value, such as a Vector. This implementation uses append on each evaluation result, so avoid data structures with non-constant append performance, e.g. List.

Execute an action repeatedly as long as the given Boolean expression returns true. The condition is evaluated before the loop body. Collects the results into an arbitrary Alternative value, such as a Vector. This implementation uses append on each evaluation result, so avoid data structures with non-constant append performance, e.g. List.

Inherited from
Monad
@noop
def whileM[G[_], A](p: F[Boolean])(body: => F[A])(implicit G: Alternative[G]): F[G[A]]
Implicitly added by monadCancelForKleisli

Execute an action repeatedly as long as the given Boolean expression returns true. The condition is evaluated before the loop body. Collects the results into an arbitrary Alternative value, such as a Vector. This implementation uses append on each evaluation result, so avoid data structures with non-constant append performance, e.g. List.

Execute an action repeatedly as long as the given Boolean expression returns true. The condition is evaluated before the loop body. Collects the results into an arbitrary Alternative value, such as a Vector. This implementation uses append on each evaluation result, so avoid data structures with non-constant append performance, e.g. List.

Inherited from
Monad
@noop
def whileM[G[_], A](p: F[Boolean])(body: => F[A])(implicit G: Alternative[G]): F[G[A]]
Implicitly added by monadCancelForStateT

Execute an action repeatedly as long as the given Boolean expression returns true. The condition is evaluated before the loop body. Collects the results into an arbitrary Alternative value, such as a Vector. This implementation uses append on each evaluation result, so avoid data structures with non-constant append performance, e.g. List.

Execute an action repeatedly as long as the given Boolean expression returns true. The condition is evaluated before the loop body. Collects the results into an arbitrary Alternative value, such as a Vector. This implementation uses append on each evaluation result, so avoid data structures with non-constant append performance, e.g. List.

Inherited from
Monad
@noop
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.

Inherited from
Monad
@noop
def whileM_[A](p: F[Boolean])(body: => F[A]): F[Unit]
Implicitly added by monadCancelForOptionT

Execute an action repeatedly as long as the given Boolean expression returns true. The condition is evaluated before the loop body. Discards results.

Execute an action repeatedly as long as the given Boolean expression returns true. The condition is evaluated before the loop body. Discards results.

Inherited from
Monad
@noop
def whileM_[A](p: F[Boolean])(body: => F[A]): F[Unit]
Implicitly added by monadCancelForEitherT

Execute an action repeatedly as long as the given Boolean expression returns true. The condition is evaluated before the loop body. Discards results.

Execute an action repeatedly as long as the given Boolean expression returns true. The condition is evaluated before the loop body. Discards results.

Inherited from
Monad
@noop
def whileM_[A](p: F[Boolean])(body: => F[A]): F[Unit]
Implicitly added by monadCancelForKleisli

Execute an action repeatedly as long as the given Boolean expression returns true. The condition is evaluated before the loop body. Discards results.

Execute an action repeatedly as long as the given Boolean expression returns true. The condition is evaluated before the loop body. Discards results.

Inherited from
Monad
@noop
def whileM_[A](p: F[Boolean])(body: => F[A]): F[Unit]
Implicitly added by monadCancelForStateT

Execute an action repeatedly as long as the given Boolean expression returns true. The condition is evaluated before the loop body. Discards results.

Execute an action repeatedly as long as the given Boolean expression returns true. The condition is evaluated before the loop body. Discards results.

Inherited from
Monad
@noop
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.

Inherited from
Monad
def widen[A, B >: A](fa: F[A]): F[B]
Implicitly added by monadCancelForOptionT

Lifts natural subtyping covariance of covariant Functors.

Lifts natural subtyping covariance of covariant Functors.

NOTE: In certain (perhaps contrived) situations that rely on universal equality this can result in a ClassCastException, because it is implemented as a type cast. It could be implemented as map(identity), but according to the functor laws, that should be equal to fa, and a type cast is often much more performant. See this example of widen creating a ClassCastException.

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption

scala> val s = Some(42)
scala> Functor[Option].widen(s)
res0: Option[Int] = Some(42)
Inherited from
Functor
def widen[A, B >: A](fa: F[A]): F[B]
Implicitly added by monadCancelForEitherT

Lifts natural subtyping covariance of covariant Functors.

Lifts natural subtyping covariance of covariant Functors.

NOTE: In certain (perhaps contrived) situations that rely on universal equality this can result in a ClassCastException, because it is implemented as a type cast. It could be implemented as map(identity), but according to the functor laws, that should be equal to fa, and a type cast is often much more performant. See this example of widen creating a ClassCastException.

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption

scala> val s = Some(42)
scala> Functor[Option].widen(s)
res0: Option[Int] = Some(42)
Inherited from
Functor
def widen[A, B >: A](fa: F[A]): F[B]
Implicitly added by monadCancelForKleisli

Lifts natural subtyping covariance of covariant Functors.

Lifts natural subtyping covariance of covariant Functors.

NOTE: In certain (perhaps contrived) situations that rely on universal equality this can result in a ClassCastException, because it is implemented as a type cast. It could be implemented as map(identity), but according to the functor laws, that should be equal to fa, and a type cast is often much more performant. See this example of widen creating a ClassCastException.

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption

scala> val s = Some(42)
scala> Functor[Option].widen(s)
res0: Option[Int] = Some(42)
Inherited from
Functor
def widen[A, B >: A](fa: F[A]): F[B]
Implicitly added by monadCancelForStateT

Lifts natural subtyping covariance of covariant Functors.

Lifts natural subtyping covariance of covariant Functors.

NOTE: In certain (perhaps contrived) situations that rely on universal equality this can result in a ClassCastException, because it is implemented as a type cast. It could be implemented as map(identity), but according to the functor laws, that should be equal to fa, and a type cast is often much more performant. See this example of widen creating a ClassCastException.

Example:

scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption

scala> val s = Some(42)
scala> Functor[Option].widen(s)
res0: Option[Int] = Some(42)
Inherited from
Functor
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)
Inherited from
Functor