Uses of Interface
eu.lunisolar.magma.func.consumer.primitives.obj.LTieConsumer

Packages that use LTieConsumer

Package	Description
eu.lunisolar.magma.func.consumer.primitives.obj
eu.lunisolar.magma.func.function.from
eu.lunisolar.magma.func.predicate

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

Subinterfaces of LTieConsumer in eu.lunisolar.magma.func.consumer.primitives.obj

Modifier and Type	Interface and Description
static interface	LTieConsumer.LInt1BiObj2Cons<T1,T2> Permutation of LTieConsumer for method references.
static interface	LTieConsumer.LInt1Obj2Obj0Cons<T2,T1> Permutation of LTieConsumer for method references.
static interface	LTieConsumer.LObj0Obj2Int1Cons<T1,T2> Permutation of LTieConsumer for method references.
static interface	LTieConsumer.LObj2Int1Obj0Cons<T2,T1> Permutation of LTieConsumer for method references.
static interface	LTieConsumer.LObj2Obj0Int1Cons<T2,T1> Permutation of LTieConsumer for method references.

Classes in eu.lunisolar.magma.func.consumer.primitives.obj that implement LTieConsumer

Modifier and Type	Class and Description
static class	LTieConsumer.LTieConsumerSingle<T1,T2>

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

Modifier and Type	Method and Description
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> LTieConsumer<T1,T2>	LTieConsumer.accept2nd(LIntConsumer 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 LTieConsumer<T1,T2>	LTieConsumer.andThen(LTieConsumer<? super T1,? super T2> after) Combines two LTieConsumer<T1,T2> together in a order.
default <V2,V3> LTieConsumer<V2,V3>	LTieConsumer.cast() Cast that replace generics.
static <V2,V3,T1,T2> LTieConsumer<V2,V3>	LTieConsumer.cast(LTieConsumer<T1,T2> function) Cast that replace generics.
default <V1,V3> LTieConsumer<V1,V3>	LTieConsumer.compose(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3) Allows to manipulate the domain of the function.
static <V1,V3,T1,T2> LTieConsumer<V1,V3>	LTieConsumer.composed(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3, LTieConsumer<T1,T2> after)
static <T1,T2> LTieConsumer<T1,T2>	LTieConsumer.failSafe(LTieConsumer<T1,T2> func, LTieConsumer<T1,T2> failSafe)
default LTieConsumer<T1,T2>	LTieConsumer.handling(HandlingInstructions<Throwable,RuntimeException> handling)
static <T1,T2> LTieConsumer<T1,T2>	LTieConsumer.recursive(LFunction<LTieConsumer<T1,T2>,LTieConsumer<T1,T2>> selfLambda)
static <T1,T2> LTieConsumer<T1,T2>	LTieConsumer.safe() Safe instance.
static <T1,T2> LTieConsumer<T1,T2>	LTieConsumer.safe(LTieConsumer<T1,T2> other) Safe wrapping.
static <T1,T2> LTieConsumer<T1,T2>	LTieConsumer.tieCons(LTieConsumer<T1,T2> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T1,T2> LTieConsumer<T1,T2>	LTieConsumer.tieConsThrowing(ExF<Throwable> exF)
static <T1,T2> LTieConsumer<T1,T2>	LTieConsumer.tieConsThrowing(String message, ExMF<Throwable> exF)
default LTieConsumer<T1,T2>	LTieConsumer.trying(ExWF<RuntimeException> exF)
default LTieConsumer<T1,T2>	LTieConsumer.trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LTieConsumer<T1,T2>	LTieConsumer.tryingThen(LConsumer<Throwable> handler)
static <T1,T2> LTieConsumer<T1,T2>	LTieConsumer.uncurry(LFunction<T1,LIntFunction<LConsumer<T2>>> func)
default LTieConsumer	LTieConsumer.untyped() Cast that removes generics.
LTieConsumer<T1,T2>	LTieConsumer.LTieConsumerSingle.value()

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

Modifier and Type	Method and Description
static <T1,T2> LSupplier<LTieConsumer<T1,T2>>	LTieConsumer.safeSupplier() Safe instance supplier.
static <T1,T2> LSupplier<LTieConsumer<T1,T2>>	LTieConsumer.safeSupplier(LSupplier<LTieConsumer<T1,T2>> supplier) Safe supplier.

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

Modifier and Type	Method and Description
default LTieConsumer<T1,T2>	LTieConsumer.andThen(LTieConsumer<? super T1,? super T2> after) Combines two LTieConsumer<T1,T2> together in a order.
static <T1,T2> void	LTieConsumer.call(T1 a1, int a2, T2 a3, LTieConsumer<T1,T2> lambda)
static <V2,V3,T1,T2> LTieConsumer<V2,V3>	LTieConsumer.cast(LTieConsumer<T1,T2> function) Cast that replace generics.
static <V1,V3,T1,T2> LTieConsumer<V1,V3>	LTieConsumer.composed(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3, LTieConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LTieConsumer.composed(LFunction<? super V1,? extends T1> before1, LToIntFunction<? super V2> before2, LFunction<? super V3,? extends T2> before3, LTieConsumer<T1,T2> after)
static <T1,T2> LTieConsumer<T1,T2>	LTieConsumer.failSafe(LTieConsumer<T1,T2> func, LTieConsumer<T1,T2> failSafe)
static <T1,T2> LTieConsumer<T1,T2>	LTieConsumer.failSafe(LTieConsumer<T1,T2> func, LTieConsumer<T1,T2> failSafe)
default void	LTieConsumer.failSafeAccept(T1 a1, int a2, T2 a3, LTieConsumer<T1,T2> failSafe)
static <T1,T2> void	LTieConsumer.failSafeAccept(T1 a1, int a2, T2 a3, LTieConsumer<T1,T2> func, LTieConsumer<T1,T2> failSafe)
static <T1,T2> void	LTieConsumer.failSafeAccept(T1 a1, int a2, T2 a3, LTieConsumer<T1,T2> func, LTieConsumer<T1,T2> failSafe)
static <C1,C2,C3,T1,T2> int	LTieConsumer.forEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.a<T2>> ia3, C3 source3, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T1,T2> void	LTieConsumer.fromTill(int min_a2, int max_a2, T1 a1, T2 a3, LTieConsumer<T1,T2> func) From-To.
static <T1,T2> void	LTieConsumer.fromTo(int min_a2, int max_a2, T1 a1, T2 a3, LTieConsumer<T1,T2> func) From-To.
static <T1,T2> void	LTieConsumer.handlingAccept(T1 a1, int a2, T2 a3, LTieConsumer<T1,T2> func, HandlingInstructions<Throwable,RuntimeException> handling)
static <C1,C3,T1,T2> int	LTieConsumer.indexedForEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C3,aType.a<T2>> ia3, C3 source3, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer (with index).
static <C1,C3,I3,T1,T2> int	LTieConsumer.indexedIterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C3,I3,aType.a<T2>> sa3, C3 source3, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer (with index).
static <C1,I1,C3,T1,T2> int	LTieConsumer.indexedIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C3,aType.a<T2>> ia3, C3 source3, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer (with index).
static <C1,I1,C3,I3,T1,T2> int	LTieConsumer.indexedIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C3,I3,aType.a<T2>> sa3, C3 source3, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer (with index).
static <C1,C2,C3,I3,T1,T2> int	LTieConsumer.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, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,C2,I2,C3,T1,T2> int	LTieConsumer.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, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,C2,I2,C3,I3,T1,T2> int	LTieConsumer.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, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,I1,C2,C3,T1,T2> int	LTieConsumer.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, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,I1,C2,C3,I3,T1,T2> int	LTieConsumer.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, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,I1,C2,I2,C3,T1,T2> int	LTieConsumer.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, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,I1,C2,I2,C3,I3,T1,T2> int	LTieConsumer.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, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T1,C3,T2> T1	LTieConsumer.ntiForEach(LIntFunction<T1> trgFactory1, IndexedRead<C3,aType.a<T2>> ia3, C3 source3, LTieConsumer<? super T1,? super T2> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH_NEW: FOR, [SourcePurpose{arg=T1 trg1, type=SIZE_FACTORY}, SourcePurpose{arg=T2 a3, type=IA}, SourcePurpose{arg=LTieConsumer<? super T1,? super T2> consumer, type=CONST}]
static <T1,C3,I3,T2> T1	LTieConsumer.ntiIterate(LSupplier<T1> source1, SequentialRead<C3,I3,aType.a<T2>> sa3, C3 source3, LTieConsumer<? super T1,? super T2> consumer) ITERATION: TARGETED_INDEXED_ITERATE_NEW: WHILE, [SourcePurpose{arg=T1 trg1, type=SUPPLIER}, SourcePurpose{arg=T2 a3, type=SA}, SourcePurpose{arg=LTieConsumer<? super T1,? super T2> consumer, type=CONST}]
static <T1,T2> LTieConsumer<T1,T2>	LTieConsumer.safe(LTieConsumer<T1,T2> other) Safe wrapping.
static <T1,C2,C3,T2> T1	LTieConsumer.targetedForEach(T1 a1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.a<T2>> ia3, C3 source3, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T1,C2,C3,I3,T2> T1	LTieConsumer.targetedIterate(T1 a1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.a<T2>> sa3, C3 source3, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T1,C2,I2,C3,T2> T1	LTieConsumer.targetedIterate(T1 a1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.a<T2>> ia3, C3 source3, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T1,C2,I2,C3,I3,T2> T1	LTieConsumer.targetedIterate(T1 a1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.a<T2>> sa3, C3 source3, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T1,T2> LTieConsumer<T1,T2>	LTieConsumer.tieCons(LTieConsumer<T1,T2> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T1,SRC,T2> int	LTieConsumer.tieForEach(int sStart, int sEnd, int tStart, T1 trg1, SRC src3, LOiFunction<SRC,T2> srcAcc3, LTieConsumer<? super T1,? super T2> consumer) ITERATION: TIE_CONSUMER: FOR, [SourcePurpose{arg=int sStart, type=CONST}, SourcePurpose{arg=int sEnd, type=CONST}, SourcePurpose{arg=int tStart, type=CONST}, SourcePurpose{arg=T1 trg1, type=CONST}, SourcePurpose{arg=T2 a3, type=TIE_SOURCE}, SourcePurpose{arg=T2 a3, type=TIE_SUPPLIER}, SourcePurpose{arg=LTieConsumer<? super T1,? super T2> consumer, type=CONST}]
static <T1,SRC,T2> int	LTieConsumer.tieForEach(int sStart, int tStart, T1 trg1, SRC src3, LPredicate<SRC> srcTest3, LFunction<SRC,T2> srcAcc3, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
static <T1,C3,T2> int	LTieConsumer.tieForEach(T1 trg1, IndexedRead<C3,aType.a<T2>> ia3, C3 source3, LTieConsumer<? super T1,? super T2> consumer) ITERATION: TIE_CONSUMER_SHORT: FOR, [SourcePurpose{arg=T1 trg1, type=CONST}, SourcePurpose{arg=T2 a3, type=IA}, SourcePurpose{arg=LTieConsumer<? super T1,? super T2> consumer, type=CONST}]
static <T1,C3,I3,T2> int	LTieConsumer.tieIterate(T1 trg1, SequentialRead<C3,I3,aType.a<T2>> sa3, C3 source3, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
static <T1,C3,T2> T1	LTieConsumer.tiForEach(T1 trg1, IndexedRead<C3,aType.a<T2>> ia3, C3 source3, LTieConsumer<? super T1,? super T2> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH: FOR, [SourcePurpose{arg=T1 trg1, type=CONST}, SourcePurpose{arg=T2 a3, type=IA}, SourcePurpose{arg=LTieConsumer<? super T1,? super T2> consumer, type=CONST}]
static <T1,C3,I3,T2> T1	LTieConsumer.tiIterate(T1 trg1, SequentialRead<C3,I3,aType.a<T2>> sa3, C3 source3, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
static <T1,T2> void	LTieConsumer.times(int max_a2, T1 a1, T2 a3, LTieConsumer<T1,T2> func) From-To.
static <T1,T2> void	LTieConsumer.tryAccept(T1 a1, int a2, T2 a3, LTieConsumer<T1,T2> func)
static <T1,T2> void	LTieConsumer.tryAccept(T1 a1, int a2, T2 a3, LTieConsumer<T1,T2> func, ExWF<RuntimeException> exF)
static <T1,T2> void	LTieConsumer.tryAccept(T1 a1, int a2, T2 a3, LTieConsumer<T1,T2> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static <T1,T2> void	LTieConsumer.tryAcceptThen(T1 a1, int a2, T2 a3, LTieConsumer<T1,T2> func, LConsumer<Throwable> handler)

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

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

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

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

Modifier and Type	Method and Description
default LTieConsumer<T1,T2>	LObjIntObjFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.

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

Modifier and Type	Method and Description
default LObjIntObjFunction<T1,T2,R>	LObjIntObjFunction.before(LTieConsumer<? super T1,? super T2> before)

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

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

Modifier and Type	Method and Description
static <T1,T2> boolean	LObjIntObjPredicate.doIf(T1 a1, int a2, T2 a3, LObjIntObjPredicate<T1,T2> predicate, LTieConsumer<? super T1,? super T2> consumer)
default boolean	LObjIntObjPredicate.doIf(T1 a1, int a2, T2 a3, LTieConsumer<? super T1,? super T2> consumer)
default <V> boolean	LPredicate.doIf(V a1, int a2, T a3, LTieConsumer<? super V,? super T> consumer)
default <V> boolean	LObjIntPredicate.doIf(V a1, int a2, T a3, LTieConsumer<? super V,? super T> consumer)
default <C1,C2,C3> void	LObjIntObjPredicate.filterForEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.a<T2>> ia3, C3 source3, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,C2,C3,I3> void	LObjIntObjPredicate.filterIterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.a<T2>> sa3, C3 source3, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,C2,I2,C3> void	LObjIntObjPredicate.filterIterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.a<T2>> ia3, C3 source3, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,C2,I2,C3,I3> void	LObjIntObjPredicate.filterIterate(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, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,I1,C2,C3> void	LObjIntObjPredicate.filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.a<T2>> ia3, C3 source3, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,I1,C2,C3,I3> void	LObjIntObjPredicate.filterIterate(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, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,I1,C2,I2,C3> void	LObjIntObjPredicate.filterIterate(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, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,I1,C2,I2,C3,I3> void	LObjIntObjPredicate.filterIterate(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, LTieConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <V,C0> int	LPredicate.tieForEach(V v, IndexedRead<C0,aType.a<T>> ia, C0 source, LTieConsumer<V,T> consumer) For each element (or tuple) from arguments, calls the consumer (with index) if predicate test passes.
default <V,C0,I0> int	LPredicate.tieIterate(V v, SequentialRead<C0,I0,aType.a<T>> sa, C0 source, LTieConsumer<V,T> consumer) For each element (or tuple) from arguments, calls the consumer (with index) if predicate test passes.