Raise

@implicitNotFound("Could not find an implicit instance of Raise[${F}, ${E}]. If you have\na good way of handling errors of type ${E} at this location, you may want\nto construct a value of type EitherT for this call-site, rather than ${F}.\nAn example type:\n\n EitherT[${F}, ${E}, *]\n\nThis is analogous to writing try/catch around this call. The EitherT will\n\"catch\" the errors of type ${E}.\n\nIf you do not wish to handle errors of type ${E} at this location, you should\nadd an implicit parameter of this type to your function. For example:\n\n (implicit fraise: Raise[${F}, ${E}])\n") trait Raise[F <: ([_$1] =>> Any), -E] extends Serializable
Raise[F, E] expresses the ability to raise errors of type E in a functorial F[_] context.
This means that a value of type F[A] may contain no A values but instead an E error value,
and further map calls will not have any values to execute the passed function on.
Raise has no external laws.
Raise has two internal laws:
{{{
def catchNonFatalDefault[A] (a: => A)(f: Throwable => E)(implicit A: Applicative[F] ) = {
catchNonFatal(a)(f) <-> try {
A.pure(a)
} catch {
case NonFatal(ex) => raise(f(ex))
}
}
def ensureDefault[A] (fa: F[A] )(error: => E)(predicate: A => Boolean)(implicit A: Monad[F] ) = {
ensure(fa)(error)(predicate) <-> for {
a <- fa
_ <- if (predicate(a)) pure(()) else raise(error)
} yield a
}
}}}
Raise has one free law, i.e. a law guaranteed by parametricity:
{{{
def failThenFlatMapFails[A, B] (ex: E, f: A => F[B] ) = {
fail(ex).flatMap(f) <-> fail(ex)
}
guaranteed by:
failX <-> failF[Y] // parametricity
failX.map(f) <-> failF[Y] // map must have no effect, because there's no X value
failX.map(f).join <-> fail[F[Y] ].join // add join to both sides
fail(ex).flatMap(f) <-> fail(ex) // join is equal, because there's no inner value to flatten effects from
// QED.
}}}
Companion
object
trait Serializable
class Object
trait Matchable
class Any
trait Handle[F, E]

Value members

Methods

def functor: Functor[F]
def raise[E2 <: E, A](e: E2): F[A]
def catchNonFatal[E2 <: E, A](a: => A)(f: Throwable => E2)(A: Applicative[F]): F[A]
def ensure[E2 <: E, A](fa: F[A])(error: => E2)(predicate: A => Boolean)(A: Monad[F]): F[A]