trait CommutativeMonadLaws[F[_]] extends MonadLaws[F] with CommutativeFlatMapLaws[F] with CommutativeApplicativeLaws[F]
Laws that must be obeyed by any CommutativeMonad
.
- Alphabetic
- By Inheritance
- CommutativeMonadLaws
- CommutativeApplicativeLaws
- CommutativeFlatMapLaws
- CommutativeApplyLaws
- MonadLaws
- FlatMapLaws
- ApplicativeLaws
- ApplyLaws
- SemigroupalLaws
- FunctorLaws
- InvariantLaws
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Abstract Value Members
- implicit abstract def F: CommutativeMonad[F]
- Definition Classes
- CommutativeMonadLaws → CommutativeApplicativeLaws → CommutativeFlatMapLaws → CommutativeApplyLaws → MonadLaws → FlatMapLaws → 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 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 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 applyCommutative[A, B, C](fa: F[A], fb: F[B], f: (A, B) => C): IsEq[F[C]]
- Definition Classes
- CommutativeApplyLaws
- 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 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
- def flatmapCommutative[A, B, C](fa: F[A], fb: F[B], g: (A, B) => F[C]): IsEq[F[C]]
- Definition Classes
- CommutativeFlatMapLaws
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- 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.Kleisli
arrows is associative.The composition of
cats.data.Kleisli
arrows is associative. This is analogous to flatMapAssociativity.- Definition Classes
- 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 ofcats.data.Kleisli
arrows.pure
is the left identity element under left-to-right composition ofcats.data.Kleisli
arrows. This is analogous to monadLeftIdentity.- Definition Classes
- 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 ofcats.data.Kleisli
arrows.pure
is the right identity element under left-to-right composition ofcats.data.Kleisli
arrows. 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 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 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 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
- 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()