LToIntTriFunction (magma-func 2.0.0 API)

All Superinterfaces:

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

All Known Subinterfaces:

LToIntTriFunction.LToIntBiObj1Obj0Func<T3,T2,T1>, LToIntTriFunction.LToIntObj0Obj2Obj1Func<T1,T3,T2>, LToIntTriFunction.LToIntObj1BiObj2Func<T2,T1,T3>, LToIntTriFunction.LToIntObj1Obj2Obj0Func<T2,T3,T1>, LToIntTriFunction.LToIntObj2Obj0Obj1Func<T3,T1,T2>

All Known Implementing Classes:

LToIntTriFunction.LToIntTriFunctionSingle
```
@FunctionalInterface
public interface LToIntTriFunction<T1,T2,T3>
extends MetaFunction, MetaInterface.NonThrowing, Codomain<aType.aInt>, Domain3<aType.a<T1>,aType.a<T2>,aType.a<T3>>
```
Non-throwing functional interface (lambda) LToIntTriFunction for Java 8.
Type: function
Domain (lvl: 3): T1 a1,T2 a2,T3 a3
Co-domain: int

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static interface`	`LToIntTriFunction.LToIntBiObj1Obj0Func<T3,T2,T1>` Permutation of LToIntTriFunction for method references.
`static interface`	`LToIntTriFunction.LToIntObj0Obj2Obj1Func<T1,T3,T2>` Permutation of LToIntTriFunction for method references.
`static interface`	`LToIntTriFunction.LToIntObj1BiObj2Func<T2,T1,T3>` Permutation of LToIntTriFunction for method references.
`static interface`	`LToIntTriFunction.LToIntObj1Obj2Obj0Func<T2,T3,T1>` Permutation of LToIntTriFunction for method references.
`static interface`	`LToIntTriFunction.LToIntObj2Obj0Obj1Func<T3,T1,T2>` Permutation of LToIntTriFunction for method references.
`static class`	`LToIntTriFunction.LToIntTriFunctionSingle<T1,T2,T3>`

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
`static <T1,T2,T3> LToIntTriFunction<T1,T2,T3>`	`apply1stAsInt(LToIntFunction<T1> func)` Captures single parameter function into this interface where only 1st parameter will be used.
`static <T1,T2,T3> LToIntTriFunction<T1,T2,T3>`	`apply2ndAsInt(LToIntFunction<T2> func)` Captures single parameter function into this interface where only 2nd parameter will be used.
`static <T1,T2,T3> LToIntTriFunction<T1,T2,T3>`	`apply3rdAsInt(LToIntFunction<T3> func)` Captures single parameter function into this interface where only 3rd parameter will be used.
`default int`	`applyAsInt(T1 a1, T2 a2, T3 a3)`
`default int`	`applyAsInt(T1 a1, T2 a2, T3 a3, ExWF<RuntimeException> exF)`
`default int`	`applyAsInt(T1 a1, T2 a2, T3 a3, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default int`	`applyAsIntThen(T1 a1, T2 a2, T3 a3, LToIntFunction<Throwable> handler)`
`int`	`applyAsIntX(T1 a1, T2 a2, T3 a3)` Implement this, but call applyAsInt(T1 a1,T2 a2,T3 a3)
`static <T1,T2,T3> int`	`call(T1 a1, T2 a2, T3 a3, LToIntTriFunction<T1,T2,T3> lambda)`
`default LIntSupplier`	`capture(T1 a1, T2 a2, T3 a3)` Captures arguments but delays the evaluation.
`default <V2,V3,V4> LToIntTriFunction<V2,V3,V4>`	`cast()` Cast that replace generics.
`static <V2,V3,V4,T1,T2,T3> LToIntTriFunction<V2,V3,V4>`	`cast(LToIntTriFunction<T1,T2,T3> function)` Cast that replace generics.
`default <V1,V2,V3> LToIntTriFunction<V1,V2,V3>`	`compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3)` Allows to manipulate the domain of the function.
`static <V1,V2,V3,T1,T2,T3> LToIntTriFunction<V1,V2,V3>`	`composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3, LToIntTriFunction<T1,T2,T3> after)`
`static <T1,T2,T3> LToIntTriFunction<T1,T2,T3>`	`constant(int r)` Creates function that always returns the same value.
`static <T1,T2,T3> LToIntTriFunction<T1,T2,T3>`	`failSafe(LToIntTriFunction<T1,T2,T3> func, LToIntTriFunction<T1,T2,T3> failSafe)`
`default int`	`failSafeApplyAsInt(T1 a1, T2 a2, T3 a3, LToIntTriFunction<T1,T2,T3> failSafe)`
`static <T1,T2,T3> int`	`failSafeApplyAsInt(T1 a1, T2 a2, T3 a3, LToIntTriFunction<T1,T2,T3> func, LToIntTriFunction<T1,T2,T3> failSafe)`
`default <C1,C2,C3> void`	`forEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LIntConsumer consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`static <T1,T2,T3> void`	`fromTill(int min_i, int max_i, T1 a1, T2 a2, T3 a3, LToIntTriFunction<T1,T2,T3> func)` From-To.
`static <T1,T2,T3> void`	`fromTo(int min_i, int max_i, T1 a1, T2 a2, T3 a3, LToIntTriFunction<T1,T2,T3> func)` From-To.
`default String`	`functionalInterfaceDescription()` Returns description of the functional interface.
`default LToIntTriFunction<T1,T2,T3>`	`handling(HandlingInstructions<Throwable,RuntimeException> handling)`
`default int`	`handlingApplyAsInt(T1 a1, T2 a2, T3 a3, HandlingInstructions<Throwable,RuntimeException> handling)` Function call that handles exceptions according to the instructions.
`static <T1,T2,T3> int`	`handlingApplyAsInt(T1 a1, T2 a2, T3 a3, LToIntTriFunction<T1,T2,T3> func, HandlingInstructions<Throwable,RuntimeException> handling)`
`default <C1,C2,C3,I3> void`	`iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LIntConsumer consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`default <C1,C2,I2,C3> void`	`iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LIntConsumer consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`default <C1,C2,I2,C3,I3> void`	`iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LIntConsumer consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`default <C1,I1,C2,C3> void`	`iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LIntConsumer consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`default <C1,I1,C2,C3,I3> void`	`iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LIntConsumer consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`default <C1,I1,C2,I2,C3> void`	`iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LIntConsumer consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`default <C1,I1,C2,I2,C3,I3> void`	`iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LIntConsumer consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`default LToIntBiFunction<T2,T3>`	`lShrink(LBiFunction<T2,T3,T1> left)`
`default LToIntBiFunction<T2,T3>`	`lShrinkc(T1 a1)`
`static <T2,T3,T1> LToIntBiFunction<T2,T3>`	`lShrinked(LBiFunction<T2,T3,T1> left, LToIntTriFunction<T1,T2,T3> func)`
`static <T2,T3,T1> LToIntBiFunction<T2,T3>`	`lShrinkedc(T1 a1, LToIntTriFunction<T1,T2,T3> func)`
`default int`	`nestingApplyAsInt(T1 a1, T2 a2, T3 a3)` Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
`default int`	`nonNullApplyAsInt(T1 a1, T2 a2, T3 a3)` Just to mirror the method: Ensures the result is not null
`static <T1,T2,T3> int`	`produceInt(T1 a1, T2 a2, T3 a3)` Does nothing (LToIntTriFunction) Function
`static <T1,T2,T3> LToIntTriFunction<T1,T2,T3>`	`recursive(LFunction<LToIntTriFunction<T1,T2,T3>,LToIntTriFunction<T1,T2,T3>> selfLambda)`
`default LToIntBiFunction<T1,T2>`	`rShrink(LBiFunction<T1,T2,T3> right)`
`default LToIntBiFunction<T1,T2>`	`rShrinkc(T3 a3)`
`static <T1,T2,T3> LToIntBiFunction<T1,T2>`	`rShrinked(LBiFunction<T1,T2,T3> right, LToIntTriFunction<T1,T2,T3> func)`
`static <T1,T2,T3> LToIntBiFunction<T1,T2>`	`rShrinkedc(T3 a3, LToIntTriFunction<T1,T2,T3> func)`
`static <T1,T2,T3> LToIntTriFunction<T1,T2,T3>`	`safe()` Safe instance.
`static <T1,T2,T3> LToIntTriFunction<T1,T2,T3>`	`safe(LToIntTriFunction<T1,T2,T3> other)` Safe wrapping.
`static <T1,T2,T3> LSupplier<LToIntTriFunction<T1,T2,T3>>`	`safeSupplier()` Safe instance supplier.
`static <T1,T2,T3> LSupplier<LToIntTriFunction<T1,T2,T3>>`	`safeSupplier(LSupplier<LToIntTriFunction<T1,T2,T3>> supplier)` Safe supplier.
`default int`	`shovingApplyAsInt(T1 a1, T2 a2, T3 a3)` Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
`default <V> LTriFunction<T1,T2,T3,V>`	`then(LIntFunction<? extends V> after)` Combines two functions together in a order.
`default LTriPredicate<T1,T2,T3>`	`thenToBool(LIntPredicate after)` Combines two functions together in a order.
`default LToIntTriFunction<T1,T2,T3>`	`thenToInt(LIntUnaryOperator after)` Combines two functions together in a order.
`static <T1,T2,T3> void`	`times(int max_i, T1 a1, T2 a2, T3 a3, LToIntTriFunction<T1,T2,T3> func)` From-To.
`static <T3,T2,T1> LToIntTriFunction.LToIntBiObj1Obj0Func<T3,T2,T1>`	`toIntBiObj1Obj0Func(LToIntTriFunction.LToIntBiObj1Obj0Func<T3,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,T3,T2> LToIntTriFunction.LToIntObj0Obj2Obj1Func<T1,T3,T2>`	`toIntObj0Obj2Obj1Func(LToIntTriFunction.LToIntObj0Obj2Obj1Func<T1,T3,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,T3> LToIntTriFunction.LToIntObj1BiObj2Func<T2,T1,T3>`	`toIntObj1BiObj2Func(LToIntTriFunction.LToIntObj1BiObj2Func<T2,T1,T3> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`static <T2,T3,T1> LToIntTriFunction.LToIntObj1Obj2Obj0Func<T2,T3,T1>`	`toIntObj1Obj2Obj0Func(LToIntTriFunction.LToIntObj1Obj2Obj0Func<T2,T3,T1> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`static <T3,T1,T2> LToIntTriFunction.LToIntObj2Obj0Obj1Func<T3,T1,T2>`	`toIntObj2Obj0Obj1Func(LToIntTriFunction.LToIntObj2Obj0Obj1Func<T3,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,T3> LToIntTriFunction<T1,T2,T3>`	`toIntTriFunc(LToIntTriFunction<T1,T2,T3> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`static <T1,T2,T3> LToIntTriFunction<T1,T2,T3>`	`toIntTriFuncThrowing(ExF<Throwable> exF)`
`static <T1,T2,T3> LToIntTriFunction<T1,T2,T3>`	`toIntTriFuncThrowing(String message, ExMF<Throwable> exF)`
`static <T1,T2,T3> int`	`tryApplyAsInt(T1 a1, T2 a2, T3 a3, LToIntTriFunction<T1,T2,T3> func)`
`static <T1,T2,T3> int`	`tryApplyAsInt(T1 a1, T2 a2, T3 a3, LToIntTriFunction<T1,T2,T3> func, ExWF<RuntimeException> exF)`
`static <T1,T2,T3> int`	`tryApplyAsInt(T1 a1, T2 a2, T3 a3, LToIntTriFunction<T1,T2,T3> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static <T1,T2,T3> int`	`tryApplyAsIntThen(T1 a1, T2 a2, T3 a3, LToIntTriFunction<T1,T2,T3> func, LToIntFunction<Throwable> handler)`
`default LToIntTriFunction<T1,T2,T3>`	`trying(ExWF<RuntimeException> exF)`
`default LToIntTriFunction<T1,T2,T3>`	`trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default LToIntTriFunction<T1,T2,T3>`	`tryingThen(LToIntFunction<Throwable> handler)`
`default int`	`tupleApplyAsInt(LTriple<T1,T2,T3> args)`
`static <T1,T2,T3> LToIntTriFunction<T1,T2,T3>`	`uncurry(LFunction<T1,LFunction<T2,LToIntFunction<T3>>> func)`
`default LToIntTriFunction`	`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

applyAsInt

default int applyAsInt(T1 a1,
                       T2 a2,
                       T3 a3)

applyAsIntX

int applyAsIntX(T1 a1,
                T2 a2,
                T3 a3)
         throws Throwable

Implement this, but call applyAsInt(T1 a1,T2 a2,T3 a3)

Throws:: Throwable

tupleApplyAsInt

default int tupleApplyAsInt(LTriple<T1,T2,T3> args)

handlingApplyAsInt

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

Function call that handles exceptions according to the instructions.

handling

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

applyAsInt

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

trying

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

applyAsInt

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

trying

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

applyAsIntThen

default int applyAsIntThen(T1 a1,
                           T2 a2,
                           T3 a3,
                           @Nonnull
                           LToIntFunction<Throwable> handler)

tryingThen

default LToIntTriFunction<T1,T2,T3> tryingThen(@Nonnull
                                               LToIntFunction<Throwable> handler)

nestingApplyAsInt

default int nestingApplyAsInt(T1 a1,
                              T2 a2,
                              T3 a3)

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

shovingApplyAsInt

default int shovingApplyAsInt(T1 a1,
                              T2 a2,
                              T3 a3)

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

handlingApplyAsInt

static <T1,T2,T3> int handlingApplyAsInt(T1 a1,
                                         T2 a2,
                                         T3 a3,
                                         LToIntTriFunction<T1,T2,T3> func,
                                         HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsInt

static <T1,T2,T3> int tryApplyAsInt(T1 a1,
                                    T2 a2,
                                    T3 a3,
                                    LToIntTriFunction<T1,T2,T3> func)

tryApplyAsInt

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

tryApplyAsInt

static <T1,T2,T3> int tryApplyAsInt(T1 a1,
                                    T2 a2,
                                    T3 a3,
                                    LToIntTriFunction<T1,T2,T3> func,
                                    @Nonnull
                                    ExWF<RuntimeException> exF)

tryApplyAsIntThen

static <T1,T2,T3> int tryApplyAsIntThen(T1 a1,
                                        T2 a2,
                                        T3 a3,
                                        LToIntTriFunction<T1,T2,T3> func,
                                        @Nonnull
                                        LToIntFunction<Throwable> handler)

failSafeApplyAsInt

default int failSafeApplyAsInt(T1 a1,
                               T2 a2,
                               T3 a3,
                               @Nonnull
                               LToIntTriFunction<T1,T2,T3> failSafe)

failSafeApplyAsInt

static <T1,T2,T3> int failSafeApplyAsInt(T1 a1,
                                         T2 a2,
                                         T3 a3,
                                         LToIntTriFunction<T1,T2,T3> func,
                                         @Nonnull
                                         LToIntTriFunction<T1,T2,T3> failSafe)

failSafe

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

nonNullApplyAsInt

default int nonNullApplyAsInt(T1 a1,
                              T2 a2,
                              T3 a3)

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,T3> void fromTo(int min_i,
                              int max_i,
                              T1 a1,
                              T2 a2,
                              T3 a3,
                              LToIntTriFunction<T1,T2,T3> func)

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

fromTill

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

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

times

static <T1,T2,T3> void times(int max_i,
                             T1 a1,
                             T2 a2,
                             T3 a3,
                             LToIntTriFunction<T1,T2,T3> func)

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

lShrink

default LToIntBiFunction<T2,T3> lShrink(LBiFunction<T2,T3,T1> left)

lShrinkc

default LToIntBiFunction<T2,T3> lShrinkc(T1 a1)

lShrinked

static <T2,T3,T1> LToIntBiFunction<T2,T3> lShrinked(LBiFunction<T2,T3,T1> left,
                                                    LToIntTriFunction<T1,T2,T3> func)

lShrinkedc

static <T2,T3,T1> LToIntBiFunction<T2,T3> lShrinkedc(T1 a1,
                                                     LToIntTriFunction<T1,T2,T3> func)

rShrink

default LToIntBiFunction<T1,T2> rShrink(LBiFunction<T1,T2,T3> right)

rShrinkc

default LToIntBiFunction<T1,T2> rShrinkc(T3 a3)

rShrinked

static <T1,T2,T3> LToIntBiFunction<T1,T2> rShrinked(LBiFunction<T1,T2,T3> right,
                                                    LToIntTriFunction<T1,T2,T3> func)

rShrinkedc

static <T1,T2,T3> LToIntBiFunction<T1,T2> rShrinkedc(T3 a3,
                                                     LToIntTriFunction<T1,T2,T3> func)

uncurry

static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> uncurry(LFunction<T1,LFunction<T2,LToIntFunction<T3>>> func)

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

cast

default <V2,V3,V4> LToIntTriFunction<V2,V3,V4> cast()

Cast that replace generics.

cast

static <V2,V3,V4,T1,T2,T3> LToIntTriFunction<V2,V3,V4> cast(LToIntTriFunction<T1,T2,T3> function)

Cast that replace generics.

capture

default LIntSupplier capture(T1 a1,
                             T2 a2,
                             T3 a3)

Captures arguments but delays the evaluation.

constant

static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> constant(int r)

Creates function that always returns the same value.

apply1stAsInt

@Nonnull
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> apply1stAsInt(@Nonnull
                                                                      LToIntFunction<T1> func)

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

apply2ndAsInt

@Nonnull
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> apply2ndAsInt(@Nonnull
                                                                      LToIntFunction<T2> func)

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

apply3rdAsInt

@Nonnull
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> apply3rdAsInt(@Nonnull
                                                                      LToIntFunction<T3> func)

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

toIntTriFunc

@Nonnull
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> toIntTriFunc(@Nonnull
                                                                     LToIntTriFunction<T1,T2,T3> 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,T3> LToIntTriFunction<T1,T2,T3> recursive(@Nonnull
                                                                  LFunction<LToIntTriFunction<T1,T2,T3>,LToIntTriFunction<T1,T2,T3>> selfLambda)

toIntTriFuncThrowing

@Nonnull
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> toIntTriFuncThrowing(@Nonnull
                                                                             ExF<Throwable> exF)

toIntTriFuncThrowing

@Nonnull
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> toIntTriFuncThrowing(String message,
                                                                             @Nonnull
                                                                             ExMF<Throwable> exF)

toIntObj0Obj2Obj1Func

@Nonnull
static <T1,T3,T2> LToIntTriFunction.LToIntObj0Obj2Obj1Func<T1,T3,T2> toIntObj0Obj2Obj1Func(@Nonnull
                                                                                                     LToIntTriFunction.LToIntObj0Obj2Obj1Func<T1,T3,T2> lambda)

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

toIntObj1BiObj2Func

@Nonnull
static <T2,T1,T3> LToIntTriFunction.LToIntObj1BiObj2Func<T2,T1,T3> toIntObj1BiObj2Func(@Nonnull
                                                                                                 LToIntTriFunction.LToIntObj1BiObj2Func<T2,T1,T3> lambda)

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

toIntObj1Obj2Obj0Func

@Nonnull
static <T2,T3,T1> LToIntTriFunction.LToIntObj1Obj2Obj0Func<T2,T3,T1> toIntObj1Obj2Obj0Func(@Nonnull
                                                                                                     LToIntTriFunction.LToIntObj1Obj2Obj0Func<T2,T3,T1> lambda)

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

toIntObj2Obj0Obj1Func

@Nonnull
static <T3,T1,T2> LToIntTriFunction.LToIntObj2Obj0Obj1Func<T3,T1,T2> toIntObj2Obj0Obj1Func(@Nonnull
                                                                                                     LToIntTriFunction.LToIntObj2Obj0Obj1Func<T3,T1,T2> lambda)

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

toIntBiObj1Obj0Func

@Nonnull
static <T3,T2,T1> LToIntTriFunction.LToIntBiObj1Obj0Func<T3,T2,T1> toIntBiObj1Obj0Func(@Nonnull
                                                                                                 LToIntTriFunction.LToIntBiObj1Obj0Func<T3,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,T3> int call(T1 a1,
                           T2 a2,
                           T3 a3,
                           @Nonnull
                           LToIntTriFunction<T1,T2,T3> lambda)

safe
```
@Nonnull
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> safe()
```
Safe instance. That always returns the same value (as produceInt).

safeSupplier

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

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

safe

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

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

safeSupplier

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

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

compose

@Nonnull
default <V1,V2,V3> LToIntTriFunction<V1,V2,V3> compose(@Nonnull
                                                                 LFunction<? super V1,? extends T1> before1,
                                                                 @Nonnull
                                                                 LFunction<? super V2,? extends T2> before2,
                                                                 @Nonnull
                                                                 LFunction<? super V3,? extends T3> before3)

Allows to manipulate the domain of the function.

composed

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

then

@Nonnull
default <V> LTriFunction<T1,T2,T3,V> then(@Nonnull
                                                    LIntFunction<? extends V> after)

Combines two functions together in a order.

thenToInt

@Nonnull
default LToIntTriFunction<T1,T2,T3> thenToInt(@Nonnull
                                                        LIntUnaryOperator after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LTriPredicate<T1,T2,T3> thenToBool(@Nonnull
                                                     LIntPredicate after)

Combines two functions together in a order.

produceInt

static <T1,T2,T3> int produceInt(T1 a1,
                                 T2 a2,
                                 T3 a3)

Does nothing (LToIntTriFunction) Function