safe

trait SafeTypes
class Object
trait Matchable
class Any

Type members

Inherited types

type Out[A] = (ThrowableEither[A], List[Throwable])
Inherited from
SafeInterpretation
type _Safe[R] = Member[Safe, R]
Inherited from
SafeTypes
type _safe[R] = MemberIn[Safe, R]
Inherited from
SafeTypes

Value members

Inherited methods

def attempt[R, A](action: Eff[R, A])(implicit m: MemberInOut[Safe, R]): Eff[R, Either[Throwable, A]]

try to execute an action an report any issue

try to execute an action an report any issue

Inherited from
SafeInterpretation
def attemptSafe[R, A](effect: Eff[R, A])(implicit m: MemberInOut[Safe, R]): Eff[R, (ThrowableEither[A], List[Throwable])]

Attempt to execute a safe action including finalizers

Attempt to execute a safe action including finalizers

Inherited from
SafeInterpretation
def bracket[R, A, B, C](acquire: Eff[R, A])(use: A => Eff[R, B])(release: A => Eff[R, C])(implicit m: MemberInOut[Safe, R]): Eff[R, B]

get a resource A and use it. Call the release function whether an exception is thrown or not when using the resource

get a resource A and use it. Call the release function whether an exception is thrown or not when using the resource

NOTE: Eff interpreters are independent so if there is an effect short-circuiting all computations inside 'use', like Option or Either then the release function will not be called. If you want to make sure that the release function is always called "at the end of the world and whatever happens" you need to call Eff.bracketLast

Inherited from
SafeInterpretation
def catchThrowable[R, A, B](action: Eff[R, A], pureValue: A => B, onThrowable: Throwable => Eff[R, B])(implicit m: MemberInOut[Safe, R]): Eff[R, B]

evaluate first action possibly having error effects

evaluate first action possibly having error effects

Execute a second action if the first one is not successful, based on the error

Inherited from
SafeInterpretation
def eval[R : _safe, A](a: Eval[A]): Eff[R, A]
Inherited from
SafeCreation
def exception[R : _safe, A](t: Throwable): Eff[R, A]
Inherited from
SafeCreation
def execSafe[R, U, A](r: Eff[R, A])(implicit m: Aux[Safe, R, U]): Eff[U, ThrowableEither[A]]

run a safe effect but drop the finalizer errors

run a safe effect but drop the finalizer errors

Inherited from
SafeInterpretation
def finalizerException[R : _safe](t: Throwable): Eff[R, Unit]
Inherited from
SafeCreation
def ignoreException[R, E <: Throwable : ClassTag, A](action: Eff[R, A])(implicit evidence$5: ClassTag[E], m: MemberInOut[Safe, R]): Eff[R, Unit]

ignore one possible exception that could be thrown

ignore one possible exception that could be thrown

Inherited from
SafeInterpretation
def otherwise[R, A](action: Eff[R, A], onThrowable: Eff[R, A])(implicit m: MemberInOut[Safe, R]): Eff[R, A]

evaluate first action possibly having exceptions

evaluate first action possibly having exceptions

Execute a second action if the first one is not successful

Inherited from
SafeInterpretation
def protect[R : _safe, A](a: => A): Eff[R, A]
Inherited from
SafeCreation
def recoverThrowable[R, A, B](action: Eff[R, A], pureValue: A => B, onThrowable: PartialFunction[Throwable, Eff[R, B]])(implicit m: MemberInOut[Safe, R]): Eff[R, B]

evaluate first action possibly having error effects

evaluate first action possibly having error effects

Execute a second action if the first one is not successful and second is defined for the error

Inherited from
SafeInterpretation
def runSafe[R, U, A](effect: Eff[R, A])(implicit m: Aux[Safe, R, U]): Eff[U, (ThrowableEither[A], List[Throwable])]

Run a safe effect

Run a safe effect

Collect finalizer exceptions if any

Inherited from
SafeInterpretation
def safeInterpreter[R, A](last: Option[(Eff[R, Unit], MemberInOut[Safe, R])]): Interpreter[Safe, R, A, (A)]
Inherited from
SafeInterpretation
def safeInterpreter[R, A]: Interpreter[Safe, R, A, (A)]
Inherited from
SafeInterpretation
def safeMemo[R, A](key: AnyRef, cache: Cache, e: Eff[R, A])(implicit safe: MemberInOut[Safe, R]): Eff[R, A]

Memoize safe effects using a cache

Memoize safe effects using a cache

if this method is called with the same key the previous value will be returned

Inherited from
SafeInterpretation
def thenFinally[R, A](effect: Eff[R, A], last: Eff[R, Unit])(implicit m: MemberInOut[Safe, R]): Eff[R, A]

evaluate first action possibly having error effects execute a second action whether the first is successful or not but keep track of finalizer exceptions

evaluate first action possibly having error effects execute a second action whether the first is successful or not but keep track of finalizer exceptions

Inherited from
SafeInterpretation
def whenFailed[R, A](action: Eff[R, A], onThrowable: Throwable => Eff[R, A])(implicit m: MemberInOut[Safe, R]): Eff[R, A]

evaluate first action possibly throwing exceptions

evaluate first action possibly throwing exceptions

Execute a second action if the first one is not successful, based on the exception

The final value type is the same as the original type

Inherited from
SafeInterpretation
def whenThrowable[R, A](action: Eff[R, A], onThrowable: PartialFunction[Throwable, Eff[R, A]])(implicit m: MemberInOut[Safe, R]): Eff[R, A]

evaluate first action possibly throwing exceptions

evaluate first action possibly throwing exceptions

Execute a second action if the first one is not successful and second is defined for the error

The final value type is the same as the original type

Inherited from
SafeInterpretation