Uses of Interface
eu.lunisolar.magma.func.consumer.primitives.LIntConsumer

Packages that use LIntConsumer

Package	Description
eu.lunisolar.magma.func.consumer.primitives
eu.lunisolar.magma.func.consumer.primitives.bi
eu.lunisolar.magma.func.consumer.primitives.obj
eu.lunisolar.magma.func.function.conversion
eu.lunisolar.magma.func.function.from
eu.lunisolar.magma.func.function.to
eu.lunisolar.magma.func.operator.binary
eu.lunisolar.magma.func.operator.unary
eu.lunisolar.magma.func.predicate

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

Classes in eu.lunisolar.magma.func.consumer.primitives that implement LIntConsumer

Modifier and Type	Class and Description
static class	LIntConsumer.LIntConsumerSingle

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

Modifier and Type	Method and Description
default LIntConsumer	LIntConsumer.andThen(LIntConsumer after) Combines two LIntConsumer together in a order.
default LIntConsumer	LIntConsumer.compose(LIntUnaryOperator before) Allows to manipulate the domain of the function.
static LIntConsumer	LIntConsumer.composed(LIntUnaryOperator before, LIntConsumer after)
static LIntConsumer	LIntConsumer.failSafe(LIntConsumer func, LIntConsumer failSafe)
default LIntConsumer	LIntConsumer.handling(HandlingInstructions<Throwable,RuntimeException> handling)
static LIntConsumer	LIntConsumer.intCons(LIntConsumer lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static LIntConsumer	LIntConsumer.intConsThrowing(ExF<Throwable> exF)
static LIntConsumer	LIntConsumer.intConsThrowing(String message, ExMF<Throwable> exF)
static LIntConsumer	LIntConsumer.recursive(LFunction<LIntConsumer,LIntConsumer> selfLambda)
static LIntConsumer	LIntConsumer.safe() Safe instance.
static LIntConsumer	LIntConsumer.safe(LIntConsumer other) Safe wrapping.
default LIntConsumer	LIntConsumer.trying(ExWF<RuntimeException> exF)
default LIntConsumer	LIntConsumer.trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LIntConsumer	LIntConsumer.tryingThen(LConsumer<Throwable> handler)
LIntConsumer	LIntConsumer.LIntConsumerSingle.value()
static LIntConsumer	LIntConsumer.wrap(java.util.function.IntConsumer other) Wraps JRE instance.

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

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

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

Modifier and Type	Method and Description
default LIntConsumer	LIntConsumer.andThen(LIntConsumer after) Combines two LIntConsumer together in a order.
static void	LIntConsumer.call(int a, LIntConsumer lambda)
static LIntConsumer	LIntConsumer.composed(LIntUnaryOperator before, LIntConsumer after)
static <V> LConsumer<V>	LIntConsumer.composed(LToIntFunction<? super V> before, LIntConsumer after)
static LIntConsumer	LIntConsumer.failSafe(LIntConsumer func, LIntConsumer failSafe)
default void	LIntConsumer.failSafeAccept(int a, LIntConsumer failSafe)
static void	LIntConsumer.failSafeAccept(int a, LIntConsumer func, LIntConsumer failSafe)
static <C0> int	LIntConsumer.forEach(IndexedRead<C0,aType.aInt> ia, C0 source, LIntConsumer consumer) For each element (or tuple) from arguments, calls the consumer.
static void	LIntConsumer.fromTill(int min_a, int max_a, LIntConsumer func) From-To.
static void	LIntConsumer.fromTo(int min_a, int max_a, LIntConsumer func) From-To.
static void	LIntConsumer.handlingAccept(int a, LIntConsumer func, HandlingInstructions<Throwable,RuntimeException> handling)
static LIntConsumer	LIntConsumer.intCons(LIntConsumer lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <C0,I0> int	LIntConsumer.iterate(SequentialRead<C0,I0,aType.aInt> sa, C0 source, LIntConsumer consumer) For each element (or tuple) from arguments, calls the consumer.
static LIntConsumer	LIntConsumer.safe(LIntConsumer other) Safe wrapping.
static void	LIntConsumer.times(int max_a, LIntConsumer func) From-To.
static void	LIntConsumer.tryAccept(int a, LIntConsumer func)
static void	LIntConsumer.tryAccept(int a, LIntConsumer func, ExWF<RuntimeException> exF)
static void	LIntConsumer.tryAccept(int a, LIntConsumer func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static void	LIntConsumer.tryAcceptThen(int a, LIntConsumer func, LConsumer<Throwable> handler)

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

Modifier and Type	Method and Description
static LIntConsumer	LIntConsumer.recursive(LFunction<LIntConsumer,LIntConsumer> selfLambda)
static LIntConsumer	LIntConsumer.recursive(LFunction<LIntConsumer,LIntConsumer> selfLambda)
static LSupplier<LIntConsumer>	LIntConsumer.safeSupplier(LSupplier<LIntConsumer> supplier) Safe supplier.

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

Methods in eu.lunisolar.magma.func.consumer.primitives.bi that return LIntConsumer

Modifier and Type	Method and Description
default LIntConsumer	LBoolIntConsumer.lShrink(LIntPredicate left)
default LIntConsumer	LByteIntConsumer.lShrink(LIntToByteFunction left)
default LIntConsumer	LCharIntConsumer.lShrink(LIntToCharFunction left)
default LIntConsumer	LDblIntConsumer.lShrink(LIntToDblFunction left)
default LIntConsumer	LFltIntConsumer.lShrink(LIntToFltFunction left)
default LIntConsumer	LLongIntConsumer.lShrink(LIntToLongFunction left)
default LIntConsumer	LSrtIntConsumer.lShrink(LIntToSrtFunction left)
default LIntConsumer	LBiIntConsumer.lShrink(LIntUnaryOperator left)
default LIntConsumer	LBoolIntConsumer.lShrinkc(boolean a1)
default LIntConsumer	LByteIntConsumer.lShrinkc(byte a1)
default LIntConsumer	LCharIntConsumer.lShrinkc(char a1)
default LIntConsumer	LDblIntConsumer.lShrinkc(double a1)
default LIntConsumer	LFltIntConsumer.lShrinkc(float a1)
default LIntConsumer	LBiIntConsumer.lShrinkc(int a1)
default LIntConsumer	LLongIntConsumer.lShrinkc(long a1)
default LIntConsumer	LSrtIntConsumer.lShrinkc(short a1)
static LIntConsumer	LBoolIntConsumer.lShrinked(LIntPredicate left, LBoolIntConsumer func)
static LIntConsumer	LByteIntConsumer.lShrinked(LIntToByteFunction left, LByteIntConsumer func)
static LIntConsumer	LCharIntConsumer.lShrinked(LIntToCharFunction left, LCharIntConsumer func)
static LIntConsumer	LDblIntConsumer.lShrinked(LIntToDblFunction left, LDblIntConsumer func)
static LIntConsumer	LFltIntConsumer.lShrinked(LIntToFltFunction left, LFltIntConsumer func)
static LIntConsumer	LLongIntConsumer.lShrinked(LIntToLongFunction left, LLongIntConsumer func)
static LIntConsumer	LSrtIntConsumer.lShrinked(LIntToSrtFunction left, LSrtIntConsumer func)
static LIntConsumer	LBiIntConsumer.lShrinked(LIntUnaryOperator left, LBiIntConsumer func)
static LIntConsumer	LBoolIntConsumer.lShrinkedc(boolean a1, LBoolIntConsumer func)
static LIntConsumer	LByteIntConsumer.lShrinkedc(byte a1, LByteIntConsumer func)
static LIntConsumer	LCharIntConsumer.lShrinkedc(char a1, LCharIntConsumer func)
static LIntConsumer	LDblIntConsumer.lShrinkedc(double a1, LDblIntConsumer func)
static LIntConsumer	LFltIntConsumer.lShrinkedc(float a1, LFltIntConsumer func)
static LIntConsumer	LBiIntConsumer.lShrinkedc(int a1, LBiIntConsumer func)
static LIntConsumer	LLongIntConsumer.lShrinkedc(long a1, LLongIntConsumer func)
static LIntConsumer	LSrtIntConsumer.lShrinkedc(short a1, LSrtIntConsumer func)
default LIntConsumer	LBiIntConsumer.rShrink(LIntUnaryOperator right)
default LIntConsumer	LBiIntConsumer.rShrinkc(int a2)
static LIntConsumer	LBiIntConsumer.rShrinked(LIntUnaryOperator right, LBiIntConsumer func)
static LIntConsumer	LBiIntConsumer.rShrinkedc(int a2, LBiIntConsumer func)

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

Modifier and Type	Method and Description
static LBiIntConsumer	LBiIntConsumer.accept1st(LIntConsumer func) Captures single parameter function into this interface where only 1st parameter will be used.
static LSrtIntConsumer	LSrtIntConsumer.accept2nd(LIntConsumer func) Captures single parameter function into this interface where only 2nd parameter will be used.
static LLongIntConsumer	LLongIntConsumer.accept2nd(LIntConsumer func) Captures single parameter function into this interface where only 2nd parameter will be used.
static LFltIntConsumer	LFltIntConsumer.accept2nd(LIntConsumer func) Captures single parameter function into this interface where only 2nd parameter will be used.
static LDblIntConsumer	LDblIntConsumer.accept2nd(LIntConsumer func) Captures single parameter function into this interface where only 2nd parameter will be used.
static LCharIntConsumer	LCharIntConsumer.accept2nd(LIntConsumer func) Captures single parameter function into this interface where only 2nd parameter will be used.
static LByteIntConsumer	LByteIntConsumer.accept2nd(LIntConsumer func) Captures single parameter function into this interface where only 2nd parameter will be used.
static LBoolIntConsumer	LBoolIntConsumer.accept2nd(LIntConsumer func) Captures single parameter function into this interface where only 2nd parameter will be used.
static LBiIntConsumer	LBiIntConsumer.accept2nd(LIntConsumer func) Captures single parameter function into this interface where only 2nd parameter will be used.

Method parameters in eu.lunisolar.magma.func.consumer.primitives.bi with type arguments of type LIntConsumer

Modifier and Type	Method and Description
static LBoolIntConsumer	LBoolIntConsumer.uncurry(LBoolFunction<LIntConsumer> func)
static LByteIntConsumer	LByteIntConsumer.uncurry(LByteFunction<LIntConsumer> func)
static LCharIntConsumer	LCharIntConsumer.uncurry(LCharFunction<LIntConsumer> func)
static LDblIntConsumer	LDblIntConsumer.uncurry(LDblFunction<LIntConsumer> func)
static LFltIntConsumer	LFltIntConsumer.uncurry(LFltFunction<LIntConsumer> func)
static LBiIntConsumer	LBiIntConsumer.uncurry(LIntFunction<LIntConsumer> func)
static LLongIntConsumer	LLongIntConsumer.uncurry(LLongFunction<LIntConsumer> func)
static LSrtIntConsumer	LSrtIntConsumer.uncurry(LSrtFunction<LIntConsumer> func)

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

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

Modifier and Type	Method and Description
default LIntConsumer	LObjIntConsumer.lShrink(LIntFunction<T> left)
default LIntConsumer	LObjIntConsumer.lShrinkc(T a1)
static <T> LIntConsumer	LObjIntConsumer.lShrinked(LIntFunction<T> left, LObjIntConsumer<T> func)
static <T> LIntConsumer	LObjIntConsumer.lShrinkedc(T a1, LObjIntConsumer<T> func)

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

Modifier and Type	Method and Description
static <T> LTieSrtConsumer<T>	LTieSrtConsumer.accept2nd(LIntConsumer func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T> LTieLongConsumer<T>	LTieLongConsumer.accept2nd(LIntConsumer func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T> LTieIntConsumer<T>	LTieIntConsumer.accept2nd(LIntConsumer func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T> LTieFltConsumer<T>	LTieFltConsumer.accept2nd(LIntConsumer func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T> LTieDblConsumer<T>	LTieDblConsumer.accept2nd(LIntConsumer func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T> LTieCharConsumer<T>	LTieCharConsumer.accept2nd(LIntConsumer func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T> LTieByteConsumer<T>	LTieByteConsumer.accept2nd(LIntConsumer func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T> LTieBoolConsumer<T>	LTieBoolConsumer.accept2nd(LIntConsumer func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T> LObjIntConsumer<T>	LObjIntConsumer.accept2nd(LIntConsumer func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2> LTieConsumer<T1,T2>	LTieConsumer.accept2nd(LIntConsumer func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T> LTieIntConsumer<T>	LTieIntConsumer.accept3rd(LIntConsumer func) Captures single parameter function into this interface where only 3rd parameter will be used.
static <T1,T2> LBiObjIntConsumer<T1,T2>	LBiObjIntConsumer.accept3rd(LIntConsumer func) Captures single parameter function into this interface where only 3rd parameter will be used.

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

Modifier and Type	Method and Description
static <T1,T2> LBiObjIntConsumer<T1,T2>	LBiObjIntConsumer.uncurry(LFunction<T1,LFunction<T2,LIntConsumer>> func)
static <T> LObjIntConsumer<T>	LObjIntConsumer.uncurry(LFunction<T,LIntConsumer> func)
static <T> LTieIntConsumer<T>	LTieIntConsumer.uncurry(LFunction<T,LIntFunction<LIntConsumer>> func)

Uses of LIntConsumer in eu.lunisolar.magma.func.function.conversion

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

Modifier and Type	Method and Description
default <C0> void	LBoolToIntFunction.forEach(IndexedRead<C0,aType.aBool> ia, C0 source, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0> void	LByteToIntFunction.forEach(IndexedRead<C0,aType.aByte> ia, C0 source, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0> void	LCharToIntFunction.forEach(IndexedRead<C0,aType.aChar> ia, C0 source, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0> void	LDblToIntFunction.forEach(IndexedRead<C0,aType.aDouble> ia, C0 source, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0> void	LFltToIntFunction.forEach(IndexedRead<C0,aType.aFloat> ia, C0 source, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0> void	LLongToIntFunction.forEach(IndexedRead<C0,aType.aLong> ia, C0 source, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0> void	LSrtToIntFunction.forEach(IndexedRead<C0,aType.aShort> ia, C0 source, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0,I0> void	LBoolToIntFunction.iterate(SequentialRead<C0,I0,aType.aBool> sa, C0 source, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0,I0> void	LByteToIntFunction.iterate(SequentialRead<C0,I0,aType.aByte> sa, C0 source, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0,I0> void	LCharToIntFunction.iterate(SequentialRead<C0,I0,aType.aChar> sa, C0 source, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0,I0> void	LDblToIntFunction.iterate(SequentialRead<C0,I0,aType.aDouble> sa, C0 source, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0,I0> void	LFltToIntFunction.iterate(SequentialRead<C0,I0,aType.aFloat> sa, C0 source, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0,I0> void	LLongToIntFunction.iterate(SequentialRead<C0,I0,aType.aLong> sa, C0 source, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0,I0> void	LSrtToIntFunction.iterate(SequentialRead<C0,I0,aType.aShort> sa, C0 source, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.

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

Methods in eu.lunisolar.magma.func.function.from that return LIntConsumer

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

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

Modifier and Type	Method and Description
default LIntFunction<R>	LIntFunction.before(LIntConsumer before)

Uses of LIntConsumer in eu.lunisolar.magma.func.function.to

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

Modifier and Type	Method and Description
default <C0> void	LToIntFunction.forEach(IndexedRead<C0,aType.a<T>> ia, C0 source, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LTieBoolFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aBool> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LTieByteFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aByte> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LTieCharFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aChar> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LTieDblFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aDouble> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LTieFltFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aFloat> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LTieIntFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aInt> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LTieLongFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aLong> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LTieSrtFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aShort> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2> void	LOiToIntFunction.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LToIntTriFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2> void	LToIntBiFunction.forEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3> void	LTieFunction.forEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.a<T2>> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LTieBoolFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aBool> sa3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LTieByteFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aByte> sa3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LTieCharFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aChar> sa3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LTieDblFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aDouble> sa3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LTieFltFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aFloat> sa3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LTieIntFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aInt> sa3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LTieLongFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LTieSrtFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aShort> sa3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LTieBoolFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aBool> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LTieByteFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aByte> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LTieCharFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aChar> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LTieDblFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aDouble> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LTieFltFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aFloat> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LTieIntFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aInt> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LTieLongFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aLong> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LTieSrtFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aShort> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2> void	LOiToIntFunction.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LTieBoolFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LTieByteFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LTieCharFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LTieDblFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LTieFltFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LTieIntFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LTieLongFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LTieSrtFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LToIntTriFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,C3,I3> void	LTieFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LToIntTriFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2> void	LToIntBiFunction.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LToIntTriFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3> void	LTieFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,C2,I2,C3,I3> void	LTieFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C0,I0> void	LToIntFunction.iterate(SequentialRead<C0,I0,aType.a<T>> sa, C0 source, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LTieBoolFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aBool> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LTieByteFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aByte> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LTieCharFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aChar> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LTieDblFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aDouble> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LTieFltFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aFloat> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LTieIntFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aInt> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LTieLongFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aLong> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LTieSrtFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aShort> ia3, C3 source3, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	LOiToIntFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LTieBoolFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LTieByteFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LTieCharFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LTieDblFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LTieFltFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LTieIntFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LTieLongFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LTieSrtFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LTieBoolFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LTieByteFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LTieCharFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LTieDblFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LTieFltFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LTieIntFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LTieLongFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LTieSrtFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	LOiToIntFunction.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, LIntConsumer 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	LTieBoolFunction.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, LIntConsumer 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	LTieByteFunction.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, LIntConsumer 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	LTieCharFunction.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, LIntConsumer 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	LTieDblFunction.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, LIntConsumer 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	LTieFltFunction.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, LIntConsumer 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	LTieIntFunction.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, LIntConsumer 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	LTieLongFunction.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, LIntConsumer 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	LTieSrtFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LToIntTriFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	LToIntBiFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LToIntTriFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3> void	LTieFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,C3,I3> void	LTieFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LToIntTriFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	LToIntBiFunction.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, LIntConsumer 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	LToIntTriFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2,C3> void	LTieFunction.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, LIntConsumer 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	LTieFunction.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, LIntConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.

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

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

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

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

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

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

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

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

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