package mtl
- Alphabetic
- By Inheritance
- mtl
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
trait
ApplicativeAsk[F[_], E] extends Serializable
ApplicativeAsk[F, E]
lets you access anE
value in theF[_]
context.ApplicativeAsk[F, E]
lets you access anE
value in theF[_]
context.Intuitively, this means that an
E
value is required as an input to get "out" of theF[_]
context.ApplicativeAsk[F, E]
has one external law:def askAddsNoEffects[A](fa: F[A]) = { (ask *> fa) <-> fa }
ApplicativeAsk[F, E]
has one internal law:def readerIsAskAndMap[A](f: E => A) = { ask.map(f) <-> reader(f) }
- trait ApplicativeCensor[F[_], L] extends FunctorListen[F, L]
- trait ApplicativeHandle[F[_], E] extends FunctorRaise[F, E] with Serializable
-
trait
ApplicativeLocal[F[_], E] extends ApplicativeAsk[F, E] with Serializable
ApplicativeLocal[F, E]
lets you alter theE
value that is observed by anF[A]
value usingask
; the modification can only be observed from within thatF[A]
value.ApplicativeLocal[F, E]
lets you alter theE
value that is observed by anF[A]
value usingask
; the modification can only be observed from within thatF[A]
value.ApplicativeLocal[F, E]
has three external laws:def askReflectsLocal(f: E => E) = { local(f)(ask) <-> ask map f } def localPureIsPure[A](a: A, f: E => E) = { local(f)(pure(a)) <-> pure(a) } def localDistributesOverAp[A, B](fa: F[A], ff: F[A => B], f: E => E) = { local(f)(ff ap fa) <-> local(f)(ff) ap local(f)(fa) }
ApplicativeLocal
has one internal law:def scopeIsLocalConst(fa: F[A], e: E) = { scope(e)(fa) <-> local(_ => e)(fa) }
- trait DefaultApplicativeAsk[F[_], E] extends ApplicativeAsk[F, E]
- trait DefaultApplicativeCensor[F[_], L] extends ApplicativeCensor[F, L] with DefaultFunctorListen[F, L]
- trait DefaultApplicativeHandle[F[_], E] extends ApplicativeHandle[F, E]
- trait DefaultApplicativeLocal[F[_], E] extends DefaultApplicativeAsk[F, E] with ApplicativeLocal[F, E]
- trait DefaultFunctorListen[F[_], L] extends DefaultFunctorTell[F, L] with FunctorListen[F, L]
- trait DefaultFunctorTell[F[_], L] extends FunctorTell[F, L]
- trait DefaultMonadChronicle[F[_], E] extends MonadChronicle[F, E]
- trait DefaultMonadState[F[_], S] extends MonadState[F, S]
-
trait
FunctorListen[F[_], L] extends FunctorTell[F, L] with Serializable
FunctorListen[F, L]
is a functionF[A] => F[(A, L)]
which exposes some state that is contained in allF[A]
values, and can be modified usingtell
.FunctorListen[F, L]
is a functionF[A] => F[(A, L)]
which exposes some state that is contained in allF[A]
values, and can be modified usingtell
.FunctorListen
has two external laws:def listenRespectsTell(l: L) = { listen(tell(l)) <-> tell(l).as(((), l)) } def listenAddsNoEffects(fa: F[A]) = { listen(fa).map(_._1) <-> fa }
FunctorListen
has one internal law:def listensIsListenThenMap(fa: F[A], f: L => B) = { listens(fa)(f) <-> listen(fa).map { case (a, l) => (a, f(l)) } }
-
trait
FunctorRaise[F[_], E] extends Serializable
FunctorRaise[F, E]
expresses the ability to raise errors of typeE
in a functorialF[_]
context.FunctorRaise[F, E]
expresses the ability to raise errors of typeE
in a functorialF[_]
context. This means that a value of typeF[A]
may contain noA
values but instead anE
error value, and furthermap
calls will not have any values to execute the passed function on.FunctorRaise
has no external laws.FunctorRaise
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 }
FunctorRaise
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: fail[X](ex) <-> fail[F[Y]](ex) // parametricity fail[X](ex).map(f) <-> fail[F[Y]](ex) // map must have no effect, because there's no X value fail[X](ex).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.
-
trait
FunctorTell[F[_], L] extends Serializable
FunctorTell[F, L]
is the ability to "log" valuesL
inside a contextF[_]
, as an effect.FunctorTell[F, L]
is the ability to "log" valuesL
inside a contextF[_]
, as an effect.FunctorTell
has no external laws.FunctorTell
has one internal law:def writerIsTellAndMap(a: A, l: L) = { (tell(l) as a) <-> writer(a, l) } def tupleIsWriterFlipped(a: A, l: L) = { writer(a, l) <-> tuple((l, a)) }
- trait MonadChronicle[F[_], E] extends Serializable
-
trait
MonadState[F[_], S] extends Serializable
MonadState[F, S]
is the capability to access and modify a state value from inside theF[_]
context, usingset(s: S): F[Unit]
andget: F[S]
.MonadState[F, S]
is the capability to access and modify a state value from inside theF[_]
context, usingset(s: S): F[Unit]
andget: F[S]
.MonadState has four external laws:
def getThenSetDoesNothing = { get >>= set <-> pure(()) } def setThenGetReturnsSetted(s: S) = { set(s) *> get <-> set(s) *> pure(s) } def setThenSetSetsLast(s1: S, s2: S) = { set(s1) *> set(s2) <-> set(s2) } def getThenGetGetsOnce = { get *> get <-> get }
MonadState
has two internal law:def modifyIsGetThenSet(f: S => S) = { modify(f) <-> (inspect(f) flatMap set) } def inspectLaw[A](f: S => A) = { inspect(f) <-> (get map f) }
Value Members
- object ApplicativeAsk extends Serializable
- object ApplicativeCensor extends Serializable
- object ApplicativeHandle extends Serializable
- object ApplicativeLocal extends Serializable
- object FunctorListen extends Serializable
- object FunctorRaise extends Serializable
- object FunctorTell extends Serializable
- object MonadChronicle extends Serializable
- object MonadState extends Serializable