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

Packages that use Lambda

edu.rice.cs.plt.collect	Contains general-purpose extensions to and variations on the java.util collections framework.
edu.rice.cs.plt.io	Provides extensions to the java.io package, which provides character- and byte- based streams and buffers, files, file filters, and serialization.
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.tuple	Classes for the type-parameterized representation of tuples.

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

Subinterfaces of Lambda in edu.rice.cs.plt.collect

interface	FunctionalRelation<T1,T2> A functional relation: each first (of type T1) corresponds to at most one second (of type T2).
interface	LambdaMap<K,V> A Map that can be treated as a Lambda.
interface	OneToOneRelation<T1,T2> A injective functional relation: each first (of type T1) corresponds to at most one second (of type T2), and vice versa.

Classes in edu.rice.cs.plt.collect that implement Lambda

class	AbstractFunctionalRelation<T1,T2> An abstract parent class for implementations of FunctionalRelation.
protected class	AbstractInjectiveRelation.InverseInjectiveRelation An inverse of the enclosing relation.
class	AbstractKeyBasedMap<K,V> An abstract parent class for Map implementations that defines its operations in terms of the key-based methods get() and keySet().
class	AbstractOneToOneRelation<T1,T2> An abstract parent class for implementations of OneToOneRelation.
protected class	AbstractOneToOneRelation.InverseOneToOneRelation An inverse of the enclosing relation.
class	ComposedMap<K,X,V> The transitive composition of two maps, lazily constructed and dynamically-updated.
class	ConsVisitor<T,Ret> A visitor for ConsLists.
class	DelegatingMap<K,V> A map that delegates all operations to a wrapped map.
class	DictionaryMap<K,V> A map wrapping a Dictionary object.
class	EmptyMap<K,V> An empty LambdaMap.
class	EmptyRelation<T1,T2> An immutable, empty, one-to-one relation.
class	ImmutableMap<K,V> Wraps a map in an immutable interface.
class	IndexedFunctionalRelation<T1,T2> An implementation of the FunctionalRelation interface based on indexing maps.
class	IndexedOneToOneRelation<T1,T2> A implementation of OneToOneRelation based on indexing maps.
class	MappedMap<K,X,V> A map whose value set is translated by a mapping lambda.
class	SingletonMap<K,V> An immutable LambdaMap containing a single entry.
class	SingletonRelation<T1,T2> An immutable Relation containing a single pair.
class	UnionMap<K,V> A lazily-constructed and dynamically-updated union of two maps.

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

static <K,V> Lambda<Map.Entry<? extends K,? extends V>,Map.Entry<K,V>>	ImmutableMapEntry.factory()
static <T> Lambda<T,SingletonSet<T>>	SingletonSet.factory()

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

static <T> Set<T>	CollectUtil.functionClosure(Set<? extends T> base, Lambda<? super T,? extends T> function) Produce the set containing the elements in base and all values produced an arbitrary number of applications of function to one of these elements.
static <T> Set<T>	CollectUtil.functionClosure(T base, Lambda<? super T,? extends T> function) Produce the set containing base and all values produced an arbitrary number of applications of function to base.
static <T> Set<T>	CollectUtil.graphClosure(Set<? extends T> base, Lambda<? super T,? extends Iterable<? extends T>> neighbors) Produce the set of all nodes reachable from the elements in base in a directed graph defined by neighbors.
static <T> Set<T>	CollectUtil.graphClosure(T base, Lambda<? super T,? extends Iterable<? extends T>> neighbors) Produce the set of all nodes reachable from base in a directed graph defined by neighbors.
static <K,V> TotalMap<K,V>	TotalMap.make(Lambda<? super K,? extends V> lambda) Call the constructor (allows the type arguments to be inferred)
static <K,V> TotalMap<K,V>	TotalMap.make(Lambda<? super K,? extends V> lambda, boolean cache) Call the constructor (allows the type arguments to be inferred)
static <K,V> TotalMap<K,V>	TotalMap.make(Lambda<? super K,? extends V> lambda, Map<? super K,V> overrides) Call the constructor (allows the type arguments to be inferred)
static <K,V> TotalMap<K,V>	TotalMap.make(Lambda<? super K,? extends V> lambda, Map<? super K,V> overrides, boolean cache) Call the constructor (allows the type arguments to be inferred)
static <S,T> ConsList<? extends T>	ConsList.map(ConsList<? extends S> list, Lambda<? super S,? extends T> lambda) Map the given list according to a lambda
static <S,T> ConsVisitor<S,ConsList<T>>	ConsVisitor.map(Lambda<? super S,? extends T> lambda) Produces a new list by applying the given lambda to each of a list's elements
static <T> Set<T>	CollectUtil.partialFunctionClosure(Set<? extends T> base, Lambda<? super T,? extends Option<? extends T>> function) Produce the set containing the elements in base and all values produced an arbitrary number of applications of function to one of these elements.
static <T> Set<T>	CollectUtil.partialFunctionClosure(T base, Lambda<? super T,? extends Option<? extends T>> function) Produce the set containing base and all values produced an arbitrary number of applications of function to base.

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

MappedMap(Map<K,? extends X> map, Lambda<? super X,? extends V> lambda)

TotalMap(Lambda<? super K,? extends V> lambda)
Create a TotalMap defined in terms of lambda.

TotalMap(Lambda<? super K,? extends V> lambda, boolean cache)
Create a TotalMap defined in terms of lambda.

TotalMap(Lambda<? super K,? extends V> lambda, Map<? super K,V> overrides)
Create a TotalMap defined in terms of lambda, with the exception of the given overriding assignments.

TotalMap(Lambda<? super K,? extends V> lambda, Map<? super K,V> overrides, boolean cache)
Create a TotalMap defined in terms of lambda, with the exception of the given overriding assignments.

Uses of Lambda in edu.rice.cs.plt.io

Fields in edu.rice.cs.plt.io declared as Lambda

static Lambda<String,File>

IOUtil.FILE_FACTORY A factory for Files based on a String filename.

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

Methods in edu.rice.cs.plt.iter with parameters of type Lambda

static <T1,A,S2> Iterable<S2>	IterUtil.distribute(Iterable<? extends T1> original, Lambda<? super T1,? extends Iterable<? extends A>> breakT, Lambda<? super Iterable<A>,? extends S2> makeS) Use the IterUtil.cross(Iterable) function to lazily apply a distribution rule to the given composite object list.
static <T1,A,S2> Iterable<S2>	IterUtil.distribute(Iterable<? extends T1> original, Lambda<? super T1,? extends Iterable<? extends A>> breakT, Lambda<? super Iterable<A>,? extends S2> makeS) Use the IterUtil.cross(Iterable) function to lazily apply a distribution rule to the given composite object list.
static <S1,T1,A,S2,T2> T2	IterUtil.distribute(S1 original, Lambda<? super S1,? extends Iterable<? extends T1>> breakS, Lambda<? super T1,? extends Iterable<? extends A>> breakT, Lambda<? super Iterable<A>,? extends S2> makeS, Lambda<? super Iterable<S2>,? extends T2> makeT) Use the IterUtil.cross(Iterable) function to apply a distribution rule to the given composite object.
static <S1,T1,A,S2,T2> T2	IterUtil.distribute(S1 original, Lambda<? super S1,? extends Iterable<? extends T1>> breakS, Lambda<? super T1,? extends Iterable<? extends A>> breakT, Lambda<? super Iterable<A>,? extends S2> makeS, Lambda<? super Iterable<S2>,? extends T2> makeT) Use the IterUtil.cross(Iterable) function to apply a distribution rule to the given composite object.
static <S1,T1,A,S2,T2> T2	IterUtil.distribute(S1 original, Lambda<? super S1,? extends Iterable<? extends T1>> breakS, Lambda<? super T1,? extends Iterable<? extends A>> breakT, Lambda<? super Iterable<A>,? extends S2> makeS, Lambda<? super Iterable<S2>,? extends T2> makeT) Use the IterUtil.cross(Iterable) function to apply a distribution rule to the given composite object.
static <S1,T1,A,S2,T2> T2	IterUtil.distribute(S1 original, Lambda<? super S1,? extends Iterable<? extends T1>> breakS, Lambda<? super T1,? extends Iterable<? extends A>> breakT, Lambda<? super Iterable<A>,? extends S2> makeS, Lambda<? super Iterable<S2>,? extends T2> makeT) Use the IterUtil.cross(Iterable) function to apply a distribution rule to the given composite object.
static <T> FiniteSequenceIterable<T>	IterUtil.finiteSequence(T initial, Lambda<? super T,? extends T> successor, int size) Create a finite sequence of the given size defined by an initial value and a successor function.
static <T> SequenceIterable<T>	IterUtil.infiniteSequence(T initial, Lambda<? super T,? extends T> successor) Create an infinite sequence defined by an initial value and a successor function.
static <S,T> MappedIterable<S,T>	MappedIterable.make(Iterable<? extends S> source, Lambda<? super S,? extends T> map) Call the constructor (allows the type arguments to be inferred)
static <S,T> MappedIterator<S,T>	MappedIterator.make(Iterator<? extends S> source, Lambda<? super S,? extends T> map) Call the constructor (allows the type arguments to be inferred)
static <T> SequenceIterable<T>	SequenceIterable.make(T initial, Lambda<? super T,? extends T> successor) Call the constructor (allows T to be inferred)
static <T> FiniteSequenceIterable<T>	FiniteSequenceIterable.make(T initial, Lambda<? super T,? extends T> successor, int size) Call the constructor (allows T to be inferred)
static <S,T> SnapshotIterable<T>	MappedIterable.makeSnapshot(Iterable<? extends S> source, Lambda<? super S,? extends T> map) Create a MappedIterable and wrap it in a SnapshotIterable, forcing immediate evaluation of the mapping.
static <T> SnapshotIterable<T>	FiniteSequenceIterable.makeSnapshot(T initial, Lambda<? super T,? extends T> successor, int size) Create a FiniteSequenceIterable and wrap it in a SnapshotIterable, forcing immediate evaluation of the sequence.
static <T,R> SizedIterable<R>	IterUtil.map(Iterable<? extends T> source, Lambda<? super T,? extends R> map) Lazily apply a map function to each element in an iterable.
static <T,R> SnapshotIterable<R>	IterUtil.mapSnapshot(Iterable<? extends T> source, Lambda<? super T,? extends R> map) Immediately apply a map function to each element in an iterable.

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

static <T,R> Iterable<R>

IterUtil.valuesOf(Iterable<? extends Lambda<? super T,? extends R>> iter, T arg) Lazily create an iterable containing the values of the application of the given lambdas.

Constructors in edu.rice.cs.plt.iter with parameters of type Lambda

FiniteSequenceIterable(T initial, Lambda<? super T,? extends T> successor, int size)

FiniteSequenceIterator(T initial, Lambda<? super T,? extends T> successor, int size)

MappedIterable(Iterable<? extends S> source, Lambda<? super S,? extends T> map)

MappedIterator(Iterator<? extends S> source, Lambda<? super S,? extends T> map)

SequenceIterable(T initial, Lambda<? super T,? extends T> successor)

SequenceIterator(T initial, Lambda<? super T,? extends T> successor)

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

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

static interface	LambdaUtil.GeneralLambda<R> An object that functions as a lambda for all arities.
static interface	LambdaUtil.LiftedLambda<T,R> A Lambda that accepts and produces Option values.

Fields in edu.rice.cs.plt.lambda declared as Lambda

static Lambda<Integer,Integer>	LambdaUtil.DECREMENT_INT Decrements an integer.
static Lambda<Object,Integer>	LambdaUtil.HASH_CODE Calls RecurUtil.safeHashCode(Object) on the input.
static Lambda<Integer,Integer>	LambdaUtil.INCREMENT_INT Increments an integer.
static Lambda<Object,String>	LambdaUtil.TO_STRING Calls RecurUtil.safeToString(Object) on the input.

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

static <T> Lambda<T,Boolean>	LambdaUtil.asLambda(Predicate<? super T> predicate) Create a Boolean lambda based on a predicate.
static <T> Lambda<T,Void>	LambdaUtil.asLambda(Runnable1<? super T> r) Create a lambda that executes the given runnable, then returns null.
static <T,R> Lambda<T,R>	LambdaUtil.asLambda(Runnable1<? super T> r, R result) Create a lambda that executes the given runnable, then returns result.
static <T1,T2,R> Lambda<T2,R>	LambdaUtil.bindFirst(Lambda2<? super T1,? super T2,? extends R> lambda, T1 arg1) Bind a fixed argument to the given binary lambda, producing a unary lambda.
static <T1,T2,R> Lambda<T1,R>	LambdaUtil.bindSecond(Lambda2<? super T1,? super T2,? extends R> lambda, T2 arg2) Bind a fixed argument to the given binary lambda, producing a unary lambda.
static <S,T,U> Lambda<S,U>	LambdaUtil.compose(Lambda<? super S,? extends T> l1, Lambda<? super T,? extends U> l2) Create a lambda that executes l2 with the result of l1.
static <T1,T2,R> Lambda<T1,Lambda<T2,R>>	LambdaUtil.curry(Lambda2<? super T1,? super T2,? extends R> lambda) Create a curried version of the input, which accepts a single argument and returns a lambda on the second argument.
static <T1,T2,T3,R> Lambda<T1,Lambda<T2,Lambda<T3,R>>>	LambdaUtil.curry(Lambda3<? super T1,? super T2,? super T3,? extends R> lambda) Create a curried version of the input, which accepts a single argument and returns a curried lambda on the other arguments.
static <T1,T2,T3,T4,R> Lambda<T1,Lambda<T2,Lambda<T3,Lambda<T4,R>>>>	LambdaUtil.curry(Lambda4<? super T1,? super T2,? super T3,? super T4,? extends R> lambda) Create a curried version of the input, which accepts a single argument and returns a curried lambda on the other arguments.
static <T> Lambda<T,T>	LambdaUtil.identity() Create the identity lambda for the type T.
static <R> Lambda<Thunk<? extends R>,R>	LambdaUtil.thunkValueLambda() Create a lambda that applies its first argument to its second argument.
static <T1,T2,R> Lambda<Pair<T1,T2>,R>	LambdaUtil.unary(Lambda2<? super T1,? super T2,? extends R> lambda) Treat a Lambda2 as a unary lambda accepting a Pair argument.
static <T1,T2,T3,R> Lambda<Triple<T1,T2,T3>,R>	LambdaUtil.unary(Lambda3<? super T1,? super T2,? super T3,? extends R> lambda) Treat a Lambda3 as a unary lambda accepting a Triple argument.
static <T1,T2,T3,T4,R> Lambda<Quad<T1,T2,T3,T4>,R>	LambdaUtil.unary(Lambda4<? super T1,? super T2,? super T3,? super T4,? extends R> lambda) Treat a Lambda4 as a unary lambda accepting a Quad argument.
static <R> Lambda<Null<?>,R>	LambdaUtil.unary(Thunk<? extends R> thunk) Treat a Thunk as a unary lambda accepting a 0-tuple argument.
static <T,R> Lambda<T,Option<R>>	LambdaUtil.wrapPartial(Lambda<? super T,? extends R> lambda, boolean filterNull, Predicate<? super RuntimeException> filterException) Treat the given lambda 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 Lambda

static <T,R> Lambda2<Lambda<? super T,? extends R>,T,R>	LambdaUtil.applicationLambda() Create a lambda that applies its first argument to its second argument.
static <T1,T2,R> Lambda<T1,Lambda<T2,R>>	LambdaUtil.curry(Lambda2<? super T1,? super T2,? extends R> lambda) Create a curried version of the input, which accepts a single argument and returns a lambda on the second argument.
static <T1,T2,T3,R> Lambda<T1,Lambda<T2,Lambda<T3,R>>>	LambdaUtil.curry(Lambda3<? super T1,? super T2,? super T3,? extends R> lambda) Create a curried version of the input, which accepts a single argument and returns a curried lambda on the other arguments.
static <T1,T2,T3,R> Lambda<T1,Lambda<T2,Lambda<T3,R>>>	LambdaUtil.curry(Lambda3<? super T1,? super T2,? super T3,? extends R> lambda) Create a curried version of the input, which accepts a single argument and returns a curried lambda on the other arguments.
static <T1,T2,T3,T4,R> Lambda<T1,Lambda<T2,Lambda<T3,Lambda<T4,R>>>>	LambdaUtil.curry(Lambda4<? super T1,? super T2,? super T3,? super T4,? extends R> lambda) Create a curried version of the input, which accepts a single argument and returns a curried lambda on the other arguments.
static <T1,T2,T3,T4,R> Lambda<T1,Lambda<T2,Lambda<T3,Lambda<T4,R>>>>	LambdaUtil.curry(Lambda4<? super T1,? super T2,? super T3,? super T4,? extends R> lambda) Create a curried version of the input, which accepts a single argument and returns a curried lambda on the other arguments.
static <T1,T2,T3,T4,R> Lambda<T1,Lambda<T2,Lambda<T3,Lambda<T4,R>>>>	LambdaUtil.curry(Lambda4<? super T1,? super T2,? super T3,? super T4,? extends R> lambda) Create a curried version of the input, which accepts a single argument and returns a curried lambda on the other arguments.

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

static <T> Predicate<T>	LambdaUtil.asPredicate(Lambda<? super T,? extends Boolean> lambda) Create a predicate based on an input that acts as a predicate but is not typed as one.
static <T> Runnable1<T>	LambdaUtil.asRunnable(Lambda<? super T,?> lambda) Create a runnable that executes the given lambda (ignoring the 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 <S,T,U> Lambda<S,U>	LambdaUtil.compose(Lambda<? super S,? extends T> l1, Lambda<? super T,? extends U> l2) Create a lambda that executes l2 with the result of l1.
static <S,T,U> Lambda<S,U>	LambdaUtil.compose(Lambda<? super S,? extends T> l1, Lambda<? super T,? extends U> l2) Create a lambda that executes l2 with the result of l1.
static <S1,S2,T,U> Lambda2<S1,S2,U>	LambdaUtil.compose(Lambda2<? super S1,? super S2,? extends T> l1, Lambda<? super T,? extends U> l2) Create a lambda that executes l2 with the result of l1.
static <S1,S2,S3,T,U> Lambda3<S1,S2,S3,U>	LambdaUtil.compose(Lambda3<? super S1,? super S2,? super S3,? extends T> l1, Lambda<? super T,? extends U> l2) Create a lambda that executes l2 with the result of l1.
static <S1,S2,S3,S4,T,U> Lambda4<S1,S2,S3,S4,U>	LambdaUtil.compose(Lambda4<? super S1,? super S2,? super S3,? super S4,? extends T> l1, Lambda<? super T,? extends U> l2) Create a lambda that executes l2 with the result of l1.
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 <T1,T2,R> Lambda2<T1,T2,R>	LambdaUtil.flatten2(Lambda<? super Pair<T1,T2>,? extends R> lambda) Treat a lambda accepting a Pair argument as a Lambda2.
static <T1,T2,T3,R> Lambda3<T1,T2,T3,R>	LambdaUtil.flatten3(Lambda<? super Triple<T1,T2,T3>,? extends R> lambda) Treat a lambda accepting a Triple argument as a Lambda3.
static <T1,T2,T3,T4,R> Lambda4<T1,T2,T3,T4,R>	LambdaUtil.flatten4(Lambda<? super Quad<T1,T2,T3,T4>,? extends R> lambda) Treat a lambda accepting a Quad argument as a Lambda4.
static <T,R> LambdaUtil.LiftedLambda<T,R>	LambdaUtil.lift(Lambda<? super T,? extends R> lambda) Lift a Lambda to accept an option value, returning Option.none() in the "none" case.
static <T,R> Lambda2<T,Object,R>	LambdaUtil.promote(Lambda<? super T,? extends R> lambda) Create a Lambda2 equivalent to lambda with an additional, ignored argument.
static <T,R> Lambda<T,Option<R>>	LambdaUtil.wrapPartial(Lambda<? super T,? extends R> lambda, boolean filterNull, Predicate<? super RuntimeException> filterException) Treat the given lambda as a partial function, where well-defined results have a "some" return type, and undefined results map to "none".

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

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

R	PrecomputedRecursionStack.apply(Lambda<? super T,? extends R> lambda, Lambda<? super T,? 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	PrecomputedRecursionStack.apply(Lambda<? super T,? extends R> lambda, Lambda<? super T,? 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	PrecomputedRecursionStack.apply(Lambda<? super T,? extends R> lambda, 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	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
<V extends T,R> R	RecursionStack.apply(Lambda<? super V,? extends R> lambda, Lambda<? super V,? extends R> infiniteCase, V arg) If arg is not on the stack, evaluate lambda with argument arg; otherwise, evaluate infiniteCase.
<V extends T,R> R	RecursionStack.apply(Lambda<? super V,? extends R> lambda, Lambda<? super V,? extends R> infiniteCase, V arg) If arg is not on the stack, evaluate lambda with argument arg; otherwise, evaluate infiniteCase.
<V extends T,R> R	RecursionStack.apply(Lambda<? super V,? extends R> lambda, Lambda<? super V,? extends R> infiniteCase, V arg, int threshold) If less than threshold instances of arg are on the stack, evaluate lambda with argument arg; otherwise, evaluate infiniteCase.
<V extends T,R> R	RecursionStack.apply(Lambda<? super V,? extends R> lambda, Lambda<? super V,? extends R> infiniteCase, V arg, int threshold) If less than threshold instances of arg are on the stack, evaluate lambda with argument arg; otherwise, evaluate infiniteCase.
<V extends T,R> R	RecursionStack.apply(Lambda<? super V,? extends R> lambda, R infiniteCase, V arg) Evaluate the given lambda with argument arg, unless arg is already on the stack; push arg onto the stack during lambda evaluation
<V extends T,R> R	RecursionStack.apply(Lambda<? super V,? extends R> lambda, R infiniteCase, V arg, int threshold) Evaluate the given lambda with argument arg, unless threshold instances of arg are already on the stack; push arg onto the stack during lambda 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
<S> Continuation<S>	ComposedContinuation.compose(Lambda<? super R,? extends Continuation<? extends S>> c) Create a new ComposedContinuation with the same first, but with a rest that will compose c onto the result of this object's rest function.
<R> Continuation<R>	ValueContinuation.compose(Lambda<? super T,? extends Continuation<? extends R>> c) Create a ComposedContinuation in terms of this object and c.
<R> Continuation<R>	PendingContinuation.compose(Lambda<? super T,? extends Continuation<? extends R>> c) Create a ComposedContinuation in terms of this object and the provided function.
<R> Continuation<? extends R>	Continuation.compose(Lambda<? super T,? extends Continuation<? extends R>> c) Produce a continuation that will invoke c with this object's result.
static <T> RecursionStack<T>	RecursionStack.make(Lambda<? super T,? extends Wrapper<T>> wrapperFactory) Call the constructor (allows T to be inferred)
static <T,R> PrecomputedRecursionStack<T,R>	PrecomputedRecursionStack.make(Lambda<? super T,? extends Wrapper<T>> wrapperFactory) Call the constructor (allows the type arguments to be inferred)
void	PrecomputedRecursionStack.push(T arg, Lambda<? super T,? extends R> value) Add arg to the top of the stack with the given lambda producing its infinite-case result.
static <T> int	RecurUtil.safeHashCode(T obj, Lambda<? super T,Integer> infiniteHashCode) Evaluate obj.hashCode() under the protection of an infinite-recursion check.
static <T> String	RecurUtil.safeToString(T obj, Lambda<? super T,String> infiniteString) Invokes RecurUtil.safeToString(Object, Lambda, int, ArrayStringMode) with a default depth of 1, and using RecurUtil.ArrayStringMode.DEEP_BRACED as a default array string mode.
static <T> String	RecurUtil.safeToString(T obj, Lambda<? super T,String> infiniteString, int depth) Invokes RecurUtil.safeToString(Object, Lambda, int, ArrayStringMode) using RecurUtil.ArrayStringMode.DEEP_BRACED as a default array string mode.
static <T> String	RecurUtil.safeToString(T obj, Lambda<? super T,String> infiniteString, int depth, RecurUtil.ArrayStringMode arrayMode) Evaluate obj.toString() under the protection of an infinite-recursion check.
static <T> String	RecurUtil.safeToString(T obj, Lambda<? super T,String> infiniteString, RecurUtil.ArrayStringMode arrayMode) Invokes RecurUtil.safeToString(Object, Lambda, int, ArrayStringMode) using a default depth of 1.

Constructors in edu.rice.cs.plt.recur with parameters of type Lambda

ComposedContinuation(Continuation<? extends T> first, Lambda<? super T,? extends Continuation<? extends R>> rest)

PrecomputedRecursionStack(Lambda<? super T,? extends Wrapper<T>> wrapperFactory)
Create an empty recursion stack with the given Wrapper factory

RecursionStack(Lambda<? super T,? extends Wrapper<T>> wrapperFactory)
Create an empty recursion stack with the given Wrapper factory

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

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

static <T,R> Lambda<T,R>	ReflectUtil.constructorAsLambda(Class<? extends R> c, Class<? super T> argT) Wrap a constructor in a lambda.
static <O,R> Lambda<O,R>	ReflectUtil.methodAsLambda(Class<? super O> c, String methodName, Class<? extends R> retT) Wrap a method in a lambda, with the receiver object as the first argument.
static <T,R> Lambda<T,R>	ReflectUtil.methodAsLambda(Object object, String methodName, Class<? super T> argT, Class<? extends R> retT) Wrap a method of the given object in a lambda.
static <O,T,R> Lambda<T,R>	ReflectUtil.staticMethodAsLambda(Class<? super O> c, String methodName, Class<? super T> argT, Class<? extends R> retT) Wrap a static method in a lambda.

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

Methods in edu.rice.cs.plt.tuple that return Lambda

static <T> Lambda<T,Wrapper<T>>	Wrapper.factory() Produce a lambda that invokes the constructor
static <T> Lambda<T,Wrapper<T>>	IdentityWrapper.factory() Produce a lambda that invokes the constructor
static <T> Lambda<Pair<? extends T,?>,T>	Pair.firstGetter() Produce a lambda that invokes Pair.first() on a provided pair.
static <T> Lambda<Triple<? extends T,?,?>,T>	Triple.firstGetter() Produce a lambda that invokes Triple.first() on a provided triple.
static <T> Lambda<Quad<? extends T,?,?,?>,T>	Quad.firstGetter() Produce a lambda that invokes Quad.first() on a provided quad.
static <T> Lambda<Quad<?,?,?,? extends T>,T>	Quad.fourthGetter() Produce a lambda that invokes Quad.fourth() on a provided quad.
static <T1,T2> Lambda<Pair<T1,T2>,Pair<T2,T1>>	Pair.inverter() Produce a lambda that invokes Pair.inverse() on a provided pair.
static <T> Lambda<Pair<?,? extends T>,T>	Pair.secondGetter() Produce a lambda that invokes Pair.second() on a provided pair.
static <T> Lambda<Triple<?,? extends T,?>,T>	Triple.secondGetter() Produce a lambda that invokes Triple.second() on a provided triple.
static <T> Lambda<Quad<?,? extends T,?,?>,T>	Quad.secondGetter() Produce a lambda that invokes Quad.second() on a provided quad.
static <T> Lambda<Triple<?,?,? extends T>,T>	Triple.thirdGetter() Produce a lambda that invokes Triple.third() on a provided triple.
static <T> Lambda<Quad<?,?,? extends T,?>,T>	Quad.thirdGetter() Produce a lambda that invokes Quad.third() on a provided quad.