core/org.atnos.eff/ErrorEffect

ErrorEffect

object ErrorEffect extends ErrorEffect[String]

Simple instantiation of the ErrorEffect trait with String as a Failure type

Companion
class
trait ErrorEffect[String]
trait ErrorInterpretation[String]
trait ErrorCreation[String]
trait ErrorTypes[String]
class Object
trait Matchable
class Any

Type members

Inherited types

type Error = Either[Throwable, F]

type of errors: exceptions or failure messages

type of errors: exceptions or failure messages

Inherited from
ErrorTypes
type ErrorOrOk[A] = Evaluate[F, A]

base type for this effect: either an error or a computation to evaluate a "by-name" value

base type for this effect: either an error or a computation to evaluate a "by-name" value

Inherited from
ErrorTypes
type _ErrorOrOk[R] = Member[ErrorOrOk, R]
Inherited from
ErrorTypes
type _errorOrOk[R] = MemberIn[ErrorOrOk, R]
Inherited from
ErrorTypes

Value members

Concrete methods

def render(t: Throwable): String
def renderWithStack(t: Throwable): String
def trace(t: Throwable): String
def traceWithIndent(t: Throwable, indent: String): String

Inherited methods

def andFinally[R, A](action: Eff[R, A], lastAction: Eff[R, Unit])(implicit m: MemberInOut[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

Inherited from
ErrorInterpretation
def catchError[R, A, B](action: Eff[R, A], pure: A => B, onError: Error => Eff[R, B])(implicit m: MemberInOut[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

Inherited from
ErrorInterpretation
def error[R, A](error: Error)(implicit evidence$3: _errorOrOk[R]): Eff[R, A]

create an Eff value from an error

create an Eff value from an error

Inherited from
ErrorCreation
def errorInterpreter[R, A, B](pureValue: A => B, onError: Error => Eff[R, B]): Interpreter[ErrorOrOk, R, A, B]
Inherited from
ErrorInterpretation
def eval[R, A](a: Eval[A])(implicit evidence$2: _errorOrOk[R]): Eff[R, A]

create an Eff value from a computation

create an Eff value from a computation

Inherited from
ErrorCreation
def exception[R, A](t: Throwable)(implicit evidence$5: _errorOrOk[R]): Eff[R, A]

create an Eff value from an exception

create an Eff value from an exception

Inherited from
ErrorCreation
def fail[R, A](failure: String)(implicit evidence$4: _errorOrOk[R]): Eff[R, A]

create an Eff value from a failure

create an Eff value from a failure

Inherited from
ErrorCreation
def ignoreException[R, E <: Throwable, A](action: Eff[R, A])(implicit evidence$6: ClassTag[E], m: MemberInOut[ErrorOrOk, R]): Eff[R, Unit]

ignore one possible exception that could be thrown

ignore one possible exception that could be thrown

Inherited from
ErrorInterpretation
def localError[SR, BR, U1, U2, F1, F2, A](r: Eff[SR, A], getter: F1 => F2)(implicit sr: Aux[[_] =>> Evaluate[F1, _$12], SR, U1], br: Aux[[_] =>> Evaluate[F2, _$13], BR, U2], into: IntoPoly[U1, U2]): 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)

Inherited from
ErrorInterpretation
def ok[R, A](a: => A)(implicit evidence$1: _errorOrOk[R]): Eff[R, A]

create an Eff value from a computation

create an Eff value from a computation

Inherited from
ErrorCreation
def orElse[R, A](action: Eff[R, A], onError: Eff[R, A])(implicit m: MemberInOut[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

Inherited from
ErrorInterpretation
def runError[R, U, A](r: Eff[R, A])(implicit m: Aux[ErrorOrOk, R, U]): Eff[U, Either[Error, A]]

Run an error effect.

Run an error effect.

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

Inherited from
ErrorInterpretation
def runLocalError[R, U, F1, F2, A](r: Eff[R, A], getter: F1 => F2)(implicit sr: Aux[[_] =>> Evaluate[F1, _$18], R, U], br: MemberIn[[_] =>> Evaluate[F2, _$19], U]): Eff[U, A]

Translate an error effect to another one in the same stack a computation over a "bigger" error (for the full application)

Translate an error effect to another one in the same stack a computation over a "bigger" error (for the full application)

Inherited from
ErrorInterpretation
def whenFailed[R, A](action: Eff[R, A], onError: Error => Eff[R, A])(implicit m: MemberInOut[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

Inherited from
ErrorInterpretation