LBiObjIntConsumer (magma-func 2.0.0 API)

All Superinterfaces:

Codomain<aType.aVoid>, Domain, Domain3<aType.a<T1>,aType.a<T2>,aType.aInt>, Formattable, MetaConsumer, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>

All Known Subinterfaces:

LBiObjIntConsumer.LInt2Obj0Obj1Cons<T1,T2>, LBiObjIntConsumer.LInt2Obj1Obj0Cons<T2,T1>, LBiObjIntConsumer.LObj0Int2Obj1Cons<T1,T2>, LBiObjIntConsumer.LObj1Int2Obj0Cons<T2,T1>, LBiObjIntConsumer.LObj1Obj0Int2Cons<T2,T1>

All Known Implementing Classes:

LBiObjIntConsumer.LBiObjIntConsumerSingle
```
@FunctionalInterface
public interface LBiObjIntConsumer<T1,T2>
extends MetaConsumer, MetaInterface.NonThrowing, Codomain<aType.aVoid>, Domain3<aType.a<T1>,aType.a<T2>,aType.aInt>
```
Non-throwing functional interface (lambda) LBiObjIntConsumer for Java 8.
Type: consumer
Domain (lvl: 3): T1 a1,T2 a2,int a3
Co-domain: none

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static class`	`LBiObjIntConsumer.LBiObjIntConsumerSingle<T1,T2>`
`static interface`	`LBiObjIntConsumer.LInt2Obj0Obj1Cons<T1,T2>` Permutation of LBiObjIntConsumer for method references.
`static interface`	`LBiObjIntConsumer.LInt2Obj1Obj0Cons<T2,T1>` Permutation of LBiObjIntConsumer for method references.
`static interface`	`LBiObjIntConsumer.LObj0Int2Obj1Cons<T1,T2>` Permutation of LBiObjIntConsumer for method references.
`static interface`	`LBiObjIntConsumer.LObj1Int2Obj0Cons<T2,T1>` Permutation of LBiObjIntConsumer for method references.
`static interface`	`LBiObjIntConsumer.LObj1Obj0Int2Cons<T2,T1>` Permutation of LBiObjIntConsumer 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

Fields
Modifier and Type	Field and Description
`static String`	`DESCRIPTION`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default void`	`accept(T1 a1, T2 a2, int a3)`
`default void`	`accept(T1 a1, T2 a2, int a3, ExWF<RuntimeException> exF)`
`default void`	`accept(T1 a1, T2 a2, int a3, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static <T1,T2> LBiObjIntConsumer<T1,T2>`	`accept1st(LConsumer<T1> func)` Captures single parameter function into this interface where only 1st parameter will be used.
`static <T1,T2> LBiObjIntConsumer<T1,T2>`	`accept2nd(LConsumer<T2> func)` Captures single parameter function into this interface where only 2nd parameter will be used.
`static <T1,T2> LBiObjIntConsumer<T1,T2>`	`accept3rd(LIntConsumer func)` Captures single parameter function into this interface where only 3rd parameter will be used.
`default void`	`acceptThen(T1 a1, T2 a2, int a3, LConsumer<Throwable> handler)`
`void`	`acceptX(T1 a1, T2 a2, int a3)` Implement this, but call accept(T1 a1,T2 a2,int a3)
`default LBiObjIntConsumer<T1,T2>`	`andThen(LBiObjIntConsumer<? super T1,? super T2> after)` Combines two LBiObjIntConsumer<T1,T2> together in a order.
`static <T1,T2> LBiObjIntConsumer<T1,T2>`	`biObjIntCons(LBiObjIntConsumer<T1,T2> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`default <V1,V2,V3> LTriConsumer<V1,V2,V3>`	`biObjIntConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToIntFunction<? super V3> before3)` Allows to manipulate the domain of the function.
`static <T1,T2> LBiObjIntConsumer<T1,T2>`	`biObjIntConsThrowing(ExF<Throwable> exF)`
`static <T1,T2> LBiObjIntConsumer<T1,T2>`	`biObjIntConsThrowing(String message, ExMF<Throwable> exF)`
`static <T1,T2> void`	`call(T1 a1, T2 a2, int a3, LBiObjIntConsumer<T1,T2> lambda)`
`default LAction`	`capture(T1 a1, T2 a2, int a3)` Captures arguments but delays the evaluation.
`default <V2,V3> LBiObjIntConsumer<V2,V3>`	`cast()` Cast that replace generics.
`static <V2,V3,T1,T2> LBiObjIntConsumer<V2,V3>`	`cast(LBiObjIntConsumer<T1,T2> function)` Cast that replace generics.
`default <V1,V2> LBiObjIntConsumer<V1,V2>`	`compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LIntUnaryOperator before3)` Allows to manipulate the domain of the function.
`static <V1,V2,T1,T2> LBiObjIntConsumer<V1,V2>`	`composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LIntUnaryOperator before3, LBiObjIntConsumer<T1,T2> after)`
`static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>`	`composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToIntFunction<? super V3> before3, LBiObjIntConsumer<T1,T2> after)`
`static <T1,T2> void`	`doNothing(int a3, T1 a1, T2 a2)` Does nothing (LBiObjIntConsumer.LInt2Obj0Obj1Cons)
`static <T1,T2> void`	`doNothing(T1 a1, int a3, T2 a2)` Does nothing (LBiObjIntConsumer.LObj0Int2Obj1Cons)
`static <T1,T2> void`	`doNothing(T1 a1, T2 a2, int a3)` Does nothing (LBiObjIntConsumer)
`static <T1,T2> LBiObjIntConsumer<T1,T2>`	`failSafe(LBiObjIntConsumer<T1,T2> func, LBiObjIntConsumer<T1,T2> failSafe)`
`default void`	`failSafeAccept(T1 a1, T2 a2, int a3, LBiObjIntConsumer<T1,T2> failSafe)`
`static <T1,T2> void`	`failSafeAccept(T1 a1, T2 a2, int a3, LBiObjIntConsumer<T1,T2> func, LBiObjIntConsumer<T1,T2> failSafe)`
`static <C1,C2,C3,T1,T2> int`	`forEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.aInt> ia3, C3 source3, LBiObjIntConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer.
`static <T1,T2> void`	`fromTill(int min_a3, int max_a3, T1 a1, T2 a2, LBiObjIntConsumer<T1,T2> func)` From-To.
`static <T1,T2> void`	`fromTo(int min_a3, int max_a3, T1 a1, T2 a2, LBiObjIntConsumer<T1,T2> func)` From-To.
`default String`	`functionalInterfaceDescription()` Returns description of the functional interface.
`default LBiObjIntConsumer<T1,T2>`	`handling(HandlingInstructions<Throwable,RuntimeException> handling)`
`default void`	`handlingAccept(T1 a1, T2 a2, int a3, HandlingInstructions<Throwable,RuntimeException> handling)` Function call that handles exceptions according to the instructions.
`static <T1,T2> void`	`handlingAccept(T1 a1, T2 a2, int a3, LBiObjIntConsumer<T1,T2> func, HandlingInstructions<Throwable,RuntimeException> handling)`
`static <C1,C2,T1,T2> int`	`indexedForEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, LBiObjIntConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer (with index).
`static <C1,C2,I2,T1,T2> int`	`indexedIterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, LBiObjIntConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer (with index).
`static <C1,I1,C2,T1,T2> int`	`indexedIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, LBiObjIntConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer (with index).
`static <C1,I1,C2,I2,T1,T2> int`	`indexedIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, LBiObjIntConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer (with index).
`static <T1,T2> LBiObjIntConsumer.LInt2Obj0Obj1Cons<T1,T2>`	`int2Obj0Obj1Cons(LBiObjIntConsumer.LInt2Obj0Obj1Cons<T1,T2> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`static <T2,T1> LBiObjIntConsumer.LInt2Obj1Obj0Cons<T2,T1>`	`int2Obj1Obj0Cons(LBiObjIntConsumer.LInt2Obj1Obj0Cons<T2,T1> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`static <C1,C2,C3,I3,T1,T2> int`	`iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.aInt> sa3, C3 source3, LBiObjIntConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer.
`static <C1,C2,I2,C3,T1,T2> int`	`iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.aInt> ia3, C3 source3, LBiObjIntConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer.
`static <C1,C2,I2,C3,I3,T1,T2> int`	`iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.aInt> sa3, C3 source3, LBiObjIntConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer.
`static <C1,I1,C2,C3,T1,T2> int`	`iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.aInt> ia3, C3 source3, LBiObjIntConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer.
`static <C1,I1,C2,C3,I3,T1,T2> int`	`iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.aInt> sa3, C3 source3, LBiObjIntConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer.
`static <C1,I1,C2,I2,C3,T1,T2> int`	`iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.aInt> ia3, C3 source3, LBiObjIntConsumer<? 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`	`iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.aInt> sa3, C3 source3, LBiObjIntConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer.
`default LObjIntConsumer<T2>`	`lShrink(LOiFunction<T2,T1> left)`
`default LObjIntConsumer<T2>`	`lShrinkc(T1 a1)`
`static <T2,T1> LObjIntConsumer<T2>`	`lShrinked(LOiFunction<T2,T1> left, LBiObjIntConsumer<T1,T2> func)`
`static <T2,T1> LObjIntConsumer<T2>`	`lShrinkedc(T1 a1, LBiObjIntConsumer<T1,T2> func)`
`default void`	`nestingAccept(T1 a1, T2 a2, int a3)` Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
`static <T1,T2> LBiObjIntConsumer.LObj0Int2Obj1Cons<T1,T2>`	`obj0Int2Obj1Cons(LBiObjIntConsumer.LObj0Int2Obj1Cons<T1,T2> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`static <T2,T1> LBiObjIntConsumer.LObj1Int2Obj0Cons<T2,T1>`	`obj1Int2Obj0Cons(LBiObjIntConsumer.LObj1Int2Obj0Cons<T2,T1> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`static <T2,T1> LBiObjIntConsumer.LObj1Obj0Int2Cons<T2,T1>`	`obj1Obj0Int2Cons(LBiObjIntConsumer.LObj1Obj0Int2Cons<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> LBiObjIntConsumer<T1,T2>`	`recursive(LFunction<LBiObjIntConsumer<T1,T2>,LBiObjIntConsumer<T1,T2>> selfLambda)`
`default LBiConsumer<T1,T2>`	`rShrink(LToIntBiFunction<T1,T2> right)`
`default LBiConsumer<T1,T2>`	`rShrinkc(int a3)`
`static <T1,T2> LBiConsumer<T1,T2>`	`rShrinked(LToIntBiFunction<T1,T2> right, LBiObjIntConsumer<T1,T2> func)`
`static <T1,T2> LBiConsumer<T1,T2>`	`rShrinkedc(int a3, LBiObjIntConsumer<T1,T2> func)`
`static <T1,T2> LBiObjIntConsumer<T1,T2>`	`safe()` Safe instance.
`static <T1,T2> LBiObjIntConsumer<T1,T2>`	`safe(LBiObjIntConsumer<T1,T2> other)` Safe wrapping.
`static <T1,T2> LSupplier<LBiObjIntConsumer<T1,T2>>`	`safeSupplier()` Safe instance supplier.
`static <T1,T2> LSupplier<LBiObjIntConsumer<T1,T2>>`	`safeSupplier(LSupplier<LBiObjIntConsumer<T1,T2>> supplier)` Safe supplier.
`default void`	`shovingAccept(T1 a1, T2 a2, int a3)` Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
`static <T1,C2,C3,T2> T1`	`targetedForEach(T1 a1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.aInt> ia3, C3 source3, LBiObjIntConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer.
`static <T1,C2,C3,I3,T2> T1`	`targetedIterate(T1 a1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.aInt> sa3, C3 source3, LBiObjIntConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer.
`static <T1,C2,I2,C3,T2> T1`	`targetedIterate(T1 a1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.aInt> ia3, C3 source3, LBiObjIntConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer.
`static <T1,C2,I2,C3,I3,T2> T1`	`targetedIterate(T1 a1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.aInt> sa3, C3 source3, LBiObjIntConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer.
`static <T1,T2> void`	`times(int max_a3, T1 a1, T2 a2, LBiObjIntConsumer<T1,T2> func)` From-To.
`static <T1,T2> void`	`tryAccept(T1 a1, T2 a2, int a3, LBiObjIntConsumer<T1,T2> func)`
`static <T1,T2> void`	`tryAccept(T1 a1, T2 a2, int a3, LBiObjIntConsumer<T1,T2> func, ExWF<RuntimeException> exF)`
`static <T1,T2> void`	`tryAccept(T1 a1, T2 a2, int a3, LBiObjIntConsumer<T1,T2> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static <T1,T2> void`	`tryAcceptThen(T1 a1, T2 a2, int a3, LBiObjIntConsumer<T1,T2> func, LConsumer<Throwable> handler)`
`default LBiObjIntConsumer<T1,T2>`	`trying(ExWF<RuntimeException> exF)`
`default LBiObjIntConsumer<T1,T2>`	`trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default LBiObjIntConsumer<T1,T2>`	`tryingThen(LConsumer<Throwable> handler)`
`default LTuple.Void`	`tupleAccept(LBiObjIntTriple<T1,T2> args)`
`static <T1,T2> LBiObjIntConsumer<T1,T2>`	`uncurry(LFunction<T1,LFunction<T2,LIntConsumer>> func)`
`default LBiObjIntConsumer`	`untyped()` Cast that removes generics.

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

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.MetaFunctionalInterface
formatTo, isAction, isFunction, 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

accept

default void accept(T1 a1,
                    T2 a2,
                    int a3)

acceptX

void acceptX(T1 a1,
             T2 a2,
             int a3)
      throws Throwable

Implement this, but call accept(T1 a1,T2 a2,int a3)

Throws:: Throwable

tupleAccept

default LTuple.Void tupleAccept(LBiObjIntTriple<T1,T2> args)

handlingAccept

default void handlingAccept(T1 a1,
                            T2 a2,
                            int a3,
                            HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

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

accept

default void accept(T1 a1,
                    T2 a2,
                    int a3,
                    @Nonnull
                    ExWMF<RuntimeException> exF,
                    @Nonnull
                    String newMessage,
                    @Nullable
                    Object... messageParams)

trying

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

accept

default void accept(T1 a1,
                    T2 a2,
                    int a3,
                    @Nonnull
                    ExWF<RuntimeException> exF)

trying

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

acceptThen

default void acceptThen(T1 a1,
                        T2 a2,
                        int a3,
                        @Nonnull
                        LConsumer<Throwable> handler)

tryingThen

default LBiObjIntConsumer<T1,T2> tryingThen(@Nonnull
                                            LConsumer<Throwable> handler)

nestingAccept

default void nestingAccept(T1 a1,
                           T2 a2,
                           int a3)

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

shovingAccept

default void shovingAccept(T1 a1,
                           T2 a2,
                           int a3)

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

handlingAccept

static <T1,T2> void handlingAccept(T1 a1,
                                   T2 a2,
                                   int a3,
                                   LBiObjIntConsumer<T1,T2> func,
                                   HandlingInstructions<Throwable,RuntimeException> handling)

tryAccept

static <T1,T2> void tryAccept(T1 a1,
                              T2 a2,
                              int a3,
                              LBiObjIntConsumer<T1,T2> func)

tryAccept

static <T1,T2> void tryAccept(T1 a1,
                              T2 a2,
                              int a3,
                              LBiObjIntConsumer<T1,T2> func,
                              @Nonnull
                              ExWMF<RuntimeException> exF,
                              @Nonnull
                              String newMessage,
                              @Nullable
                              Object... messageParams)

tryAccept

static <T1,T2> void tryAccept(T1 a1,
                              T2 a2,
                              int a3,
                              LBiObjIntConsumer<T1,T2> func,
                              @Nonnull
                              ExWF<RuntimeException> exF)

tryAcceptThen

static <T1,T2> void tryAcceptThen(T1 a1,
                                  T2 a2,
                                  int a3,
                                  LBiObjIntConsumer<T1,T2> func,
                                  @Nonnull
                                  LConsumer<Throwable> handler)

failSafeAccept

default void failSafeAccept(T1 a1,
                            T2 a2,
                            int a3,
                            @Nonnull
                            LBiObjIntConsumer<T1,T2> failSafe)

failSafeAccept

static <T1,T2> void failSafeAccept(T1 a1,
                                   T2 a2,
                                   int a3,
                                   LBiObjIntConsumer<T1,T2> func,
                                   @Nonnull
                                   LBiObjIntConsumer<T1,T2> failSafe)

failSafe

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

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_a3,
                           int max_a3,
                           T1 a1,
                           T2 a2,
                           LBiObjIntConsumer<T1,T2> func)

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

fromTill

static <T1,T2> void fromTill(int min_a3,
                             int max_a3,
                             T1 a1,
                             T2 a2,
                             LBiObjIntConsumer<T1,T2> func)

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

times

static <T1,T2> void times(int max_a3,
                          T1 a1,
                          T2 a2,
                          LBiObjIntConsumer<T1,T2> func)

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

lShrink

default LObjIntConsumer<T2> lShrink(LOiFunction<T2,T1> left)

lShrinkc

default LObjIntConsumer<T2> lShrinkc(T1 a1)

lShrinked

static <T2,T1> LObjIntConsumer<T2> lShrinked(LOiFunction<T2,T1> left,
                                             LBiObjIntConsumer<T1,T2> func)

lShrinkedc

static <T2,T1> LObjIntConsumer<T2> lShrinkedc(T1 a1,
                                              LBiObjIntConsumer<T1,T2> func)

rShrink

default LBiConsumer<T1,T2> rShrink(LToIntBiFunction<T1,T2> right)

rShrinkc

default LBiConsumer<T1,T2> rShrinkc(int a3)

rShrinked

static <T1,T2> LBiConsumer<T1,T2> rShrinked(LToIntBiFunction<T1,T2> right,
                                            LBiObjIntConsumer<T1,T2> func)

rShrinkedc

static <T1,T2> LBiConsumer<T1,T2> rShrinkedc(int a3,
                                             LBiObjIntConsumer<T1,T2> func)

uncurry

static <T1,T2> LBiObjIntConsumer<T1,T2> uncurry(LFunction<T1,LFunction<T2,LIntConsumer>> func)

untyped
```
default LBiObjIntConsumer untyped()
```
Cast that removes generics.

cast

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

Cast that replace generics.

cast

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

Cast that replace generics.

capture

default LAction capture(T1 a1,
                        T2 a2,
                        int a3)

Captures arguments but delays the evaluation.

accept1st

@Nonnull
static <T1,T2> LBiObjIntConsumer<T1,T2> accept1st(@Nonnull
                                                            LConsumer<T1> func)

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

accept2nd

@Nonnull
static <T1,T2> LBiObjIntConsumer<T1,T2> accept2nd(@Nonnull
                                                            LConsumer<T2> func)

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

accept3rd

@Nonnull
static <T1,T2> LBiObjIntConsumer<T1,T2> accept3rd(@Nonnull
                                                            LIntConsumer func)

Captures single parameter function into this interface where only 3rd parameter will be used.

biObjIntCons

@Nonnull
static <T1,T2> LBiObjIntConsumer<T1,T2> biObjIntCons(@Nonnull
                                                               LBiObjIntConsumer<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> LBiObjIntConsumer<T1,T2> recursive(@Nonnull
                                                            LFunction<LBiObjIntConsumer<T1,T2>,LBiObjIntConsumer<T1,T2>> selfLambda)

biObjIntConsThrowing

@Nonnull
static <T1,T2> LBiObjIntConsumer<T1,T2> biObjIntConsThrowing(@Nonnull
                                                                       ExF<Throwable> exF)

biObjIntConsThrowing

@Nonnull
static <T1,T2> LBiObjIntConsumer<T1,T2> biObjIntConsThrowing(String message,
                                                                       @Nonnull
                                                                       ExMF<Throwable> exF)

obj0Int2Obj1Cons

@Nonnull
static <T1,T2> LBiObjIntConsumer.LObj0Int2Obj1Cons<T1,T2> obj0Int2Obj1Cons(@Nonnull
                                                                                     LBiObjIntConsumer.LObj0Int2Obj1Cons<T1,T2> lambda)

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

obj1Obj0Int2Cons

@Nonnull
static <T2,T1> LBiObjIntConsumer.LObj1Obj0Int2Cons<T2,T1> obj1Obj0Int2Cons(@Nonnull
                                                                                     LBiObjIntConsumer.LObj1Obj0Int2Cons<T2,T1> lambda)

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

obj1Int2Obj0Cons

@Nonnull
static <T2,T1> LBiObjIntConsumer.LObj1Int2Obj0Cons<T2,T1> obj1Int2Obj0Cons(@Nonnull
                                                                                     LBiObjIntConsumer.LObj1Int2Obj0Cons<T2,T1> lambda)

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

int2Obj0Obj1Cons

@Nonnull
static <T1,T2> LBiObjIntConsumer.LInt2Obj0Obj1Cons<T1,T2> int2Obj0Obj1Cons(@Nonnull
                                                                                     LBiObjIntConsumer.LInt2Obj0Obj1Cons<T1,T2> lambda)

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

int2Obj1Obj0Cons

@Nonnull
static <T2,T1> LBiObjIntConsumer.LInt2Obj1Obj0Cons<T2,T1> int2Obj1Obj0Cons(@Nonnull
                                                                                     LBiObjIntConsumer.LInt2Obj1Obj0Cons<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> void call(T1 a1,
                         T2 a2,
                         int a3,
                         @Nonnull
                         LBiObjIntConsumer<T1,T2> lambda)

safe

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

Safe instance.

safeSupplier

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

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

safe

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

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

safeSupplier

@Nonnull
static <T1,T2> LSupplier<LBiObjIntConsumer<T1,T2>> safeSupplier(@Nullable
                                                                          LSupplier<LBiObjIntConsumer<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> LBiObjIntConsumer<V1,V2> compose(@Nonnull
                                                           LFunction<? super V1,? extends T1> before1,
                                                           @Nonnull
                                                           LFunction<? super V2,? extends T2> before2,
                                                           @Nonnull
                                                           LIntUnaryOperator before3)

Allows to manipulate the domain of the function.

composed

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

biObjIntConsCompose

@Nonnull
default <V1,V2,V3> LTriConsumer<V1,V2,V3> biObjIntConsCompose(@Nonnull
                                                                        LFunction<? super V1,? extends T1> before1,
                                                                        @Nonnull
                                                                        LFunction<? super V2,? extends T2> before2,
                                                                        @Nonnull
                                                                        LToIntFunction<? super V3> before3)

Allows to manipulate the domain of the function.

composed

static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3> composed(@Nonnull
                                                        LFunction<? super V1,? extends T1> before1,
                                                        @Nonnull
                                                        LFunction<? super V2,? extends T2> before2,
                                                        @Nonnull
                                                        LToIntFunction<? super V3> before3,
                                                        LBiObjIntConsumer<T1,T2> after)

andThen

@Nonnull
default LBiObjIntConsumer<T1,T2> andThen(@Nonnull
                                                   LBiObjIntConsumer<? super T1,? super T2> after)

Combines two LBiObjIntConsumer<T1,T2> together in a order.

doNothing

static <T1,T2> void doNothing(T1 a1,
                              T2 a2,
                              int a3)

Does nothing (LBiObjIntConsumer)

doNothing

static <T1,T2> void doNothing(T1 a1,
                              int a3,
                              T2 a2)

Does nothing (LBiObjIntConsumer.LObj0Int2Obj1Cons)

doNothing

static <T1,T2> void doNothing(int a3,
                              T1 a1,
                              T2 a2)

Does nothing (LBiObjIntConsumer.LInt2Obj0Obj1Cons)