IndexedReaderWriterStateT

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def apply[F[_], E, L, SA, SB, A](runF: (E, SA) ⇒ F[(L, SB, A)])(implicit F: Applicative[F]): IndexedReaderWriterStateT[F, E, L, SA, SB, A]

Construct a new computation using the provided function.

def applyF[F[_], E, L, SA, SB, A](runF: F[(E, SA) ⇒ F[(L, SB, A)]]): IndexedReaderWriterStateT[F, E, L, SA, SB, A]

Like apply, but using a function in a context F.

final def asInstanceOf[T0]: T0

def ask[F[_], E, L, S](implicit F: Applicative[F], L: Monoid[L]): IndexedReaderWriterStateT[F, E, L, S, S, E]

Get the provided environment, without modifying the input state.

implicit def catsDataAlternativeForIRWST[F[_], E, L, S](implicit FM: Monad[F], FA: Alternative[F], L0: Monoid[L]): Alternative[[ζ$14$]IndexedReaderWriterStateT[F, E, L, S, S, ζ$14$]]

implicit def catsDataBifunctorForIRWST[F[_], E, L, SA](implicit F0: Functor[F]): Bifunctor[[ε$5$, ζ$6$]IndexedReaderWriterStateT[F, E, L, SA, ε$5$, ζ$6$]]

implicit def catsDataContravariantForIRWST[F[_], E, L, SB, T](implicit F0: Functor[F]): Contravariant[[δ$7$]IndexedReaderWriterStateT[F, E, L, δ$7$, SB, T]]

implicit def catsDataDeferForIRWST[F[_], E, L, SA, SB](implicit F: Defer[F]): Defer[[ζ$9$]IndexedReaderWriterStateT[F, E, L, SA, SB, ζ$9$]]

implicit def catsDataFunctorForIRWST[F[_], E, L, SA, SB](implicit F0: Functor[F]): Functor[[ζ$16$]IndexedReaderWriterStateT[F, E, L, SA, SB, ζ$16$]]

implicit def catsDataMonadErrorForIRWST[F[_], E, L, S, R](implicit F0: MonadError[F, R], L0: Monoid[L]): MonadError[[ζ$8$]IndexedReaderWriterStateT[F, E, L, S, S, ζ$8$], R]

implicit def catsDataMonadForRWST[F[_], E, L, S](implicit F0: Monad[F], L0: Monoid[L]): Monad[[ε$11$]IndexedReaderWriterStateT[F, E, L, S, S, ε$11$]]

implicit def catsDataProfunctorForIRWST[F[_], E, L, T](implicit F0: Functor[F]): Profunctor[[δ$12$, ε$13$]IndexedReaderWriterStateT[F, E, L, δ$12$, ε$13$, T]]

implicit def catsDataSemigroupKForIRWST[F[_], E, L, SA, SB](implicit F0: Monad[F], G0: SemigroupK[F]): SemigroupK[[ζ$15$]IndexedReaderWriterStateT[F, E, L, SA, SB, ζ$15$]]

implicit def catsDataStrongForIRWST[F[_], E, L, T](implicit F0: Monad[F]): Strong[[δ$3$, ε$4$]IndexedReaderWriterStateT[F, E, L, δ$3$, ε$4$, T]]

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def get[F[_], E, L, S](implicit F: Applicative[F], L: Monoid[L]): IndexedReaderWriterStateT[F, E, L, S, S, S]

Return the input state without modifying it.

final def getClass(): Class[_]

def hashCode(): Int

def inspect[F[_], E, L, S, A](f: (S) ⇒ A)(implicit F: Applicative[F], L: Monoid[L]): IndexedReaderWriterStateT[F, E, L, S, S, A]

Inspect a value from the input state, without modifying the state.

def inspectF[F[_], E, L, S, A](f: (S) ⇒ F[A])(implicit F: Applicative[F], L: Monoid[L]): IndexedReaderWriterStateT[F, E, L, S, S, A]

Like inspect, but using an effectful function.

final def isInstanceOf[T0]: Boolean

def liftF[F[_], E, L, S, A](fa: F[A])(implicit F: Applicative[F], L: Monoid[L]): IndexedReaderWriterStateT[F, E, L, S, S, A]

Return an effectful a and an empty log without modifying the input state.

def liftK[F[_], E, L, S](implicit F: Applicative[F], L: Monoid[L]): ~>[F, [ζ$0$]IndexedReaderWriterStateT[F, E, L, S, S, ζ$0$]]

Same as liftF, but expressed as a FunctionK for use with mapK

scala> import cats._, data._, implicits._
scala> val a: OptionT[Eval, Int] = 1.pure[OptionT[Eval, ?]]
scala> val b: OptionT[RWST[Eval, Boolean, List[String], String, ?], Int] = a.mapK(RWST.liftK)
scala> b.value.runEmpty(true).value
res0: (List[String], String, Option[Int]) = (List(),"",Some(1))

def modify[F[_], E, L, SA, SB](f: (SA) ⇒ SB)(implicit F: Applicative[F], L: Monoid[L]): IndexedReaderWriterStateT[F, E, L, SA, SB, Unit]

Modify the input state using f.

def modifyF[F[_], E, L, SA, SB](f: (SA) ⇒ F[SB])(implicit F: Applicative[F], L: Monoid[L]): IndexedReaderWriterStateT[F, E, L, SA, SB, Unit]

Like modify, but using an effectful function.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def pure[F[_], E, L, S, A](a: A)(implicit F: Applicative[F], L: Monoid[L]): IndexedReaderWriterStateT[F, E, L, S, S, A]

Return a and an empty log without modifying the input state.

def set[F[_], E, L, S](s: S)(implicit F: Applicative[F], L: Monoid[L]): IndexedReaderWriterStateT[F, E, L, S, S, Unit]

Set the state to s.

def setF[F[_], E, L, S](fs: F[S])(implicit F: Applicative[F], L: Monoid[L]): IndexedReaderWriterStateT[F, E, L, S, S, Unit]

Like set, but using an effectful S value.

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

def tell[F[_], E, L, S](l: L)(implicit F: Applicative[F]): IndexedReaderWriterStateT[F, E, L, S, S, Unit]

Add a value to the log, without modifying the input state.

def tellF[F[_], E, L, S](fl: F[L])(implicit F: Applicative[F]): IndexedReaderWriterStateT[F, E, L, S, S, Unit]

Like tell, but using an effectful L value.

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def lift[F[_], E, L, S, A](fa: F[A])(implicit F: Applicative[F], L: Monoid[L]): IndexedReaderWriterStateT[F, E, L, S, S, A]