cats-effect/cats.effect.laws/SyncLaws

SyncLaws

trait SyncLaws[F[_]] extends BracketLaws[F, Throwable] with DeferLaws[F]
Companion
object
trait DeferLaws[F]
trait BracketLaws[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
trait AsyncLaws[F]
trait EffectLaws[F]

Value members

Concrete methods

def bindSuspendsEvaluation[A](fa: F[A], a1: A, f: (A, A) => A): IsEq[F[A]]
def delayConstantIsPure[A](a: A): IsEq[F[A]]
def delayThrowIsRaiseError[A](e: Throwable): IsEq[F[A]]
def mapSuspendsEvaluation[A](fa: F[A], a1: A, f: (A, A) => A): IsEq[F[A]]
def propagateErrorsThroughBindSuspend[A](t: Throwable): IsEq[F[A]]
def repeatedSyncEvaluationNotMemoized[A](a: A, f: A => A): IsEq[F[A]]
def stackSafetyOfBracketOnRepeatedLeftBinds(iterations: Int): IsEq[F[Unit]]
def stackSafetyOfBracketOnRepeatedRightBinds(iterations: Int): IsEq[F[Unit]]
def stackSafetyOfGuaranteeOnRepeatedLeftBinds(iterations: Int): IsEq[F[Unit]]
def stackSafetyOfGuaranteeOnRepeatedRightBinds(iterations: Int): IsEq[F[Unit]]
def stackSafetyOnRepeatedAttempts(iterations: Int): IsEq[F[Unit]]
def stackSafetyOnRepeatedLeftBinds(iterations: Int): IsEq[F[Unit]]
def stackSafetyOnRepeatedMaps(iterations: Int): IsEq[F[Int]]
def stackSafetyOnRepeatedRightBinds(iterations: Int): IsEq[F[Unit]]
def suspendConstantIsPureJoin[A](fa: F[A]): IsEq[F[A]]
def suspendThrowIsRaiseError[A](e: Throwable): IsEq[F[A]]
def unsequencedDelayIsNoop[A](a: A, f: A => A): IsEq[F[A]]

Inherited methods

def acquireAndReleaseAreUncancelable[A, B](fa: F[A], use: A => F[B], release: A => F[Unit]): IsEq[F[B]]
Inherited from
BracketLaws
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 bracketCaseFailureInAcquisitionRemainsFailure[A, B](e: Throwable, f: A => F[B], release: F[Unit]): IsEq[F[B]]
Inherited from
BracketLaws
def bracketCaseWithPureUnitIsEqvMap[A, B](fa: F[A], f: A => B): IsEq[F[B]]
Inherited from
BracketLaws
def bracketCaseWithPureUnitIsUncancelable[A, B](fa: F[A], f: A => F[B]): IsEq[F[B]]
Inherited from
BracketLaws
def bracketIsDerivedFromBracketCase[A, B](fa: F[A], use: A => F[B], release: A => F[Unit]): IsEq[F[B]]
Inherited from
BracketLaws
def bracketPropagatesTransformerEffects[M[_], A, B](fromM: FunctionK[M, F])(acquire: F[A], use: A => F[B], release: A => M[Unit]): IsEq[F[B]]
Inherited from
BracketLaws
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 deferDoesNotEvaluate[A](fa: Unit => F[A]): IsEq[Boolean]
Inherited from
DeferLaws
def deferIdentity[A](fa: Unit => F[A]): IsEq[F[A]]
Inherited from
DeferLaws
def deferIsStackSafe[A](fa: Unit => F[A]): IsEq[F[A]]
Inherited from
DeferLaws
def deferMatchesFix[A](fa: Unit => F[A]): IsEq[F[A]]
Inherited from
DeferLaws
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 guaranteeCaseIsDerivedFromBracketCase[A](fa: F[A], finalizer: ExitCase[Throwable] => F[Unit]): IsEq[F[A]]
Inherited from
BracketLaws
def guaranteeIsDerivedFromBracket[A](fa: F[A], finalizer: F[Unit]): IsEq[F[A]]
Inherited from
BracketLaws
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 mproductConsistency[A, B](fa: F[A], fb: A => F[B]): IsEq[F[(A, B)]]
Inherited from
FlatMapLaws
def onCancelIsDerivedFromGuaranteeCase[A](fa: F[A], finalizer: F[Unit]): IsEq[F[A]]
Inherited from
BracketLaws
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 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 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
def uncancelablePreventsCanceledCase[A](fa: F[A], onCancel: F[Unit], onFinish: F[Unit]): IsEq[F[A]]
Inherited from
BracketLaws

Inherited fields

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

Implicits

Implicits

implicit def F: Sync[F]