Uses of Interface
eu.lunisolar.magma.func.consumer.LConsumer

Packages that use LConsumer

Package	Description
eu.lunisolar.magma.func.action
eu.lunisolar.magma.func.consumer
eu.lunisolar.magma.func.consumer.primitives
eu.lunisolar.magma.func.consumer.primitives.bi
eu.lunisolar.magma.func.consumer.primitives.obj
eu.lunisolar.magma.func.consumer.primitives.tri
eu.lunisolar.magma.func.function
eu.lunisolar.magma.func.function.from
eu.lunisolar.magma.func.operator.binary
eu.lunisolar.magma.func.operator.ternary
eu.lunisolar.magma.func.operator.unary
eu.lunisolar.magma.func.predicate
eu.lunisolar.magma.func.supplier

Uses of LConsumer in eu.lunisolar.magma.func.action

Methods in eu.lunisolar.magma.func.action with parameters of type LConsumer

Modifier and Type	Method and Description
default void	LAction.executeThen(LConsumer<Throwable> handler)
static void	LAction.tryExecuteThen(LAction func, LConsumer<Throwable> handler)
default LAction	LAction.tryingThen(LConsumer<Throwable> handler)

Uses of LConsumer in eu.lunisolar.magma.func.consumer

Classes in eu.lunisolar.magma.func.consumer that implement LConsumer

Modifier and Type	Class and Description
static class	LConsumer.LConsumerSingle<T>

Methods in eu.lunisolar.magma.func.consumer that return LConsumer

Modifier and Type	Method and Description
default LConsumer<T>	LConsumer.andThen(LConsumer<? super T> after) Combines two LConsumer together in a order.
default <V2> LConsumer<V2>	LConsumer.cast() Cast that replace generics.
static <V2,T> LConsumer<V2>	LConsumer.cast(LConsumer<T> function) Cast that replace generics.
default <V> LConsumer<V>	LConsumer.compose(LFunction<? super V,? extends T> before) Allows to manipulate the domain of the function.
static <V,T> LConsumer<V>	LConsumer.composed(LFunction<? super V,? extends T> before, LConsumer<T> after)
static <T> LConsumer<T>	LConsumer.cons(LConsumer<T> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T> LConsumer<T>	LConsumer.consThrowing(ExF<Throwable> exF)
static <T> LConsumer<T>	LConsumer.consThrowing(String message, ExMF<Throwable> exF)
static <T> LConsumer<T>	LConsumer.failSafe(LConsumer<T> func, LConsumer<T> failSafe)
default LConsumer<T>	LConsumer.handling(HandlingInstructions<Throwable,RuntimeException> handling)
default LConsumer<T2>	LBiConsumer.lShrink(LFunction<T2,T1> left)
default LConsumer<T2>	LBiConsumer.lShrinkc(T1 a1)
static <T2,T1> LConsumer<T2>	LBiConsumer.lShrinked(LFunction<T2,T1> left, LBiConsumer<T1,T2> func)
static <T2,T1> LConsumer<T2>	LBiConsumer.lShrinkedc(T1 a1, LBiConsumer<T1,T2> func)
static <T> LConsumer<T>	LConsumer.recursive(LFunction<LConsumer<T>,LConsumer<T>> selfLambda)
default LConsumer<T1>	LBiConsumer.rShrink(LFunction<T1,T2> right)
default LConsumer<T1>	LBiConsumer.rShrinkc(T2 a2)
static <T1,T2> LConsumer<T1>	LBiConsumer.rShrinked(LFunction<T1,T2> right, LBiConsumer<T1,T2> func)
static <T1,T2> LConsumer<T1>	LBiConsumer.rShrinkedc(T2 a2, LBiConsumer<T1,T2> func)
static <T> LConsumer<T>	LConsumer.safe() Safe instance.
static <T> LConsumer<T>	LConsumer.safe(LConsumer<T> other) Safe wrapping.
default LConsumer<T>	LConsumer.trying(ExWF<RuntimeException> exF)
default LConsumer<T>	LConsumer.trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LConsumer<T>	LConsumer.tryingThen(LConsumer<Throwable> handler)
default LConsumer	LConsumer.untyped() Cast that removes generics.
LConsumer<T>	LConsumer.LConsumerSingle.value()
static <T> LConsumer<T>	LConsumer.wrap(java.util.function.Consumer<T> other) Wraps JRE instance.

Methods in eu.lunisolar.magma.func.consumer that return types with arguments of type LConsumer

Modifier and Type	Method and Description
static <T> LSupplier<LConsumer<T>>	LConsumer.safeSupplier() Safe instance supplier.
static <T> LSupplier<LConsumer<T>>	LConsumer.safeSupplier(LSupplier<LConsumer<T>> supplier) Safe supplier.

Methods in eu.lunisolar.magma.func.consumer with parameters of type LConsumer

Modifier and Type	Method and Description
static <T1,T2> LBiConsumer<T1,T2>	LBiConsumer.accept1st(LConsumer<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.accept1st(LConsumer<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LBiConsumer<T1,T2>	LBiConsumer.accept2nd(LConsumer<T2> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.accept2nd(LConsumer<T2> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.accept3rd(LConsumer<T3> func) Captures single parameter function into this interface where only 3rd parameter will be used.
default void	LBiConsumer.acceptThen(T1 a1, T2 a2, LConsumer<Throwable> handler)
default void	LTriConsumer.acceptThen(T1 a1, T2 a2, T3 a3, LConsumer<Throwable> handler)
default void	LConsumer.acceptThen(T a, LConsumer<Throwable> handler)
default LConsumer<T>	LConsumer.andThen(LConsumer<? super T> after) Combines two LConsumer together in a order.
static <T> void	LConsumer.call(T a, LConsumer<T> lambda)
static <V2,T> LConsumer<V2>	LConsumer.cast(LConsumer<T> function) Cast that replace generics.
static <V,T> LConsumer<V>	LConsumer.composed(LFunction<? super V,? extends T> before, LConsumer<T> after)
static <T> LConsumer<T>	LConsumer.cons(LConsumer<T> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T> LConsumer<T>	LConsumer.failSafe(LConsumer<T> func, LConsumer<T> failSafe)
static <T> LConsumer<T>	LConsumer.failSafe(LConsumer<T> func, LConsumer<T> failSafe)
default void	LConsumer.failSafeAccept(T a, LConsumer<T> failSafe)
static <T> void	LConsumer.failSafeAccept(T a, LConsumer<T> func, LConsumer<T> failSafe)
static <T> void	LConsumer.failSafeAccept(T a, LConsumer<T> func, LConsumer<T> failSafe)
static <C0,T> int	LConsumer.forEach(IndexedRead<C0,aType.a<T>> ia, C0 source, LConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T> void	LConsumer.fromTill(int min_i, int max_i, T a, LConsumer<T> func) From-To.
static <T> void	LConsumer.fromTo(int min_i, int max_i, T a, LConsumer<T> func) From-To.
static <T> void	LConsumer.handlingAccept(T a, LConsumer<T> func, HandlingInstructions<Throwable,RuntimeException> handling)
static <C0,I0,T> int	LConsumer.iterate(SequentialRead<C0,I0,aType.a<T>> sa, C0 source, LConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T> LConsumer<T>	LConsumer.safe(LConsumer<T> other) Safe wrapping.
static <T> void	LConsumer.times(int max_i, T a, LConsumer<T> func) From-To.
static <T> void	LConsumer.tryAccept(T a, LConsumer<T> func)
static <T> void	LConsumer.tryAccept(T a, LConsumer<T> func, ExWF<RuntimeException> exF)
static <T> void	LConsumer.tryAccept(T a, LConsumer<T> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static <T1,T2> void	LBiConsumer.tryAcceptThen(T1 a1, T2 a2, LBiConsumer<T1,T2> func, LConsumer<Throwable> handler)
static <T1,T2,T3> void	LTriConsumer.tryAcceptThen(T1 a1, T2 a2, T3 a3, LTriConsumer<T1,T2,T3> func, LConsumer<Throwable> handler)
static <T> void	LConsumer.tryAcceptThen(T a, LConsumer<T> func, LConsumer<Throwable> handler)
static <T> void	LConsumer.tryAcceptThen(T a, LConsumer<T> func, LConsumer<Throwable> handler)
default LTriConsumer<T1,T2,T3>	LTriConsumer.tryingThen(LConsumer<Throwable> handler)
default LConsumer<T>	LConsumer.tryingThen(LConsumer<Throwable> handler)
default LBiConsumer<T1,T2>	LBiConsumer.tryingThen(LConsumer<Throwable> handler)

Method parameters in eu.lunisolar.magma.func.consumer with type arguments of type LConsumer

Modifier and Type	Method and Description
static <T> LConsumer<T>	LConsumer.recursive(LFunction<LConsumer<T>,LConsumer<T>> selfLambda)
static <T> LConsumer<T>	LConsumer.recursive(LFunction<LConsumer<T>,LConsumer<T>> selfLambda)
static <T> LSupplier<LConsumer<T>>	LConsumer.safeSupplier(LSupplier<LConsumer<T>> supplier) Safe supplier.
static <T1,T2> LBiConsumer<T1,T2>	LBiConsumer.uncurry(LFunction<T1,LConsumer<T2>> func)
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.uncurry(LFunction<T1,LFunction<T2,LConsumer<T3>>> func)

Uses of LConsumer in eu.lunisolar.magma.func.consumer.primitives

Methods in eu.lunisolar.magma.func.consumer.primitives that return LConsumer

Modifier and Type	Method and Description
default <V> LConsumer<V>	LBoolConsumer.boolConsCompose(LPredicate<? super V> before) Allows to manipulate the domain of the function.
default <V> LConsumer<V>	LByteConsumer.byteConsCompose(LToByteFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LConsumer<V>	LCharConsumer.charConsCompose(LToCharFunction<? super V> before) Allows to manipulate the domain of the function.
static <V> LConsumer<V>	LBoolConsumer.composed(LPredicate<? super V> before, LBoolConsumer after)
static <V> LConsumer<V>	LByteConsumer.composed(LToByteFunction<? super V> before, LByteConsumer after)
static <V> LConsumer<V>	LCharConsumer.composed(LToCharFunction<? super V> before, LCharConsumer after)
static <V> LConsumer<V>	LDblConsumer.composed(LToDblFunction<? super V> before, LDblConsumer after)
static <V> LConsumer<V>	LFltConsumer.composed(LToFltFunction<? super V> before, LFltConsumer after)
static <V> LConsumer<V>	LIntConsumer.composed(LToIntFunction<? super V> before, LIntConsumer after)
static <V> LConsumer<V>	LLongConsumer.composed(LToLongFunction<? super V> before, LLongConsumer after)
static <V> LConsumer<V>	LSrtConsumer.composed(LToSrtFunction<? super V> before, LSrtConsumer after)
default <V> LConsumer<V>	LDblConsumer.dblConsCompose(LToDblFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LConsumer<V>	LFltConsumer.fltConsCompose(LToFltFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LConsumer<V>	LIntConsumer.intConsCompose(LToIntFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LConsumer<V>	LLongConsumer.longConsCompose(LToLongFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LConsumer<V>	LSrtConsumer.srtConsCompose(LToSrtFunction<? super V> before) Allows to manipulate the domain of the function.

Methods in eu.lunisolar.magma.func.consumer.primitives with parameters of type LConsumer

Modifier and Type	Method and Description
default void	LBoolConsumer.acceptThen(boolean a, LConsumer<Throwable> handler)
default void	LByteConsumer.acceptThen(byte a, LConsumer<Throwable> handler)
default void	LCharConsumer.acceptThen(char a, LConsumer<Throwable> handler)
default void	LDblConsumer.acceptThen(double a, LConsumer<Throwable> handler)
default void	LFltConsumer.acceptThen(float a, LConsumer<Throwable> handler)
default void	LIntConsumer.acceptThen(int a, LConsumer<Throwable> handler)
default void	LLongConsumer.acceptThen(long a, LConsumer<Throwable> handler)
default void	LSrtConsumer.acceptThen(short a, LConsumer<Throwable> handler)
static void	LBoolConsumer.tryAcceptThen(boolean a, LBoolConsumer func, LConsumer<Throwable> handler)
static void	LByteConsumer.tryAcceptThen(byte a, LByteConsumer func, LConsumer<Throwable> handler)
static void	LCharConsumer.tryAcceptThen(char a, LCharConsumer func, LConsumer<Throwable> handler)
static void	LDblConsumer.tryAcceptThen(double a, LDblConsumer func, LConsumer<Throwable> handler)
static void	LFltConsumer.tryAcceptThen(float a, LFltConsumer func, LConsumer<Throwable> handler)
static void	LIntConsumer.tryAcceptThen(int a, LIntConsumer func, LConsumer<Throwable> handler)
static void	LLongConsumer.tryAcceptThen(long a, LLongConsumer func, LConsumer<Throwable> handler)
static void	LSrtConsumer.tryAcceptThen(short a, LSrtConsumer func, LConsumer<Throwable> handler)
default LSrtConsumer	LSrtConsumer.tryingThen(LConsumer<Throwable> handler)
default LLongConsumer	LLongConsumer.tryingThen(LConsumer<Throwable> handler)
default LIntConsumer	LIntConsumer.tryingThen(LConsumer<Throwable> handler)
default LFltConsumer	LFltConsumer.tryingThen(LConsumer<Throwable> handler)
default LDblConsumer	LDblConsumer.tryingThen(LConsumer<Throwable> handler)
default LCharConsumer	LCharConsumer.tryingThen(LConsumer<Throwable> handler)
default LByteConsumer	LByteConsumer.tryingThen(LConsumer<Throwable> handler)
default LBoolConsumer	LBoolConsumer.tryingThen(LConsumer<Throwable> handler)

Uses of LConsumer in eu.lunisolar.magma.func.consumer.primitives.bi

Methods in eu.lunisolar.magma.func.consumer.primitives.bi with parameters of type LConsumer

Modifier and Type	Method and Description
default void	LBiBoolConsumer.acceptThen(boolean a1, boolean a2, LConsumer<Throwable> handler)
default void	LBoolIntConsumer.acceptThen(boolean a1, int a2, LConsumer<Throwable> handler)
default void	LBiByteConsumer.acceptThen(byte a1, byte a2, LConsumer<Throwable> handler)
default void	LByteIntConsumer.acceptThen(byte a1, int a2, LConsumer<Throwable> handler)
default void	LBiCharConsumer.acceptThen(char a1, char a2, LConsumer<Throwable> handler)
default void	LCharIntConsumer.acceptThen(char a1, int a2, LConsumer<Throwable> handler)
default void	LBiDblConsumer.acceptThen(double a1, double a2, LConsumer<Throwable> handler)
default void	LDblIntConsumer.acceptThen(double a1, int a2, LConsumer<Throwable> handler)
default void	LBiFltConsumer.acceptThen(float a1, float a2, LConsumer<Throwable> handler)
default void	LFltIntConsumer.acceptThen(float a1, int a2, LConsumer<Throwable> handler)
default void	LBiIntConsumer.acceptThen(int a1, int a2, LConsumer<Throwable> handler)
default void	LLongIntConsumer.acceptThen(long a1, int a2, LConsumer<Throwable> handler)
default void	LBiLongConsumer.acceptThen(long a1, long a2, LConsumer<Throwable> handler)
default void	LSrtIntConsumer.acceptThen(short a1, int a2, LConsumer<Throwable> handler)
default void	LBiSrtConsumer.acceptThen(short a1, short a2, LConsumer<Throwable> handler)
static void	LBiBoolConsumer.tryAcceptThen(boolean a1, boolean a2, LBiBoolConsumer func, LConsumer<Throwable> handler)
static void	LBoolIntConsumer.tryAcceptThen(boolean a1, int a2, LBoolIntConsumer func, LConsumer<Throwable> handler)
static void	LBiByteConsumer.tryAcceptThen(byte a1, byte a2, LBiByteConsumer func, LConsumer<Throwable> handler)
static void	LByteIntConsumer.tryAcceptThen(byte a1, int a2, LByteIntConsumer func, LConsumer<Throwable> handler)
static void	LBiCharConsumer.tryAcceptThen(char a1, char a2, LBiCharConsumer func, LConsumer<Throwable> handler)
static void	LCharIntConsumer.tryAcceptThen(char a1, int a2, LCharIntConsumer func, LConsumer<Throwable> handler)
static void	LBiDblConsumer.tryAcceptThen(double a1, double a2, LBiDblConsumer func, LConsumer<Throwable> handler)
static void	LDblIntConsumer.tryAcceptThen(double a1, int a2, LDblIntConsumer func, LConsumer<Throwable> handler)
static void	LBiFltConsumer.tryAcceptThen(float a1, float a2, LBiFltConsumer func, LConsumer<Throwable> handler)
static void	LFltIntConsumer.tryAcceptThen(float a1, int a2, LFltIntConsumer func, LConsumer<Throwable> handler)
static void	LBiIntConsumer.tryAcceptThen(int a1, int a2, LBiIntConsumer func, LConsumer<Throwable> handler)
static void	LLongIntConsumer.tryAcceptThen(long a1, int a2, LLongIntConsumer func, LConsumer<Throwable> handler)
static void	LBiLongConsumer.tryAcceptThen(long a1, long a2, LBiLongConsumer func, LConsumer<Throwable> handler)
static void	LSrtIntConsumer.tryAcceptThen(short a1, int a2, LSrtIntConsumer func, LConsumer<Throwable> handler)
static void	LBiSrtConsumer.tryAcceptThen(short a1, short a2, LBiSrtConsumer func, LConsumer<Throwable> handler)
default LSrtIntConsumer	LSrtIntConsumer.tryingThen(LConsumer<Throwable> handler)
default LLongIntConsumer	LLongIntConsumer.tryingThen(LConsumer<Throwable> handler)
default LFltIntConsumer	LFltIntConsumer.tryingThen(LConsumer<Throwable> handler)
default LDblIntConsumer	LDblIntConsumer.tryingThen(LConsumer<Throwable> handler)
default LCharIntConsumer	LCharIntConsumer.tryingThen(LConsumer<Throwable> handler)
default LByteIntConsumer	LByteIntConsumer.tryingThen(LConsumer<Throwable> handler)
default LBoolIntConsumer	LBoolIntConsumer.tryingThen(LConsumer<Throwable> handler)
default LBiSrtConsumer	LBiSrtConsumer.tryingThen(LConsumer<Throwable> handler)
default LBiLongConsumer	LBiLongConsumer.tryingThen(LConsumer<Throwable> handler)
default LBiIntConsumer	LBiIntConsumer.tryingThen(LConsumer<Throwable> handler)
default LBiFltConsumer	LBiFltConsumer.tryingThen(LConsumer<Throwable> handler)
default LBiDblConsumer	LBiDblConsumer.tryingThen(LConsumer<Throwable> handler)
default LBiCharConsumer	LBiCharConsumer.tryingThen(LConsumer<Throwable> handler)
default LBiByteConsumer	LBiByteConsumer.tryingThen(LConsumer<Throwable> handler)
default LBiBoolConsumer	LBiBoolConsumer.tryingThen(LConsumer<Throwable> handler)

Uses of LConsumer in eu.lunisolar.magma.func.consumer.primitives.obj

Methods in eu.lunisolar.magma.func.consumer.primitives.obj that return LConsumer

Modifier and Type	Method and Description
default LConsumer<T>	LObjBoolConsumer.rShrink(LPredicate<T> right)
default LConsumer<T>	LObjByteConsumer.rShrink(LToByteFunction<T> right)
default LConsumer<T>	LObjCharConsumer.rShrink(LToCharFunction<T> right)
default LConsumer<T>	LObjDblConsumer.rShrink(LToDblFunction<T> right)
default LConsumer<T>	LObjFltConsumer.rShrink(LToFltFunction<T> right)
default LConsumer<T>	LObjIntConsumer.rShrink(LToIntFunction<T> right)
default LConsumer<T>	LObjLongConsumer.rShrink(LToLongFunction<T> right)
default LConsumer<T>	LObjSrtConsumer.rShrink(LToSrtFunction<T> right)
default LConsumer<T>	LObjBoolConsumer.rShrinkc(boolean a2)
default LConsumer<T>	LObjByteConsumer.rShrinkc(byte a2)
default LConsumer<T>	LObjCharConsumer.rShrinkc(char a2)
default LConsumer<T>	LObjDblConsumer.rShrinkc(double a2)
default LConsumer<T>	LObjFltConsumer.rShrinkc(float a2)
default LConsumer<T>	LObjIntConsumer.rShrinkc(int a2)
default LConsumer<T>	LObjLongConsumer.rShrinkc(long a2)
default LConsumer<T>	LObjSrtConsumer.rShrinkc(short a2)
static <T> LConsumer<T>	LObjBoolConsumer.rShrinked(LPredicate<T> right, LObjBoolConsumer<T> func)
static <T> LConsumer<T>	LObjByteConsumer.rShrinked(LToByteFunction<T> right, LObjByteConsumer<T> func)
static <T> LConsumer<T>	LObjCharConsumer.rShrinked(LToCharFunction<T> right, LObjCharConsumer<T> func)
static <T> LConsumer<T>	LObjDblConsumer.rShrinked(LToDblFunction<T> right, LObjDblConsumer<T> func)
static <T> LConsumer<T>	LObjFltConsumer.rShrinked(LToFltFunction<T> right, LObjFltConsumer<T> func)
static <T> LConsumer<T>	LObjIntConsumer.rShrinked(LToIntFunction<T> right, LObjIntConsumer<T> func)
static <T> LConsumer<T>	LObjLongConsumer.rShrinked(LToLongFunction<T> right, LObjLongConsumer<T> func)
static <T> LConsumer<T>	LObjSrtConsumer.rShrinked(LToSrtFunction<T> right, LObjSrtConsumer<T> func)
static <T> LConsumer<T>	LObjBoolConsumer.rShrinkedc(boolean a2, LObjBoolConsumer<T> func)
static <T> LConsumer<T>	LObjByteConsumer.rShrinkedc(byte a2, LObjByteConsumer<T> func)
static <T> LConsumer<T>	LObjCharConsumer.rShrinkedc(char a2, LObjCharConsumer<T> func)
static <T> LConsumer<T>	LObjDblConsumer.rShrinkedc(double a2, LObjDblConsumer<T> func)
static <T> LConsumer<T>	LObjFltConsumer.rShrinkedc(float a2, LObjFltConsumer<T> func)
static <T> LConsumer<T>	LObjIntConsumer.rShrinkedc(int a2, LObjIntConsumer<T> func)
static <T> LConsumer<T>	LObjLongConsumer.rShrinkedc(long a2, LObjLongConsumer<T> func)
static <T> LConsumer<T>	LObjSrtConsumer.rShrinkedc(short a2, LObjSrtConsumer<T> func)

Methods in eu.lunisolar.magma.func.consumer.primitives.obj with parameters of type LConsumer

Modifier and Type	Method and Description
static <T> LTieSrtConsumer<T>	LTieSrtConsumer.accept1st(LConsumer<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LTieLongConsumer<T>	LTieLongConsumer.accept1st(LConsumer<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LTieIntConsumer<T>	LTieIntConsumer.accept1st(LConsumer<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LTieFltConsumer<T>	LTieFltConsumer.accept1st(LConsumer<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LTieDblConsumer<T>	LTieDblConsumer.accept1st(LConsumer<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LTieCharConsumer<T>	LTieCharConsumer.accept1st(LConsumer<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LTieByteConsumer<T>	LTieByteConsumer.accept1st(LConsumer<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LTieBoolConsumer<T>	LTieBoolConsumer.accept1st(LConsumer<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LObjSrtConsumer<T>	LObjSrtConsumer.accept1st(LConsumer<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LObjLongConsumer<T>	LObjLongConsumer.accept1st(LConsumer<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LObjIntConsumer<T>	LObjIntConsumer.accept1st(LConsumer<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LObjFltConsumer<T>	LObjFltConsumer.accept1st(LConsumer<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LObjDblConsumer<T>	LObjDblConsumer.accept1st(LConsumer<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LObjCharConsumer<T>	LObjCharConsumer.accept1st(LConsumer<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LObjByteConsumer<T>	LObjByteConsumer.accept1st(LConsumer<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LObjBoolConsumer<T>	LObjBoolConsumer.accept1st(LConsumer<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LTieConsumer<T1,T2>	LTieConsumer.accept1st(LConsumer<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LBiObjSrtConsumer<T1,T2>	LBiObjSrtConsumer.accept1st(LConsumer<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LBiObjLongConsumer<T1,T2>	LBiObjLongConsumer.accept1st(LConsumer<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LBiObjIntConsumer<T1,T2>	LBiObjIntConsumer.accept1st(LConsumer<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LBiObjFltConsumer<T1,T2>	LBiObjFltConsumer.accept1st(LConsumer<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LBiObjDblConsumer<T1,T2>	LBiObjDblConsumer.accept1st(LConsumer<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LBiObjCharConsumer<T1,T2>	LBiObjCharConsumer.accept1st(LConsumer<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LBiObjByteConsumer<T1,T2>	LBiObjByteConsumer.accept1st(LConsumer<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LBiObjBoolConsumer<T1,T2>	LBiObjBoolConsumer.accept1st(LConsumer<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LBiObjSrtConsumer<T1,T2>	LBiObjSrtConsumer.accept2nd(LConsumer<T2> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2> LBiObjLongConsumer<T1,T2>	LBiObjLongConsumer.accept2nd(LConsumer<T2> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2> LBiObjIntConsumer<T1,T2>	LBiObjIntConsumer.accept2nd(LConsumer<T2> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2> LBiObjFltConsumer<T1,T2>	LBiObjFltConsumer.accept2nd(LConsumer<T2> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2> LBiObjDblConsumer<T1,T2>	LBiObjDblConsumer.accept2nd(LConsumer<T2> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2> LBiObjCharConsumer<T1,T2>	LBiObjCharConsumer.accept2nd(LConsumer<T2> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2> LBiObjByteConsumer<T1,T2>	LBiObjByteConsumer.accept2nd(LConsumer<T2> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2> LBiObjBoolConsumer<T1,T2>	LBiObjBoolConsumer.accept2nd(LConsumer<T2> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2> LTieConsumer<T1,T2>	LTieConsumer.accept3rd(LConsumer<T2> func) Captures single parameter function into this interface where only 3rd parameter will be used.
default void	LTieConsumer.acceptThen(T1 a1, int a2, T2 a3, LConsumer<Throwable> handler)
default void	LBiObjBoolConsumer.acceptThen(T1 a1, T2 a2, boolean a3, LConsumer<Throwable> handler)
default void	LBiObjByteConsumer.acceptThen(T1 a1, T2 a2, byte a3, LConsumer<Throwable> handler)
default void	LBiObjCharConsumer.acceptThen(T1 a1, T2 a2, char a3, LConsumer<Throwable> handler)
default void	LBiObjDblConsumer.acceptThen(T1 a1, T2 a2, double a3, LConsumer<Throwable> handler)
default void	LBiObjFltConsumer.acceptThen(T1 a1, T2 a2, float a3, LConsumer<Throwable> handler)
default void	LBiObjIntConsumer.acceptThen(T1 a1, T2 a2, int a3, LConsumer<Throwable> handler)
default void	LBiObjLongConsumer.acceptThen(T1 a1, T2 a2, long a3, LConsumer<Throwable> handler)
default void	LBiObjSrtConsumer.acceptThen(T1 a1, T2 a2, short a3, LConsumer<Throwable> handler)
default void	LObjBoolConsumer.acceptThen(T a1, boolean a2, LConsumer<Throwable> handler)
default void	LObjByteConsumer.acceptThen(T a1, byte a2, LConsumer<Throwable> handler)
default void	LObjCharConsumer.acceptThen(T a1, char a2, LConsumer<Throwable> handler)
default void	LObjDblConsumer.acceptThen(T a1, double a2, LConsumer<Throwable> handler)
default void	LObjFltConsumer.acceptThen(T a1, float a2, LConsumer<Throwable> handler)
default void	LTieBoolConsumer.acceptThen(T a1, int a2, boolean a3, LConsumer<Throwable> handler)
default void	LTieByteConsumer.acceptThen(T a1, int a2, byte a3, LConsumer<Throwable> handler)
default void	LTieCharConsumer.acceptThen(T a1, int a2, char a3, LConsumer<Throwable> handler)
default void	LTieDblConsumer.acceptThen(T a1, int a2, double a3, LConsumer<Throwable> handler)
default void	LTieFltConsumer.acceptThen(T a1, int a2, float a3, LConsumer<Throwable> handler)
default void	LTieIntConsumer.acceptThen(T a1, int a2, int a3, LConsumer<Throwable> handler)
default void	LObjIntConsumer.acceptThen(T a1, int a2, LConsumer<Throwable> handler)
default void	LTieLongConsumer.acceptThen(T a1, int a2, long a3, LConsumer<Throwable> handler)
default void	LTieSrtConsumer.acceptThen(T a1, int a2, short a3, LConsumer<Throwable> handler)
default void	LObjLongConsumer.acceptThen(T a1, long a2, LConsumer<Throwable> handler)
default void	LObjSrtConsumer.acceptThen(T a1, short a2, LConsumer<Throwable> handler)
static <T1,T2> void	LTieConsumer.tryAcceptThen(T1 a1, int a2, T2 a3, LTieConsumer<T1,T2> func, LConsumer<Throwable> handler)
static <T1,T2> void	LBiObjBoolConsumer.tryAcceptThen(T1 a1, T2 a2, boolean a3, LBiObjBoolConsumer<T1,T2> func, LConsumer<Throwable> handler)
static <T1,T2> void	LBiObjByteConsumer.tryAcceptThen(T1 a1, T2 a2, byte a3, LBiObjByteConsumer<T1,T2> func, LConsumer<Throwable> handler)
static <T1,T2> void	LBiObjCharConsumer.tryAcceptThen(T1 a1, T2 a2, char a3, LBiObjCharConsumer<T1,T2> func, LConsumer<Throwable> handler)
static <T1,T2> void	LBiObjDblConsumer.tryAcceptThen(T1 a1, T2 a2, double a3, LBiObjDblConsumer<T1,T2> func, LConsumer<Throwable> handler)
static <T1,T2> void	LBiObjFltConsumer.tryAcceptThen(T1 a1, T2 a2, float a3, LBiObjFltConsumer<T1,T2> func, LConsumer<Throwable> handler)
static <T1,T2> void	LBiObjIntConsumer.tryAcceptThen(T1 a1, T2 a2, int a3, LBiObjIntConsumer<T1,T2> func, LConsumer<Throwable> handler)
static <T1,T2> void	LBiObjLongConsumer.tryAcceptThen(T1 a1, T2 a2, long a3, LBiObjLongConsumer<T1,T2> func, LConsumer<Throwable> handler)
static <T1,T2> void	LBiObjSrtConsumer.tryAcceptThen(T1 a1, T2 a2, short a3, LBiObjSrtConsumer<T1,T2> func, LConsumer<Throwable> handler)
static <T> void	LObjBoolConsumer.tryAcceptThen(T a1, boolean a2, LObjBoolConsumer<T> func, LConsumer<Throwable> handler)
static <T> void	LObjByteConsumer.tryAcceptThen(T a1, byte a2, LObjByteConsumer<T> func, LConsumer<Throwable> handler)
static <T> void	LObjCharConsumer.tryAcceptThen(T a1, char a2, LObjCharConsumer<T> func, LConsumer<Throwable> handler)
static <T> void	LObjDblConsumer.tryAcceptThen(T a1, double a2, LObjDblConsumer<T> func, LConsumer<Throwable> handler)
static <T> void	LObjFltConsumer.tryAcceptThen(T a1, float a2, LObjFltConsumer<T> func, LConsumer<Throwable> handler)
static <T> void	LTieBoolConsumer.tryAcceptThen(T a1, int a2, boolean a3, LTieBoolConsumer<T> func, LConsumer<Throwable> handler)
static <T> void	LTieByteConsumer.tryAcceptThen(T a1, int a2, byte a3, LTieByteConsumer<T> func, LConsumer<Throwable> handler)
static <T> void	LTieCharConsumer.tryAcceptThen(T a1, int a2, char a3, LTieCharConsumer<T> func, LConsumer<Throwable> handler)
static <T> void	LTieDblConsumer.tryAcceptThen(T a1, int a2, double a3, LTieDblConsumer<T> func, LConsumer<Throwable> handler)
static <T> void	LTieFltConsumer.tryAcceptThen(T a1, int a2, float a3, LTieFltConsumer<T> func, LConsumer<Throwable> handler)
static <T> void	LTieIntConsumer.tryAcceptThen(T a1, int a2, int a3, LTieIntConsumer<T> func, LConsumer<Throwable> handler)
static <T> void	LObjIntConsumer.tryAcceptThen(T a1, int a2, LObjIntConsumer<T> func, LConsumer<Throwable> handler)
static <T> void	LTieLongConsumer.tryAcceptThen(T a1, int a2, long a3, LTieLongConsumer<T> func, LConsumer<Throwable> handler)
static <T> void	LTieSrtConsumer.tryAcceptThen(T a1, int a2, short a3, LTieSrtConsumer<T> func, LConsumer<Throwable> handler)
static <T> void	LObjLongConsumer.tryAcceptThen(T a1, long a2, LObjLongConsumer<T> func, LConsumer<Throwable> handler)
static <T> void	LObjSrtConsumer.tryAcceptThen(T a1, short a2, LObjSrtConsumer<T> func, LConsumer<Throwable> handler)
default LTieSrtConsumer<T>	LTieSrtConsumer.tryingThen(LConsumer<Throwable> handler)
default LTieLongConsumer<T>	LTieLongConsumer.tryingThen(LConsumer<Throwable> handler)
default LTieIntConsumer<T>	LTieIntConsumer.tryingThen(LConsumer<Throwable> handler)
default LTieFltConsumer<T>	LTieFltConsumer.tryingThen(LConsumer<Throwable> handler)
default LTieDblConsumer<T>	LTieDblConsumer.tryingThen(LConsumer<Throwable> handler)
default LTieConsumer<T1,T2>	LTieConsumer.tryingThen(LConsumer<Throwable> handler)
default LTieCharConsumer<T>	LTieCharConsumer.tryingThen(LConsumer<Throwable> handler)
default LTieByteConsumer<T>	LTieByteConsumer.tryingThen(LConsumer<Throwable> handler)
default LTieBoolConsumer<T>	LTieBoolConsumer.tryingThen(LConsumer<Throwable> handler)
default LObjSrtConsumer<T>	LObjSrtConsumer.tryingThen(LConsumer<Throwable> handler)
default LObjLongConsumer<T>	LObjLongConsumer.tryingThen(LConsumer<Throwable> handler)
default LObjIntConsumer<T>	LObjIntConsumer.tryingThen(LConsumer<Throwable> handler)
default LObjFltConsumer<T>	LObjFltConsumer.tryingThen(LConsumer<Throwable> handler)
default LObjDblConsumer<T>	LObjDblConsumer.tryingThen(LConsumer<Throwable> handler)
default LObjCharConsumer<T>	LObjCharConsumer.tryingThen(LConsumer<Throwable> handler)
default LObjByteConsumer<T>	LObjByteConsumer.tryingThen(LConsumer<Throwable> handler)
default LObjBoolConsumer<T>	LObjBoolConsumer.tryingThen(LConsumer<Throwable> handler)
default LBiObjSrtConsumer<T1,T2>	LBiObjSrtConsumer.tryingThen(LConsumer<Throwable> handler)
default LBiObjLongConsumer<T1,T2>	LBiObjLongConsumer.tryingThen(LConsumer<Throwable> handler)
default LBiObjIntConsumer<T1,T2>	LBiObjIntConsumer.tryingThen(LConsumer<Throwable> handler)
default LBiObjFltConsumer<T1,T2>	LBiObjFltConsumer.tryingThen(LConsumer<Throwable> handler)
default LBiObjDblConsumer<T1,T2>	LBiObjDblConsumer.tryingThen(LConsumer<Throwable> handler)
default LBiObjCharConsumer<T1,T2>	LBiObjCharConsumer.tryingThen(LConsumer<Throwable> handler)
default LBiObjByteConsumer<T1,T2>	LBiObjByteConsumer.tryingThen(LConsumer<Throwable> handler)
default LBiObjBoolConsumer<T1,T2>	LBiObjBoolConsumer.tryingThen(LConsumer<Throwable> handler)

Method parameters in eu.lunisolar.magma.func.consumer.primitives.obj with type arguments of type LConsumer

Modifier and Type	Method and Description
static <T1,T2> LTieConsumer<T1,T2>	LTieConsumer.uncurry(LFunction<T1,LIntFunction<LConsumer<T2>>> func)

Uses of LConsumer in eu.lunisolar.magma.func.consumer.primitives.tri

Methods in eu.lunisolar.magma.func.consumer.primitives.tri with parameters of type LConsumer

Modifier and Type	Method and Description
default void	LTriBoolConsumer.acceptThen(boolean a1, boolean a2, boolean a3, LConsumer<Throwable> handler)
static void	LTriBoolConsumer.tryAcceptThen(boolean a1, boolean a2, boolean a3, LTriBoolConsumer func, LConsumer<Throwable> handler)
default LTriBoolConsumer	LTriBoolConsumer.tryingThen(LConsumer<Throwable> handler)

Uses of LConsumer in eu.lunisolar.magma.func.function

Methods in eu.lunisolar.magma.func.function that return LConsumer

Modifier and Type	Method and Description
default LConsumer<T>	LFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.

Methods in eu.lunisolar.magma.func.function with parameters of type LConsumer

Modifier and Type	Method and Description
default LTriFunction<T1,T2,T3,R>	LTriFunction.after(LConsumer<? super R> after)
default LFunction<T,R>	LFunction.after(LConsumer<? super R> after)
default LBiFunction<T1,T2,R>	LBiFunction.after(LConsumer<? super R> after)
default LFunction<T,R>	LFunction.before(LConsumer<? super T> before)
default <C0> void	LFunction.forEach(IndexedRead<C0,aType.a<T>> ia, C0 source, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LTriFunction.forEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2> void	LBiFunction.forEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LTriFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LTriFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2> void	LBiFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LTriFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0,I0> void	LFunction.iterate(SequentialRead<C0,I0,aType.a<T>> sa, C0 source, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LTriFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	LBiFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LTriFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LTriFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	LBiFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3,I3> void	LTriFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default LTriConsumer<T1,T2,T3>	LTriFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LConsumer<T>	LFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LBiConsumer<T1,T2>	LBiFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.

Uses of LConsumer in eu.lunisolar.magma.func.function.from

Methods in eu.lunisolar.magma.func.function.from with parameters of type LConsumer

Modifier and Type	Method and Description
default LTriBoolFunction<R>	LTriBoolFunction.after(LConsumer<? super R> after)
default LSrtFunction<R>	LSrtFunction.after(LConsumer<? super R> after)
default LOiFunction<T,R>	LOiFunction.after(LConsumer<? super R> after)
default LObjSrtFunction<T,R>	LObjSrtFunction.after(LConsumer<? super R> after)
default LObjLongFunction<T,R>	LObjLongFunction.after(LConsumer<? super R> after)
default LObjIntSrtFunction<T,R>	LObjIntSrtFunction.after(LConsumer<? super R> after)
default LObjIntObjFunction<T1,T2,R>	LObjIntObjFunction.after(LConsumer<? super R> after)
default LObjIntLongFunction<T,R>	LObjIntLongFunction.after(LConsumer<? super R> after)
default LObjIntFltFunction<T,R>	LObjIntFltFunction.after(LConsumer<? super R> after)
default LObjIntDblFunction<T,R>	LObjIntDblFunction.after(LConsumer<? super R> after)
default LObjIntCharFunction<T,R>	LObjIntCharFunction.after(LConsumer<? super R> after)
default LObjIntByteFunction<T,R>	LObjIntByteFunction.after(LConsumer<? super R> after)
default LObjIntBoolFunction<T,R>	LObjIntBoolFunction.after(LConsumer<? super R> after)
default LObjFltFunction<T,R>	LObjFltFunction.after(LConsumer<? super R> after)
default LObjDblFunction<T,R>	LObjDblFunction.after(LConsumer<? super R> after)
default LObjCharFunction<T,R>	LObjCharFunction.after(LConsumer<? super R> after)
default LObjByteFunction<T,R>	LObjByteFunction.after(LConsumer<? super R> after)
default LObjBoolFunction<T,R>	LObjBoolFunction.after(LConsumer<? super R> after)
default LObjBiIntFunction<T,R>	LObjBiIntFunction.after(LConsumer<? super R> after)
default LLongFunction<R>	LLongFunction.after(LConsumer<? super R> after)
default LIntFunction<R>	LIntFunction.after(LConsumer<? super R> after)
default LFltFunction<R>	LFltFunction.after(LConsumer<? super R> after)
default LDblFunction<R>	LDblFunction.after(LConsumer<? super R> after)
default LCharFunction<R>	LCharFunction.after(LConsumer<? super R> after)
default LByteFunction<R>	LByteFunction.after(LConsumer<? super R> after)
default LBoolFunction<R>	LBoolFunction.after(LConsumer<? super R> after)
default LBiSrtFunction<R>	LBiSrtFunction.after(LConsumer<? super R> after)
default LBiObjSrtFunction<T1,T2,R>	LBiObjSrtFunction.after(LConsumer<? super R> after)
default LBiObjLongFunction<T1,T2,R>	LBiObjLongFunction.after(LConsumer<? super R> after)
default LBiObjIntFunction<T1,T2,R>	LBiObjIntFunction.after(LConsumer<? super R> after)
default LBiObjFltFunction<T1,T2,R>	LBiObjFltFunction.after(LConsumer<? super R> after)
default LBiObjDblFunction<T1,T2,R>	LBiObjDblFunction.after(LConsumer<? super R> after)
default LBiObjCharFunction<T1,T2,R>	LBiObjCharFunction.after(LConsumer<? super R> after)
default LBiObjByteFunction<T1,T2,R>	LBiObjByteFunction.after(LConsumer<? super R> after)
default LBiObjBoolFunction<T1,T2,R>	LBiObjBoolFunction.after(LConsumer<? super R> after)
default LBiLongFunction<R>	LBiLongFunction.after(LConsumer<? super R> after)
default LBiIntFunction<R>	LBiIntFunction.after(LConsumer<? super R> after)
default LBiFltFunction<R>	LBiFltFunction.after(LConsumer<? super R> after)
default LBiDblFunction<R>	LBiDblFunction.after(LConsumer<? super R> after)
default LBiCharFunction<R>	LBiCharFunction.after(LConsumer<? super R> after)
default LBiByteFunction<R>	LBiByteFunction.after(LConsumer<? super R> after)
default LBiBoolFunction<R>	LBiBoolFunction.after(LConsumer<? super R> after)
default <C0> void	LBoolFunction.forEach(IndexedRead<C0,aType.aBool> ia, C0 source, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0> void	LByteFunction.forEach(IndexedRead<C0,aType.aByte> ia, C0 source, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0> void	LCharFunction.forEach(IndexedRead<C0,aType.aChar> ia, C0 source, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0> void	LDblFunction.forEach(IndexedRead<C0,aType.aDouble> ia, C0 source, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0> void	LFltFunction.forEach(IndexedRead<C0,aType.aFloat> ia, C0 source, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0> void	LIntFunction.forEach(IndexedRead<C0,aType.aInt> ia, C0 source, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0> void	LLongFunction.forEach(IndexedRead<C0,aType.aLong> ia, C0 source, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0> void	LSrtFunction.forEach(IndexedRead<C0,aType.aShort> ia, C0 source, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2> void	LObjBoolFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aBool> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2> void	LObjByteFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aByte> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2> void	LObjCharFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aChar> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2> void	LObjDblFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aDouble> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2> void	LObjFltFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aFloat> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LObjIntBoolFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aBool> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LObjIntByteFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aByte> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LObjIntCharFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aChar> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LObjIntDblFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aDouble> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LObjIntFltFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aFloat> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LObjBiIntFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aInt> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LObjIntLongFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aLong> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LObjIntSrtFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aShort> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2> void	LOiFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2> void	LObjLongFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aLong> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2> void	LObjSrtFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aShort> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LBiObjBoolFunction.forEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.aBool> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LBiObjByteFunction.forEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.aByte> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LBiObjCharFunction.forEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.aChar> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LBiObjDblFunction.forEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.aDouble> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LBiObjFltFunction.forEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.aFloat> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LBiObjIntFunction.forEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.aInt> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LBiObjLongFunction.forEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.aLong> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LBiObjSrtFunction.forEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.aShort> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LObjIntObjFunction.forEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.a<T2>> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LTriBoolFunction.forEach(IndexedRead<C1,aType.aBool> ia1, C1 source1, IndexedRead<C2,aType.aBool> ia2, C2 source2, IndexedRead<C3,aType.aBool> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2> void	LBiBoolFunction.forEach(IndexedRead<C1,aType.aBool> ia1, C1 source1, IndexedRead<C2,aType.aBool> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2> void	LBiByteFunction.forEach(IndexedRead<C1,aType.aByte> ia1, C1 source1, IndexedRead<C2,aType.aByte> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2> void	LBiCharFunction.forEach(IndexedRead<C1,aType.aChar> ia1, C1 source1, IndexedRead<C2,aType.aChar> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2> void	LBiDblFunction.forEach(IndexedRead<C1,aType.aDouble> ia1, C1 source1, IndexedRead<C2,aType.aDouble> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2> void	LBiFltFunction.forEach(IndexedRead<C1,aType.aFloat> ia1, C1 source1, IndexedRead<C2,aType.aFloat> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2> void	LBiIntFunction.forEach(IndexedRead<C1,aType.aInt> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2> void	LBiLongFunction.forEach(IndexedRead<C1,aType.aLong> ia1, C1 source1, IndexedRead<C2,aType.aLong> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2> void	LBiSrtFunction.forEach(IndexedRead<C1,aType.aShort> ia1, C1 source1, IndexedRead<C2,aType.aShort> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LObjIntBoolFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aBool> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LObjIntByteFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aByte> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LObjIntCharFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aChar> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LObjIntDblFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aDouble> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LObjIntFltFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aFloat> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LObjBiIntFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aInt> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LObjIntLongFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LObjIntSrtFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aShort> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2> void	LObjBoolFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aBool> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2> void	LObjByteFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aByte> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2> void	LObjCharFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aChar> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2> void	LObjDblFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aDouble> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2> void	LObjFltFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aFloat> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LObjIntBoolFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aBool> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LObjIntByteFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aByte> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LObjIntCharFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aChar> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LObjIntDblFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aDouble> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LObjIntFltFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aFloat> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LObjBiIntFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aInt> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LObjIntLongFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aLong> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LObjIntSrtFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aShort> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2> void	LOiFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LObjIntBoolFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.aBool> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LObjIntByteFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.aByte> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LObjIntCharFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.aChar> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LObjIntDblFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.aDouble> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LObjIntFltFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.aFloat> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LObjBiIntFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.aInt> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LObjIntLongFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LObjIntSrtFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.aShort> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2> void	LObjLongFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aLong> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2> void	LObjSrtFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aShort> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LBiObjBoolFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.aBool> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LBiObjByteFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.aByte> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LBiObjCharFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.aChar> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LBiObjDblFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.aDouble> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LBiObjFltFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.aFloat> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LBiObjIntFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.aInt> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LBiObjLongFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LBiObjSrtFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.aShort> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LObjIntObjFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.a<T2>> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LBiObjBoolFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.aBool> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LBiObjByteFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.aByte> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LBiObjCharFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.aChar> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LBiObjDblFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.aDouble> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LBiObjFltFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.aFloat> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LBiObjIntFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.aInt> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LBiObjLongFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.aLong> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LBiObjSrtFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.aShort> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LBiObjBoolFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.aBool> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LBiObjByteFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.aByte> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LBiObjCharFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.aChar> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LBiObjDblFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.aDouble> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LBiObjFltFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.aFloat> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LBiObjIntFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.aInt> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LBiObjLongFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LBiObjSrtFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.aShort> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LObjIntObjFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.a<T2>> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LObjIntObjFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.a<T2>> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LTriBoolFunction.iterate(IndexedRead<C1,aType.aBool> ia1, C1 source1, IndexedRead<C2,aType.aBool> ia2, C2 source2, SequentialRead<C3,I3,aType.aBool> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LTriBoolFunction.iterate(IndexedRead<C1,aType.aBool> ia1, C1 source1, SequentialRead<C2,I2,aType.aBool> sa2, C2 source2, IndexedRead<C3,aType.aBool> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2> void	LBiBoolFunction.iterate(IndexedRead<C1,aType.aBool> ia1, C1 source1, SequentialRead<C2,I2,aType.aBool> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LTriBoolFunction.iterate(IndexedRead<C1,aType.aBool> ia1, C1 source1, SequentialRead<C2,I2,aType.aBool> sa2, C2 source2, SequentialRead<C3,I3,aType.aBool> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2> void	LBiByteFunction.iterate(IndexedRead<C1,aType.aByte> ia1, C1 source1, SequentialRead<C2,I2,aType.aByte> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2> void	LBiCharFunction.iterate(IndexedRead<C1,aType.aChar> ia1, C1 source1, SequentialRead<C2,I2,aType.aChar> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2> void	LBiDblFunction.iterate(IndexedRead<C1,aType.aDouble> ia1, C1 source1, SequentialRead<C2,I2,aType.aDouble> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2> void	LBiFltFunction.iterate(IndexedRead<C1,aType.aFloat> ia1, C1 source1, SequentialRead<C2,I2,aType.aFloat> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2> void	LBiIntFunction.iterate(IndexedRead<C1,aType.aInt> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2> void	LBiLongFunction.iterate(IndexedRead<C1,aType.aLong> ia1, C1 source1, SequentialRead<C2,I2,aType.aLong> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2> void	LBiSrtFunction.iterate(IndexedRead<C1,aType.aShort> ia1, C1 source1, SequentialRead<C2,I2,aType.aShort> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0,I0> void	LBoolFunction.iterate(SequentialRead<C0,I0,aType.aBool> sa, C0 source, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0,I0> void	LByteFunction.iterate(SequentialRead<C0,I0,aType.aByte> sa, C0 source, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0,I0> void	LCharFunction.iterate(SequentialRead<C0,I0,aType.aChar> sa, C0 source, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0,I0> void	LDblFunction.iterate(SequentialRead<C0,I0,aType.aDouble> sa, C0 source, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0,I0> void	LFltFunction.iterate(SequentialRead<C0,I0,aType.aFloat> sa, C0 source, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0,I0> void	LIntFunction.iterate(SequentialRead<C0,I0,aType.aInt> sa, C0 source, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0,I0> void	LLongFunction.iterate(SequentialRead<C0,I0,aType.aLong> sa, C0 source, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0,I0> void	LSrtFunction.iterate(SequentialRead<C0,I0,aType.aShort> sa, C0 source, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	LObjBoolFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aBool> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	LObjByteFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aByte> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	LObjCharFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aChar> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	LObjDblFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aDouble> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	LObjFltFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aFloat> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LObjIntBoolFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aBool> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LObjIntByteFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aByte> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LObjIntCharFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aChar> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LObjIntDblFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aDouble> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LObjIntFltFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aFloat> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LObjBiIntFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aInt> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LObjIntLongFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aLong> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LObjIntSrtFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aShort> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	LOiFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LObjIntBoolFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aBool> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LObjIntByteFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aByte> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LObjIntCharFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aChar> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LObjIntDblFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aDouble> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LObjIntFltFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aFloat> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LObjBiIntFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aInt> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LObjIntLongFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LObjIntSrtFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aShort> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	LObjLongFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aLong> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	LObjSrtFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aShort> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	LObjBoolFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aBool> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	LObjByteFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aByte> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	LObjCharFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aChar> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	LObjDblFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aDouble> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	LObjFltFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aFloat> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LObjIntBoolFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aBool> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LObjIntByteFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aByte> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LObjIntCharFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aChar> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LObjIntDblFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aDouble> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LObjIntFltFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aFloat> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LObjBiIntFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aInt> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LObjIntLongFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aLong> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LObjIntSrtFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aShort> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	LOiFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3,I3> void	LObjIntBoolFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.aBool> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3,I3> void	LObjIntByteFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.aByte> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3,I3> void	LObjIntCharFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.aChar> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3,I3> void	LObjIntDblFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.aDouble> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3,I3> void	LObjIntFltFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.aFloat> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3,I3> void	LObjBiIntFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.aInt> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3,I3> void	LObjIntLongFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3,I3> void	LObjIntSrtFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.aShort> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	LObjLongFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aLong> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	LObjSrtFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aShort> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LBiObjBoolFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.aBool> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LBiObjByteFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.aByte> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LBiObjCharFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.aChar> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LBiObjDblFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.aDouble> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LBiObjFltFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.aFloat> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LBiObjIntFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.aInt> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LBiObjLongFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.aLong> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LBiObjSrtFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.aShort> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LBiObjBoolFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.aBool> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LBiObjByteFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.aByte> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LBiObjCharFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.aChar> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LBiObjDblFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.aDouble> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LBiObjFltFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.aFloat> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LBiObjIntFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.aInt> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LBiObjLongFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LBiObjSrtFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.aShort> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LObjIntObjFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.a<T2>> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LObjIntObjFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.a<T2>> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LBiObjBoolFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.aBool> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LBiObjByteFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.aByte> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LBiObjCharFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.aChar> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LBiObjDblFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.aDouble> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LBiObjFltFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.aFloat> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LBiObjIntFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.aInt> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LBiObjLongFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.aLong> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LBiObjSrtFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.aShort> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3,I3> void	LBiObjBoolFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.aBool> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3,I3> void	LBiObjByteFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.aByte> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3,I3> void	LBiObjCharFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.aChar> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3,I3> void	LBiObjDblFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.aDouble> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3,I3> void	LBiObjFltFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.aFloat> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3,I3> void	LBiObjIntFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.aInt> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3,I3> void	LBiObjLongFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3,I3> void	LBiObjSrtFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.aShort> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LObjIntObjFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.a<T2>> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3,I3> void	LObjIntObjFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.a<T2>> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LTriBoolFunction.iterate(SequentialRead<C1,I1,aType.aBool> sa1, C1 source1, IndexedRead<C2,aType.aBool> ia2, C2 source2, IndexedRead<C3,aType.aBool> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	LBiBoolFunction.iterate(SequentialRead<C1,I1,aType.aBool> sa1, C1 source1, IndexedRead<C2,aType.aBool> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LTriBoolFunction.iterate(SequentialRead<C1,I1,aType.aBool> sa1, C1 source1, IndexedRead<C2,aType.aBool> ia2, C2 source2, SequentialRead<C3,I3,aType.aBool> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LTriBoolFunction.iterate(SequentialRead<C1,I1,aType.aBool> sa1, C1 source1, SequentialRead<C2,I2,aType.aBool> sa2, C2 source2, IndexedRead<C3,aType.aBool> ia3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	LBiBoolFunction.iterate(SequentialRead<C1,I1,aType.aBool> sa1, C1 source1, SequentialRead<C2,I2,aType.aBool> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3,I3> void	LTriBoolFunction.iterate(SequentialRead<C1,I1,aType.aBool> sa1, C1 source1, SequentialRead<C2,I2,aType.aBool> sa2, C2 source2, SequentialRead<C3,I3,aType.aBool> sa3, C3 source3, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	LBiByteFunction.iterate(SequentialRead<C1,I1,aType.aByte> sa1, C1 source1, IndexedRead<C2,aType.aByte> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	LBiByteFunction.iterate(SequentialRead<C1,I1,aType.aByte> sa1, C1 source1, SequentialRead<C2,I2,aType.aByte> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	LBiCharFunction.iterate(SequentialRead<C1,I1,aType.aChar> sa1, C1 source1, IndexedRead<C2,aType.aChar> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	LBiCharFunction.iterate(SequentialRead<C1,I1,aType.aChar> sa1, C1 source1, SequentialRead<C2,I2,aType.aChar> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	LBiDblFunction.iterate(SequentialRead<C1,I1,aType.aDouble> sa1, C1 source1, IndexedRead<C2,aType.aDouble> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	LBiDblFunction.iterate(SequentialRead<C1,I1,aType.aDouble> sa1, C1 source1, SequentialRead<C2,I2,aType.aDouble> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	LBiFltFunction.iterate(SequentialRead<C1,I1,aType.aFloat> sa1, C1 source1, IndexedRead<C2,aType.aFloat> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	LBiFltFunction.iterate(SequentialRead<C1,I1,aType.aFloat> sa1, C1 source1, SequentialRead<C2,I2,aType.aFloat> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	LBiIntFunction.iterate(SequentialRead<C1,I1,aType.aInt> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	LBiIntFunction.iterate(SequentialRead<C1,I1,aType.aInt> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	LBiLongFunction.iterate(SequentialRead<C1,I1,aType.aLong> sa1, C1 source1, IndexedRead<C2,aType.aLong> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	LBiLongFunction.iterate(SequentialRead<C1,I1,aType.aLong> sa1, C1 source1, SequentialRead<C2,I2,aType.aLong> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	LBiSrtFunction.iterate(SequentialRead<C1,I1,aType.aShort> sa1, C1 source1, IndexedRead<C2,aType.aShort> ia2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	LBiSrtFunction.iterate(SequentialRead<C1,I1,aType.aShort> sa1, C1 source1, SequentialRead<C2,I2,aType.aShort> sa2, C2 source2, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default LTriBoolConsumer	LTriBoolFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LSrtConsumer	LSrtFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LObjIntConsumer<T>	LOiFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LObjSrtConsumer<T>	LObjSrtFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LObjLongConsumer<T>	LObjLongFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LTieSrtConsumer<T>	LObjIntSrtFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LTieConsumer<T1,T2>	LObjIntObjFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LTieLongConsumer<T>	LObjIntLongFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LTieFltConsumer<T>	LObjIntFltFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LTieDblConsumer<T>	LObjIntDblFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LTieCharConsumer<T>	LObjIntCharFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LTieByteConsumer<T>	LObjIntByteFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LTieBoolConsumer<T>	LObjIntBoolFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LObjFltConsumer<T>	LObjFltFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LObjDblConsumer<T>	LObjDblFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LObjCharConsumer<T>	LObjCharFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LObjByteConsumer<T>	LObjByteFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LObjBoolConsumer<T>	LObjBoolFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LTieIntConsumer<T>	LObjBiIntFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LLongConsumer	LLongFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LIntConsumer	LIntFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LFltConsumer	LFltFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LDblConsumer	LDblFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LCharConsumer	LCharFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LByteConsumer	LByteFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LBoolConsumer	LBoolFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LBiSrtConsumer	LBiSrtFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LBiObjSrtConsumer<T1,T2>	LBiObjSrtFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LBiObjLongConsumer<T1,T2>	LBiObjLongFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LBiObjIntConsumer<T1,T2>	LBiObjIntFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LBiObjFltConsumer<T1,T2>	LBiObjFltFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LBiObjDblConsumer<T1,T2>	LBiObjDblFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LBiObjCharConsumer<T1,T2>	LBiObjCharFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LBiObjByteConsumer<T1,T2>	LBiObjByteFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LBiObjBoolConsumer<T1,T2>	LBiObjBoolFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LBiLongConsumer	LBiLongFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LBiIntConsumer	LBiIntFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LBiFltConsumer	LBiFltFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LBiDblConsumer	LBiDblFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LBiCharConsumer	LBiCharFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LBiByteConsumer	LBiByteFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LBiBoolConsumer	LBiBoolFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.

Uses of LConsumer in eu.lunisolar.magma.func.operator.binary

Methods in eu.lunisolar.magma.func.operator.binary with parameters of type LConsumer

Modifier and Type	Method and Description
default <C1,C2> void	LBinaryOperator.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.a<T>> ia2, C2 source2, LConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2> void	LBinaryOperator.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T>> sa2, C2 source2, LConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	LBinaryOperator.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.a<T>> ia2, C2 source2, LConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	LBinaryOperator.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T>> sa2, C2 source2, LConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.

Uses of LConsumer in eu.lunisolar.magma.func.operator.ternary

Methods in eu.lunisolar.magma.func.operator.ternary with parameters of type LConsumer

Modifier and Type	Method and Description
default <C1,C2,C3> void	LTernaryOperator.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.a<T>> ia2, C2 source2, IndexedRead<C3,aType.a<T>> ia3, C3 source3, LConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LTernaryOperator.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.a<T>> ia2, C2 source2, SequentialRead<C3,I3,aType.a<T>> sa3, C3 source3, LConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LTernaryOperator.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T>> sa2, C2 source2, IndexedRead<C3,aType.a<T>> ia3, C3 source3, LConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LTernaryOperator.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T>> sa2, C2 source2, SequentialRead<C3,I3,aType.a<T>> sa3, C3 source3, LConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LTernaryOperator.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.a<T>> ia2, C2 source2, IndexedRead<C3,aType.a<T>> ia3, C3 source3, LConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LTernaryOperator.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.a<T>> ia2, C2 source2, SequentialRead<C3,I3,aType.a<T>> sa3, C3 source3, LConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LTernaryOperator.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T>> sa2, C2 source2, IndexedRead<C3,aType.a<T>> ia3, C3 source3, LConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3,I3> void	LTernaryOperator.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T>> sa2, C2 source2, SequentialRead<C3,I3,aType.a<T>> sa3, C3 source3, LConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.

Uses of LConsumer in eu.lunisolar.magma.func.operator.unary

Methods in eu.lunisolar.magma.func.operator.unary with parameters of type LConsumer

Modifier and Type	Method and Description
default <C0> void	LUnaryOperator.forEach(IndexedRead<C0,aType.a<T>> ia, C0 source, LConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0,I0> void	LUnaryOperator.iterate(SequentialRead<C0,I0,aType.a<T>> sa, C0 source, LConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.

Uses of LConsumer in eu.lunisolar.magma.func.predicate

Methods in eu.lunisolar.magma.func.predicate with parameters of type LConsumer

Modifier and Type	Method and Description
default boolean	LPredicate.doIf(T a, LConsumer<? super T> consumer)
static <T> boolean	LPredicate.doIf(T a, LPredicate<T> predicate, LConsumer<? super T> consumer)
default <C0> void	LPredicate.filterForEach(IndexedRead<C0,aType.a<T>> ia, C0 source, LConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C0,I0> void	LPredicate.filterIterate(SequentialRead<C0,I0,aType.a<T>> sa, C0 source, LConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.

Uses of LConsumer in eu.lunisolar.magma.func.supplier

Methods in eu.lunisolar.magma.func.supplier with parameters of type LConsumer

Modifier and Type	Method and Description
default LSupplier<T>	LSupplier.after(LConsumer<? super T> after)
default LAction	LSupplier.toAct(LConsumer<? super T> after) Combines two functions together in a order.