scalaz/scalaz/IndexedStateT

IndexedStateT

sealed abstract
class IndexedStateT[F[_], -S1, S2, A]
Companion
object
class Object
trait Matchable
class Any
IndexedStateT[F, S1, S2, A]

Value members

Abstract methods

def getF[S <: S1]: Monad[F] => F[S => F[(S2, A)]]

Concrete methods

def apply(initial: S1)(implicit F: Monad[F]): F[(S2, A)]

Run and return the final value and state in the context of F

Run and return the final value and state in the context of F

def bimap[X, B](f: S2 => X)(g: A => B)(implicit F: Functor[F]): IndexedStateT[F, S1, X, B]
def bmap[X, S >: S2 <: S1](b: Bijection[S, X]): StateT[F, X, A]
def contramap[X](g: X => S1): IndexedStateT[F, X, S2, A]
def eval(initial: S1)(implicit F: Monad[F]): F[A]

Run, discard the final state, and return the final value in the context of F

Run, discard the final state, and return the final value in the context of F

def evalZero[S <: S1](implicit F: Monad[F], S: Monoid[S]): F[A]

Calls eval using Monoid[S].zero as the initial state

Calls eval using Monoid[S].zero as the initial state

def exec(initial: S1)(implicit F: Monad[F]): F[S2]

Run, discard the final value, and return the final state in the context of F

Run, discard the final value, and return the final state in the context of F

def execZero[S <: S1](implicit F: Monad[F], S: Monoid[S]): F[S2]

Calls exec using Monoid[S].zero as the initial state

Calls exec using Monoid[S].zero as the initial state

def flatMap[S3, B](f: A => IndexedStateT[F, S2, S3, B])(implicit F: Monad[F]): IndexedStateT[F, S1, S3, B]
def imap[X](f: S2 => X)(implicit F: Functor[F]): IndexedStateT[F, S1, X, A]
def leftMap[X](f: S2 => X)(implicit F: Functor[F]): IndexedStateT[F, S1, X, A]
def lift[M[_]](implicit F: Monad[F], M: Applicative[M]): IndexedStateT[[α] =>> M[F[α]], S1, S2, A]
def liftF[S <: S1](implicit F: Functor[[_] =>> IndexedStateT[F, S, S2, _$11]]): Free[[_] =>> IndexedStateT[F, S, S2, _$12], A]
def map[B](f: A => B)(implicit F: Functor[F]): IndexedStateT[F, S1, S2, B]
def mapK[G[_], B, S](f: F[(S2, A)] => G[(S, B)])(implicit M: Monad[F]): IndexedStateT[G, S1, S, B]

Alias for mapT

Alias for mapT

def mapT[G[_], B, S](f: F[(S2, A)] => G[(S, B)])(implicit M: Monad[F]): IndexedStateT[G, S1, S, B]

Map both the return value and final state using the given function.

Map both the return value and final state using the given function.

def mapsf[X1, X2, B](f: S1 => F[(S2, A)] => X1 => F[(X2, B)]): IndexedStateT[F, X1, X2, B]
def run(initial: S1)(implicit F: Monad[F]): F[(S2, A)]

An alias for apply

An alias for apply

def runZero[S <: S1](implicit S: Monoid[S], F: Monad[F]): F[(S2, A)]

Calls run using Monoid[S].zero as the initial state

Calls run using Monoid[S].zero as the initial state

def rwst[W, R](implicit F: Monad[F], W: Monoid[W]): IndexedReaderWriterStateT[F, R, W, S1, S2, A]
def unlift[M[_], FF[_], S <: S1](implicit M: Comonad[M], F: Monad[[α] =>> M[FF[α]]], ev: Liskov[IndexedStateT[F, S1, S2, A], IndexedStateT[[α] =>> M[FF[α]], S, S2, A]]): IndexedStateT[FF, S, S2, A]
def unliftId[M[_], S <: S1](implicit M: Comonad[M], F: Monad[M], ev: Liskov[IndexedStateT[F, S1, S2, A], IndexedStateT[M, S, S2, A]]): IndexedState[S, S2, A]
def xmap[X1, X2](f: S2 => X1)(g: X2 => S1): IndexedStateT[F, X2, X1, A]
def zoom[S0, S3, S <: S1](l: LensFamily[S0, S3, S, S2])(implicit F: Functor[F]): IndexedStateT[F, S0, S3, A]