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

MonadCancelLaws

trait MonadCancelLaws[F <: ([_$1] =>> Any), 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 AsyncLaws[F]
trait GenSpawnLaws[F, E]
trait SyncLaws[F]

Value members

Methods

def uncancelableEliminatesOnCancel[A](fa: F[A], fin: F[Unit]): IsEq[F[A]]
def onCancelAssociatesOverUncancelableBoundary[A](fa: F[A], fin: F[Unit]): IsEq[F[A]]
def forceRDiscardsPure[A, B](a: A, fa: F[B]): IsEq[F[B]]
def forceRDiscardsError[A](e: E, fa: F[A]): IsEq[F[A]]
def uncancelableFinalizers[A](fin: F[Unit]): IsEq[F[Unit]]
def canceledSequencesOnCancelInOrder(fin1: F[Unit], fin2: F[Unit]): IsEq[F[Unit]]
def uncancelableIdentity[A](fa: F[A]): IsEq[F[A]]

Inherited methods

def monoidalLeftIdentity[A](fa: F[A]): (F[(Unit, A)], F[A])
Inhertied from
ApplicativeLaws
def raiseErrorDistributesOverApRight[A](h: E => F[A], e: E): IsEq[F[A]]
Inhertied 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]]
Inhertied from
InvariantLaws
def redeemDerivedFromAttemptMap[A, B](fa: F[A], fe: E => B, fs: A => B): IsEq[F[B]]
Inhertied from
ApplicativeErrorLaws
def recoverConsistentWithRecoverWith[A](fa: F[A], pf: PartialFunction[E, A]): IsEq[F[A]]
Inhertied from
ApplicativeErrorLaws
def mapFlatMapCoherence[A, B](fa: F[A], f: A => B): IsEq[F[B]]
Make sure that map and flatMap are consistent.
Inhertied from
MonadLaws
def monadErrorEnsureOrConsistency[A](fa: F[A], e: A => E, p: A => Boolean): IsEq[F[A]]
Inhertied from
MonadErrorLaws
override def adaptErrorRaise[A](e: E, f: E => E): IsEq[F[A]]
Definition Classes
MonadErrorLaws -> ApplicativeErrorLaws
Inhertied from
MonadErrorLaws
def covariantIdentity[A](fa: F[A]): IsEq[F[A]]
Inhertied from
FunctorLaws
def handleErrorConsistentWithRecover[A](fa: F[A], f: E => A): IsEq[F[A]]
Inhertied from
ApplicativeErrorLaws
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.
Inhertied from
ApplicativeLaws
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.
Inhertied from
FlatMapLaws
def applicativeErrorHandle[A](e: E, f: E => A): IsEq[F[A]]
Inhertied from
ApplicativeErrorLaws
def handleErrorWithConsistentWithRecoverWith[A](fa: F[A], f: E => F[A]): IsEq[F[A]]
Inhertied from
ApplicativeErrorLaws
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.
Inhertied from
FlatMapLaws
def attemptConsistentWithAttemptT[A](fa: F[A]): IsEq[EitherT[F, E, A]]
Inhertied from
ApplicativeErrorLaws
def monadErrorEnsureConsistency[A](fa: F[A], e: E, p: A => Boolean): IsEq[F[A]]
Inhertied from
MonadErrorLaws
def map2ProductConsistency[A, B, C](fa: F[A], fb: F[B], f: (A, B) => C): IsEq[F[C]]
Inhertied from
ApplyLaws
def invariantIdentity[A](fa: F[A]): IsEq[F[A]]
Inhertied from
InvariantLaws
def handleErrorPure[A](a: A, f: E => A): IsEq[F[A]]
Inhertied from
ApplicativeErrorLaws
def pureAttempt[A](a: A): IsEq[F[Either[E, A]]]
Inhertied from
ApplicativeErrorLaws
def applicativeMap[A, B](fa: F[A], f: A => B): IsEq[F[B]]
Inhertied from
ApplicativeLaws
def semigroupalAssociativity[A, B, C](fa: F[A], fb: F[B], fc: F[C]): (F[(A, (B, C))], F[((A, B), C)])
Inhertied from
SemigroupalLaws
def rethrowAttempt[A](fa: F[A]): IsEq[F[A]]
Inhertied from
MonadErrorLaws
def map2EvalConsistency[A, B, C](fa: F[A], fb: F[B], f: (A, B) => C): IsEq[F[C]]
Inhertied from
ApplyLaws
def mproductConsistency[A, B](fa: F[A], fb: A => F[B]): IsEq[F[(A, B)]]
Inhertied from
FlatMapLaws
def handleErrorWithPure[A](a: A, f: E => F[A]): IsEq[F[A]]
Inhertied from
ApplicativeErrorLaws
def applicativeIdentity[A](fa: F[A]): IsEq[F[A]]
Inhertied from
ApplicativeLaws
def raiseErrorAttempt(e: E): IsEq[F[Either[E, Unit]]]
Inhertied from
ApplicativeErrorLaws
def redeemWithDerivedFromAttemptFlatMap[A, B](fa: F[A], fe: E => F[B], fs: A => F[B]): IsEq[F[B]]
Inhertied from
MonadErrorLaws
def monadErrorLeftZero[A, B](e: E, f: A => F[B]): IsEq[F[B]]
Inhertied from
MonadErrorLaws
def apProductConsistent[A, B](fa: F[A], f: F[A => B]): IsEq[F[B]]
Inhertied from
ApplicativeLaws
def monadLeftIdentity[A, B](a: A, f: A => F[B]): IsEq[F[B]]
Inhertied from
MonadLaws
def applicativeErrorHandleWith[A](e: E, f: E => F[A]): IsEq[F[A]]
Inhertied from
ApplicativeErrorLaws
def onErrorRaise[A](fa: F[A], e: E, fb: F[Unit]): IsEq[F[A]]
Inhertied from
ApplicativeErrorLaws
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.
Inhertied from
MonadLaws
def monadRightIdentity[A](fa: F[A]): IsEq[F[A]]
Inhertied from
MonadLaws
def applicativeUnit[A](a: A): IsEq[F[A]]
Inhertied from
ApplicativeLaws
override def adaptErrorPure[A](a: A, f: E => E): IsEq[F[A]]
Definition Classes
MonadErrorLaws -> ApplicativeErrorLaws
Inhertied from
MonadErrorLaws
def applicativeHomomorphism[A, B](a: A, f: A => B): IsEq[F[B]]
Inhertied from
ApplicativeLaws
def tailRecMConsistentFlatMap[A](a: A, f: A => F[A]): IsEq[F[A]]
Inhertied from
FlatMapLaws
def productLConsistency[A, B](fa: F[A], fb: F[B]): IsEq[F[A]]
Inhertied from
ApplyLaws
def attemptFromEitherConsistentWithPure[A](eab: Either[E, A]): IsEq[F[Either[E, A]]]
Inhertied from
ApplicativeErrorLaws
def onErrorPure[A](a: A, f: E => F[Unit]): IsEq[F[A]]
Inhertied from
ApplicativeErrorLaws
def flatMapConsistentApply[A, B](fa: F[A], fab: F[A => B]): IsEq[F[B]]
Inhertied from
FlatMapLaws
def productRConsistency[A, B](fa: F[A], fb: F[B]): IsEq[F[B]]
Inhertied from
ApplyLaws
def covariantComposition[A, B, C](fa: F[A], f: A => B, g: B => C): IsEq[F[C]]
Inhertied from
FunctorLaws
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.
Inhertied from
MonadLaws
def applicativeInterchange[A, B](a: A, ff: F[A => B]): IsEq[F[B]]
Inhertied from
ApplicativeLaws
def raiseErrorDistributesOverApLeft[A](h: E => F[A], e: E): IsEq[F[A]]
Inhertied from
ApplicativeErrorLaws
def applyComposition[A, B, C](fa: F[A], fab: F[A => B], fbc: F[B => C]): IsEq[F[C]]
Inhertied from
ApplyLaws
def flatMapAssociativity[A, B, C](fa: F[A], f: A => F[B], g: B => F[C]): IsEq[F[C]]
Inhertied from
FlatMapLaws
def monoidalRightIdentity[A](fa: F[A]): (F[(A, Unit)], F[A])
Inhertied from
ApplicativeLaws

Inherited fields

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

Implicits

Implicits

implicit val F: MonadCancel[F, E]