State

abstract def getF[S <: S1]: (Monad[F]) ⇒ F[(S) ⇒ F[(S2, A)]]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

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

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

final def asInstanceOf[T0]: T0

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 clone(): AnyRef

def contramap[X](g: (X) ⇒ S1): IndexedStateT[F, X, S2, A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

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

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

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

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

def finalize(): Unit

def flatMap[S3, B](f: (A) ⇒ IndexedStateT[F, S2, S3, B])(implicit F: Monad[F]): IndexedStateT[F, S1, S3, B]

final def getClass(): Class[_]

def hashCode(): Int

def imap[X](f: (S2) ⇒ X)(implicit F: Functor[F]): IndexedStateT[F, S1, X, A]

final def isInstanceOf[T0]: Boolean

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[[δ$0$]IndexedStateT[F, S, S2, δ$0$]]): Free[[δ$1$]IndexedStateT[F, S, S2, δ$1$], 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

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.

def mapsf[X1, X2, B](f: ((S1) ⇒ F[(S2, A)]) ⇒ (X1) ⇒ F[(X2, B)]): IndexedStateT[F, X1, X2, B]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

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

def rwst[W, R](implicit F: Monad[F], W: Monoid[W]): IndexedReaderWriterStateT[F, R, W, S1, S2, A]

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

def toString(): String

def unlift[M[_], FF[_], S <: S1](implicit M: Comonad[M], F: Monad[[α]M[FF[α]]], ev: <~<[IndexedStateT.this.type, IndexedStateT[[α]M[FF[α]], S, S2, A]]): IndexedStateT[FF, S, S2, A]

def unliftId[M[_], S <: S1](implicit M: Comonad[M], F: Monad[M], ev: <~<[IndexedStateT.this.type, IndexedStateT[M, S, S2, A]]): IndexedState[S, S2, A]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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]