SafeEffect

object SafeEffect extends SafeEffect
Companion:
class
Source:
SafeEffect.scala
trait SafeTypes
class Object
trait Matchable
class Any

Type members

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

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
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

Inherited from:
SafeInterpretation
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

Inherited from:
SafeInterpretation
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

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

Inherited from:
SafeInterpretation
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

Inherited from:
SafeInterpretation
Source:
SafeEffect.scala
def protect[R : _safe, A](a: => A): Eff[R, A]
Inherited from:
SafeCreation
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

Inherited from:
SafeInterpretation
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

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

Inherited from:
SafeInterpretation
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

Inherited from:
SafeInterpretation
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

Inherited from:
SafeInterpretation
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

Inherited from:
SafeInterpretation
Source:
SafeEffect.scala