trait BimonadLaws[F[_]] extends MonadLaws[F] with ComonadLaws[F]
Laws that must be obeyed by any Bimonad
.
For more information, see definition 4.1 from this paper: http://arxiv.org/pdf/0710.1163v3.pdf
- Alphabetic
- By Inheritance
- BimonadLaws
- ComonadLaws
- CoflatMapLaws
- MonadLaws
- FlatMapLaws
- ApplicativeLaws
- ApplyLaws
- SemigroupalLaws
- FunctorLaws
- InvariantLaws
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Abstract Value Members
-
implicit abstract
def
F: Bimonad[F]
- Definition Classes
- BimonadLaws → ComonadLaws → CoflatMapLaws → 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
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[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
def
coflatMapAssociativity[A, B, C](fa: F[A], f: (F[A]) ⇒ B, g: (F[B]) ⇒ C): IsEq[F[C]]
- Definition Classes
- CoflatMapLaws
-
def
coflatMapIdentity[A, B](fa: F[A]): IsEq[F[F[A]]]
- Definition Classes
- CoflatMapLaws
-
def
coflattenCoherence[A, B](fa: F[A], f: (F[A]) ⇒ B): IsEq[F[B]]
- Definition Classes
- CoflatMapLaws
-
def
coflattenThroughMap[A](fa: F[A]): IsEq[F[F[F[A]]]]
- Definition Classes
- CoflatMapLaws
-
def
cokleisliAssociativity[A, B, C, D](f: (F[A]) ⇒ B, g: (F[B]) ⇒ C, h: (F[C]) ⇒ D, fa: F[A]): IsEq[D]
The composition of
cats.data.Cokleisli
arrows is associative.The composition of
cats.data.Cokleisli
arrows is associative. This is analogous to coflatMapAssociativity.- Definition Classes
- CoflatMapLaws
-
def
cokleisliLeftIdentity[A, B](fa: F[A], f: (F[A]) ⇒ B): IsEq[B]
extract
is the left identity element under left-to-right composition ofcats.data.Cokleisli
arrows.extract
is the left identity element under left-to-right composition ofcats.data.Cokleisli
arrows. This is analogous to comonadLeftIdentity.- Definition Classes
- ComonadLaws
-
def
cokleisliRightIdentity[A, B](fa: F[A], f: (F[A]) ⇒ B): IsEq[B]
extract
is the right identity element under left-to-right composition ofcats.data.Cokleisli
arrows.extract
is the right identity element under left-to-right composition ofcats.data.Cokleisli
arrows. This is analogous to comonadRightIdentity.- Definition Classes
- ComonadLaws
-
def
comonadLeftIdentity[A](fa: F[A]): IsEq[F[A]]
- Definition Classes
- ComonadLaws
-
def
comonadRightIdentity[A, B](fa: F[A], f: (F[A]) ⇒ B): IsEq[B]
- Definition Classes
- ComonadLaws
-
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: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
extractCoflattenIdentity[A](fa: F[A]): IsEq[F[A]]
- Definition Classes
- ComonadLaws
- def extractFlatMapEntwining[A](ffa: F[F[A]]): IsEq[A]
-
def
finalize(): Unit
- Attributes
- protected[java.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[_]
- 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
mapCoflatMapCoherence[A, B](fa: F[A], f: (A) ⇒ B): IsEq[F[B]]
- Definition Classes
- ComonadLaws
-
def
mapCoflattenIdentity[A](fa: F[A]): IsEq[F[A]]
- Definition Classes
- ComonadLaws
-
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 pureCoflatMapEntwining[A](a: A): IsEq[F[F[A]]]
- def pureExtractIsId[A](a: A): IsEq[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
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )