ActionT

A data type for holding computations that can fail with exceptions. This is effectively a ReaderT > ErrorT > WriterT > F stack, with a specialized error type. This particular specialization handles string/exception based failures and should be used to wrap up unsafe apis (i.e. java code).

This specialization exists for a number of reasons:

Basically because you can't use the stack directly via a type alias without incurring the wrath of scalac and the inference warlords.
The formulation lets us plug in a few things together to handle IO and other values of F, whilst keeping some level of sanity.

Credits to @markhibberd

Linear Supertypes

Serializable, Serializable, Product, Equals, AnyRef, Any

Instance Constructors

new ActionT(runT: (R) ⇒ StatusT[[a]WriterT[F, W, a], A])

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 andFinally(otherwise: ActionT[F, W, R, Unit])(implicit W: Monoid[W], F: Monad[F]): ActionT[F, W, R, A]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def contramap[B](f: (B) ⇒ R)(implicit W: Monoid[W], F: Functor[F]): ActionT[F, W, B, A]
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def execute(r: R)(implicit F: Functor[F]): F[Status[A]]
def executeT(r: R)(implicit F: Functor[F]): StatusT[F, A]
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def flatMap[B](f: (A) ⇒ ActionT[F, W, R, B])(implicit W: Monoid[W], F: Monad[F]): ActionT[F, W, R, B]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def map[B](f: (A) ⇒ B)(implicit W: Monoid[W], F: Functor[F]): ActionT[F, W, R, B]
def mapError(f: (scalaz.\&/.These[String, Throwable]) ⇒ scalaz.\&/.These[String, Throwable])(implicit W: Monoid[W], F: Functor[F]): ActionT[F, W, R, A]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def onStatus[B](f: (Status[A]) ⇒ Status[B])(implicit W: Monoid[W], F: Functor[F]): ActionT[F, W, R, B]
def orElse(otherwise: ActionT[F, W, R, A])(implicit W: Monoid[W], F: Monad[F]): ActionT[F, W, R, A]
def orElse(otherwise: ⇒ A)(implicit W: Monoid[W], F: Monad[F]): ActionT[F, W, R, A]
def run(r: R): F[(W, Status[A])]
val runT: (R) ⇒ StatusT[[a]WriterT[F, W, a], A]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def unless(condition: Boolean)(implicit W: Monoid[W], F: Monad[F]): ActionT[F, W, R, Unit]
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( ... )
def when(condition: Boolean)(implicit W: Monoid[W], F: Monad[F]): ActionT[F, W, R, Unit]
def whenFailed(otherwise: (\&/[String, Throwable]) ⇒ ActionT[F, W, R, A])(implicit W: Monoid[W], F: Monad[F]): ActionT[F, W, R, A]
def |||(otherwise: ⇒ ActionT[F, W, R, A])(implicit W: Monoid[W], F: Monad[F]): ActionT[F, W, R, A]

Related Docs: object ActionT | package control

case class ActionT[F[_], W, R, A](runT: (R) ⇒ StatusT[[a]WriterT[F, W, a], A]) extends Product with Serializable

Instance Constructors

new ActionT(runT: (R) ⇒ StatusT[[a]WriterT[F, W, a], A])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def andFinally(otherwise: ActionT[F, W, R, Unit])(implicit W: Monoid[W], F: Monad[F]): ActionT[F, W, R, A]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def contramap[B](f: (B) ⇒ R)(implicit W: Monoid[W], F: Functor[F]): ActionT[F, W, B, A]

final def eq(arg0: AnyRef): Boolean

def execute(r: R)(implicit F: Functor[F]): F[Status[A]]

def executeT(r: R)(implicit F: Functor[F]): StatusT[F, A]

def finalize(): Unit

def flatMap[B](f: (A) ⇒ ActionT[F, W, R, B])(implicit W: Monoid[W], F: Monad[F]): ActionT[F, W, R, B]

final def getClass(): Class[_]

final def isInstanceOf[T0]: Boolean

def map[B](f: (A) ⇒ B)(implicit W: Monoid[W], F: Functor[F]): ActionT[F, W, R, B]

def mapError(f: (scalaz.\&/.These[String, Throwable]) ⇒ scalaz.\&/.These[String, Throwable])(implicit W: Monoid[W], F: Functor[F]): ActionT[F, W, R, A]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onStatus[B](f: (Status[A]) ⇒ Status[B])(implicit W: Monoid[W], F: Functor[F]): ActionT[F, W, R, B]

def orElse(otherwise: ActionT[F, W, R, A])(implicit W: Monoid[W], F: Monad[F]): ActionT[F, W, R, A]

def orElse(otherwise: ⇒ A)(implicit W: Monoid[W], F: Monad[F]): ActionT[F, W, R, A]

def run(r: R): F[(W, Status[A])]

val runT: (R) ⇒ StatusT[[a]WriterT[F, W, a], A]

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

def unless(condition: Boolean)(implicit W: Monoid[W], F: Monad[F]): ActionT[F, W, R, Unit]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def when(condition: Boolean)(implicit W: Monoid[W], F: Monad[F]): ActionT[F, W, R, Unit]

def whenFailed(otherwise: (\&/[String, Throwable]) ⇒ ActionT[F, W, R, A])(implicit W: Monoid[W], F: Monad[F]): ActionT[F, W, R, A]

def |||(otherwise: ⇒ ActionT[F, W, R, A])(implicit W: Monoid[W], F: Monad[F]): ActionT[F, W, R, A]

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from AnyRef

Inherited from Any

Ungrouped