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

Packages that use Lambda4

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 Lambda4 in edu.rice.cs.plt.iter

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

static <T1,T2,T3,T4,R> SizedIterable<R>	IterUtil.cross(Iterable<? extends T1> iter1, Iterable<? extends T2> iter2, Iterable<? extends T3> iter3, Iterable<? extends T4> iter4, Lambda4<? super T1,? super T2,? super T3,? super T4,? extends R> combiner) Lazily produce the cartesian (cross) product of four iterables.
static <T1,T2,T3,T4,R> SizedIterable<R>	IterUtil.diagonalCross(Iterable<? extends T1> iter1, Iterable<? extends T2> iter2, Iterable<? extends T3> iter3, Iterable<? extends T4> iter4, Lambda4<? super T1,? super T2,? super T3,? super T4,? extends R> combiner) Lazily produce the cartesian (cross) product of four iterables.
static <T1,T2,T3,T4,R> SizedIterable<R>	IterUtil.map(Iterable<? extends T1> iter1, Iterable<? extends T2> iter2, Iterable<? extends T3> iter3, Iterable<? extends T4> iter4, Lambda4<? super T1,? super T2,? super T3,? super T4,? extends R> map) Lazily apply a map function to each corresponding quadruple of elements in the given iterables.
static <T1,T2,T3,T4,R> SnapshotIterable<R>	IterUtil.mapSnapshot(Iterable<? extends T1> iter1, Iterable<? extends T2> iter2, Iterable<? extends T3> iter3, Iterable<? extends T4> iter4, Lambda4<? super T1,? super T2,? super T3,? super T4,? extends R> map) Immediately apply a map function to each corresponding quadruple of elements in the given iterables.

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

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

static interface	LambdaUtil.GeneralLambda<R> An object that functions as a lambda for all arities.
static interface	LambdaUtil.LiftedLambda4<T1,T2,T3,T4,R> A Lambda4 that accepts and produces Option values.

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

static <T1,T2,T3,T4> Lambda4<T1,T2,T3,T4,Boolean>	LambdaUtil.asLambda(Predicate4<? super T1,? super T2,? super T3,? super T4> predicate) Create a Boolean lambda based on a predicate.
static <T1,T2,T3,T4> Lambda4<T1,T2,T3,T4,Void>	LambdaUtil.asLambda(Runnable4<? super T1,? super T2,? super T3,? super T4> r) Create a lambda that executes the given runnable, then returns null.
static <T1,T2,T3,T4,R> Lambda4<T1,T2,T3,T4,R>	LambdaUtil.asLambda(Runnable4<? super T1,? super T2,? super T3,? super T4> r, R result) Create a lambda that executes the given runnable, then returns result.
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 <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 <T1,T2,T3,R> Lambda4<T1,T2,T3,Object,R>	LambdaUtil.promote(Lambda3<? super T1,? super T2,? super T3,? extends R> lambda) Create a Lambda4 equivalent to lambda with an additional, ignored argument.
static <T1,T2,T3,R> Lambda4<Lambda3<? super T1,? super T2,? super T3,? extends R>,T1,T2,T3,R>	LambdaUtil.ternaryApplicationLambda() Create a lambda that applies its first argument to its second argument.
static <T1,T2,T3,T4,R> Lambda4<T1,T2,T3,T4,Option<R>>	LambdaUtil.wrapPartial(Lambda4<? super T1,? super T2,? super T3,? super T4,? 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 with parameters of type Lambda4

static <T1,T2,T3,T4> Predicate4<T1,T2,T3,T4>	LambdaUtil.asPredicate(Lambda4<? super T1,? super T2,? super T3,? super T4,? extends Boolean> lambda) Create a predicate based on an input that acts as a predicate but is not typed as one.
static <T1,T2,T3,T4> Runnable4<T1,T2,T3,T4>	LambdaUtil.asRunnable(Lambda4<? super T1,? super T2,? super T3,? super T4,?> lambda) Create a runnable that executes the given lambda (ignoring the result).
static <T1,T2,T3,T4,R> Lambda3<T2,T3,T4,R>	LambdaUtil.bindFirst(Lambda4<? super T1,? super T2,? super T3,? super T4,? extends R> lambda, T1 arg1) Bind a fixed argument to the given quaternary lambda, producing a ternary lambda.
static <T1,T2,T3,T4,R> Lambda3<T1,T2,T3,R>	LambdaUtil.bindFourth(Lambda4<? super T1,? super T2,? super T3,? super T4,? extends R> lambda, T4 arg4) Bind a fixed argument to the given quaternary lambda, producing a ternary lambda.
static <T1,T2,T3,T4,R> Lambda3<T1,T3,T4,R>	LambdaUtil.bindSecond(Lambda4<? super T1,? super T2,? super T3,? super T4,? extends R> lambda, T2 arg2) Bind a fixed argument to the given quaternary lambda, producing a ternary lambda.
static <T1,T2,T3,T4,R> Lambda3<T1,T2,T4,R>	LambdaUtil.bindThird(Lambda4<? super T1,? super T2,? super T3,? super T4,? extends R> lambda, T3 arg3) Bind a fixed argument to the given quaternary lambda, producing a ternary lambda.
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 <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> LambdaUtil.LiftedLambda4<T1,T2,T3,T4,R>	LambdaUtil.lift(Lambda4<? super T1,? super T2,? super T3,? super T4,? extends R> lambda) Lift a Lambda4 to accept option values, returning Option.none() if any argument is "none".
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 <T1,T2,T3,T4,R> Lambda4<T1,T2,T3,T4,Option<R>>	LambdaUtil.wrapPartial(Lambda4<? super T1,? super T2,? super T3,? super T4,? 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 Lambda4 in edu.rice.cs.plt.recur

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

R	PrecomputedRecursionStack4.apply(Lambda4<? super T1,? super T2,? super T3,? super T4,? extends R> lambda, Lambda4<? super T1,? super T2,? super T3,? super T4,? 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	PrecomputedRecursionStack4.apply(Lambda4<? super T1,? super T2,? super T3,? super T4,? extends R> lambda, Lambda4<? super T1,? super T2,? super T3,? super T4,? 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	PrecomputedRecursionStack4.apply(Lambda4<? super T1,? super T2,? super T3,? super T4,? extends R> lambda, 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	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
<V1 extends T1,V2 extends T2,V3 extends T3,V4 extends T4,R> R	RecursionStack4.apply(Lambda4<? super V1,? super V2,? super V3,? super V4,? extends R> lambda, Lambda4<? super V1,? super V2,? super V3,? super V4,? extends R> infiniteCase, V1 arg1, V2 arg2, V3 arg3, V4 arg4) If the given arguments are not on the stack, evaluate lambda with the arguments; otherwise, evaluate infiniteCase.
<V1 extends T1,V2 extends T2,V3 extends T3,V4 extends T4,R> R	RecursionStack4.apply(Lambda4<? super V1,? super V2,? super V3,? super V4,? extends R> lambda, Lambda4<? super V1,? super V2,? super V3,? super V4,? extends R> infiniteCase, V1 arg1, V2 arg2, V3 arg3, V4 arg4) If the given arguments are not on the stack, evaluate lambda with the arguments; otherwise, evaluate infiniteCase.
<V1 extends T1,V2 extends T2,V3 extends T3,V4 extends T4,R> R	RecursionStack4.apply(Lambda4<? super V1,? super V2,? super V3,? super V4,? extends R> lambda, Lambda4<? super V1,? super V2,? super V3,? super V4,? extends R> infiniteCase, V1 arg1, V2 arg2, V3 arg3, V4 arg4, int threshold) If less than threshold instances of the given arguments are on the stack, evaluate lambda with the arguments; otherwise, evaluate infiniteCase.
<V1 extends T1,V2 extends T2,V3 extends T3,V4 extends T4,R> R	RecursionStack4.apply(Lambda4<? super V1,? super V2,? super V3,? super V4,? extends R> lambda, Lambda4<? super V1,? super V2,? super V3,? super V4,? extends R> infiniteCase, V1 arg1, V2 arg2, V3 arg3, V4 arg4, int threshold) If less than threshold instances of the given arguments are on the stack, evaluate lambda with the arguments; otherwise, evaluate infiniteCase.
<V1 extends T1,V2 extends T2,V3 extends T3,V4 extends T4,R> R	RecursionStack4.apply(Lambda4<? super V1,? super V2,? super V3,? super V4,? extends R> lambda, R infiniteCase, V1 arg1, V2 arg2, V3 arg3, V4 arg4) Evaluate the given lambda with the given arguments, unless the arguments are already on the stack; push the arguments onto the stack during lambda evaluation
<V1 extends T1,V2 extends T2,V3 extends T3,V4 extends T4,R> R	RecursionStack4.apply(Lambda4<? super V1,? super V2,? super V3,? super V4,? extends R> lambda, R infiniteCase, V1 arg1, V2 arg2, V3 arg3, V4 arg4, int threshold) Evaluate the given lambda with the given arguments, unless threshold instances of the arguments are already on the stack; push the arguments onto the stack during lambda 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
static <T1,T2,T3,T4> RecursionStack4<T1,T2,T3,T4>	RecursionStack4.make(Lambda4<? super T1,? super T2,? super T3,? super T4,? extends Quad<T1,T2,T3,T4>> quadFactory) Call the constructor (allows the type arguments to be inferred)
static <T1,T2,T3,T4,R> PrecomputedRecursionStack4<T1,T2,T3,T4,R>	PrecomputedRecursionStack4.make(Lambda4<? super T1,? super T2,? super T3,? super T4,? extends Quad<T1,T2,T3,T4>> quadFactory) Call the constructor (allows the type arguments to be inferred)
void	PrecomputedRecursionStack4.push(T1 arg1, T2 arg2, T3 arg3, T4 arg4, Lambda4<? super T1,? super T2,? super T3,? super T4,? extends R> value) Add the given arguments to the top of the stack with the given lambda producing their infinite-case result.

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

PrecomputedRecursionStack4(Lambda4<? super T1,? super T2,? super T3,? super T4,? extends Quad<T1,T2,T3,T4>> quadFactory)
Create an empty recursion stack with the given Quad factory

RecursionStack4(Lambda4<? super T1,? super T2,? super T3,? super T4,? extends Quad<T1,T2,T3,T4>> quadFactory)
Create an empty recursion stack with the given Quad factory

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

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

static <T1,T2,T3,T4,R> Lambda4<T1,T2,T3,T4,R>	ReflectUtil.constructorAsLambda4(Class<? extends R> c, Class<? super T1> arg1T, Class<? super T2> arg2T, Class<? super T3> arg3T, Class<? super T4> arg4T) Wrap a constructor in a lambda.
static <O,T1,T2,T3,R> Lambda4<O,T1,T2,T3,R>	ReflectUtil.methodAsLambda4(Class<? super O> c, String methodName, Class<? super T1> arg1T, Class<? super T2> arg2T, Class<? super T3> arg3T, Class<? extends R> retT) Wrap a method in a lambda, with the receiver object as the first argument.

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

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

static <T1,T2,T3,T4> Lambda4<T1,T2,T3,T4,Quad<T1,T2,T3,T4>>	IdentityQuad.factory() Produce a lambda that invokes the constructor
static <T1,T2,T3,T4> Lambda4<T1,T2,T3,T4,Quad<T1,T2,T3,T4>>	Quad.factory() Produce a lambda that invokes the constructor