fj.control

Class Trampoline<A>

java.lang.Object

fj.control.Trampoline<A>

public abstract class Trampoline<A>
extends java.lang.Object

A Trampoline is a potentially branching computation that can be stepped through and executed in constant stack. It represent suspendable coroutines with subroutine calls, reified as a data structure.

Constructor Summary

Constructors

Constructor and Description
Trampoline()

Method Summary

Methods

Modifier and Type	Method and Description
<B> Trampoline<B>	apply(Trampoline<F<A,B>> lf) Performs function application within a Trampoline (applicative functor pattern).
static <A,B> F<F<A,Trampoline<B>>,F<Trampoline<A>,Trampoline<B>>>	bind_()
abstract <B> Trampoline<B>	bind(F<A,Trampoline<B>> f) Binds the given continuation to the result of this trampoline.
<B,C> Trampoline<C>	bind(Trampoline<B> lb, F<A,F<B,C>> f) Binds the given function across the result of this Trampoline and the given Trampoline.
protected static <A,B> fj.control.Trampoline.Codense<B>	codense(fj.control.Trampoline.Normal<A> a, F<A,Trampoline<B>> k)
protected abstract <R> R	fold(F<fj.control.Trampoline.Normal<A>,R> n, F<fj.control.Trampoline.Codense<A>,R> gs)
static <A,B,C> F<Trampoline<A>,F<Trampoline<B>,Trampoline<C>>>	liftM2(F<A,F<B,C>> f) Promotes the given function of arity-2 to a function on Trampolines.
static <A,B> F<F<A,B>,F<Trampoline<A>,Trampoline<B>>>	map_()
<B> Trampoline<B>	map(F<A,B> f) Maps the given function across the result of this trampoline.
static <A> F<A,Trampoline<A>>	pure()
static <A> Trampoline<A>	pure(A a) Constructs a pure computation that results in the given value.
static <A> F<Trampoline<A>,Either<P1<Trampoline<A>>,A>>	resume_()
abstract Either<P1<Trampoline<A>>,A>	resume() Runs a single step of this computation.
A	run() Runs this computation all the way to the end, in constant stack.
static <A> F<P1<Trampoline<A>>,Trampoline<A>>	suspend_()
static <A> Trampoline<A>	suspend(P1<Trampoline<A>> a) Suspends the given computation in a thunk.
<B,C> Trampoline<C>	zipWith(Trampoline<B> b, F2<A,B,C> f) Combines two trampolines so they run cooperatively.

Methods inherited from class java.lang.Object

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

Constructor Detail

Trampoline

public Trampoline()

Method Detail

codense

protected static <A,B> fj.control.Trampoline.Codense<B> codense(fj.control.Trampoline.Normal<A> a,
                                             F<A,Trampoline<B>> k)

pure

public static <A> F<A,Trampoline<A>> pure()

Returns:

The first-class version of `pure`.

pure

public static <A> Trampoline<A> pure(A a)

Constructs a pure computation that results in the given value.

Parameters:

a - The value of the result.

Returns:

A trampoline that results in the given value.

suspend

public static <A> Trampoline<A> suspend(P1<Trampoline<A>> a)

Suspends the given computation in a thunk.

Parameters:

a - A trampoline suspended in a thunk.

Returns:

A trampoline whose next step runs the given thunk.

suspend_

public static <A> F<P1<Trampoline<A>>,Trampoline<A>> suspend_()

Returns:

The first-class version of `suspend`.

fold

protected abstract <R> R fold(F<fj.control.Trampoline.Normal<A>,R> n,
         F<fj.control.Trampoline.Codense<A>,R> gs)

bind

public abstract <B> Trampoline<B> bind(F<A,Trampoline<B>> f)

Binds the given continuation to the result of this trampoline.

Parameters:

f - A function that constructs a trampoline from the result of this trampoline.

Returns:

A new trampoline that runs this trampoline, then continues with the given function.

map

public final <B> Trampoline<B> map(F<A,B> f)

Maps the given function across the result of this trampoline.

Parameters:

f - A function that gets applied to the result of this trampoline.

Returns:

A new trampoline that runs this trampoline, then applies the given function to the result.

bind_

public static <A,B> F<F<A,Trampoline<B>>,F<Trampoline<A>,Trampoline<B>>> bind_()

Returns:

The first-class version of `bind`.

map_

public static <A,B> F<F<A,B>,F<Trampoline<A>,Trampoline<B>>> map_()

Returns:

The first-class version of `map`.

resume_

public static <A> F<Trampoline<A>,Either<P1<Trampoline<A>>,A>> resume_()

Returns:

The first-class version of `resume`.

resume

public abstract Either<P1<Trampoline<A>>,A> resume()

Runs a single step of this computation.

Returns:

The next step of this compuation.

run

public A run()

Runs this computation all the way to the end, in constant stack.

Returns:

The end result of this computation.

apply

public final <B> Trampoline<B> apply(Trampoline<F<A,B>> lf)

Performs function application within a Trampoline (applicative functor pattern).

Parameters:

lf - A Trampoline resulting in the function to apply.

Returns:

A new Trampoline after applying the given function through this Trampoline.

bind

public final <B,C> Trampoline<C> bind(Trampoline<B> lb,
                       F<A,F<B,C>> f)

Binds the given function across the result of this Trampoline and the given Trampoline.

Parameters:

lb - A given Trampoline to bind the given function with.

f - The function to combine the results of this Trampoline and the given Trampoline.

Returns:

A new Trampoline combining the results of the two trampolines with the given function.

liftM2

public static <A,B,C> F<Trampoline<A>,F<Trampoline<B>,Trampoline<C>>> liftM2(F<A,F<B,C>> f)

Promotes the given function of arity-2 to a function on Trampolines.

Parameters:

f - The function to promote to a function on Trampolines.

Returns:

The given function, promoted to operate on Trampolines.

zipWith

public <B,C> Trampoline<C> zipWith(Trampoline<B> b,
                          F2<A,B,C> f)

Combines two trampolines so they run cooperatively. The results are combined with the given function.

Parameters:

b - Another trampoline to combine with this trampoline.

f - A function to combine the results of the two trampolines.

Returns:

A new trampoline that runs this trampoline and the given trampoline simultaneously.