ErrorEffect

Type Members

type Error = Xor[Throwable, F]

type of errors: exceptions or failure messages
type of errors: exceptions or failure messages

Definition Classes
ErrorTypes
type ErrorOrOk[A] = Xor[Error, Eval[A]]

base type for this effect: either an error or a computation to evaluate scala.Name represents "by-name" value: values not yet evaluated
base type for this effect: either an error or a computation to evaluate scala.Name represents "by-name" value: values not yet evaluated

Definition Classes
ErrorTypes

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[R <: Effects, A](action: Eff[R, A], last: Eff[R, Unit])(implicit m: <=[ErrorOrOk, R]): Eff[R, A]

evaluate 1 action possibly having error effects
evaluate 1 action possibly having error effects
Execute a second action whether the first is successful or not

Definition Classes
ErrorInterpretation
final def asInstanceOf[T0]: T0

Definition Classes
Any
def catchError[R <: Effects, A, B](action: Eff[R, A], pure: (A) ⇒ B, onError: (Error) ⇒ Eff[R, B])(implicit m: <=[ErrorOrOk, R]): Eff[R, B]

evaluate 1 action possibly having error effects
evaluate 1 action possibly having error effects
Execute a second action if the first one is not successful, based on the error

Definition Classes
ErrorInterpretation
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def error[R, A](error: Error)(implicit m: <=[ErrorOrOk, R]): Eff[R, A]

create an Eff value from an error
create an Eff value from an error

Definition Classes
ErrorCreation
def eval[R, A](a: EvalEffect.Eval[A])(implicit m: <=[ErrorOrOk, R]): Eff[R, A]

create an Eff value from a computation
create an Eff value from a computation

Definition Classes
ErrorCreation
def exception[R, A](t: Throwable)(implicit m: <=[ErrorOrOk, R]): Eff[R, A]

create an Eff value from an exception
create an Eff value from an exception

Definition Classes
ErrorCreation
def fail[R, A](failure: F)(implicit m: <=[ErrorOrOk, R]): Eff[R, A]

create an Eff value from a failure
create an Eff value from a failure

Definition Classes
ErrorCreation
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def ignoreException[R <: Effects, E <: Throwable, A](action: Eff[R, A])(implicit arg0: ClassTag[E], m: <=[ErrorOrOk, R]): Eff[R, Unit]

ignore one possible exception that could be thrown
ignore one possible exception that could be thrown

Definition Classes
ErrorInterpretation
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def localError[SR, BR, U, E1, E2, A](r: Eff[SR, A], getter: (E1) ⇒ E2)(implicit sr: Aux[[X]Xor[Xor[Throwable, E1], Eval[X]], SR, U], br: Aux[[X]Xor[Xor[Throwable, E2], Eval[X]], BR, U]): Eff[BR, A]

Lift a computation over a "small" error (for a subsystem) into a computation over a "bigger" error (for the full application)
Lift a computation over a "small" error (for a subsystem) into a computation over a "bigger" error (for the full application)

Definition Classes
ErrorInterpretation
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def ok[R, A](a: ⇒ A)(implicit m: <=[ErrorOrOk, R]): Eff[R, A]

create an Eff value from a computation
create an Eff value from a computation

Definition Classes
ErrorCreation
def orElse[R <: Effects, A](action: Eff[R, A], onError: Eff[R, A])(implicit m: <=[ErrorOrOk, R]): Eff[R, A]

evaluate 1 action possibly having error effects
evaluate 1 action possibly having error effects
Execute a second action if the first one is not successful

Definition Classes
ErrorInterpretation
def runError[R <: Effects, U <: Effects, A](r: Eff[R, A])(implicit m: Aux[ErrorOrOk, R, U]): Eff[U, Xor[Error, A]]

Run an error effect.
Run an error effect.
Stop all computation if there is an exception or a failure.

Definition Classes
ErrorInterpretation
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( ... )
def whenFailed[R <: Effects, A](action: Eff[R, A], onError: (Error) ⇒ Eff[R, A])(implicit m: <=[ErrorOrOk, R]): Eff[R, A]

evaluate 1 action possibly having error effects
evaluate 1 action possibly having error effects
Execute a second action if the first one is not successful, based on the error
The final value type is the same as the original type

Definition Classes
ErrorInterpretation

Related Docs: object ErrorEffect | package eff

trait ErrorEffect[F] extends ErrorCreation[F] with ErrorInterpretation[F]

Type Members

type Error = Xor[Throwable, F]

type ErrorOrOk[A] = Xor[Error, Eval[A]]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def andFinally[R <: Effects, A](action: Eff[R, A], last: Eff[R, Unit])(implicit m: <=[ErrorOrOk, R]): Eff[R, A]

final def asInstanceOf[T0]: T0

def catchError[R <: Effects, A, B](action: Eff[R, A], pure: (A) ⇒ B, onError: (Error) ⇒ Eff[R, B])(implicit m: <=[ErrorOrOk, R]): Eff[R, B]

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error[R, A](error: Error)(implicit m: <=[ErrorOrOk, R]): Eff[R, A]

def eval[R, A](a: EvalEffect.Eval[A])(implicit m: <=[ErrorOrOk, R]): Eff[R, A]

def exception[R, A](t: Throwable)(implicit m: <=[ErrorOrOk, R]): Eff[R, A]

def fail[R, A](failure: F)(implicit m: <=[ErrorOrOk, R]): Eff[R, A]

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def ignoreException[R <: Effects, E <: Throwable, A](action: Eff[R, A])(implicit arg0: ClassTag[E], m: <=[ErrorOrOk, R]): Eff[R, Unit]

final def isInstanceOf[T0]: Boolean

def localError[SR, BR, U, E1, E2, A](r: Eff[SR, A], getter: (E1) ⇒ E2)(implicit sr: Aux[[X]Xor[Xor[Throwable, E1], Eval[X]], SR, U], br: Aux[[X]Xor[Xor[Throwable, E2], Eval[X]], BR, U]): Eff[BR, A]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def ok[R, A](a: ⇒ A)(implicit m: <=[ErrorOrOk, R]): Eff[R, A]

def orElse[R <: Effects, A](action: Eff[R, A], onError: Eff[R, A])(implicit m: <=[ErrorOrOk, R]): Eff[R, A]

def runError[R <: Effects, U <: Effects, A](r: Eff[R, A])(implicit m: Aux[ErrorOrOk, R, U]): Eff[U, Xor[Error, A]]

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

def whenFailed[R <: Effects, A](action: Eff[R, A], onError: (Error) ⇒ Eff[R, A])(implicit m: <=[ErrorOrOk, R]): Eff[R, A]

Inherited from ErrorInterpretation[F]

Inherited from ErrorCreation[F]

Inherited from ErrorTypes[F]

Inherited from AnyRef

Inherited from Any

Ungrouped