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

Packages that use LBiConsumer

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

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

Subinterfaces of LBiConsumer in eu.lunisolar.magma.func.consumer

Modifier and Type	Interface and Description
static interface	LBiConsumer.LObj1Obj0Cons<T2,T1> Permutation of LBiConsumer for method references.

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

Modifier and Type	Class and Description
static class	LBiConsumer.LBiConsumerSingle<T1,T2>

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

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> LBiConsumer<T1,T2>	LBiConsumer.accept2nd(LConsumer<T2> func) Captures single parameter function into this interface where only 2nd parameter will be used.
default LBiConsumer<T1,T2>	LBiConsumer.andThen(LBiConsumer<? super T1,? super T2> after) Combines two LBiConsumer<T1,T2> together in a order.
static <T1,T2> LBiConsumer<T1,T2>	LBiConsumer.biCons(LBiConsumer<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> LBiConsumer<T1,T2>	LBiConsumer.biConsThrowing(ExF<Throwable> exF)
static <T1,T2> LBiConsumer<T1,T2>	LBiConsumer.biConsThrowing(String message, ExMF<Throwable> exF)
default <V2,V3> LBiConsumer<V2,V3>	LBiConsumer.cast() Cast that replace generics.
static <V2,V3,T1,T2> LBiConsumer<V2,V3>	LBiConsumer.cast(LBiConsumer<T1,T2> function) Cast that replace generics.
default <V1,V2> LBiConsumer<V1,V2>	LBiConsumer.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> LBiConsumer<V1,V2>	LBiConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LBiConsumer<T1,T2> after)
static <T1,T2> LBiConsumer<T1,T2>	LBiConsumer.failSafe(LBiConsumer<T1,T2> func, LBiConsumer<T1,T2> failSafe)
default LBiConsumer<T1,T2>	LBiConsumer.handling(HandlingInstructions<Throwable,RuntimeException> handling)
default LBiConsumer<T2,T3>	LTriConsumer.lShrink(LBiFunction<T2,T3,T1> left)
default LBiConsumer<T2,T3>	LTriConsumer.lShrinkc(T1 a1)
static <T2,T3,T1> LBiConsumer<T2,T3>	LTriConsumer.lShrinked(LBiFunction<T2,T3,T1> left, LTriConsumer<T1,T2,T3> func)
static <T2,T3,T1> LBiConsumer<T2,T3>	LTriConsumer.lShrinkedc(T1 a1, LTriConsumer<T1,T2,T3> func)
static <T1,T2> LBiConsumer<T1,T2>	LBiConsumer.recursive(LFunction<LBiConsumer<T1,T2>,LBiConsumer<T1,T2>> selfLambda)
default LBiConsumer<T1,T2>	LTriConsumer.rShrink(LBiFunction<T1,T2,T3> right)
default LBiConsumer<T1,T2>	LTriConsumer.rShrinkc(T3 a3)
static <T1,T2,T3> LBiConsumer<T1,T2>	LTriConsumer.rShrinked(LBiFunction<T1,T2,T3> right, LTriConsumer<T1,T2,T3> func)
static <T1,T2,T3> LBiConsumer<T1,T2>	LTriConsumer.rShrinkedc(T3 a3, LTriConsumer<T1,T2,T3> func)
static <T1,T2> LBiConsumer<T1,T2>	LBiConsumer.safe() Safe instance.
static <T1,T2> LBiConsumer<T1,T2>	LBiConsumer.safe(LBiConsumer<T1,T2> other) Safe wrapping.
default LBiConsumer<T1,T2>	LBiConsumer.trying(ExWF<RuntimeException> exF)
default LBiConsumer<T1,T2>	LBiConsumer.trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LBiConsumer<T1,T2>	LBiConsumer.tryingThen(LConsumer<Throwable> handler)
static <T1,T2> LBiConsumer<T1,T2>	LBiConsumer.uncurry(LFunction<T1,LConsumer<T2>> func)
default LBiConsumer	LBiConsumer.untyped() Cast that removes generics.
LBiConsumer<T1,T2>	LBiConsumer.LBiConsumerSingle.value()
static <T1,T2> LBiConsumer<T1,T2>	LBiConsumer.wrap(java.util.function.BiConsumer<T1,T2> other) Wraps JRE instance.

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

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

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

Modifier and Type	Method and Description
default LBiConsumer<T1,T2>	LBiConsumer.andThen(LBiConsumer<? super T1,? super T2> after) Combines two LBiConsumer<T1,T2> together in a order.
static <T1,T2> LBiConsumer<T1,T2>	LBiConsumer.biCons(LBiConsumer<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> void	LBiConsumer.call(T1 a1, T2 a2, LBiConsumer<T1,T2> lambda)
static <V2,V3,T1,T2> LBiConsumer<V2,V3>	LBiConsumer.cast(LBiConsumer<T1,T2> function) Cast that replace generics.
static <V1,V2,T1,T2> LBiConsumer<V1,V2>	LBiConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LBiConsumer<T1,T2> after)
static <T1,T2> LBiConsumer<T1,T2>	LBiConsumer.failSafe(LBiConsumer<T1,T2> func, LBiConsumer<T1,T2> failSafe)
static <T1,T2> LBiConsumer<T1,T2>	LBiConsumer.failSafe(LBiConsumer<T1,T2> func, LBiConsumer<T1,T2> failSafe)
default void	LBiConsumer.failSafeAccept(T1 a1, T2 a2, LBiConsumer<T1,T2> failSafe)
static <T1,T2> void	LBiConsumer.failSafeAccept(T1 a1, T2 a2, LBiConsumer<T1,T2> func, LBiConsumer<T1,T2> failSafe)
static <T1,T2> void	LBiConsumer.failSafeAccept(T1 a1, T2 a2, LBiConsumer<T1,T2> func, LBiConsumer<T1,T2> failSafe)
static <C1,C2,T1,T2> int	LBiConsumer.forEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, LBiConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T1,T2> void	LBiConsumer.fromTill(int min_i, int max_i, T1 a1, T2 a2, LBiConsumer<T1,T2> func) From-To.
static <T1,T2> void	LBiConsumer.fromTo(int min_i, int max_i, T1 a1, T2 a2, LBiConsumer<T1,T2> func) From-To.
static <T1,T2> void	LBiConsumer.handlingAccept(T1 a1, T2 a2, LBiConsumer<T1,T2> func, HandlingInstructions<Throwable,RuntimeException> handling)
static <C1,C2,I2,T1,T2> int	LBiConsumer.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, LBiConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,I1,C2,T1,T2> int	LBiConsumer.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, LBiConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,I1,C2,I2,T1,T2> int	LBiConsumer.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, LBiConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer.
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 <C,T1,T2> int	LBiConsumer.pairForEach(IndexedRead<C,aType.a<? extends Object>> ia, C s, LBiConsumer<T1,T2> consumer)
static <C,I,T1,T2> int	LBiConsumer.pairIterate(SequentialRead<C,I,aType.a<? extends Object>> sa, C s, LBiConsumer<T1,T2> consumer)
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 <T1,T2> LBiConsumer<T1,T2>	LBiConsumer.safe(LBiConsumer<T1,T2> other) Safe wrapping.
static <T1,C2,T2> T1	LBiConsumer.targetedForEach(T1 a1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, LBiConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T1,C2,I2,T2> T1	LBiConsumer.targetedIterate(T1 a1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, LBiConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T1,T2> void	LBiConsumer.times(int max_i, T1 a1, T2 a2, LBiConsumer<T1,T2> func) From-To.
static <T1,T2> void	LBiConsumer.tryAccept(T1 a1, T2 a2, LBiConsumer<T1,T2> func)
static <T1,T2> void	LBiConsumer.tryAccept(T1 a1, T2 a2, LBiConsumer<T1,T2> func, ExWF<RuntimeException> exF)
static <T1,T2> void	LBiConsumer.tryAccept(T1 a1, T2 a2, LBiConsumer<T1,T2> 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)

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

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

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

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

Modifier and Type	Method and Description
default <V1,V2> LBiConsumer<V1,V2>	LBiBoolConsumer.biBoolConsCompose(LPredicate<? super V1> before1, LPredicate<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LBiByteConsumer.biByteConsCompose(LToByteFunction<? super V1> before1, LToByteFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LBiCharConsumer.biCharConsCompose(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LBiDblConsumer.biDblConsCompose(LToDblFunction<? super V1> before1, LToDblFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LBiFltConsumer.biFltConsCompose(LToFltFunction<? super V1> before1, LToFltFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LBiIntConsumer.biIntConsCompose(LToIntFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LBiLongConsumer.biLongConsCompose(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LBiSrtConsumer.biSrtConsCompose(LToSrtFunction<? super V1> before1, LToSrtFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LBoolIntConsumer.boolIntConsCompose(LPredicate<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LByteIntConsumer.byteIntConsCompose(LToByteFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LCharIntConsumer.charIntConsCompose(LToCharFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
static <V1,V2> LBiConsumer<V1,V2>	LBiBoolConsumer.composed(LPredicate<? super V1> before1, LPredicate<? super V2> before2, LBiBoolConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LBoolIntConsumer.composed(LPredicate<? super V1> before1, LToIntFunction<? super V2> before2, LBoolIntConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LBiByteConsumer.composed(LToByteFunction<? super V1> before1, LToByteFunction<? super V2> before2, LBiByteConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LByteIntConsumer.composed(LToByteFunction<? super V1> before1, LToIntFunction<? super V2> before2, LByteIntConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LBiCharConsumer.composed(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2, LBiCharConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LCharIntConsumer.composed(LToCharFunction<? super V1> before1, LToIntFunction<? super V2> before2, LCharIntConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LBiDblConsumer.composed(LToDblFunction<? super V1> before1, LToDblFunction<? super V2> before2, LBiDblConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LDblIntConsumer.composed(LToDblFunction<? super V1> before1, LToIntFunction<? super V2> before2, LDblIntConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LBiFltConsumer.composed(LToFltFunction<? super V1> before1, LToFltFunction<? super V2> before2, LBiFltConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LFltIntConsumer.composed(LToFltFunction<? super V1> before1, LToIntFunction<? super V2> before2, LFltIntConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LBiIntConsumer.composed(LToIntFunction<? super V1> before1, LToIntFunction<? super V2> before2, LBiIntConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LLongIntConsumer.composed(LToLongFunction<? super V1> before1, LToIntFunction<? super V2> before2, LLongIntConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LBiLongConsumer.composed(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2, LBiLongConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LSrtIntConsumer.composed(LToSrtFunction<? super V1> before1, LToIntFunction<? super V2> before2, LSrtIntConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LBiSrtConsumer.composed(LToSrtFunction<? super V1> before1, LToSrtFunction<? super V2> before2, LBiSrtConsumer after)
default <V1,V2> LBiConsumer<V1,V2>	LDblIntConsumer.dblIntConsCompose(LToDblFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LFltIntConsumer.fltIntConsCompose(LToFltFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LLongIntConsumer.longIntConsCompose(LToLongFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LSrtIntConsumer.srtIntConsCompose(LToSrtFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.

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

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

Modifier and Type	Method and Description
static <V1,V2,T> LBiConsumer<V1,V2>	LObjBoolConsumer.composed(LFunction<? super V1,? extends T> before1, LPredicate<? super V2> before2, LObjBoolConsumer<T> after)
static <V1,V2,T> LBiConsumer<V1,V2>	LObjByteConsumer.composed(LFunction<? super V1,? extends T> before1, LToByteFunction<? super V2> before2, LObjByteConsumer<T> after)
static <V1,V2,T> LBiConsumer<V1,V2>	LObjCharConsumer.composed(LFunction<? super V1,? extends T> before1, LToCharFunction<? super V2> before2, LObjCharConsumer<T> after)
static <V1,V2,T> LBiConsumer<V1,V2>	LObjDblConsumer.composed(LFunction<? super V1,? extends T> before1, LToDblFunction<? super V2> before2, LObjDblConsumer<T> after)
static <V1,V2,T> LBiConsumer<V1,V2>	LObjFltConsumer.composed(LFunction<? super V1,? extends T> before1, LToFltFunction<? super V2> before2, LObjFltConsumer<T> after)
static <V1,V2,T> LBiConsumer<V1,V2>	LObjIntConsumer.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LObjIntConsumer<T> after)
static <V1,V2,T> LBiConsumer<V1,V2>	LObjLongConsumer.composed(LFunction<? super V1,? extends T> before1, LToLongFunction<? super V2> before2, LObjLongConsumer<T> after)
static <V1,V2,T> LBiConsumer<V1,V2>	LObjSrtConsumer.composed(LFunction<? super V1,? extends T> before1, LToSrtFunction<? super V2> before2, LObjSrtConsumer<T> after)
default <V1,V2> LBiConsumer<V1,V2>	LObjBoolConsumer.objBoolConsCompose(LFunction<? super V1,? extends T> before1, LPredicate<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LObjByteConsumer.objByteConsCompose(LFunction<? super V1,? extends T> before1, LToByteFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LObjCharConsumer.objCharConsCompose(LFunction<? super V1,? extends T> before1, LToCharFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LObjDblConsumer.objDblConsCompose(LFunction<? super V1,? extends T> before1, LToDblFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LObjFltConsumer.objFltConsCompose(LFunction<? super V1,? extends T> before1, LToFltFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LObjIntConsumer.objIntConsCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LObjLongConsumer.objLongConsCompose(LFunction<? super V1,? extends T> before1, LToLongFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LObjSrtConsumer.objSrtConsCompose(LFunction<? super V1,? extends T> before1, LToSrtFunction<? super V2> before2) Allows to manipulate the domain of the function.
default LBiConsumer<T1,T2>	LBiObjBoolConsumer.rShrink(LBiPredicate<T1,T2> right)
default LBiConsumer<T1,T2>	LBiObjByteConsumer.rShrink(LToByteBiFunction<T1,T2> right)
default LBiConsumer<T1,T2>	LBiObjCharConsumer.rShrink(LToCharBiFunction<T1,T2> right)
default LBiConsumer<T1,T2>	LBiObjDblConsumer.rShrink(LToDblBiFunction<T1,T2> right)
default LBiConsumer<T1,T2>	LBiObjFltConsumer.rShrink(LToFltBiFunction<T1,T2> right)
default LBiConsumer<T1,T2>	LBiObjIntConsumer.rShrink(LToIntBiFunction<T1,T2> right)
default LBiConsumer<T1,T2>	LBiObjLongConsumer.rShrink(LToLongBiFunction<T1,T2> right)
default LBiConsumer<T1,T2>	LBiObjSrtConsumer.rShrink(LToSrtBiFunction<T1,T2> right)
default LBiConsumer<T1,T2>	LBiObjBoolConsumer.rShrinkc(boolean a3)
default LBiConsumer<T1,T2>	LBiObjByteConsumer.rShrinkc(byte a3)
default LBiConsumer<T1,T2>	LBiObjCharConsumer.rShrinkc(char a3)
default LBiConsumer<T1,T2>	LBiObjDblConsumer.rShrinkc(double a3)
default LBiConsumer<T1,T2>	LBiObjFltConsumer.rShrinkc(float a3)
default LBiConsumer<T1,T2>	LBiObjIntConsumer.rShrinkc(int a3)
default LBiConsumer<T1,T2>	LBiObjLongConsumer.rShrinkc(long a3)
default LBiConsumer<T1,T2>	LBiObjSrtConsumer.rShrinkc(short a3)
static <T1,T2> LBiConsumer<T1,T2>	LBiObjBoolConsumer.rShrinked(LBiPredicate<T1,T2> right, LBiObjBoolConsumer<T1,T2> func)
static <T1,T2> LBiConsumer<T1,T2>	LBiObjByteConsumer.rShrinked(LToByteBiFunction<T1,T2> right, LBiObjByteConsumer<T1,T2> func)
static <T1,T2> LBiConsumer<T1,T2>	LBiObjCharConsumer.rShrinked(LToCharBiFunction<T1,T2> right, LBiObjCharConsumer<T1,T2> func)
static <T1,T2> LBiConsumer<T1,T2>	LBiObjDblConsumer.rShrinked(LToDblBiFunction<T1,T2> right, LBiObjDblConsumer<T1,T2> func)
static <T1,T2> LBiConsumer<T1,T2>	LBiObjFltConsumer.rShrinked(LToFltBiFunction<T1,T2> right, LBiObjFltConsumer<T1,T2> func)
static <T1,T2> LBiConsumer<T1,T2>	LBiObjIntConsumer.rShrinked(LToIntBiFunction<T1,T2> right, LBiObjIntConsumer<T1,T2> func)
static <T1,T2> LBiConsumer<T1,T2>	LBiObjLongConsumer.rShrinked(LToLongBiFunction<T1,T2> right, LBiObjLongConsumer<T1,T2> func)
static <T1,T2> LBiConsumer<T1,T2>	LBiObjSrtConsumer.rShrinked(LToSrtBiFunction<T1,T2> right, LBiObjSrtConsumer<T1,T2> func)
static <T1,T2> LBiConsumer<T1,T2>	LBiObjBoolConsumer.rShrinkedc(boolean a3, LBiObjBoolConsumer<T1,T2> func)
static <T1,T2> LBiConsumer<T1,T2>	LBiObjByteConsumer.rShrinkedc(byte a3, LBiObjByteConsumer<T1,T2> func)
static <T1,T2> LBiConsumer<T1,T2>	LBiObjCharConsumer.rShrinkedc(char a3, LBiObjCharConsumer<T1,T2> func)
static <T1,T2> LBiConsumer<T1,T2>	LBiObjDblConsumer.rShrinkedc(double a3, LBiObjDblConsumer<T1,T2> func)
static <T1,T2> LBiConsumer<T1,T2>	LBiObjFltConsumer.rShrinkedc(float a3, LBiObjFltConsumer<T1,T2> func)
static <T1,T2> LBiConsumer<T1,T2>	LBiObjIntConsumer.rShrinkedc(int a3, LBiObjIntConsumer<T1,T2> func)
static <T1,T2> LBiConsumer<T1,T2>	LBiObjLongConsumer.rShrinkedc(long a3, LBiObjLongConsumer<T1,T2> func)
static <T1,T2> LBiConsumer<T1,T2>	LBiObjSrtConsumer.rShrinkedc(short a3, LBiObjSrtConsumer<T1,T2> func)

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

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

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

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

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

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

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

Modifier and Type	Method and Description
default boolean	LBiPredicate.doIf(T1 a1, T2 a2, LBiConsumer<? super T1,? super T2> consumer)
static <T1,T2> boolean	LBiPredicate.doIf(T1 a1, T2 a2, LBiPredicate<T1,T2> predicate, LBiConsumer<? super T1,? super T2> consumer)
default <V> boolean	LPredicate.doIf(V a1, T a2, LBiConsumer<V,? super T> consumer)
default <C1,C2> void	LBiPredicate.filterForEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, LBiConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,C2,I2> void	LBiPredicate.filterIterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, LBiConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,I1,C2> void	LBiPredicate.filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, LBiConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,I1,C2,I2> void	LBiPredicate.filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, LBiConsumer<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.