cats-effect-laws/cats.effect.laws/AsyncLaws

AsyncLaws

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

Value members

Concrete methods

def asyncCancelTokenIsUnsequencedOnCompletion[A](a: A, fu: F[Unit]): IsEq[F[A]]
def asyncCancelTokenIsUnsequencedOnError[A](e: Throwable, fu: F[Unit]): IsEq[F[A]]
def asyncLeftIsUncancelableSequencedRaiseError[A](e: Throwable, fu: F[Unit]): IsEq[F[A]]
def asyncRightIsUncancelableSequencedPure[A](a: A, fu: F[Unit]): IsEq[F[A]]
def evalOnCanceledIdentity(ec: ExecutionContext): IsEq[F[Unit]]
def evalOnLocalPure(ec: ExecutionContext): IsEq[F[ExecutionContext]]
def evalOnNeverIdentity(ec: ExecutionContext): IsEq[F[Unit]]
def evalOnPureIdentity[A](a: A, ec: ExecutionContext): IsEq[F[A]]
def evalOnRaiseErrorIdentity(e: Throwable, ec: ExecutionContext): IsEq[F[Unit]]
def executionContextCommutativity[A](fa: F[A]): IsEq[F[ExecutionContext]]

Inherited methods

override def adaptErrorPure[A](a: A, f: Throwable => Throwable): IsEq[F[A]]
Definition Classes
MonadErrorLaws -> ApplicativeErrorLaws
Inherited from
MonadErrorLaws
override def adaptErrorRaise[A](e: Throwable, f: Throwable => Throwable): 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: Throwable, f: Throwable => A): IsEq[F[A]]
Inherited from
ApplicativeErrorLaws
def applicativeErrorHandleWith[A](e: Throwable, f: Throwable => 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, Throwable, A]]
Inherited from
ApplicativeErrorLaws
def attemptFromEitherConsistentWithPure[A](eab: Either[Throwable, A]): IsEq[F[Either[Throwable, A]]]
Inherited from
ApplicativeErrorLaws
def canceledAssociatesLeftOverFlatMap[A](fa: F[A]): IsEq[F[Unit]]
Inherited from
MonadCancelLaws
def canceledSequencesOnCancelInOrder(fin1: F[Unit], fin2: F[Unit]): IsEq[F[Unit]]
Inherited from
MonadCancelLaws
def canceledUnitIdentity: IsEq[F[Unit]]
Inherited from
MonadCancelLaws
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 fiberCancelationIsOutcomeCanceled: IsEq[F[Outcome[F, Throwable, Unit]]]
Inherited from
GenSpawnLaws
def fiberCanceledIsOutcomeCanceled: IsEq[F[Outcome[F, Throwable, Unit]]]
Inherited from
GenSpawnLaws
def fiberErrorIsOutcomeErrored(e: Throwable): IsEq[F[Outcome[F, Throwable, Unit]]]
Inherited from
GenSpawnLaws
def fiberJoinIsGuaranteeCase[A](fa0: F[A], f: Outcome[F, Throwable, A] => F[Unit]): IsEq[F[A]]
Inherited from
GenSpawnLaws
def fiberNeverIsNever: IsEq[F[Outcome[F, Throwable, Unit]]]
Inherited from
GenSpawnLaws
def fiberPureIsOutcomeCompletedPure[A](a: A): IsEq[F[Outcome[F, Throwable, A]]]
Inherited from
GenSpawnLaws
def fiberStartOfNeverIsUnit: IsEq[F[Unit]]
Inherited from
GenSpawnLaws
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 forceRAssociativity[A, B, C](fa: F[A], fb: F[B], fc: F[C]): IsEq[F[C]]
Inherited from
MonadCancelLaws
def forceRCanceledShortCircuits[A](fa: F[A]): IsEq[F[A]]
Inherited from
MonadCancelLaws
def forceRDiscardsError[A](e: Throwable, fa: F[A]): IsEq[F[A]]
Inherited from
MonadCancelLaws
def forceRDiscardsPure[A, B](a: A, fa: F[B]): IsEq[F[B]]
Inherited from
MonadCancelLaws
def forceRNeverIsNever[A](fa: F[A]): IsEq[F[A]]
Inherited from
GenSpawnLaws
def guaranteeIsGuaranteeCase[A](fa: F[A], fin: F[Unit]): IsEq[F[A]]
Inherited from
MonadCancelLaws
def handleErrorConsistentWithRecover[A](fa: F[A], f: Throwable => A): IsEq[F[A]]
Inherited from
ApplicativeErrorLaws
def handleErrorPure[A](a: A, f: Throwable => A): IsEq[F[A]]
Inherited from
ApplicativeErrorLaws
def handleErrorWithConsistentWithRecoverWith[A](fa: F[A], f: Throwable => F[A]): IsEq[F[A]]
Inherited from
ApplicativeErrorLaws
def handleErrorWithPure[A](a: A, f: Throwable => 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: Throwable, p: A => Boolean): IsEq[F[A]]
Inherited from
MonadErrorLaws
def monadErrorEnsureOrConsistency[A](fa: F[A], e: A => Throwable, p: A => Boolean): IsEq[F[A]]
Inherited from
MonadErrorLaws
def monadErrorLeftZero[A, B](e: Throwable, 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 monotonicSleepSumIdentity(delta: FiniteDuration): IsEq[F[FiniteDuration]]
Inherited from
GenTemporalLaws
def monotonicity: F[Boolean]
Inherited from
ClockLaws
def mproductConsistency[A, B](fa: F[A], fb: A => F[B]): IsEq[F[(A, B)]]
Inherited from
FlatMapLaws
def neverDominatesOverFlatMap[A](fa: F[A]): IsEq[F[A]]
Inherited from
GenSpawnLaws
def onCancelAssociatesOverUncancelableBoundary[A](fa: F[A], fin: F[Unit]): IsEq[F[A]]
Inherited from
MonadCancelLaws
def onCancelImpliesUncancelable[A](fa: F[A], fin1: F[Unit], fin2: F[Unit]): IsEq[F[A]]
Inherited from
MonadCancelLaws
def onErrorPure[A](a: A, f: Throwable => F[Unit]): IsEq[F[A]]
Inherited from
ApplicativeErrorLaws
def onErrorRaise[A](fa: F[A], e: Throwable, 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[Throwable, A]]]
Inherited from
ApplicativeErrorLaws
def raceCanceledIdentityLeft[A](fa: F[A]): IsEq[F[Either[Unit, A]]]
Inherited from
GenSpawnLaws
def raceCanceledIdentityRight[A](fa: F[A]): IsEq[F[Either[A, Unit]]]
Inherited from
GenSpawnLaws
def raceDerivesFromRacePairLeft[A, B](fa: F[A]): IsEq[F[Either[A, B]]]
Inherited from
GenSpawnLaws
def raceDerivesFromRacePairRight[A, B](fb: F[B]): IsEq[F[Either[A, B]]]
Inherited from
GenSpawnLaws
def raceNeverNoncanceledIdentityLeft[A](fa: F[A]): IsEq[F[Either[Unit, A]]]
Inherited from
GenSpawnLaws
def raceNeverNoncanceledIdentityRight[A](fa: F[A]): IsEq[F[Either[A, Unit]]]
Inherited from
GenSpawnLaws
def raiseErrorAttempt(e: Throwable): IsEq[F[Either[Throwable, Unit]]]
Inherited from
ApplicativeErrorLaws
def raiseErrorDistributesOverApLeft[A](h: Throwable => F[A], e: Throwable): IsEq[F[A]]
Inherited from
ApplicativeErrorLaws
def raiseErrorDistributesOverApRight[A](h: Throwable => F[A], e: Throwable): IsEq[F[A]]
Inherited from
ApplicativeErrorLaws
def recoverConsistentWithRecoverWith[A](fa: F[A], pf: PartialFunction[Throwable, A]): IsEq[F[A]]
Inherited from
ApplicativeErrorLaws
def redeemDerivedFromAttemptMap[A, B](fa: F[A], fe: Throwable => B, fs: A => B): IsEq[F[B]]
Inherited from
ApplicativeErrorLaws
def redeemWithDerivedFromAttemptFlatMap[A, B](fa: F[A], fe: Throwable => F[B], fs: A => F[B]): IsEq[F[B]]
Inherited from
MonadErrorLaws
def repeatedSuspendNotMemoized[A](a: A, f: A => A, hint: Type): IsEq[F[A]]
Inherited from
SyncLaws
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 sleepRaceMinimum(d1: FiniteDuration, d2: FiniteDuration): IsEq[F[FiniteDuration]]
Inherited from
GenTemporalLaws
def startSleepMaximum(d1: FiniteDuration, d2: FiniteDuration): IsEq[F[FiniteDuration]]
Inherited from
GenTemporalLaws
def suspendThrowIsRaiseError[A](e: Throwable, hint: Type): IsEq[F[A]]
Inherited from
SyncLaws
def suspendValueIsPure[A](a: A, hint: Type): IsEq[F[A]]
Inherited from
SyncLaws
def tailRecMConsistentFlatMap[A](a: A, f: A => F[A]): IsEq[F[A]]
Inherited from
FlatMapLaws
def uncancelableCancelCancels: IsEq[F[Outcome[F, Throwable, Unit]]]
Inherited from
GenSpawnLaws
def uncancelableEliminatesOnCancel[A](fa: F[A], fin: F[Unit]): IsEq[F[A]]
Inherited from
MonadCancelLaws
def uncancelableFinalizers[A](fin: F[Unit]): IsEq[F[Unit]]
Inherited from
MonadCancelLaws
def uncancelableIdentity[A](fa: F[A]): IsEq[F[A]]
Inherited from
MonadCancelLaws
def uncancelablePollIsIdentity[A](fa: F[A]): IsEq[F[A]]
Inherited from
MonadCancelLaws
def uncancelableStartIsCancelable: IsEq[F[Outcome[F, Throwable, Unit]]]
Inherited from
GenSpawnLaws
def uniqueness: F[Boolean]
Inherited from
UniqueLaws
def unsequencedSuspendIsNoop[A](a: A, f: A => A, hint: Type): IsEq[F[A]]
Inherited from
SyncLaws

Inherited fields

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

Implicits

Implicits

implicit val F: Async[F]