eu.lunisolar.magma.func.function.to

Interface LToSrtBiFunction<T1,T2>

All Superinterfaces:

Codomain<aType.aShort>, Domain, Domain2<aType.a<T1>,aType.a<T2>>, Formattable, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>

All Known Subinterfaces:

LToSrtBiFunction.LToSrtObj1Obj0Func<T2,T1>

All Known Implementing Classes:

LToSrtBiFunction.LToSrtBiFunctionSingle

@FunctionalInterface
public interface LToSrtBiFunction<T1,T2>
extends MetaFunction, MetaInterface.NonThrowing, Codomain<aType.aShort>, Domain2<aType.a<T1>,aType.a<T2>>

Non-throwing functional interface (lambda) LToSrtBiFunction for Java 8.

Type: function

Domain (lvl: 2): T1 a1,T2 a2

Co-domain: short

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LToSrtBiFunction.LToSrtBiFunctionSingle<T1,T2>
static interface	LToSrtBiFunction.LToSrtObj1Obj0Func<T2,T1> Permutation of LToSrtBiFunction for method references.

Nested classes/interfaces inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface

MetaInterface.NonThrowing, MetaInterface.Throwing<X>

Field Summary

Fields

Modifier and Type	Field and Description
static String	DESCRIPTION

Method Summary

Modifier and Type	Method and Description
static <T1,T2> LToSrtBiFunction<T1,T2>	apply1stAsSrt(LToSrtFunction<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LToSrtBiFunction<T1,T2>	apply2ndAsSrt(LToSrtFunction<T2> func) Captures single parameter function into this interface where only 2nd parameter will be used.
default short	applyAsSrt(T1 a1, T2 a2)
default short	applyAsSrt(T1 a1, T2 a2, ExWF<RuntimeException> exF)
default short	applyAsSrt(T1 a1, T2 a2, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default short	applyAsSrtThen(T1 a1, T2 a2, LToSrtFunction<Throwable> handler)
short	applyAsSrtX(T1 a1, T2 a2) Implement this, but call applyAsSrt(T1 a1,T2 a2)
static <T1,T2> short	call(T1 a1, T2 a2, LToSrtBiFunction<T1,T2> lambda)
default LSrtSupplier	capture(T1 a1, T2 a2) Captures arguments but delays the evaluation.
default <V2,V3> LToSrtBiFunction<V2,V3>	cast() Cast that replace generics.
static <V2,V3,T1,T2> LToSrtBiFunction<V2,V3>	cast(LToSrtBiFunction<T1,T2> function) Cast that replace generics.
default <V1,V2> LToSrtBiFunction<V1,V2>	compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
static <V1,V2,T1,T2> LToSrtBiFunction<V1,V2>	composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtBiFunction<T1,T2> after)
static <T1,T2> LToSrtBiFunction<T1,T2>	constant(short r) Creates function that always returns the same value.
static <T1,T2> LToSrtBiFunction<T1,T2>	failSafe(LToSrtBiFunction<T1,T2> func, LToSrtBiFunction<T1,T2> failSafe)
default short	failSafeApplyAsSrt(T1 a1, T2 a2, LToSrtBiFunction<T1,T2> failSafe)
static <T1,T2> short	failSafeApplyAsSrt(T1 a1, T2 a2, LToSrtBiFunction<T1,T2> func, LToSrtBiFunction<T1,T2> failSafe)
default <C1,C2> void	forEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, LSrtConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
static <T1,T2> void	fromTill(int min_i, int max_i, T1 a1, T2 a2, LToSrtBiFunction<T1,T2> func) From-To.
static <T1,T2> void	fromTo(int min_i, int max_i, T1 a1, T2 a2, LToSrtBiFunction<T1,T2> func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LToSrtBiFunction<T1,T2>	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default short	handlingApplyAsSrt(T1 a1, T2 a2, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static <T1,T2> short	handlingApplyAsSrt(T1 a1, T2 a2, LToSrtBiFunction<T1,T2> func, HandlingInstructions<Throwable,RuntimeException> handling)
default <C1,C2,I2> void	iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, LSrtConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, LSrtConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, LSrtConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default LToSrtFunction<T2>	lShrink(LFunction<T2,T1> left)
default LToSrtFunction<T2>	lShrinkc(T1 a1)
static <T2,T1> LToSrtFunction<T2>	lShrinked(LFunction<T2,T1> left, LToSrtBiFunction<T1,T2> func)
static <T2,T1> LToSrtFunction<T2>	lShrinkedc(T1 a1, LToSrtBiFunction<T1,T2> func)
default short	nestingApplyAsSrt(T1 a1, T2 a2) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default short	nonNullApplyAsSrt(T1 a1, T2 a2) Just to mirror the method: Ensures the result is not null
static <T1,T2> short	produceShort(T1 a1, T2 a2) Does nothing (LToSrtBiFunction) Function
static <T1,T2> LToSrtBiFunction<T1,T2>	recursive(LFunction<LToSrtBiFunction<T1,T2>,LToSrtBiFunction<T1,T2>> selfLambda)
default LToSrtFunction<T1>	rShrink(LFunction<T1,T2> right)
default LToSrtFunction<T1>	rShrinkc(T2 a2)
static <T1,T2> LToSrtFunction<T1>	rShrinked(LFunction<T1,T2> right, LToSrtBiFunction<T1,T2> func)
static <T1,T2> LToSrtFunction<T1>	rShrinkedc(T2 a2, LToSrtBiFunction<T1,T2> func)
static <T1,T2> LToSrtBiFunction<T1,T2>	safe() Safe instance.
static <T1,T2> LToSrtBiFunction<T1,T2>	safe(LToSrtBiFunction<T1,T2> other) Safe wrapping.
static <T1,T2> LSupplier<LToSrtBiFunction<T1,T2>>	safeSupplier() Safe instance supplier.
static <T1,T2> LSupplier<LToSrtBiFunction<T1,T2>>	safeSupplier(LSupplier<LToSrtBiFunction<T1,T2>> supplier) Safe supplier.
default short	shovingApplyAsSrt(T1 a1, T2 a2) Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
default <V> LBiFunction<T1,T2,V>	then(LSrtFunction<? extends V> after) Combines two functions together in a order.
default LBiPredicate<T1,T2>	thenToBool(LSrtPredicate after) Combines two functions together in a order.
default LToByteBiFunction<T1,T2>	thenToByte(LSrtToByteFunction after) Combines two functions together in a order.
default LToCharBiFunction<T1,T2>	thenToChar(LSrtToCharFunction after) Combines two functions together in a order.
default LToDblBiFunction<T1,T2>	thenToDbl(LSrtToDblFunction after) Combines two functions together in a order.
default LToFltBiFunction<T1,T2>	thenToFlt(LSrtToFltFunction after) Combines two functions together in a order.
default LToIntBiFunction<T1,T2>	thenToInt(LSrtToIntFunction after) Combines two functions together in a order.
default LToLongBiFunction<T1,T2>	thenToLong(LSrtToLongFunction after) Combines two functions together in a order.
default LToSrtBiFunction<T1,T2>	thenToSrt(LSrtUnaryOperator after) Combines two functions together in a order.
static <T1,T2> void	times(int max_i, T1 a1, T2 a2, LToSrtBiFunction<T1,T2> func) From-To.
static <T1,T2> LToSrtBiFunction<T1,T2>	toSrtBiFunc(LToSrtBiFunction<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> LToSrtBiFunction<T1,T2>	toSrtBiFuncThrowing(ExF<Throwable> exF)
static <T1,T2> LToSrtBiFunction<T1,T2>	toSrtBiFuncThrowing(String message, ExMF<Throwable> exF)
static <T2,T1> LToSrtBiFunction.LToSrtObj1Obj0Func<T2,T1>	toSrtObj1Obj0Func(LToSrtBiFunction.LToSrtObj1Obj0Func<T2,T1> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T1,T2> short	tryApplyAsSrt(T1 a1, T2 a2, LToSrtBiFunction<T1,T2> func)
static <T1,T2> short	tryApplyAsSrt(T1 a1, T2 a2, LToSrtBiFunction<T1,T2> func, ExWF<RuntimeException> exF)
static <T1,T2> short	tryApplyAsSrt(T1 a1, T2 a2, LToSrtBiFunction<T1,T2> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static <T1,T2> short	tryApplyAsSrtThen(T1 a1, T2 a2, LToSrtBiFunction<T1,T2> func, LToSrtFunction<Throwable> handler)
default LToSrtBiFunction<T1,T2>	trying(ExWF<RuntimeException> exF)
default LToSrtBiFunction<T1,T2>	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LToSrtBiFunction<T1,T2>	tryingThen(LToSrtFunction<Throwable> handler)
default short	tupleApplyAsSrt(LPair<T1,T2> args)
static <T1,T2> LToSrtBiFunction<T1,T2>	uncurry(LFunction<T1,LToSrtFunction<T2>> func)
default LToSrtBiFunction	untyped() Cast that removes generics.

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.type.MetaFunction

isFunction

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.MetaFunctionalInterface

formatTo, isAction, isConsumer, isOperator, isPredicate, isSupplier

Methods inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface.NonThrowing

isThrowing

Field Detail

DESCRIPTION

static final String DESCRIPTION

See Also:

Constant Field Values

Method Detail

applyAsSrt

default short applyAsSrt(T1 a1,
                         T2 a2)

applyAsSrtX

short applyAsSrtX(T1 a1,
                  T2 a2)
           throws Throwable

Implement this, but call applyAsSrt(T1 a1,T2 a2)

Throws:

Throwable

tupleApplyAsSrt

default short tupleApplyAsSrt(LPair<T1,T2> args)

handlingApplyAsSrt

default short handlingApplyAsSrt(T1 a1,
                                 T2 a2,
                                 HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

default LToSrtBiFunction<T1,T2> handling(HandlingInstructions<Throwable,RuntimeException> handling)

applyAsSrt

default short applyAsSrt(T1 a1,
                         T2 a2,
                         @Nonnull
                         ExWMF<RuntimeException> exF,
                         @Nonnull
                         String newMessage,
                         @Nullable
                         Object... messageParams)

trying

default LToSrtBiFunction<T1,T2> trying(@Nonnull
                                       ExWMF<RuntimeException> exF,
                                       @Nonnull
                                       String newMessage,
                                       @Nullable
                                       Object... messageParams)

applyAsSrt

default short applyAsSrt(T1 a1,
                         T2 a2,
                         @Nonnull
                         ExWF<RuntimeException> exF)

trying

default LToSrtBiFunction<T1,T2> trying(@Nonnull
                                       ExWF<RuntimeException> exF)

applyAsSrtThen

default short applyAsSrtThen(T1 a1,
                             T2 a2,
                             @Nonnull
                             LToSrtFunction<Throwable> handler)

tryingThen

default LToSrtBiFunction<T1,T2> tryingThen(@Nonnull
                                           LToSrtFunction<Throwable> handler)

nestingApplyAsSrt

default short nestingApplyAsSrt(T1 a1,
                                T2 a2)

Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.

shovingApplyAsSrt

default short shovingApplyAsSrt(T1 a1,
                                T2 a2)

Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.

handlingApplyAsSrt

static <T1,T2> short handlingApplyAsSrt(T1 a1,
                                        T2 a2,
                                        LToSrtBiFunction<T1,T2> func,
                                        HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsSrt

static <T1,T2> short tryApplyAsSrt(T1 a1,
                                   T2 a2,
                                   LToSrtBiFunction<T1,T2> func)

tryApplyAsSrt

static <T1,T2> short tryApplyAsSrt(T1 a1,
                                   T2 a2,
                                   LToSrtBiFunction<T1,T2> func,
                                   @Nonnull
                                   ExWMF<RuntimeException> exF,
                                   @Nonnull
                                   String newMessage,
                                   @Nullable
                                   Object... messageParams)

tryApplyAsSrt

static <T1,T2> short tryApplyAsSrt(T1 a1,
                                   T2 a2,
                                   LToSrtBiFunction<T1,T2> func,
                                   @Nonnull
                                   ExWF<RuntimeException> exF)

tryApplyAsSrtThen

static <T1,T2> short tryApplyAsSrtThen(T1 a1,
                                       T2 a2,
                                       LToSrtBiFunction<T1,T2> func,
                                       @Nonnull
                                       LToSrtFunction<Throwable> handler)

failSafeApplyAsSrt

default short failSafeApplyAsSrt(T1 a1,
                                 T2 a2,
                                 @Nonnull
                                 LToSrtBiFunction<T1,T2> failSafe)

failSafeApplyAsSrt

static <T1,T2> short failSafeApplyAsSrt(T1 a1,
                                        T2 a2,
                                        LToSrtBiFunction<T1,T2> func,
                                        @Nonnull
                                        LToSrtBiFunction<T1,T2> failSafe)

failSafe

static <T1,T2> LToSrtBiFunction<T1,T2> failSafe(LToSrtBiFunction<T1,T2> func,
                                                @Nonnull
                                                LToSrtBiFunction<T1,T2> failSafe)

nonNullApplyAsSrt

default short nonNullApplyAsSrt(T1 a1,
                                T2 a2)

Just to mirror the method: Ensures the result is not null

functionalInterfaceDescription

@Nonnull
default String functionalInterfaceDescription()

Returns description of the functional interface.

Specified by:

functionalInterfaceDescription in interface MetaFunctionalInterface

fromTo

static <T1,T2> void fromTo(int min_i,
                           int max_i,
                           T1 a1,
                           T2 a2,
                           LToSrtBiFunction<T1,T2> func)

From-To. Intended to be used with non-capturing lambda.

fromTill

static <T1,T2> void fromTill(int min_i,
                             int max_i,
                             T1 a1,
                             T2 a2,
                             LToSrtBiFunction<T1,T2> func)

From-To. Intended to be used with non-capturing lambda.

times

static <T1,T2> void times(int max_i,
                          T1 a1,
                          T2 a2,
                          LToSrtBiFunction<T1,T2> func)

From-To. Intended to be used with non-capturing lambda.

lShrink

default LToSrtFunction<T2> lShrink(LFunction<T2,T1> left)

lShrinkc

default LToSrtFunction<T2> lShrinkc(T1 a1)

lShrinked

static <T2,T1> LToSrtFunction<T2> lShrinked(LFunction<T2,T1> left,
                                            LToSrtBiFunction<T1,T2> func)

lShrinkedc

static <T2,T1> LToSrtFunction<T2> lShrinkedc(T1 a1,
                                             LToSrtBiFunction<T1,T2> func)

rShrink

default LToSrtFunction<T1> rShrink(LFunction<T1,T2> right)

rShrinkc

default LToSrtFunction<T1> rShrinkc(T2 a2)

rShrinked

static <T1,T2> LToSrtFunction<T1> rShrinked(LFunction<T1,T2> right,
                                            LToSrtBiFunction<T1,T2> func)

rShrinkedc

static <T1,T2> LToSrtFunction<T1> rShrinkedc(T2 a2,
                                             LToSrtBiFunction<T1,T2> func)

uncurry

static <T1,T2> LToSrtBiFunction<T1,T2> uncurry(LFunction<T1,LToSrtFunction<T2>> func)

untyped

default LToSrtBiFunction untyped()

Cast that removes generics.

cast

default <V2,V3> LToSrtBiFunction<V2,V3> cast()

Cast that replace generics.

cast

static <V2,V3,T1,T2> LToSrtBiFunction<V2,V3> cast(LToSrtBiFunction<T1,T2> function)

Cast that replace generics.

capture

default LSrtSupplier capture(T1 a1,
                             T2 a2)

Captures arguments but delays the evaluation.

constant

static <T1,T2> LToSrtBiFunction<T1,T2> constant(short r)

Creates function that always returns the same value.

apply1stAsSrt

@Nonnull
static <T1,T2> LToSrtBiFunction<T1,T2> apply1stAsSrt(@Nonnull
                                                               LToSrtFunction<T1> func)

Captures single parameter function into this interface where only 1st parameter will be used.

apply2ndAsSrt

@Nonnull
static <T1,T2> LToSrtBiFunction<T1,T2> apply2ndAsSrt(@Nonnull
                                                               LToSrtFunction<T2> func)

Captures single parameter function into this interface where only 2nd parameter will be used.

toSrtBiFunc

@Nonnull
static <T1,T2> LToSrtBiFunction<T1,T2> toSrtBiFunc(@Nonnull
                                                             LToSrtBiFunction<T1,T2> lambda)

Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).

recursive

@Nonnull
static <T1,T2> LToSrtBiFunction<T1,T2> recursive(@Nonnull
                                                           LFunction<LToSrtBiFunction<T1,T2>,LToSrtBiFunction<T1,T2>> selfLambda)

toSrtBiFuncThrowing

@Nonnull
static <T1,T2> LToSrtBiFunction<T1,T2> toSrtBiFuncThrowing(@Nonnull
                                                                     ExF<Throwable> exF)

toSrtBiFuncThrowing

@Nonnull
static <T1,T2> LToSrtBiFunction<T1,T2> toSrtBiFuncThrowing(String message,
                                                                     @Nonnull
                                                                     ExMF<Throwable> exF)

toSrtObj1Obj0Func

@Nonnull
static <T2,T1> LToSrtBiFunction.LToSrtObj1Obj0Func<T2,T1> toSrtObj1Obj0Func(@Nonnull
                                                                                      LToSrtBiFunction.LToSrtObj1Obj0Func<T2,T1> lambda)

Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).

call

static <T1,T2> short call(T1 a1,
                          T2 a2,
                          @Nonnull
                          LToSrtBiFunction<T1,T2> lambda)

safe

@Nonnull
static <T1,T2> LToSrtBiFunction<T1,T2> safe()

Safe instance. That always returns the same value (as produceShort).

safeSupplier

@Nonnull
static <T1,T2> LSupplier<LToSrtBiFunction<T1,T2>> safeSupplier()

Safe instance supplier. Returns supplier of safe() instance.

safe

@Nonnull
static <T1,T2> LToSrtBiFunction<T1,T2> safe(@Nullable
                                                      LToSrtBiFunction<T1,T2> other)

Safe wrapping. Either argument function is returned (if it is not null) or safe() instance.

safeSupplier

@Nonnull
static <T1,T2> LSupplier<LToSrtBiFunction<T1,T2>> safeSupplier(@Nullable
                                                                         LSupplier<LToSrtBiFunction<T1,T2>> supplier)

Safe supplier. Either argument supplier is returned (if it is not null) or supplier of safe() instance.

compose

@Nonnull
default <V1,V2> LToSrtBiFunction<V1,V2> compose(@Nonnull
                                                          LFunction<? super V1,? extends T1> before1,
                                                          @Nonnull
                                                          LFunction<? super V2,? extends T2> before2)

Allows to manipulate the domain of the function.

composed

static <V1,V2,T1,T2> LToSrtBiFunction<V1,V2> composed(@Nonnull
                                                      LFunction<? super V1,? extends T1> before1,
                                                      @Nonnull
                                                      LFunction<? super V2,? extends T2> before2,
                                                      LToSrtBiFunction<T1,T2> after)

then

@Nonnull
default <V> LBiFunction<T1,T2,V> then(@Nonnull
                                                LSrtFunction<? extends V> after)

Combines two functions together in a order.

thenToByte

@Nonnull
default LToByteBiFunction<T1,T2> thenToByte(@Nonnull
                                                      LSrtToByteFunction after)

Combines two functions together in a order.

thenToSrt

@Nonnull
default LToSrtBiFunction<T1,T2> thenToSrt(@Nonnull
                                                    LSrtUnaryOperator after)

Combines two functions together in a order.

thenToInt

@Nonnull
default LToIntBiFunction<T1,T2> thenToInt(@Nonnull
                                                    LSrtToIntFunction after)

Combines two functions together in a order.

thenToLong

@Nonnull
default LToLongBiFunction<T1,T2> thenToLong(@Nonnull
                                                      LSrtToLongFunction after)

Combines two functions together in a order.

thenToFlt

@Nonnull
default LToFltBiFunction<T1,T2> thenToFlt(@Nonnull
                                                    LSrtToFltFunction after)

Combines two functions together in a order.

thenToDbl

@Nonnull
default LToDblBiFunction<T1,T2> thenToDbl(@Nonnull
                                                    LSrtToDblFunction after)

Combines two functions together in a order.

thenToChar

@Nonnull
default LToCharBiFunction<T1,T2> thenToChar(@Nonnull
                                                      LSrtToCharFunction after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LBiPredicate<T1,T2> thenToBool(@Nonnull
                                                 LSrtPredicate after)

Combines two functions together in a order.

produceShort

static <T1,T2> short produceShort(T1 a1,
                                  T2 a2)

Does nothing (LToSrtBiFunction) Function

forEach

default <C1,C2> void forEach(IndexedRead<C1,aType.a<T1>> ia1,
                             C1 source1,
                             IndexedRead<C2,aType.a<T2>> ia2,
                             C2 source2,
                             LSrtConsumer consumer)

For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method is not expected.

iterate

default <C1,I1,C2> void iterate(SequentialRead<C1,I1,aType.a<T1>> sa1,
                                C1 source1,
                                IndexedRead<C2,aType.a<T2>> ia2,
                                C2 source2,
                                LSrtConsumer consumer)

For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method is not expected.

iterate

default <C1,C2,I2> void iterate(IndexedRead<C1,aType.a<T1>> ia1,
                                C1 source1,
                                SequentialRead<C2,I2,aType.a<T2>> sa2,
                                C2 source2,
                                LSrtConsumer consumer)

For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method is not expected.

iterate

default <C1,I1,C2,I2> void iterate(SequentialRead<C1,I1,aType.a<T1>> sa1,
                                   C1 source1,
                                   SequentialRead<C2,I2,aType.a<T2>> sa2,
                                   C2 source2,
                                   LSrtConsumer consumer)

For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method depends highly on the arguments.