Package com.jnape.palatable.lambda.monad
Interface MonadRec<A,M extends MonadRec<?,M>>
-
- Type Parameters:
A
- the carrier typeM
- thewitness
- 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 ofmonads
that offer a stack-safe interface for performing arbitrarily manyflatmap-like
operations viatrampolineM(Fn1)
.Inspired by Phil Freeman's paper _Stack Safety for Free_
-
-
Method Summary
All Methods Instance Methods Abstract Methods Default Methods Modifier and Type Method Description default <B> MonadRec<B,M>
discardL(Applicative<B,M> appB)
Sequence both thisApplicative
andappB
, discarding thisApplicative's
result and returningappB
.default <B> MonadRec<A,M>
discardR(Applicative<B,M> appB)
Sequence both thisApplicative
andappB
, discardingappB's
result and returning thisApplicative
.<B> 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 <B> MonadRec<B,M>
fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.default <B> Lazy<? extends MonadRec<B,M>>
lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,M>> lazyAppFn)
Given alazy
instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.<B> MonadRec<B,M>
pure(B b)
Lift the valueb
into this applicative functor.<B> MonadRec<B,M>
trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,M>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.default <B> 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.
-
-
-
Method Detail
-
trampolineM
<B> MonadRec<B,M> trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,M>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
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 implementation
,for an implementation leveraging an already stack-safe
,for a implementation
-
flatMap
<B> 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.
-
fmap
default <B> 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 interfaceApplicative<A,M extends MonadRec<?,M>>
- Specified by:
fmap
in interfaceFunctor<A,M extends MonadRec<?,M>>
- Specified by:
fmap
in interfaceMonad<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 <B> 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.
-
lazyZip
default <B> Lazy<? extends MonadRec<B,M>> lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,M>> lazyAppFn)
Given alazy
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 interfaceApplicative<A,M extends MonadRec<?,M>>
- Specified by:
lazyZip
in interfaceMonad<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 <B> MonadRec<B,M> discardL(Applicative<B,M> appB)
Sequence both thisApplicative
andappB
, discarding thisApplicative's
result and returningappB
. This is generally useful for sequentially performing side-effects.
-
discardR
default <B> MonadRec<A,M> discardR(Applicative<B,M> appB)
Sequence both thisApplicative
andappB
, discardingappB's
result and returning thisApplicative
. This is generally useful for sequentially performing side-effects.
-
-