Uses of Interface
edu.rice.cs.plt.lambda.Thunk

Packages that use Thunk

edu.rice.cs.plt.collect	Contains general-purpose extensions to and variations on the java.util collections framework.
edu.rice.cs.plt.concurrent	Contains tools to support safe multi-threaded programs.
edu.rice.cs.plt.debug	Defines a variety of logging classes, along with other facilities for code-embedded debugging.
edu.rice.cs.plt.iter	A collection of implementations of Iterable and Iterator.
edu.rice.cs.plt.lambda	A collection of interfaces facilitating first-class functions in Java.
edu.rice.cs.plt.recur	Classes enabling safe handling of infinite or extremely deep recursion.
edu.rice.cs.plt.reflect	Facilities for loading and accessing Class objects and other reflection APIs.
edu.rice.cs.plt.swing
edu.rice.cs.plt.tuple	Classes for the type-parameterized representation of tuples.

Uses of Thunk in edu.rice.cs.plt.collect

Methods in edu.rice.cs.plt.collect that return Thunk

static <T> Thunk<List<T>>	CollectUtil.arrayListFactory() Get a factory that produces ArrayLists by invoking the empty ArrayList constructor.
static <T> Thunk<List<T>>	CollectUtil.arrayListFactory(int initialCapacity) Get a factory that produces ArrayLists with the given initial capacity.
static <T> Thunk<List<T>>	CollectUtil.copyOnWriteArrayListFactory() Get a factory that produces CopyOnWriteArraySets by invoking the empty CopyOnWriteArraySet constructor.
static <T> Thunk<Set<T>>	CollectUtil.copyOnWriteArraySetFactory() Get a factory that produces CopyOnWriteArraySets by invoking the empty CopyOnWriteArraySet constructor.
static <T> Thunk<List<T>>	SnapshotSynchronizedList.factory(Thunk<? extends List<T>> delegateFactory) Get a thunk that invokes the constructor with sets produced by the given factory.
static <T> Thunk<Set<T>>	SnapshotSynchronizedSet.factory(Thunk<? extends Set<T>> delegateFactory) Get a thunk that invokes the constructor with sets produced by the given factory.
static <K,V> Thunk<Map<K,V>>	CollectUtil.hashMapFactory() Get a factory that produces HashMaps by invoking the empty HashMap constructor.
static <K,V> Thunk<Map<K,V>>	CollectUtil.hashMapFactory(int initialCapacity) Get a factory that produces HashMaps with the given initial capacity.
static <T> Thunk<Set<T>>	CollectUtil.hashSetFactory() Get a factory that produces HashSets by invoking the empty HashSet constructor.
static <T> Thunk<Set<T>>	CollectUtil.hashSetFactory(int initialCapacity) Get a factory that produces HashSets with the given initial capacity.
static <K,V> Thunk<Map<K,V>>	CollectUtil.linkedHashMapFactory() Get a factory that produces LinkedHashMaps by invoking the empty LinkedHashMap constructor.
static <K,V> Thunk<Map<K,V>>	CollectUtil.linkedHashMapFactory(int initialCapacity) Get a factory that produces LinkedHashMaps with the given initial capacity.
static <T> Thunk<Set<T>>	CollectUtil.linkedHashSetFactory() Get a factory that produces LinkedHashSets by invoking the empty LinkedHashSet constructor.
static <T> Thunk<Set<T>>	CollectUtil.linkedHashSetFactory(int initialCapacity) Get a factory that produces LinkedHashSets with the given initial capacity.
static <T> Thunk<List<T>>	CollectUtil.linkedListFactory() Get a factory that produces LinkedLists by invoking the empty LinkedList constructor.
static <K extends Comparable<? super K>,V> Thunk<Map<K,V>>	CollectUtil.treeMapFactory() Get a factory that produces TreeMaps sorted according to the elements' natural order.
static <K,V> Thunk<Map<K,V>>	CollectUtil.treeMapFactory(Comparator<? super K> comparator) Get a factory that produces TreeMaps sorted according to the given comparator.
static <T extends Comparable<? super T>> Thunk<Set<T>>	CollectUtil.treeSetFactory() Get a factory that produces TreeSets sorted according to the elements' natural order.
static <T> Thunk<Set<T>>	CollectUtil.treeSetFactory(Comparator<? super T> comparator) Get a factory that produces TreeSets sorted according to the given comparator.

Methods in edu.rice.cs.plt.collect with parameters of type Thunk

static <T> Thunk<List<T>>	SnapshotSynchronizedList.factory(Thunk<? extends List<T>> delegateFactory) Get a thunk that invokes the constructor with sets produced by the given factory.
static <T> Thunk<Set<T>>	SnapshotSynchronizedSet.factory(Thunk<? extends Set<T>> delegateFactory) Get a thunk that invokes the constructor with sets produced by the given factory.

Constructors in edu.rice.cs.plt.collect with parameters of type Thunk

ConcreteRelationIndex(Thunk<? extends Map<K,PredicateSet<V>>> mapFactory, Thunk<? extends Set<V>> setFactory)
Create an empty ConcreteRelationIndex.

ConcreteRelationIndex(Thunk<? extends Map<K,PredicateSet<V>>> mapFactory, Thunk<? extends Set<V>> setFactory)
Create an empty ConcreteRelationIndex.

IndexedFunctionalRelation(Thunk<Map<T1,T2>> firstIndexFactory)
Create an index based on the given factory.

IndexedFunctionalRelation(Thunk<Map<T1,T2>> firstIndexFactory, Thunk<Map<T2,PredicateSet<T1>>> secondIndexFactory, Thunk<Set<T1>> secondIndexEntryFactory)
Create indices based on the given factories.

IndexedFunctionalRelation(Thunk<Map<T1,T2>> firstIndexFactory, Thunk<Map<T2,PredicateSet<T1>>> secondIndexFactory, Thunk<Set<T1>> secondIndexEntryFactory)
Create indices based on the given factories.

IndexedFunctionalRelation(Thunk<Map<T1,T2>> firstIndexFactory, Thunk<Map<T2,PredicateSet<T1>>> secondIndexFactory, Thunk<Set<T1>> secondIndexEntryFactory)
Create indices based on the given factories.

IndexedInjectiveRelation(Thunk<Map<T2,T1>> secondIndexFactory)
Create an index based on the given factory.

IndexedInjectiveRelation(Thunk<Map<T2,T1>> secondIndexFactory, Thunk<Map<T1,PredicateSet<T2>>> firstIndexFactory, Thunk<Set<T2>> firstIndexEntryFactory)
Create indices based on the given factories.

IndexedInjectiveRelation(Thunk<Map<T2,T1>> secondIndexFactory, Thunk<Map<T1,PredicateSet<T2>>> firstIndexFactory, Thunk<Set<T2>> firstIndexEntryFactory)
Create indices based on the given factories.

IndexedInjectiveRelation(Thunk<Map<T2,T1>> secondIndexFactory, Thunk<Map<T1,PredicateSet<T2>>> firstIndexFactory, Thunk<Set<T2>> firstIndexEntryFactory)
Create indices based on the given factories.

IndexedOneToOneRelation(Thunk<Map<T1,T2>> firstIndexFactory, Thunk<Map<T2,T1>> secondIndexFactory)
Create an IndexedOneToOneRelation using the given map factories to produce indices.

IndexedOneToOneRelation(Thunk<Map<T1,T2>> firstIndexFactory, Thunk<Map<T2,T1>> secondIndexFactory)
Create an IndexedOneToOneRelation using the given map factories to produce indices.

IndexedRelation(Thunk<Map<T1,PredicateSet<T2>>> firstIndexFactory, Thunk<Set<T2>> firstIndexEntryFactory)
Create an index based on the given factories.

IndexedRelation(Thunk<Map<T1,PredicateSet<T2>>> firstIndexFactory, Thunk<Set<T2>> firstIndexEntryFactory)
Create an index based on the given factories.

IndexedRelation(Thunk<Map<T1,PredicateSet<T2>>> firstIndexFactory, Thunk<Set<T2>> firstIndexEntryFactory, Thunk<Map<T2,PredicateSet<T1>>> secondIndexFactory, Thunk<Set<T1>> secondIndexEntryFactory)
Create indices based on the given factories.

IndexedRelation(Thunk<Map<T1,PredicateSet<T2>>> firstIndexFactory, Thunk<Set<T2>> firstIndexEntryFactory, Thunk<Map<T2,PredicateSet<T1>>> secondIndexFactory, Thunk<Set<T1>> secondIndexEntryFactory)
Create indices based on the given factories.

IndexedRelation(Thunk<Map<T1,PredicateSet<T2>>> firstIndexFactory, Thunk<Set<T2>> firstIndexEntryFactory, Thunk<Map<T2,PredicateSet<T1>>> secondIndexFactory, Thunk<Set<T1>> secondIndexEntryFactory)
Create indices based on the given factories.

IndexedRelation(Thunk<Map<T1,PredicateSet<T2>>> firstIndexFactory, Thunk<Set<T2>> firstIndexEntryFactory, Thunk<Map<T2,PredicateSet<T1>>> secondIndexFactory, Thunk<Set<T1>> secondIndexEntryFactory)
Create indices based on the given factories.

UnindexedRelation(Thunk<Set<Pair<T1,T2>>> setFactory)
Create an UnindexedRelation wrapping an instance of the provided set.

Uses of Thunk in edu.rice.cs.plt.concurrent

Subinterfaces of Thunk in edu.rice.cs.plt.concurrent

interface

IncrementalTask<I,R> A thunk that performs incremental computation.

Classes in edu.rice.cs.plt.concurrent that implement Thunk

class	ConcurrentBox<T> A thread-safe box implementation.
class	ExecutorIncrementalTaskController<I,R> A TaskController for an IncrementalTask, which is scheduled for execution by an Executor.
class	ExecutorTaskController<R> A TaskController for a simple task, which is scheduled for execution by an Executor.
class	FutureTaskController<T> Treats an arbitrary Future-producing computation as a TaskController.
class	IncrementalTaskController<I,R> Provides access to a concurrent task that produces incremental results.
class	PollingTaskController<R> A TaskController for tasks that are run without any facility for executing code when the task is complete — instead, the controller must either block, poll for the task's current status.
class	ProcessIncrementalTaskController<I,R> A TaskController that executes an IncrementalTask in another Java process.
class	ProcessTaskController<R> A TaskController that executes a simple task in another Java process.
class	StateMonitor<T> Provides a convenient facility for blocking until a state change explicitly occurs.
class	TaskController<R> Provides access to a concurrent task that produces a value.

Methods in edu.rice.cs.plt.concurrent with parameters of type Thunk

static <T> Callable<T>	ConcurrentUtil.asCallable(Thunk<? extends T> thunk) Wrap a thunk in a Callable interface.
static <T> TaskController<T>	ConcurrentUtil.asTaskController(Thunk<? extends Future<? extends T>> futureThunk) Wrap a Future produced by a Thunk in a TaskController interface (which is also a Thunk).
static <R> TaskController<R>	ConcurrentUtil.computeInProcess(Thunk<? extends R> task) Execute the given task in a separate process and provide access to its result.
static <R> TaskController<R>	ConcurrentUtil.computeInProcess(Thunk<? extends R> task, boolean start) Execute the given task in a separate process and provide access to its result.
static <R> TaskController<R>	ConcurrentUtil.computeInProcess(Thunk<? extends R> task, JVMBuilder jvmBuilder) Execute the given task in a separate process and provide access to its result.
static <R> TaskController<R>	ConcurrentUtil.computeInProcess(Thunk<? extends R> task, JVMBuilder jvmBuilder, boolean start) Execute the given task in a separate process and provide access to its result.
static <R> TaskController<R>	ConcurrentUtil.computeInThread(Thunk<? extends R> task) Execute the given task in a separate thread, and provide access to its result.
static <R> TaskController<R>	ConcurrentUtil.computeInThread(Thunk<? extends R> task, boolean start) Execute the given task in a separate thread, and provide access to its result.
static <R> TaskController<R>	ConcurrentUtil.computeWithExecutor(Thunk<? extends R> task, Executor exec) Execute the given task with exec and provide access to its result.
static <R> TaskController<R>	ConcurrentUtil.computeWithExecutor(Thunk<? extends R> task, Executor exec, boolean start) Execute the given task with exec and provide access to its result.
static Remote	ConcurrentUtil.exportInProcess(Thunk<? extends Remote> factory) Export the given RMI object in a new process and return the exported stub.
static Remote	ConcurrentUtil.exportInProcess(Thunk<? extends Remote> factory, JVMBuilder jvmBuilder) Export the given RMI object in a new process and return the exported stub.
static Remote	ConcurrentUtil.exportInProcess(Thunk<? extends Remote> factory, JVMBuilder jvmBuilder, Runnable1<? super Process> onExit) Export the given RMI object in a new process and return the exported stub.

Constructors in edu.rice.cs.plt.concurrent with parameters of type Thunk

ExecutorTaskController(Executor executor, Thunk<? extends R> task)

FutureTaskController(Thunk<? extends Future<? extends T>> futureThunk)

ProcessTaskController(JVMBuilder jvmBuilder, Executor executor, Thunk<? extends R> task)
Create, but do not start, a ProcessTaskController.

ProcessTaskController(JVMBuilder jvmBuilder, Executor executor, Thunk<? extends R> task, Runnable1<? super Process> onExit)
Create, but do not start, a ProcessTaskController.

Uses of Thunk in edu.rice.cs.plt.debug

Methods in edu.rice.cs.plt.debug that return Thunk

static Thunk<TreeLogSink>	TreeLogSink.factory(String name) Create a serializable TreeLogSink factory.
static Thunk<TreeLogSink>	TreeLogSink.factory(String name, boolean exitOnClose)

Constructors in edu.rice.cs.plt.debug with parameters of type Thunk

RMILogSink(Thunk<? extends LogSink> factory)
Create a LogSink server in a new process using JVMBuilder.DEFAULT.

RMILogSink(Thunk<? extends LogSink> factory, boolean closeOnExit)
Create a LogSink server in a new process using JVMBuilder.DEFAULT.

RMILogSink(Thunk<? extends LogSink> factory, JVMBuilder jvm)
Create a LogSink server in a new process using JVMBuilder.DEFAULT.

RMILogSink(Thunk<? extends LogSink> factory, JVMBuilder jvm, boolean closeOnExit)
Create a LogSink server in a new process using JVMBuilder.DEFAULT.

Uses of Thunk in edu.rice.cs.plt.iter

Method parameters in edu.rice.cs.plt.iter with type arguments of type Thunk

static <R> SizedIterable<R>

IterUtil.valuesOf(Iterable<? extends Thunk<? extends R>> iter) Lazily create an iterable containing the values of the given thunks.

Uses of Thunk in edu.rice.cs.plt.lambda

Subinterfaces of Thunk in edu.rice.cs.plt.lambda

interface	Box<T> A thunk with a mutable value.
static interface	LambdaUtil.GeneralLambda<R> An object that functions as a lambda for all arities.
interface	ResolvingThunk<R> A thunk that may be in a "resolved" or "unresolved" state.

Classes in edu.rice.cs.plt.lambda that implement Thunk

class	CachedThunk<R> A thunk that caches the result of a nested thunk on the first invocation of value().
class	DelayedThunk<R> A thunk whose value is set once after creation, but before the first invocation of DelayedThunk.value().
class	LazyThunk<R> A thunk providing call-by-need evaluation of the nested thunk, value.
class	SimpleBox<T> A box that freely supports reads and writes.

Methods in edu.rice.cs.plt.lambda that return Thunk

static Thunk<Boolean>	LambdaUtil.asThunk(Condition cond) Create a Boolean thunk based on a condition.
static Thunk<Void>	LambdaUtil.asThunk(Runnable r) Create a thunk that executes the given runnable, then returns null.
static <R> Thunk<R>	LambdaUtil.asThunk(Runnable r, R result) Create a thunk that executes the given runnable, then returns result.
static <T,R> Thunk<R>	LambdaUtil.bindFirst(Lambda<? super T,? extends R> lambda, T arg) Bind a fixed argument to the given lambda, producing a thunk.
static <T,U> Thunk<U>	LambdaUtil.compose(Thunk<? extends T> thunk, Lambda<? super T,? extends U> lambda) Create a thunk that executes lambda with the result of thunk.
static <T,R> Thunk<R>	LambdaUtil.flatten0(Lambda<? super Null<T>,? extends R> lambda) Treat a lambda accepting a 0-tuple argument as a Thunk.
static <R> Thunk<Option<R>>	LambdaUtil.wrapPartial(Thunk<? extends R> thunk, boolean filterNull, Predicate<? super RuntimeException> filterException) Treat the given thunk as a partial function, where well-defined results have a "some" return type, and undefined results map to "none".

Methods in edu.rice.cs.plt.lambda that return types with arguments of type Thunk

static <R> Lambda<Thunk<? extends R>,R>

LambdaUtil.thunkValueLambda() Create a lambda that applies its first argument to its second argument.

Methods in edu.rice.cs.plt.lambda with parameters of type Thunk

static Condition	LambdaUtil.asCondition(Thunk<? extends Boolean> thunk) Create a condition based on an input that acts as a condition but is not typed as one.
static Runnable	LambdaUtil.asRunnable(Thunk<?> thunk) Create a runnable that executes the given thunk (ignoring the result).
static <T,U> Thunk<U>	LambdaUtil.compose(Thunk<? extends T> thunk, Lambda<? super T,? extends U> lambda) Create a thunk that executes lambda with the result of thunk.
static <R> CachedThunk<R>	CachedThunk.make(Thunk<? extends R> value)
static <R> LazyThunk<R>	LazyThunk.make(Thunk<? extends R> value)
static <R> LambdaUtil.GeneralLambda<R>	LambdaUtil.promote(Thunk<? extends R> thunk) Create a GeneralLambda equivalent to thunk that ignores any arguments.
static <R> Lambda<Null<?>,R>	LambdaUtil.unary(Thunk<? extends R> thunk) Treat a Thunk as a unary lambda accepting a 0-tuple argument.
static <R> Thunk<Option<R>>	LambdaUtil.wrapPartial(Thunk<? extends R> thunk, boolean filterNull, Predicate<? super RuntimeException> filterException) Treat the given thunk as a partial function, where well-defined results have a "some" return type, and undefined results map to "none".

Constructors in edu.rice.cs.plt.lambda with parameters of type Thunk

CachedThunk(Thunk<? extends R> value)

LazyThunk(Thunk<? extends R> value)

Uses of Thunk in edu.rice.cs.plt.recur

Subinterfaces of Thunk in edu.rice.cs.plt.recur

interface

Continuation<T> A thunk enabling iterative evaluation of a recursive function.

Classes in edu.rice.cs.plt.recur that implement Thunk

class	ArgContinuation<T,R> A continuation for results that depend on a single recursive invocation, followed by some additional computation.
class	BinaryArgContinuation<T1,T2,R> A continuation for results that depend on a two recursive invocations, followed by some additional computation.
class	ComposedContinuation<T,R> A continuation defined in terms of two other continuations, where the second is parameterized by the result of the first.
class	PendingContinuation<T> A continuation representing computation left to be done (in contrast to ValueContinuation, which represents a completed computation).
class	ValueContinuation<T> A continuation that is resolved at creation time.

Methods in edu.rice.cs.plt.recur with parameters of type Thunk

R	PrecomputedRecursionStack.apply(Lambda<? super T,? extends R> lambda, Thunk<? extends R> precomputed, T arg) Evaluate the given lambda with argument arg, unless arg is already on the stack; push arg onto the stack with the given precomputed result during lambda's evaluation
R	PrecomputedRecursionStack2.apply(Lambda2<? super T1,? super T2,? extends R> lambda, Thunk<? extends R> precomputed, T1 arg1, T2 arg2) Evaluate the given lambda with the given arguments, unless the arguments are already on the stack; push the arguments onto the stack with the given precomputed result during lambda's evaluation
R	PrecomputedRecursionStack3.apply(Lambda3<? super T1,? super T2,? super T3,? extends R> lambda, Thunk<? extends R> precomputed, T1 arg1, T2 arg2, T3 arg3) Evaluate the given lambda with the given arguments, unless the arguments are already on the stack; push the arguments onto the stack with the given precomputed result during lambda's evaluation
R	PrecomputedRecursionStack4.apply(Lambda4<? super T1,? super T2,? super T3,? super T4,? extends R> lambda, Thunk<? extends R> precomputed, T1 arg1, T2 arg2, T3 arg3, T4 arg4) Evaluate the given lambda with the given arguments, unless the arguments are already on the stack; push the arguments onto the stack with the given precomputed result during lambda's evaluation
R	PrecomputedRecursionStack.apply(Thunk<? extends R> thunk, Lambda<? super T,? extends R> precomputed, T arg) Evaluate the given thunk, unless arg is already on the stack; push arg onto the stack with the given precomputed result during thunk's evaluation
R	PrecomputedRecursionStack2.apply(Thunk<? extends R> thunk, Lambda2<? super T1,? super T2,? extends R> precomputed, T1 arg1, T2 arg2) Evaluate the given thunk, unless the given arguments are already on the stack; push the arguments onto the stack with the given precomputed result during thunk's evaluation
R	PrecomputedRecursionStack3.apply(Thunk<? extends R> thunk, Lambda3<? super T1,? super T2,? super T3,? extends R> precomputed, T1 arg1, T2 arg2, T3 arg3) Evaluate the given thunk, unless the given arguments are already on the stack; push the arguments onto the stack with the given precomputed result during thunk's evaluation
R	PrecomputedRecursionStack4.apply(Thunk<? extends R> thunk, Lambda4<? super T1,? super T2,? super T3,? super T4,? extends R> precomputed, T1 arg1, T2 arg2, T3 arg3, T4 arg4) Evaluate the given thunk, unless the given arguments are already on the stack; push the arguments onto the stack with the given precomputed result during thunk's evaluation
R	PrecomputedRecursionStack.apply(Thunk<? extends R> thunk, R precomputed, T arg) Evaluate the given thunk, unless arg is already on the stack; push arg onto the stack with the given precomputed result during thunk's evaluation
<R> R	RecursionStack.apply(Thunk<? extends R> thunk, R infiniteCase, T arg) Evaluate the given thunk, unless arg is already on the stack; push arg onto the stack during thunk evaluation
R	PrecomputedRecursionStack2.apply(Thunk<? extends R> thunk, R precomputed, T1 arg1, T2 arg2) Evaluate the given thunk, unless the given arguments are already on the stack; push the arguments onto the stack with the given precomputed result during thunk's evaluation
<R> R	RecursionStack2.apply(Thunk<? extends R> thunk, R infiniteCase, T1 arg1, T2 arg2) Evaluate the given thunk, unless the given arguments are already on the stack; push the arguments onto the stack during thunk evaluation
<R> R	RecursionStack2.apply(Thunk<? extends R> thunk, R infiniteCase, T1 arg1, T2 arg2, int threshold) Evaluate the given thunk, unless threshold instances of the given arguments are already on the stack; push the arguments onto the stack during thunk evaluation
R	PrecomputedRecursionStack3.apply(Thunk<? extends R> thunk, R precomputed, T1 arg1, T2 arg2, T3 arg3) Evaluate the given thunk, unless the given arguments are already on the stack; push the arguments onto the stack with the given precomputed result during thunk's evaluation
<R> R	RecursionStack3.apply(Thunk<? extends R> thunk, R infiniteCase, T1 arg1, T2 arg2, T3 arg3) Evaluate the given thunk, unless the given arguments are already on the stack; push the arguments onto the stack during thunk evaluation
<R> R	RecursionStack3.apply(Thunk<? extends R> thunk, R infiniteCase, T1 arg1, T2 arg2, T3 arg3, int threshold) Evaluate the given thunk, unless threshold instances of the given arguments are already on the stack; push the arguments onto the stack during thunk evaluation
R	PrecomputedRecursionStack4.apply(Thunk<? extends R> thunk, R precomputed, T1 arg1, T2 arg2, T3 arg3, T4 arg4) Evaluate the given thunk, unless the given arguments are already on the stack; push the arguments onto the stack with the given precomputed result during thunk's evaluation
<R> R	RecursionStack4.apply(Thunk<? extends R> thunk, R infiniteCase, T1 arg1, T2 arg2, T3 arg3, T4 arg4) Evaluate the given thunk, unless the given arguments are already on the stack; push the arguments onto the stack during thunk evaluation
<R> R	RecursionStack4.apply(Thunk<? extends R> thunk, R infiniteCase, T1 arg1, T2 arg2, T3 arg3, T4 arg4, int threshold) Evaluate the given thunk, unless threshold instances of the given arguments are already on the stack; push the arguments onto the stack during thunk evaluation
<R> R	RecursionStack.apply(Thunk<? extends R> thunk, R infiniteCase, T arg, int threshold) Evaluate the given thunk, unless threshold instances of arg are already on the stack; push arg onto the stack during thunk evaluation
R	PrecomputedRecursionStack.apply(Thunk<? extends R> thunk, Thunk<? extends R> precomputed, T arg) Evaluate the given thunk, unless arg is already on the stack; push arg onto the stack with the given precomputed result during thunk's evaluation
R	PrecomputedRecursionStack.apply(Thunk<? extends R> thunk, Thunk<? extends R> precomputed, T arg) Evaluate the given thunk, unless arg is already on the stack; push arg onto the stack with the given precomputed result during thunk's evaluation
<R> R	RecursionStack.apply(Thunk<? extends R> thunk, Thunk<? extends R> infiniteCase, T arg) If arg is not on the stack, evaluate thunk; otherwise, evaluate infiniteCase.
<R> R	RecursionStack.apply(Thunk<? extends R> thunk, Thunk<? extends R> infiniteCase, T arg) If arg is not on the stack, evaluate thunk; otherwise, evaluate infiniteCase.
R	PrecomputedRecursionStack2.apply(Thunk<? extends R> thunk, Thunk<? extends R> precomputed, T1 arg1, T2 arg2) Evaluate the given thunk, unless the given arguments are already on the stack; push the arguments onto the stack with the given precomputed result during thunk's evaluation
R	PrecomputedRecursionStack2.apply(Thunk<? extends R> thunk, Thunk<? extends R> precomputed, T1 arg1, T2 arg2) Evaluate the given thunk, unless the given arguments are already on the stack; push the arguments onto the stack with the given precomputed result during thunk's evaluation
<R> R	RecursionStack2.apply(Thunk<? extends R> thunk, Thunk<? extends R> infiniteCase, T1 arg1, T2 arg2) If the given arguments are not on the stack, evaluate thunk; otherwise, evaluate infiniteCase.
<R> R	RecursionStack2.apply(Thunk<? extends R> thunk, Thunk<? extends R> infiniteCase, T1 arg1, T2 arg2) If the given arguments are not on the stack, evaluate thunk; otherwise, evaluate infiniteCase.
<R> R	RecursionStack2.apply(Thunk<? extends R> thunk, Thunk<? extends R> infiniteCase, T1 arg1, T2 arg2, int threshold) If less than threshold instances of the given arguments are on the stack, evaluate thunk; otherwise, evaluate infiniteCase.
<R> R	RecursionStack2.apply(Thunk<? extends R> thunk, Thunk<? extends R> infiniteCase, T1 arg1, T2 arg2, int threshold) If less than threshold instances of the given arguments are on the stack, evaluate thunk; otherwise, evaluate infiniteCase.
R	PrecomputedRecursionStack3.apply(Thunk<? extends R> thunk, Thunk<? extends R> precomputed, T1 arg1, T2 arg2, T3 arg3) Evaluate the given thunk, unless the given arguments are already on the stack; push the arguments onto the stack with the given precomputed result during thunk's evaluation
R	PrecomputedRecursionStack3.apply(Thunk<? extends R> thunk, Thunk<? extends R> precomputed, T1 arg1, T2 arg2, T3 arg3) Evaluate the given thunk, unless the given arguments are already on the stack; push the arguments onto the stack with the given precomputed result during thunk's evaluation
<R> R	RecursionStack3.apply(Thunk<? extends R> thunk, Thunk<? extends R> infiniteCase, T1 arg1, T2 arg2, T3 arg3) If the given arguments are not on the stack, evaluate thunk; otherwise, evaluate infiniteCase.
<R> R	RecursionStack3.apply(Thunk<? extends R> thunk, Thunk<? extends R> infiniteCase, T1 arg1, T2 arg2, T3 arg3) If the given arguments are not on the stack, evaluate thunk; otherwise, evaluate infiniteCase.
<R> R	RecursionStack3.apply(Thunk<? extends R> thunk, Thunk<? extends R> infiniteCase, T1 arg1, T2 arg2, T3 arg3, int threshold) If less than threshold instances of the given arguments are on the stack, evaluate thunk; otherwise, evaluate infiniteCase.
<R> R	RecursionStack3.apply(Thunk<? extends R> thunk, Thunk<? extends R> infiniteCase, T1 arg1, T2 arg2, T3 arg3, int threshold) If less than threshold instances of the given arguments are on the stack, evaluate thunk; otherwise, evaluate infiniteCase.
R	PrecomputedRecursionStack4.apply(Thunk<? extends R> thunk, Thunk<? extends R> precomputed, T1 arg1, T2 arg2, T3 arg3, T4 arg4) Evaluate the given thunk, unless the given arguments are already on the stack; push the arguments onto the stack with the given precomputed result during thunk's evaluation
R	PrecomputedRecursionStack4.apply(Thunk<? extends R> thunk, Thunk<? extends R> precomputed, T1 arg1, T2 arg2, T3 arg3, T4 arg4) Evaluate the given thunk, unless the given arguments are already on the stack; push the arguments onto the stack with the given precomputed result during thunk's evaluation
<R> R	RecursionStack4.apply(Thunk<? extends R> thunk, Thunk<? extends R> infiniteCase, T1 arg1, T2 arg2, T3 arg3, T4 arg4) If the given arguments are not on the stack, evaluate thunk; otherwise, evaluate infiniteCase.
<R> R	RecursionStack4.apply(Thunk<? extends R> thunk, Thunk<? extends R> infiniteCase, T1 arg1, T2 arg2, T3 arg3, T4 arg4) If the given arguments are not on the stack, evaluate thunk; otherwise, evaluate infiniteCase.
<R> R	RecursionStack4.apply(Thunk<? extends R> thunk, Thunk<? extends R> infiniteCase, T1 arg1, T2 arg2, T3 arg3, T4 arg4, int threshold) If less than threshold instances of the given arguments are on the stack, evaluate thunk; otherwise, evaluate infiniteCase.
<R> R	RecursionStack4.apply(Thunk<? extends R> thunk, Thunk<? extends R> infiniteCase, T1 arg1, T2 arg2, T3 arg3, T4 arg4, int threshold) If less than threshold instances of the given arguments are on the stack, evaluate thunk; otherwise, evaluate infiniteCase.
<R> R	RecursionStack.apply(Thunk<? extends R> thunk, Thunk<? extends R> infiniteCase, T arg, int threshold) If less than threshold instances of arg are on the stack, evaluate thunk; otherwise, evaluate infiniteCase.
<R> R	RecursionStack.apply(Thunk<? extends R> thunk, Thunk<? extends R> infiniteCase, T arg, int threshold) If less than threshold instances of arg are on the stack, evaluate thunk; otherwise, evaluate infiniteCase.
void	PrecomputedRecursionStack4.push(T1 arg1, T2 arg2, T3 arg3, T4 arg4, Thunk<? extends R> value) Add the given arguments to the top of the stack with the given thunk producing their infinite-case result.
void	PrecomputedRecursionStack3.push(T1 arg1, T2 arg2, T3 arg3, Thunk<? extends R> value) Add the given arguments to the top of the stack with the given thunk producing their infinite-case result.
void	PrecomputedRecursionStack2.push(T1 arg1, T2 arg2, Thunk<? extends R> value) Add the given arguments to the top of the stack with the given thunk producing their infinite-case result.
void	PrecomputedRecursionStack.push(T arg, Thunk<? extends R> value) Add arg to the top of the stack with the given thunk producing its infinite-case result.

Uses of Thunk in edu.rice.cs.plt.reflect

Methods in edu.rice.cs.plt.reflect that return Thunk

static <R> Thunk<R>	ReflectUtil.constructorAsThunk(Class<? extends R> c) Wrap a constructor in a thunk.
static <R> Thunk<R>	ReflectUtil.methodAsThunk(Object object, String methodName, Class<? extends R> retT) Wrap a method of the given object in a thunk.
static <O,R> Thunk<R>	ReflectUtil.staticMethodAsThunk(Class<? super O> c, String methodName, Class<? extends R> retT) Wrap a static method in a thunk.

Uses of Thunk in edu.rice.cs.plt.swing

Classes in edu.rice.cs.plt.swing that implement Thunk

class

SwingWorker<R,I> A utility class providing the core functionality of javax.swing.SwingWorker (first available in Java 6), in addition to supporting the IncrementalTaskController interface.

Uses of Thunk in edu.rice.cs.plt.tuple

Classes in edu.rice.cs.plt.tuple that implement Thunk

class	IdentityWrapper<T> A wrapper that defines IdentityWrapper.equals(java.lang.Object) and Tuple.hashCode() in terms of its value's identity (==) instead of equality (@code equals})
class	Wrapper<T> An arbitrary 1-tuple; overrides Wrapper.toString(), Wrapper.equals(Object), and Tuple.hashCode().