Package com.jnape.palatable.lambda.functions.recursion

Class RecursiveResult<A,B>

java.lang.Object

com.jnape.palatable.lambda.functions.recursion.RecursiveResult<A,B>

Type Parameters:

A - the recursive function's input type

B - the recursive function's output type

All Implemented Interfaces:

CoProduct2<A,B,RecursiveResult<A,B>>, Applicative<B,RecursiveResult<A,?>>, Bifunctor<A,B,RecursiveResult<?,?>>, BoundedBifunctor<A,B,java.lang.Object,java.lang.Object,RecursiveResult<?,?>>, Functor<B,RecursiveResult<A,?>>, Monad<B,RecursiveResult<A,?>>, MonadRec<B,RecursiveResult<A,?>>, Traversable<B,RecursiveResult<A,?>>

Direct Known Subclasses:

RecursiveResult.Recurse, RecursiveResult.Terminate

public abstract class RecursiveResult<A,B>
extends java.lang.Object
implements CoProduct2<A,B,RecursiveResult<A,B>>, Bifunctor<A,B,RecursiveResult<?,?>>, MonadRec<B,RecursiveResult<A,?>>, Traversable<B,RecursiveResult<A,?>>

Specialized CoProduct2 representing the possible results of a primitive recursive function. Used by Trampoline to cheat around CoProduct2.match(com.jnape.palatable.lambda.functions.Fn1<? super A, ? extends R>, com.jnape.palatable.lambda.functions.Fn1<? super B, ? extends R>) and quickly unpack values via instanceof checks to package private inner subtypes.

See Also:

Trampoline

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
(package private) static class	RecursiveResult.Recurse<A,B>
(package private) static class	RecursiveResult.Terminate<A,B>

Constructor Summary

Constructors

Modifier	Constructor	Description
private	RecursiveResult()

Method Summary

Modifier and Type	Method	Description
<C,D> RecursiveResult<C,D>	biMap(Fn1<? super A,? extends C> lFn, Fn1<? super B,? extends D> rFn)	Dually map covariantly over both the left and right parameters.
<C> RecursiveResult<C,B>	biMapL(Fn1<? super A,? extends C> fn)	Covariantly map over the left parameter.
<C> RecursiveResult<A,C>	biMapR(Fn1<? super B,? extends C> fn)	Covariantly map over the right parameter.
<C> RecursiveResult<A,C>	discardL(Applicative<C,RecursiveResult<A,?>> appB)	Sequence both this Applicative and appB, discarding this Applicative's result and returning appB.
<C> RecursiveResult<A,B>	discardR(Applicative<C,RecursiveResult<A,?>> appB)	Sequence both this Applicative and appB, discarding appB's result and returning this Applicative.
<C> RecursiveResult<A,C>	flatMap(Fn1<? super B,? extends Monad<C,RecursiveResult<A,?>>> f)	Chain dependent computations that may continue or short-circuit based on previous results.
<C> RecursiveResult<A,C>	fmap(Fn1<? super B,? extends C> fn)	Covariantly transmute this functor's parameter using the given mapping function.
RecursiveResult<B,A>	invert()	Swap the type parameters.
<C> RecursiveResult<A,C>	pure(C c)	Lift the value b into this applicative functor.
static <A> Pure<RecursiveResult<A,?>>	pureRecursiveResult()	The canonical Pure instance for RecursiveResult.
static <A,B> RecursiveResult<A,B>	recurse(A a)	Static factory method for creating a "recurse" value.
static <A,B> RecursiveResult<A,B>	terminate(B b)	Static factory method for creating a "terminate" value.
<C> RecursiveResult<A,C>	trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,RecursiveResult<A,?>>> fn)	Given some operation yielding a RecursiveResult inside this MonadRec, internally trampoline the operation until it yields a termination instruction.
<C,App extends Applicative<?,App>,TravB extends Traversable<C,RecursiveResult<A,?>>,AppTrav extends Applicative<TravB,App>> AppTrav	traverse(Fn1<? super B,? extends Applicative<C,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)	Apply fn to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
<C> RecursiveResult<A,C>	zip(Applicative<Fn1<? super B,? extends C>,RecursiveResult<A,?>> 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 class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface com.jnape.palatable.lambda.adt.coproduct.CoProduct2

diverge, embed, match, project, projectA, projectB

Methods inherited from interface com.jnape.palatable.lambda.functor.Functor

coerce

Methods inherited from interface com.jnape.palatable.lambda.monad.MonadRec

lazyZip

Constructor Detail

RecursiveResult

private RecursiveResult()

Method Detail

invert

public RecursiveResult<B,A> invert()

Swap the type parameters.

Specified by:

invert in interface CoProduct2<A,B,RecursiveResult<A,B>>

Returns:

The inverted coproduct

biMapL

public <C> RecursiveResult<C,B> biMapL(Fn1<? super A,? extends C> fn)

Covariantly map over the left parameter.

Specified by:

biMapL in interface Bifunctor<A,B,RecursiveResult<?,?>>

Specified by:

biMapL in interface BoundedBifunctor<A,B,java.lang.Object,java.lang.Object,RecursiveResult<?,?>>

Type Parameters:

C - the new left parameter type

Parameters:

fn - the mapping function

Returns:

a bifunctor over C (the new left parameter) and B (the same right parameter)

biMapR

public <C> RecursiveResult<A,C> biMapR(Fn1<? super B,? extends C> fn)

Covariantly map over the right parameter. For all bifunctors that are also functors, it should hold that biMapR(f) == fmap(f).

Specified by:

biMapR in interface Bifunctor<A,B,RecursiveResult<?,?>>

Specified by:

biMapR in interface BoundedBifunctor<A,B,java.lang.Object,java.lang.Object,RecursiveResult<?,?>>

Type Parameters:

C - the new right parameter type

Parameters:

fn - the mapping function

Returns:

a bifunctor over A (the same left parameter) and C (the new right parameter)

biMap

public <C,D> RecursiveResult<C,D> biMap(Fn1<? super A,? extends C> lFn,
                                                    Fn1<? super B,? extends D> rFn)

Dually map covariantly over both the left and right parameters. This is isomorphic to biMapL(lFn).biMapR(rFn).

Specified by:

biMap in interface Bifunctor<A,B,RecursiveResult<?,?>>

Specified by:

biMap in interface BoundedBifunctor<A,B,java.lang.Object,java.lang.Object,RecursiveResult<?,?>>

Type Parameters:

C - the new left parameter type

D - the new right parameter type

Parameters:

lFn - the left parameter mapping function

rFn - the right parameter mapping function

Returns:

a bifunctor over C (the new left parameter type) and D (the new right parameter type)

flatMap

public <C> RecursiveResult<A,C> flatMap(Fn1<? super B,? extends Monad<C,RecursiveResult<A,?>>> f)

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

Specified by:

flatMap in interface Monad<A,B>

Specified by:

flatMap in interface MonadRec<A,B>

Type Parameters:

C - the resulting monad parameter type

Parameters:

f - the dependent computation over A

Returns:

the new monad instance

pure

public <C> RecursiveResult<A,C> pure(C c)

Lift the value b into this applicative functor.

Specified by:

pure in interface Applicative<A,B>

Specified by:

pure in interface Monad<A,B>

Specified by:

pure in interface MonadRec<A,B>

Type Parameters:

C - the type of the returned applicative's parameter

Parameters:

c - the value

Returns:

an instance of this applicative over b

fmap

public <C> RecursiveResult<A,C> fmap(Fn1<? super B,? extends C> 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,B>

Specified by:

fmap in interface Functor<A,B>

Specified by:

fmap in interface Monad<A,B>

Specified by:

fmap in interface MonadRec<A,B>

Specified by:

fmap in interface Traversable<A,B>

Type Parameters:

C - the new parameter type

Parameters:

fn - the mapping function

Returns:

a functor over B (the new parameter type)

zip

public <C> RecursiveResult<A,C> zip(Applicative<Fn1<? super B,? extends C>,RecursiveResult<A,?>> 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,B>

Specified by:

zip in interface Monad<A,B>

Specified by:

zip in interface MonadRec<A,B>

Type Parameters:

C - the resulting applicative parameter type

Parameters:

appFn - the other applicative instance

Returns:

the mapped applicative

discardL

public <C> RecursiveResult<A,C> discardL(Applicative<C,RecursiveResult<A,?>> 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,B>

Specified by:

discardL in interface Monad<A,B>

Specified by:

discardL in interface MonadRec<A,B>

Type Parameters:

C - the type of the returned Applicative's parameter

Parameters:

appB - the other Applicative

Returns:

appB

discardR

public <C> RecursiveResult<A,B> discardR(Applicative<C,RecursiveResult<A,?>> 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,B>

Specified by:

discardR in interface Monad<A,B>

Specified by:

discardR in interface MonadRec<A,B>

Type Parameters:

C - the type of appB's parameter

Parameters:

appB - the other Applicative

Returns:

this Applicative

trampolineM

public <C> RecursiveResult<A,C> trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,RecursiveResult<A,?>>> 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.

Specified by:

trampolineM in interface MonadRec<A,B>

Type Parameters:

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

traverse

public <C,App extends Applicative<?,App>,TravB extends Traversable<C,RecursiveResult<A,?>>,AppTrav extends Applicative<TravB,App>> AppTrav traverse(Fn1<? super B,? extends Applicative<C,App>> fn,
                                                                                                                                                                                              Fn1<? super TravB,? extends AppTrav> pure)

Apply fn to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.

Specified by:

traverse in interface Traversable<A,B>

Type Parameters:

C - the resulting element type

App - the result applicative type

TravB - this Traversable instance over B

AppTrav - the full inferred resulting type from the traversal

Parameters:

fn - the function to apply

pure - the applicative pure function

Returns:

the traversed Traversable, wrapped inside an applicative

recurse

public static <A,B> RecursiveResult<A,B> recurse(A a)

Static factory method for creating a "recurse" value.

Type Parameters:

A - the recurse type

B - the terminate type

Parameters:

a - the value

Returns:

the RecursiveResult

terminate

public static <A,B> RecursiveResult<A,B> terminate(B b)

Static factory method for creating a "terminate" value.

Type Parameters:

A - the recurse type

B - the terminate type

Parameters:

b - the value

Returns:

the RecursiveResult

pureRecursiveResult

public static <A> Pure<RecursiveResult<A,?>> pureRecursiveResult()

The canonical Pure instance for RecursiveResult.

Type Parameters:

A - the recursive function's input type

Returns:

the Pure instance