trait MonadErrorLaws[F[_], E] extends ApplicativeErrorLaws[F, E] with MonadLaws[F]
Ordering
- Alphabetic
- By Inheritance
Inherited
- MonadErrorLaws
- MonadLaws
- FlatMapLaws
- ApplicativeErrorLaws
- ApplicativeLaws
- ApplyLaws
- SemigroupalLaws
- FunctorLaws
- InvariantLaws
- AnyRef
- Any
- Hide All
- Show All
Visibility
- Public
- Protected
Abstract Value Members
- implicit abstract def F: MonadError[F, E]
- Definition Classes
- MonadErrorLaws → MonadLaws → FlatMapLaws → ApplicativeErrorLaws → ApplicativeLaws → ApplyLaws → SemigroupalLaws → FunctorLaws → InvariantLaws
Concrete Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def adaptErrorPure[A](a: A, f: (E) => E): IsEq[F[A]]
- Definition Classes
- MonadErrorLaws → ApplicativeErrorLaws
- def adaptErrorRaise[A](e: E, f: (E) => E): IsEq[F[A]]
- Definition Classes
- MonadErrorLaws → ApplicativeErrorLaws
- def apProductConsistent[A, B](fa: F[A], f: F[(A) => B]): IsEq[F[B]]
- Definition Classes
- 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.This law is applyComposition stated in terms of
pure. It is a combination of applyComposition and applicativeMap and hence not strictly necessary.- Definition Classes
- ApplicativeLaws
- def applicativeErrorHandle[A](e: E, f: (E) => A): IsEq[F[A]]
- Definition Classes
- ApplicativeErrorLaws
- def applicativeErrorHandleWith[A](e: E, f: (E) => F[A]): IsEq[F[A]]
- Definition Classes
- ApplicativeErrorLaws
- def applicativeHomomorphism[A, B](a: A, f: (A) => B): IsEq[F[B]]
- Definition Classes
- ApplicativeLaws
- def applicativeIdentity[A](fa: F[A]): IsEq[F[A]]
- Definition Classes
- ApplicativeLaws
- def applicativeInterchange[A, B](a: A, ff: F[(A) => B]): IsEq[F[B]]
- Definition Classes
- ApplicativeLaws
- def applicativeMap[A, B](fa: F[A], f: (A) => B): IsEq[F[B]]
- Definition Classes
- ApplicativeLaws
- def applicativeUnit[A](a: A): IsEq[F[A]]
- Definition Classes
- ApplicativeLaws
- def applyComposition[A, B, C](fa: F[A], fab: F[(A) => B], fbc: F[(B) => C]): IsEq[F[C]]
- Definition Classes
- ApplyLaws
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def attemptConsistentWithAttemptT[A](fa: F[A]): IsEq[EitherT[F, E, A]]
- Definition Classes
- ApplicativeErrorLaws
- def attemptFromEitherConsistentWithPure[A](eab: Either[E, A]): IsEq[F[Either[E, A]]]
- Definition Classes
- ApplicativeErrorLaws
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def covariantComposition[A, B, C](fa: F[A], f: (A) => B, g: (B) => C): IsEq[F[C]]
- Definition Classes
- FunctorLaws
- def covariantIdentity[A](fa: F[A]): IsEq[F[A]]
- Definition Classes
- FunctorLaws
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def flatMapAssociativity[A, B, C](fa: F[A], f: (A) => F[B], g: (B) => F[C]): IsEq[F[C]]
- Definition Classes
- FlatMapLaws
- def flatMapConsistentApply[A, B](fa: F[A], fab: F[(A) => B]): IsEq[F[B]]
- Definition Classes
- 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.
- Definition Classes
- FlatMapLaws
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def handleErrorConsistentWithRecover[A](fa: F[A], f: (E) => A): IsEq[F[A]]
- Definition Classes
- ApplicativeErrorLaws
- def handleErrorPure[A](a: A, f: (E) => A): IsEq[F[A]]
- Definition Classes
- ApplicativeErrorLaws
- def handleErrorWithConsistentWithRecoverWith[A](fa: F[A], f: (E) => F[A]): IsEq[F[A]]
- Definition Classes
- ApplicativeErrorLaws
- def handleErrorWithPure[A](a: A, f: (E) => F[A]): IsEq[F[A]]
- Definition Classes
- ApplicativeErrorLaws
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def invariantComposition[A, B, C](fa: F[A], f1: (A) => B, f2: (B) => A, g1: (B) => C, g2: (C) => B): IsEq[F[C]]
- Definition Classes
- InvariantLaws
- def invariantIdentity[A](fa: F[A]): IsEq[F[A]]
- Definition Classes
- InvariantLaws
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- 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.Kleisliarrows is associative.The composition of
cats.data.Kleisliarrows is associative. This is analogous to flatMapAssociativity.- Definition Classes
- FlatMapLaws
- def kleisliLeftIdentity[A, B](a: A, f: (A) => F[B]): IsEq[F[B]]
pureis the left identity element under left-to-right composition ofcats.data.Kleisliarrows.pureis the left identity element under left-to-right composition ofcats.data.Kleisliarrows. This is analogous to monadLeftIdentity.- Definition Classes
- MonadLaws
- def kleisliRightIdentity[A, B](a: A, f: (A) => F[B]): IsEq[F[B]]
pureis the right identity element under left-to-right composition ofcats.data.Kleisliarrows.pureis the right identity element under left-to-right composition ofcats.data.Kleisliarrows. This is analogous to monadRightIdentity.- Definition Classes
- MonadLaws
- def map2EvalConsistency[A, B, C](fa: F[A], fb: F[B], f: (A, B) => C): IsEq[F[C]]
- Definition Classes
- ApplyLaws
- def map2ProductConsistency[A, B, C](fa: F[A], fb: F[B], f: (A, B) => C): IsEq[F[C]]
- Definition Classes
- 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.
- Definition Classes
- MonadLaws
- def monadErrorEnsureConsistency[A](fa: F[A], e: E, p: (A) => Boolean): IsEq[F[A]]
- def monadErrorEnsureOrConsistency[A](fa: F[A], e: (A) => E, p: (A) => Boolean): IsEq[F[A]]
- def monadErrorLeftZero[A, B](e: E, f: (A) => F[B]): IsEq[F[B]]
- def monadLeftIdentity[A, B](a: A, f: (A) => F[B]): IsEq[F[B]]
- Definition Classes
- MonadLaws
- def monadRightIdentity[A](fa: F[A]): IsEq[F[A]]
- Definition Classes
- MonadLaws
- def monoidalLeftIdentity[A](fa: F[A]): (F[(Unit, A)], F[A])
- Definition Classes
- ApplicativeLaws
- def monoidalRightIdentity[A](fa: F[A]): (F[(A, Unit)], F[A])
- Definition Classes
- ApplicativeLaws
- def mproductConsistency[A, B](fa: F[A], fb: (A) => F[B]): IsEq[F[(A, B)]]
- Definition Classes
- FlatMapLaws
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def onErrorPure[A](a: A, f: (E) => F[Unit]): IsEq[F[A]]
- Definition Classes
- ApplicativeErrorLaws
- def onErrorRaise[A](fa: F[A], e: E, fb: F[Unit]): IsEq[F[A]]
- Definition Classes
- ApplicativeErrorLaws
- def productLConsistency[A, B](fa: F[A], fb: F[B]): IsEq[F[A]]
- Definition Classes
- ApplyLaws
- def productRConsistency[A, B](fa: F[A], fb: F[B]): IsEq[F[B]]
- Definition Classes
- ApplyLaws
- def pureAttempt[A](a: A): IsEq[F[Either[E, A]]]
- Definition Classes
- ApplicativeErrorLaws
- def raiseErrorAttempt(e: E): IsEq[F[Either[E, Unit]]]
- Definition Classes
- ApplicativeErrorLaws
- def raiseErrorDistributesOverApLeft[A](h: (E) => F[A], e: E): IsEq[F[A]]
- Definition Classes
- ApplicativeErrorLaws
- def raiseErrorDistributesOverApRight[A](h: (E) => F[A], e: E): IsEq[F[A]]
- Definition Classes
- ApplicativeErrorLaws
- def recoverConsistentWithRecoverWith[A](fa: F[A], pf: PartialFunction[E, A]): IsEq[F[A]]
- Definition Classes
- ApplicativeErrorLaws
- def redeemDerivedFromAttemptMap[A, B](fa: F[A], fe: (E) => B, fs: (A) => B): IsEq[F[B]]
- Definition Classes
- ApplicativeErrorLaws
- def redeemWithDerivedFromAttemptFlatMap[A, B](fa: F[A], fe: (E) => F[B], fs: (A) => F[B]): IsEq[F[B]]
- def replicateAVoidReplicateA_Consistent[A](n: Int, fa: F[A]): IsEq[F[Unit]]
- Definition Classes
- ApplicativeLaws
- 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)])
- Definition Classes
- SemigroupalLaws
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def tailRecMConsistentFlatMap[A](a: A, f: (A) => F[A]): IsEq[F[A]]
- Definition Classes
- FlatMapLaws
- lazy val tailRecMStackSafety: IsEq[F[Int]]
- Definition Classes
- MonadLaws
- def toString(): String
- Definition Classes
- AnyRef → Any
- def voidErrorConsistentWithHandleError(fu: F[Unit]): IsEq[F[Unit]]
- Definition Classes
- ApplicativeErrorLaws
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()