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

AsyncLaws

trait AsyncLaws[F[_]] extends GenTemporalLaws[F, Throwable] with SyncLaws[F]
Companion:
object
trait SyncLaws[F]
trait ClockLaws[F]
trait UniqueLaws[F]
trait MonadLaws[F]
trait FlatMapLaws[F]
trait ApplyLaws[F]
trait FunctorLaws[F]
trait InvariantLaws[F]
class Object
trait Matchable
class Any

Value members

Concrete methods

def asyncRightIsUncancelableSequencedPure[A](a: A, fu: F[Unit]): IsEq[F[A]]
def evalOnPureIdentity[A](a: A, ec: ExecutionContext): IsEq[F[A]]

Inherited methods

override def adaptErrorPure[A](a: A, f: Throwable => Throwable): IsEq[F[A]]
Definition Classes
Inherited from:
MonadErrorLaws
override def adaptErrorRaise[A](e: Throwable, f: Throwable => Throwable): 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: 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 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 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 fiberJoinIsGuaranteeCase[A](fa0: F[A], f: Outcome[F, Throwable, A] => F[Unit]): IsEq[F[A]]
Inherited from:
GenSpawnLaws
def fiberPureIsOutcomeCompletedPure[A](a: A): IsEq[F[Outcome[F, Throwable, A]]]
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 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 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 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 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 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 uncancelableIgnoredPollEliminatesNesting[A](fa: F[A]): IsEq[F[A]]
Inherited from:
MonadCancelLaws
def uncancelablePollInverseNestIsUncancelable[A](fa: F[A]): IsEq[F[A]]
Inherited from:
MonadCancelLaws
def uncancelablePollIsIdentity[A](fa: F[A]): IsEq[F[A]]
Inherited from:
MonadCancelLaws
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]