SafeInterpretation

Companion:
object
Source:
SafeEffect.scala
trait SafeTypes
class Object
trait Matchable
class Any
object SafeEffect.type
object all.type
object SafeInterpretation.type
object safe.type

Type members

Types

Inherited types

type _Safe[R] = Member[Safe, R]
Inherited from:
SafeTypes
Source:
SafeEffect.scala
type _safe[R] = MemberIn[Safe, R]
Inherited from:
SafeTypes
Source:
SafeEffect.scala

Value members

Concrete 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

Source:
SafeEffect.scala
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

Source:
SafeEffect.scala
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

Source:
SafeEffect.scala
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

Source:
SafeEffect.scala
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

Source:
SafeEffect.scala
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

Source:
SafeEffect.scala
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

Source:
SafeEffect.scala
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

Source:
SafeEffect.scala
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

Source:
SafeEffect.scala
def safeInterpreter[R, A]: Interpreter[Safe, R, A, (A)]
def safeInterpreter[R, A](last: Option[(Eff[R, Unit], MemberInOut[Safe, R])]): Interpreter[Safe, R, A, (A)]
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

Source:
SafeEffect.scala
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

Source:
SafeEffect.scala
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

Source:
SafeEffect.scala
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

Source:
SafeEffect.scala

Inherited methods

def eval[R : _safe, A](a: Eval[A]): Eff[R, A]
Inherited from:
SafeCreation
Source:
SafeEffect.scala
def exception[R : _safe, A](t: Throwable): Eff[R, A]
Inherited from:
SafeCreation
Source:
SafeEffect.scala
def protect[R : _safe, A](a: => A): Eff[R, A]
Inherited from:
SafeCreation
Source:
SafeEffect.scala