Type Parameters:: A - the carrier type; M - the witness

All Superinterfaces:: Applicative<A,M>, Functor<A,M>, Monad<A,M>

All Known Subinterfaces:: BiMonoidFactory<A,B,C>, BiPredicate<A,B>, BiSemigroupFactory<A,B,C>, Effect<A>, Fn0<A>, Fn1<A,B>, Fn2<A,B,C>, Fn3<A,B,C,D>, Fn4<A,B,C,D,E>, Fn5<A,B,C,D,E,F>, Fn6<A,B,C,D,E,F,G>, Fn7<A,B,C,D,E,F,G,H>, Fn8<A,B,C,D,E,F,G,H,I>, Iso<S,T,A,B>, Iso.Simple<S,A>, Kleisli<A,B,M,MB>, Lens<S,T,A,B>, Lens.Simple<S,A>, MonadT<M,A,MT,T>, Monoid<A>, MonoidFactory<A,B>, Predicate<A>, Prism<S,T,A,B>, Prism.Simple<S,A>, Schema<Values>, Semigroup<A>, SemigroupFactory<A,B>, TypeSafeKey<A,B>, TypeSafeKey.Simple<A>

All Known Implementing Classes:: $, Absent, AddAll, All, Alter, And, Any, AutoBracket, Between, Both, Bracket, CartesianProduct, CatMaybes, Choice2, Choice2._A, Choice2._B, Choice3, Choice3._A, Choice3._B, Choice3._C, Choice4, Choice4._A, Choice4._B, Choice4._C, Choice4._D, Choice5, Choice5._A, Choice5._B, Choice5._C, Choice5._D, Choice5._E, Choice6, Choice6._A, Choice6._B, Choice6._C, Choice6._D, Choice6._E, Choice6._F, Choice7, Choice7._A, Choice7._B, Choice7._C, Choice7._D, Choice7._E, Choice7._F, Choice7._G, Choice8, Choice8._A, Choice8._B, Choice8._C, Choice8._D, Choice8._E, Choice8._F, Choice8._G, Choice8._H, Clamp, CmpEq, CmpEqBy, CmpEqWith, Coalesce, Collapse, Collapse, Compare, Compose, Compose, Concat, Cons, Const, Constantly, Cycle, Difference, Distinct, Downcast, Drop, DropWhile, Either, Either.Left, Either.Right, EitherT, Empty, Endo, EndoK, Eq, Filter, Find, First, Flatten, FoldLeft, FoldRight, Force, GroupBy, GT, GTBy, GTE, GTEBy, GTEWith, GTWith, Head, Id, Identity, IdentityT, IfThenElse, InGroupsOf, Init, Inits, Intersection, Intersperse, Into, Into1, Into3, Into4, Into5, Into6, Into7, Into8, IO, IO.Compose, Iterate, IterateT, Join, LambdaIterable, Last, Last, Lazy, Lazy.Compose, Lazy.Later, LazyRec, LazyT, LeftAll, LeftAll, LeftAny, LeftAny, LiftA2, LiftA3, LiftA4, LiftA5, LiftA6, LiftA7, LT, LTBy, LTE, LTEBy, LTEWith, LTWith, Magnetize, MagnetizeBy, Map, Market, Matching, Max, MaxBy, MaxWith, Maybe, Maybe.Just, Maybe.Nothing, MaybeT, Merge, Merge, MergeHMaps, MergeMaps, Min, MinBy, MinWith, Not, Occurrences, Or, Over, Partition, Peek, Peek2, Pre, PrependAll, Present, PutAll, RateLimit, Re, ReaderT, RecursiveResult, RecursiveResult.Recurse, RecursiveResult.Terminate, ReduceLeft, ReduceRight, Repeat, Replicate, Reverse, RightAll, RightAll, RightAny, RightAny, RunAll, RunAll, SafeT, ScanLeft, Sequence, Set, SingletonHList, Size, Slide, Snoc, Sort, SortBy, SortWith, Span, State, StateT, Tagged, Tail, Tails, Take, TakeWhile, These, These._A, These._B, These.Both, Times, ToArray, ToCollection, ToMap, Trampoline, Trivial, Try, Try.Failure, Try.Success, Tuple2, Tuple3, Tuple4, Tuple5, Tuple6, Tuple7, Tuple8, Tupler2, Uncons, Under, Unfoldr, Union, Until, Upcast, View, Writer, WriterT, Xor, Zip, ZipWith

public interface MonadRec<A, M extends MonadRec<?,M>> extends Monad<A,M>

A class of monads that offer a stack-safe interface for performing arbitrarily many flatmap-like operations via trampolineM(Fn1).

Inspired by Phil Freeman's paper _Stack Safety for Free_

Method Summary

Modifier and Type

Method

Description

default MonadRec<B,M>

discardL(Applicative<B,M> appB)

Sequence both this Applicative and appB, discarding this Applicative's result and returning appB.

default MonadRec<A,M>

discardR(Applicative<B,M> appB)

Sequence both this Applicative and appB, discarding appB's result and returning this Applicative.

 MonadRec<B,M>

flatMap(Fn1<? super A, ? extends Monad<B,M>> f)

Chain dependent computations that may continue or short-circuit based on previous results.

default MonadRec<B,M>

fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

default Lazy<? extends MonadRec<B,M>>

lazyZip(Lazy<? extends Applicative<Fn1<? super A, ? extends B>, M>> lazyAppFn)

Given a lazy instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.

 MonadRec<B,M>

pure(B b)

Lift the value b into this applicative functor.

 MonadRec<B,M>

trampolineM(Fn1<? super A, ? extends MonadRec<RecursiveResult<A,B>, M>> fn)

Given some operation yielding a RecursiveResult inside this MonadRec, internally trampoline the operation until it yields a termination instruction.

default MonadRec<B,M>

zip(Applicative<Fn1<? super A, ? extends B>, M> appFn)

Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.

Methods inherited from interface Functor
coerce

Method Details
- trampolineM
 MonadRec<B,M> trampolineM(Fn1<? super A, ? extends MonadRec<RecursiveResult<A,B>, M>> fn)
 
 Given some operation yielding a RecursiveResult inside this MonadRec, internally trampoline the operation until it yields a termination instruction.
 Stack-safety depends on implementations guaranteeing that the growth of the call stack is a constant factor independent of the number of invocations of the operation. For various examples of how this can be achieved in stereotypical circumstances, see the referenced types.
 
 Type Parameters:
 
 B - the ultimate resulting carrier type
 
 Parameters:
 
 fn - the function to internally trampoline
 
 Returns:
 
 the trampolined MonadRec
 
 See Also:
 
 for a basic implementation
 
 for a coproduct implementation
 
 for an implementation leveraging an already stack-safe Monad#flatMap(Fn1)
 
 for a monad transformer implementation
- flatMap
 
 MonadRec<B,M> flatMap(Fn1<? super A, ? extends Monad<B,M>> f)
 
 Chain dependent computations that may continue or short-circuit based on previous results.
 
 Specified by:
 
 flatMap in interface Monad<A, M extends MonadRec<?,M>>
 
 Type Parameters:
 
 B - the resulting monad parameter type
 
 Parameters:
 
 f - the dependent computation over A
 
 Returns:
 
 the new monad instance
- pure
 
 MonadRec<B,M> pure(B b)
 
 Lift the value b into this applicative functor.
 
 Specified by:
 
 pure in interface Applicative<A, M extends MonadRec<?,M>>
 
 Specified by:
 
 pure in interface Monad<A, M extends MonadRec<?,M>>
 
 Type Parameters:
 
 B - the type of the returned applicative's parameter
 
 Parameters:
 
 b - the value
 
 Returns:
 
 an instance of this applicative over b
- fmap
 
 default MonadRec<B,M> fmap(Fn1<? super A, ? extends B> fn)
 
 Covariantly transmute this functor's parameter using the given mapping function. Generally this method is specialized to return an instance of the class implementing Functor.
 
 Specified by:
 
 fmap in interface Applicative<A, M extends MonadRec<?,M>>
 
 Specified by:
 
 fmap in interface Functor<A, M extends MonadRec<?,M>>
 
 Specified by:
 
 fmap in interface Monad<A, M extends MonadRec<?,M>>
 
 Type Parameters:
 
 B - the new parameter type
 
 Parameters:
 
 fn - the mapping function
 
 Returns:
 
 a functor over B (the new parameter type)
- zip
 
 default MonadRec<B,M> zip(Applicative<Fn1<? super A, ? extends B>, M> appFn)
 
 Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
 
 Specified by:
 
 zip in interface Applicative<A, M extends MonadRec<?,M>>
 
 Specified by:
 
 zip in interface Monad<A, M extends MonadRec<?,M>>
 
 Type Parameters:
 
 B - the resulting applicative parameter type
 
 Parameters:
 
 appFn - the other applicative instance
 
 Returns:
 
 the mapped applicative
- lazyZip
 default Lazy<? extends MonadRec<B,M>> lazyZip(Lazy<? extends Applicative<Fn1<? super A, ? extends B>, M>> lazyAppFn)
 
 Given a lazy instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports. This is useful for applicatives that support lazy evaluation and early termination.
 
 Specified by:
 
 lazyZip in interface Applicative<A, M extends MonadRec<?,M>>
 
 Specified by:
 
 lazyZip in interface Monad<A, M extends MonadRec<?,M>>
 
 Type Parameters:
 
 B - the resulting applicative parameter type
 
 Parameters:
 
 lazyAppFn - the lazy other applicative instance
 
 Returns:
 
 the mapped applicative
 
 See Also:
 
 Maybe
 
 Either
- discardL
 
 default MonadRec<B,M> discardL(Applicative<B,M> appB)
 
 Sequence both this Applicative and appB, discarding this Applicative's result and returning appB. This is generally useful for sequentially performing side-effects.
 
 Specified by:
 
 discardL in interface Applicative<A, M extends MonadRec<?,M>>
 
 Specified by:
 
 discardL in interface Monad<A, M extends MonadRec<?,M>>
 
 Type Parameters:
 
 B - the type of the returned Applicative's parameter
 
 Parameters:
 
 appB - the other Applicative
 
 Returns:
 
 appB
- discardR
 
 default MonadRec<A,M> discardR(Applicative<B,M> appB)
 
 Sequence both this Applicative and appB, discarding appB's result and returning this Applicative. This is generally useful for sequentially performing side-effects.
 
 Specified by:
 
 discardR in interface Applicative<A, M extends MonadRec<?,M>>
 
 Specified by:
 
 discardR in interface Monad<A, M extends MonadRec<?,M>>
 
 Type Parameters:
 
 B - the type of appB's parameter
 
 Parameters:
 
 appB - the other Applicative
 
 Returns:
 
 this Applicative

Interface MonadRec<A, M extends MonadRec<?,M>>

Method Summary

Methods inherited from interface Functor

Method Details

trampolineM

flatMap

pure

fmap

zip

lazyZip

discardL

discardR