ErrorEffect

Type Members

type Error = \/[Throwable, F]

type of errors: exceptions or failure messages
implicit class ErrorEffectOps[R <: Effects, A] extends AnyRef

OPERATIONS
type ErrorOrOk[A] = \/[Error, Name[A]]

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

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 actions possibly having error effects
evaluate 1 actions possibly having error effects
Execute a second action whether the first is successful or not
final def asInstanceOf[T0]: T0

Definition Classes
Any
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
def exception[R, A](t: Throwable)(implicit m: <=[ErrorOrOk, R]): Eff[R, A]

create an Eff value from an exception
def fail[R, A](failure: F)(implicit m: <=[ErrorOrOk, R]): Eff[R, A]

create an Eff value from a failure
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
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
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
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
def runError[R <: Effects, A](r: Eff[|:[ErrorOrOk, R], A]): Eff[R, \/[Error, A]]

Run an error effect.
Run an error effect.
Stop all computation if there is an exception or a failure.
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

Related Docs: object ErrorEffect | package eff

trait ErrorEffect[F] extends AnyRef

Type Members

type Error = \/[Throwable, F]

implicit class ErrorEffectOps[R <: Effects, A] extends AnyRef

type ErrorOrOk[A] = \/[Error, Name[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 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 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

final def isInstanceOf[T0]: Boolean

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, A](r: Eff[|:[ErrorOrOk, R], A]): Eff[R, \/[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 AnyRef

Inherited from Any

Ungrouped