MonadStateLaws

Abstract Value Members

implicit abstract def F: MonadState[F, S]

Definition Classes
MonadStateLaws → MonadLaws → FlatMapLaws → ApplicativeLaws → ApplyLaws → 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 applicativeComposition[A, B, C](fa: F[S, A], fab: F[S, (A) ⇒ B], fbc: F[S, (B) ⇒ C]): IsEq[F[S, 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[S, B]]

Definition Classes
ApplicativeLaws
def applicativeIdentity[A](fa: F[S, A]): IsEq[F[S, A]]

Definition Classes
ApplicativeLaws
def applicativeInterchange[A, B](a: A, ff: F[S, (A) ⇒ B]): IsEq[F[S, B]]

Definition Classes
ApplicativeLaws
def applicativeMap[A, B](fa: F[S, A], f: (A) ⇒ B): IsEq[F[S, B]]

Definition Classes
ApplicativeLaws
def applyComposition[A, B, C](fa: F[S, A], fab: F[S, (A) ⇒ B], fbc: F[S, (B) ⇒ C]): IsEq[F[S, C]]

Definition Classes
ApplyLaws
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def covariantComposition[A, B, C](fa: F[S, A], f: (A) ⇒ B, g: (B) ⇒ C): IsEq[F[S, C]]

Definition Classes
FunctorLaws
def covariantIdentity[A](fa: F[S, A]): IsEq[F[S, A]]

Definition Classes
FunctorLaws
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def flatMapAssociativity[A, B, C](fa: F[S, A], f: (A) ⇒ F[S, B], g: (B) ⇒ F[S, C]): IsEq[F[S, C]]

Definition Classes
FlatMapLaws
def flatMapConsistentApply[A, B](fa: F[S, A], fab: F[S, (A) ⇒ B]): IsEq[F[S, B]]

Definition Classes
FlatMapLaws
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def invariantComposition[A, B, C](fa: F[S, A], f1: (A) ⇒ B, f2: (B) ⇒ A, g1: (B) ⇒ C, g2: (C) ⇒ B): IsEq[F[S, C]]

Definition Classes
InvariantLaws
def invariantIdentity[A](fa: F[S, A]): IsEq[F[S, A]]

Definition Classes
InvariantLaws
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def kleisliAssociativity[A, B, C, D](f: (A) ⇒ F[S, B], g: (B) ⇒ F[S, C], h: (C) ⇒ F[S, D], a: A): IsEq[F[S, 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[S, B]): IsEq[F[S, B]]

pure is the left identity element under left-to-right composition of cats.data.Kleisli arrows.
pure is the left identity element under left-to-right composition of cats.data.Kleisli arrows. This is analogous to monadLeftIdentity.

Definition Classes
MonadLaws
def kleisliRightIdentity[A, B](a: A, f: (A) ⇒ F[S, B]): IsEq[F[S, B]]

pure is the right identity element under left-to-right composition of cats.data.Kleisli arrows.
pure is the right identity element under left-to-right composition of cats.data.Kleisli arrows. This is analogous to monadRightIdentity.

Definition Classes
MonadLaws
def monadLeftIdentity[A, B](a: A, f: (A) ⇒ F[S, B]): IsEq[F[S, B]]

Definition Classes
MonadLaws
def monadRightIdentity[A](fa: F[S, A]): IsEq[F[S, A]]

Definition Classes
MonadLaws
val monadStateGetIdempotent: IsEq[F[S, S]]
val monadStateGetSet: IsEq[F[S, Unit]]
def monadStateSetGet(s: S): IsEq[F[S, S]]
def monadStateSetTwice(s: S, t: S): IsEq[F[S, Unit]]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
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
@throws( ... )

Related Docs: object MonadStateLaws | package laws

trait MonadStateLaws[F[_, _], S] extends MonadLaws[[β]F[S, β]]

Abstract Value Members

implicit abstract def F: MonadState[F, S]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def applicativeComposition[A, B, C](fa: F[S, A], fab: F[S, (A) ⇒ B], fbc: F[S, (B) ⇒ C]): IsEq[F[S, C]]

def applicativeHomomorphism[A, B](a: A, f: (A) ⇒ B): IsEq[F[S, B]]

def applicativeIdentity[A](fa: F[S, A]): IsEq[F[S, A]]

def applicativeInterchange[A, B](a: A, ff: F[S, (A) ⇒ B]): IsEq[F[S, B]]

def applicativeMap[A, B](fa: F[S, A], f: (A) ⇒ B): IsEq[F[S, B]]

def applyComposition[A, B, C](fa: F[S, A], fab: F[S, (A) ⇒ B], fbc: F[S, (B) ⇒ C]): IsEq[F[S, C]]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def covariantComposition[A, B, C](fa: F[S, A], f: (A) ⇒ B, g: (B) ⇒ C): IsEq[F[S, C]]

def covariantIdentity[A](fa: F[S, A]): IsEq[F[S, A]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def flatMapAssociativity[A, B, C](fa: F[S, A], f: (A) ⇒ F[S, B], g: (B) ⇒ F[S, C]): IsEq[F[S, C]]

def flatMapConsistentApply[A, B](fa: F[S, A], fab: F[S, (A) ⇒ B]): IsEq[F[S, B]]

final def getClass(): Class[_]

def hashCode(): Int

def invariantComposition[A, B, C](fa: F[S, A], f1: (A) ⇒ B, f2: (B) ⇒ A, g1: (B) ⇒ C, g2: (C) ⇒ B): IsEq[F[S, C]]

def invariantIdentity[A](fa: F[S, A]): IsEq[F[S, A]]

final def isInstanceOf[T0]: Boolean

def kleisliAssociativity[A, B, C, D](f: (A) ⇒ F[S, B], g: (B) ⇒ F[S, C], h: (C) ⇒ F[S, D], a: A): IsEq[F[S, D]]

def kleisliLeftIdentity[A, B](a: A, f: (A) ⇒ F[S, B]): IsEq[F[S, B]]

def kleisliRightIdentity[A, B](a: A, f: (A) ⇒ F[S, B]): IsEq[F[S, B]]

def monadLeftIdentity[A, B](a: A, f: (A) ⇒ F[S, B]): IsEq[F[S, B]]

def monadRightIdentity[A](fa: F[S, A]): IsEq[F[S, A]]

val monadStateGetIdempotent: IsEq[F[S, S]]

val monadStateGetSet: IsEq[F[S, Unit]]

def monadStateSetGet(s: S): IsEq[F[S, S]]

def monadStateSetTwice(s: S, t: S): IsEq[F[S, Unit]]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from MonadLaws[[β]F[S, β]]

Inherited from FlatMapLaws[[β]F[S, β]]

Inherited from ApplicativeLaws[[β]F[S, β]]

Inherited from ApplyLaws[[β]F[S, β]]

Inherited from FunctorLaws[[β]F[S, β]]

Inherited from InvariantLaws[[β]F[S, β]]

Inherited from AnyRef

Inherited from Any

Ungrouped