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

AsyncLaws

trait AsyncLaws[F[_]] extends GenTemporalLaws[F, Throwable] with SyncLaws[F]
Companion:
object
Source:
AsyncLaws.scala
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 ApplyLaws[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 asyncCheckAttemptSuspendedLeftIsAsyncLeft[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]]
def syncStepIdentity[A](fa: F[A], limit: Int): IsEq[F[A]]

Inherited methods

override def adaptErrorPure[A](a: A, f: Throwable => Throwable): IsEq[F[A]]
override def adaptErrorRaise[A](e: Throwable, f: Throwable => Throwable): IsEq[F[A]]
def apProductConsistent[A, B](fa: F[A], f: F[A => B]): IsEq[F[B]]
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
Source:
ApplicativeLaws.scala
def applicativeErrorHandle[A](e: Throwable, f: Throwable => A): IsEq[F[A]]
def applicativeErrorHandleWith[A](e: Throwable, f: Throwable => F[A]): IsEq[F[A]]
def applicativeHomomorphism[A, B](a: A, f: A => B): IsEq[F[B]]
def applicativeIdentity[A](fa: F[A]): IsEq[F[A]]
def applicativeInterchange[A, B](a: A, ff: F[A => B]): IsEq[F[B]]
def applicativeMap[A, B](fa: F[A], f: A => B): IsEq[F[B]]
def applicativeUnit[A](a: A): IsEq[F[A]]
def applyComposition[A, B, C](fa: F[A], fab: F[A => B], fbc: F[B => C]): IsEq[F[C]]
Inherited from:
ApplyLaws
Source:
ApplyLaws.scala
def attemptFromEitherConsistentWithPure[A](eab: Either[Throwable, A]): IsEq[F[Either[E, A]]]
def canceledAssociatesLeftOverFlatMap[A](fa: F[A]): IsEq[F[Unit]]
def canceledSequencesOnCancelInOrder(fin1: F[Unit], fin2: F[Unit]): IsEq[F[Unit]]
def covariantComposition[A, B, C](fa: F[A], f: A => B, g: B => C): IsEq[F[C]]
Inherited from:
FunctorLaws
Source:
FunctorLaws.scala
def covariantIdentity[A](fa: F[A]): IsEq[F[A]]
Inherited from:
FunctorLaws
Source:
FunctorLaws.scala
def fiberErrorIsOutcomeErrored(e: Throwable): IsEq[F[Outcome[F, E, Unit]]]
Inherited from:
GenSpawnLaws
Source:
GenSpawnLaws.scala
def fiberJoinIsGuaranteeCase[A](fa0: F[A], f: Outcome[F, Throwable, A] => F[Unit]): IsEq[F[A]]
Inherited from:
GenSpawnLaws
Source:
GenSpawnLaws.scala
def fiberNeverIsNever: IsEq[F[Outcome[F, E, Unit]]]
Inherited from:
GenSpawnLaws
Source:
GenSpawnLaws.scala
def fiberPureIsOutcomeCompletedPure[A](a: A): IsEq[F[Outcome[F, E, A]]]
Inherited from:
GenSpawnLaws
Source:
GenSpawnLaws.scala
def flatMapAssociativity[A, B, C](fa: F[A], f: A => F[B], g: B => F[C]): IsEq[F[C]]
Inherited from:
FlatMapLaws
Source:
FlatMapLaws.scala
def flatMapConsistentApply[A, B](fa: F[A], fab: F[A => B]): IsEq[F[B]]
Inherited from:
FlatMapLaws
Source:
FlatMapLaws.scala
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
Source:
FlatMapLaws.scala
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: Throwable, fa: F[A]): IsEq[F[A]]
def forceRDiscardsPure[A, B](a: A, fa: F[B]): IsEq[F[B]]
def forceRNeverIsNever[A](fa: F[A]): IsEq[F[A]]
Inherited from:
GenSpawnLaws
Source:
GenSpawnLaws.scala
def guaranteeIsGuaranteeCase[A](fa: F[A], fin: F[Unit]): IsEq[F[A]]
def handleErrorConsistentWithRecover[A](fa: F[A], f: Throwable => A): IsEq[F[A]]
def handleErrorPure[A](a: A, f: Throwable => A): IsEq[F[A]]
def handleErrorWithConsistentWithRecoverWith[A](fa: F[A], f: Throwable => F[A]): IsEq[F[A]]
def handleErrorWithPure[A](a: A, f: Throwable => F[A]): IsEq[F[A]]
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
Source:
InvariantLaws.scala
def invariantIdentity[A](fa: F[A]): IsEq[F[A]]
Inherited from:
InvariantLaws
Source:
InvariantLaws.scala
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
Source:
FlatMapLaws.scala
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
Source:
MonadLaws.scala
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
Source:
MonadLaws.scala
def map2EvalConsistency[A, B, C](fa: F[A], fb: F[B], f: (A, B) => C): IsEq[F[C]]
Inherited from:
ApplyLaws
Source:
ApplyLaws.scala
def map2ProductConsistency[A, B, C](fa: F[A], fb: F[B], f: (A, B) => C): IsEq[F[C]]
Inherited from:
ApplyLaws
Source:
ApplyLaws.scala
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
Source:
MonadLaws.scala
def monadErrorEnsureConsistency[A](fa: F[A], e: Throwable, p: A => Boolean): IsEq[F[A]]
def monadErrorEnsureOrConsistency[A](fa: F[A], e: A => Throwable, p: A => Boolean): IsEq[F[A]]
def monadErrorLeftZero[A, B](e: Throwable, f: A => F[B]): IsEq[F[B]]
def monadLeftIdentity[A, B](a: A, f: A => F[B]): IsEq[F[B]]
Inherited from:
MonadLaws
Source:
MonadLaws.scala
def monadRightIdentity[A](fa: F[A]): IsEq[F[A]]
Inherited from:
MonadLaws
Source:
MonadLaws.scala
def monoidalLeftIdentity[A](fa: F[A]): (F[(Unit, A)], F[A])
def monoidalRightIdentity[A](fa: F[A]): (F[(A, Unit)], F[A])
def monotonicSleepSumIdentity(delta: FiniteDuration): IsEq[F[FiniteDuration]]
def monotonicity: F[Boolean]
Inherited from:
ClockLaws
Source:
ClockLaws.scala
def mproductConsistency[A, B](fa: F[A], fb: A => F[B]): IsEq[F[(A, B)]]
Inherited from:
FlatMapLaws
Source:
FlatMapLaws.scala
def neverDominatesOverFlatMap[A](fa: F[A]): IsEq[F[A]]
Inherited from:
GenSpawnLaws
Source:
GenSpawnLaws.scala
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 onErrorPure[A](a: A, f: Throwable => F[Unit]): IsEq[F[A]]
def onErrorRaise[A](fa: F[A], e: Throwable, fb: F[Unit]): IsEq[F[A]]
def productLConsistency[A, B](fa: F[A], fb: F[B]): IsEq[F[A]]
Inherited from:
ApplyLaws
Source:
ApplyLaws.scala
def productRConsistency[A, B](fa: F[A], fb: F[B]): IsEq[F[B]]
Inherited from:
ApplyLaws
Source:
ApplyLaws.scala
def pureAttempt[A](a: A): IsEq[F[Either[E, A]]]
def raceCanceledIdentityLeft[A](fa: F[A]): IsEq[F[Either[Unit, A]]]
Inherited from:
GenSpawnLaws
Source:
GenSpawnLaws.scala
def raceCanceledIdentityRight[A](fa: F[A]): IsEq[F[Either[A, Unit]]]
Inherited from:
GenSpawnLaws
Source:
GenSpawnLaws.scala
def raceDerivesFromRacePairLeft[A, B](fa: F[A]): IsEq[F[Either[A, B]]]
Inherited from:
GenSpawnLaws
Source:
GenSpawnLaws.scala
def raceDerivesFromRacePairRight[A, B](fb: F[B]): IsEq[F[Either[A, B]]]
Inherited from:
GenSpawnLaws
Source:
GenSpawnLaws.scala
def raceNeverNoncanceledIdentityLeft[A](fa: F[A]): IsEq[F[Either[Unit, A]]]
Inherited from:
GenSpawnLaws
Source:
GenSpawnLaws.scala
def raceNeverNoncanceledIdentityRight[A](fa: F[A]): IsEq[F[Either[A, Unit]]]
Inherited from:
GenSpawnLaws
Source:
GenSpawnLaws.scala
def raiseErrorAttempt(e: Throwable): IsEq[F[Either[E, Unit]]]
def raiseErrorDistributesOverApLeft[A](h: Throwable => F[A], e: Throwable): IsEq[F[A]]
def raiseErrorDistributesOverApRight[A](h: Throwable => F[A], e: Throwable): IsEq[F[A]]
def recoverConsistentWithRecoverWith[A](fa: F[A], pf: PartialFunction[Throwable, A]): IsEq[F[A]]
def redeemDerivedFromAttemptMap[A, B](fa: F[A], fe: Throwable => B, fs: A => B): IsEq[F[B]]
def redeemWithDerivedFromAttemptFlatMap[A, B](fa: F[A], fe: Throwable => F[B], fs: A => F[B]): IsEq[F[B]]
def repeatedSuspendNotMemoized[A](a: A, f: A => A, hint: Type): IsEq[F[A]]
Inherited from:
SyncLaws
Source:
SyncLaws.scala
def replicateAVoidReplicateA_Consistent[A](n: Int, fa: F[A]): IsEq[F[Unit]]
def rethrowAttempt[A](fa: F[A]): IsEq[F[A]]
def semigroupalAssociativity[A, B, C](fa: F[A], fb: F[B], fc: F[C]): (F[(A, (B, C))], F[((A, B), C)])
def sleepRaceMinimum(d1: FiniteDuration, d2: FiniteDuration): IsEq[F[FiniteDuration]]
def startSleepMaximum(d1: FiniteDuration, d2: FiniteDuration): IsEq[F[FiniteDuration]]
def suspendThrowIsRaiseError[A](e: Throwable, hint: Type): IsEq[F[A]]
Inherited from:
SyncLaws
Source:
SyncLaws.scala
def suspendValueIsPure[A](a: A, hint: Type): IsEq[F[A]]
Inherited from:
SyncLaws
Source:
SyncLaws.scala
def tailRecMConsistentFlatMap[A](a: A, f: A => F[A]): IsEq[F[A]]
Inherited from:
FlatMapLaws
Source:
FlatMapLaws.scala
def uncancelableCancelCancels: IsEq[F[Outcome[F, E, Unit]]]
Inherited from:
GenSpawnLaws
Source:
GenSpawnLaws.scala
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]]
def uniqueness: F[Boolean]
Inherited from:
UniqueLaws
Source:
UniqueLaws.scala
def unsequencedSuspendIsNoop[A](a: A, f: A => A, hint: Type): IsEq[F[A]]
Inherited from:
SyncLaws
Source:
SyncLaws.scala

Inherited fields

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

Implicits

Implicits

implicit val F: Async[F]