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 ApplyLaws[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 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
Inherited from:
MonadErrorLaws
override def adaptErrorRaise[A](e: E, f: E => E): IsEq[F[A]]
Definition Classes
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 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 replicateAVoidReplicateA_Consistent[A](n: Int, fa: F[A]): IsEq[F[Unit]]
Inherited from:
ApplicativeLaws
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]