cats-effect-laws/cats.effect.laws/MonadCancelLaws

MonadCancelLaws

trait MonadCancelLaws[F[_], E] extends MonadErrorLaws[F, E]
Companion
object
trait MonadErrorLaws[F, E]
trait MonadLaws[F]
trait FlatMapLaws[F]
trait ApplicativeErrorLaws[F, E]
trait ApplicativeLaws[F]
trait ApplyLaws[F]
trait SemigroupalLaws[F]
trait FunctorLaws[F]
trait InvariantLaws[F]
class Object
trait Matchable
class Any
trait GenSpawnLaws[F, E]
trait GenTemporalLaws[F, E]
trait AsyncLaws[F]
trait SyncLaws[F]

Value members

Concrete methods

def canceledAssociatesLeftOverFlatMap[A](fa: F[A]): IsEq[F[Unit]]
def canceledSequencesOnCancelInOrder(fin1: F[Unit], fin2: F[Unit]): IsEq[F[Unit]]
def forceRAssociativity[A, B, C](fa: F[A], fb: F[B], fc: F[C]): IsEq[F[C]]
def forceRCanceledShortCircuits[A](fa: F[A]): IsEq[F[A]]
def forceRDiscardsError[A](e: E, fa: F[A]): IsEq[F[A]]
def forceRDiscardsPure[A, B](a: A, fa: F[B]): IsEq[F[B]]
def guaranteeIsGuaranteeCase[A](fa: F[A], fin: F[Unit]): IsEq[F[A]]
def onCancelAssociatesOverUncancelableBoundary[A](fa: F[A], fin: F[Unit]): IsEq[F[A]]
def onCancelImpliesUncancelable[A](fa: F[A], fin1: F[Unit], fin2: F[Unit]): IsEq[F[A]]
def uncancelableEliminatesOnCancel[A](fa: F[A], fin: F[Unit]): IsEq[F[A]]
def uncancelableFinalizers[A](fin: F[Unit]): IsEq[F[Unit]]
def uncancelableIdentity[A](fa: F[A]): IsEq[F[A]]
def uncancelablePollIsIdentity[A](fa: F[A]): IsEq[F[A]]

Inherited methods

override def adaptErrorPure[A](a: A, f: E => E): IsEq[F[A]]
Definition Classes
MonadErrorLaws -> ApplicativeErrorLaws
Inherited from
MonadErrorLaws
override def adaptErrorRaise[A](e: E, f: E => E): IsEq[F[A]]
Definition Classes
MonadErrorLaws -> ApplicativeErrorLaws
Inherited from
MonadErrorLaws
def apProductConsistent[A, B](fa: F[A], f: F[A => B]): IsEq[F[B]]
Inherited from
ApplicativeLaws
def applicativeComposition[A, B, C](fa: F[A], fab: F[A => B], fbc: F[B => C]): IsEq[F[C]]

This law is applyComposition stated in terms of pure. It is a combination of applyComposition and applicativeMap and hence not strictly necessary.

This law is applyComposition stated in terms of pure. It is a combination of applyComposition and applicativeMap and hence not strictly necessary.

Inherited from
ApplicativeLaws
def applicativeErrorHandle[A](e: E, f: E => A): IsEq[F[A]]
Inherited from
ApplicativeErrorLaws
def applicativeErrorHandleWith[A](e: E, f: E => F[A]): IsEq[F[A]]
Inherited from
ApplicativeErrorLaws
def applicativeHomomorphism[A, B](a: A, f: A => B): IsEq[F[B]]
Inherited from
ApplicativeLaws
def applicativeIdentity[A](fa: F[A]): IsEq[F[A]]
Inherited from
ApplicativeLaws
def applicativeInterchange[A, B](a: A, ff: F[A => B]): IsEq[F[B]]
Inherited from
ApplicativeLaws
def applicativeMap[A, B](fa: F[A], f: A => B): IsEq[F[B]]
Inherited from
ApplicativeLaws
def applicativeUnit[A](a: A): IsEq[F[A]]
Inherited from
ApplicativeLaws
def applyComposition[A, B, C](fa: F[A], fab: F[A => B], fbc: F[B => C]): IsEq[F[C]]
Inherited from
ApplyLaws
def attemptConsistentWithAttemptT[A](fa: F[A]): IsEq[EitherT[F, E, A]]
Inherited from
ApplicativeErrorLaws
def attemptFromEitherConsistentWithPure[A](eab: Either[E, A]): IsEq[F[Either[E, A]]]
Inherited from
ApplicativeErrorLaws
def covariantComposition[A, B, C](fa: F[A], f: A => B, g: B => C): IsEq[F[C]]
Inherited from
FunctorLaws
def covariantIdentity[A](fa: F[A]): IsEq[F[A]]
Inherited from
FunctorLaws
def flatMapAssociativity[A, B, C](fa: F[A], f: A => F[B], g: B => F[C]): IsEq[F[C]]
Inherited from
FlatMapLaws
def flatMapConsistentApply[A, B](fa: F[A], fab: F[A => B]): IsEq[F[B]]
Inherited from
FlatMapLaws
def flatMapFromTailRecMConsistency[A, B](fa: F[A], fn: A => F[B]): IsEq[F[B]]

It is possible to implement flatMap from tailRecM and map and it should agree with the flatMap implementation.

It is possible to implement flatMap from tailRecM and map and it should agree with the flatMap implementation.

Inherited from
FlatMapLaws
def handleErrorConsistentWithRecover[A](fa: F[A], f: E => A): IsEq[F[A]]
Inherited from
ApplicativeErrorLaws
def handleErrorPure[A](a: A, f: E => A): IsEq[F[A]]
Inherited from
ApplicativeErrorLaws
def handleErrorWithConsistentWithRecoverWith[A](fa: F[A], f: E => F[A]): IsEq[F[A]]
Inherited from
ApplicativeErrorLaws
def handleErrorWithPure[A](a: A, f: E => F[A]): IsEq[F[A]]
Inherited from
ApplicativeErrorLaws
def invariantComposition[A, B, C](fa: F[A], f1: A => B, f2: B => A, g1: B => C, g2: C => B): IsEq[F[C]]
Inherited from
InvariantLaws
def invariantIdentity[A](fa: F[A]): IsEq[F[A]]
Inherited from
InvariantLaws
def kleisliAssociativity[A, B, C, D](f: A => F[B], g: B => F[C], h: C => F[D], a: A): IsEq[F[D]]

The composition of cats.data.Kleisli arrows is associative. This is analogous to flatMapAssociativity.

The composition of cats.data.Kleisli arrows is associative. This is analogous to flatMapAssociativity.

Inherited from
FlatMapLaws
def kleisliLeftIdentity[A, B](a: A, f: A => F[B]): IsEq[F[B]]

pure is the left identity element under left-to-right composition of cats.data.Kleisli arrows. This is analogous to monadLeftIdentity.

pure is the left identity element under left-to-right composition of cats.data.Kleisli arrows. This is analogous to monadLeftIdentity.

Inherited from
MonadLaws
def kleisliRightIdentity[A, B](a: A, f: A => F[B]): IsEq[F[B]]

pure is the right identity element under left-to-right composition of cats.data.Kleisli arrows. This is analogous to monadRightIdentity.

pure is the right identity element under left-to-right composition of cats.data.Kleisli arrows. This is analogous to monadRightIdentity.

Inherited from
MonadLaws
def map2EvalConsistency[A, B, C](fa: F[A], fb: F[B], f: (A, B) => C): IsEq[F[C]]
Inherited from
ApplyLaws
def map2ProductConsistency[A, B, C](fa: F[A], fb: F[B], f: (A, B) => C): IsEq[F[C]]
Inherited from
ApplyLaws
def mapFlatMapCoherence[A, B](fa: F[A], f: A => B): IsEq[F[B]]

Make sure that map and flatMap are consistent.

Make sure that map and flatMap are consistent.

Inherited from
MonadLaws
def monadErrorEnsureConsistency[A](fa: F[A], e: E, p: A => Boolean): IsEq[F[A]]
Inherited from
MonadErrorLaws
def monadErrorEnsureOrConsistency[A](fa: F[A], e: A => E, p: A => Boolean): IsEq[F[A]]
Inherited from
MonadErrorLaws
def monadErrorLeftZero[A, B](e: E, f: A => F[B]): IsEq[F[B]]
Inherited from
MonadErrorLaws
def monadLeftIdentity[A, B](a: A, f: A => F[B]): IsEq[F[B]]
Inherited from
MonadLaws
def monadRightIdentity[A](fa: F[A]): IsEq[F[A]]
Inherited from
MonadLaws
def monoidalLeftIdentity[A](fa: F[A]): (F[(Unit, A)], F[A])
Inherited from
ApplicativeLaws
def monoidalRightIdentity[A](fa: F[A]): (F[(A, Unit)], F[A])
Inherited from
ApplicativeLaws
def mproductConsistency[A, B](fa: F[A], fb: A => F[B]): IsEq[F[(A, B)]]
Inherited from
FlatMapLaws
def onErrorPure[A](a: A, f: E => F[Unit]): IsEq[F[A]]
Inherited from
ApplicativeErrorLaws
def onErrorRaise[A](fa: F[A], e: E, fb: F[Unit]): IsEq[F[A]]
Inherited from
ApplicativeErrorLaws
def productLConsistency[A, B](fa: F[A], fb: F[B]): IsEq[F[A]]
Inherited from
ApplyLaws
def productRConsistency[A, B](fa: F[A], fb: F[B]): IsEq[F[B]]
Inherited from
ApplyLaws
def pureAttempt[A](a: A): IsEq[F[Either[E, A]]]
Inherited from
ApplicativeErrorLaws
def raiseErrorAttempt(e: E): IsEq[F[Either[E, Unit]]]
Inherited from
ApplicativeErrorLaws
def raiseErrorDistributesOverApLeft[A](h: E => F[A], e: E): IsEq[F[A]]
Inherited from
ApplicativeErrorLaws
def raiseErrorDistributesOverApRight[A](h: E => F[A], e: E): IsEq[F[A]]
Inherited from
ApplicativeErrorLaws
def recoverConsistentWithRecoverWith[A](fa: F[A], pf: PartialFunction[E, A]): IsEq[F[A]]
Inherited from
ApplicativeErrorLaws
def redeemDerivedFromAttemptMap[A, B](fa: F[A], fe: E => B, fs: A => B): IsEq[F[B]]
Inherited from
ApplicativeErrorLaws
def redeemWithDerivedFromAttemptFlatMap[A, B](fa: F[A], fe: E => F[B], fs: A => F[B]): IsEq[F[B]]
Inherited from
MonadErrorLaws
def rethrowAttempt[A](fa: F[A]): IsEq[F[A]]
Inherited from
MonadErrorLaws
def semigroupalAssociativity[A, B, C](fa: F[A], fb: F[B], fc: F[C]): (F[(A, (B, C))], F[((A, B), C)])
Inherited from
SemigroupalLaws
def tailRecMConsistentFlatMap[A](a: A, f: A => F[A]): IsEq[F[A]]
Inherited from
FlatMapLaws

Inherited fields

lazy val tailRecMStackSafety: IsEq[F[Int]]
Inherited from
MonadLaws

Implicits

Implicits

implicit val F: MonadCancel[F, E]