eu.lunisolar.magma.func.function

Interface LTriFunction<T1,T2,T3,R>

All Superinterfaces:

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

All Known Subinterfaces:

LTernaryOperator<T>, LTriFunction.LBiObj1Obj0Func<T3,T2,T1,R>, LTriFunction.LObj0Obj2Obj1Func<T1,T3,T2,R>, LTriFunction.LObj1BiObj2Func<T2,T1,T3,R>, LTriFunction.LObj1Obj2Obj0Func<T2,T3,T1,R>, LTriFunction.LObj2Obj0Obj1Func<T3,T1,T2,R>

All Known Implementing Classes:

LTernaryOperator.LTernaryOperatorSingle, LTriFunction.LTriFunctionSingle

@FunctionalInterface
public interface LTriFunction<T1,T2,T3,R>
extends MetaFunction, MetaInterface.NonThrowing, Codomain<aType.a<R>>, Domain3<aType.a<T1>,aType.a<T2>,aType.a<T3>>

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

Type: function

Domain (lvl: 3): T1 a1,T2 a2,T3 a3

Co-domain: R

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	LTriFunction.LBiObj1Obj0Func<T3,T2,T1,R> Permutation of LTriFunction for method references.
static interface	LTriFunction.LObj0Obj2Obj1Func<T1,T3,T2,R> Permutation of LTriFunction for method references.
static interface	LTriFunction.LObj1BiObj2Func<T2,T1,T3,R> Permutation of LTriFunction for method references.
static interface	LTriFunction.LObj1Obj2Obj0Func<T2,T3,T1,R> Permutation of LTriFunction for method references.
static interface	LTriFunction.LObj2Obj0Obj1Func<T3,T1,T2,R> Permutation of LTriFunction for method references.
static class	LTriFunction.LTriFunctionSingle<T1,T2,T3,R>

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
static LSupplier<String>	NULL_VALUE_MESSAGE_SUPPLIER

Method Summary

Modifier and Type	Method and Description
default LTriFunction<T1,T2,T3,R>	after(LConsumer<? super R> after)
default R	apply(T1 a1, T2 a2, T3 a3)
default R	apply(T1 a1, T2 a2, T3 a3, ExWF<RuntimeException> exF)
default R	apply(T1 a1, T2 a2, T3 a3, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	apply1st(LFunction<T1,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	apply2nd(LFunction<T2,R> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	apply3rd(LFunction<T3,R> func) Captures single parameter function into this interface where only 3rd parameter will be used.
default R	applyThen(T1 a1, T2 a2, T3 a3, LFunction<Throwable,R> handler)
R	applyX(T1 a1, T2 a2, T3 a3) Implement this, but call apply(T1 a1,T2 a2,T3 a3)
default LTriFunction<T1,T2,T3,R>	before(LTriConsumer<? super T1,? super T2,? super T3> before)
static <T3,T2,T1,R> LTriFunction.LBiObj1Obj0Func<T3,T2,T1,R>	biObj1Obj0Func(LTriFunction.LBiObj1Obj0Func<T3,T2,T1,R> 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,R> R	call(T1 a1, T2 a2, T3 a3, LTriFunction<T1,T2,T3,R> lambda)
default LSupplier<R>	capture(T1 a1, T2 a2, T3 a3) Captures arguments but delays the evaluation.
default <V2,V3,V4,V5> LTriFunction<V2,V3,V4,V5>	cast() Cast that replace generics.
static <V2,V3,V4,V5,T1,T2,T3,R> LTriFunction<V2,V3,V4,V5>	cast(LTriFunction<T1,T2,T3,R> function) Cast that replace generics.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	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,R> LTriFunction<V1,V2,V3,R>	composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3, LTriFunction<T1,T2,T3,R> after)
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	constant(R r) Creates function that always returns the same value.
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	failSafe(LTriFunction<T1,T2,T3,R> func, LTriFunction<T1,T2,T3,R> failSafe)
default R	failSafeApply(T1 a1, T2 a2, T3 a3, LTriFunction<T1,T2,T3,R> failSafe)
static <T1,T2,T3,R> R	failSafeApply(T1 a1, T2 a2, T3 a3, LTriFunction<T1,T2,T3,R> func, LTriFunction<T1,T2,T3,R> 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, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
static <T1,T2,T3,R> void	fromTill(int min_i, int max_i, T1 a1, T2 a2, T3 a3, LTriFunction<T1,T2,T3,R> func) From-To.
static <T1,T2,T3,R> void	fromTo(int min_i, int max_i, T1 a1, T2 a2, T3 a3, LTriFunction<T1,T2,T3,R> func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LTriFunction<T1,T2,T3,R>	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default R	handlingApply(T1 a1, T2 a2, T3 a3, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static <T1,T2,T3,R> R	handlingApply(T1 a1, T2 a2, T3 a3, LTriFunction<T1,T2,T3,R> 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, LConsumer<? super R> 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, LConsumer<? super R> 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, LConsumer<? super R> 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, LConsumer<? super R> 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, LConsumer<? super R> 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, LConsumer<? super R> 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, LConsumer<? super R> consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default LBiFunction<T2,T3,R>	lShrink(LBiFunction<T2,T3,T1> left)
default LBiFunction<T2,T3,R>	lShrinkc(T1 a1)
static <T2,T3,R,T1> LBiFunction<T2,T3,R>	lShrinked(LBiFunction<T2,T3,T1> left, LTriFunction<T1,T2,T3,R> func)
static <T2,T3,R,T1> LBiFunction<T2,T3,R>	lShrinkedc(T1 a1, LTriFunction<T1,T2,T3,R> func)
default R	nestingApply(T1 a1, T2 a2, T3 a3) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default LTriFunction<T1,T2,T3,R>	nonNullable() Converts to function that makes sure that the result is not null.
default R	nonNullApply(T1 a1, T2 a2, T3 a3) Function call that ensures the result is not null
static <T1,T3,T2,R> LTriFunction.LObj0Obj2Obj1Func<T1,T3,T2,R>	obj0Obj2Obj1Func(LTriFunction.LObj0Obj2Obj1Func<T1,T3,T2,R> 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,R> LTriFunction.LObj1BiObj2Func<T2,T1,T3,R>	obj1BiObj2Func(LTriFunction.LObj1BiObj2Func<T2,T1,T3,R> 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,R> LTriFunction.LObj1Obj2Obj0Func<T2,T3,T1,R>	obj1Obj2Obj0Func(LTriFunction.LObj1Obj2Obj0Func<T2,T3,T1,R> 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,R> LTriFunction.LObj2Obj0Obj1Func<T3,T1,T2,R>	obj2Obj0Obj1Func(LTriFunction.LObj2Obj0Obj1Func<T3,T1,T2,R> 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,R> R	produce(T1 a1, T2 a2, T3 a3) Does nothing (LTriFunction) Function
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	recursive(LFunction<LTriFunction<T1,T2,T3,R>,LTriFunction<T1,T2,T3,R>> selfLambda)
default LBiFunction<T1,T2,R>	rShrink(LBiFunction<T1,T2,T3> right)
default LBiFunction<T1,T2,R>	rShrinkc(T3 a3)
static <T1,T2,R,T3> LBiFunction<T1,T2,R>	rShrinked(LBiFunction<T1,T2,T3> right, LTriFunction<T1,T2,T3,R> func)
static <T1,T2,R,T3> LBiFunction<T1,T2,R>	rShrinkedc(T3 a3, LTriFunction<T1,T2,T3,R> func)
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	safe() Safe instance.
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	safe(LTriFunction<T1,T2,T3,R> other) Safe wrapping.
static <T1,T2,T3,R> LSupplier<LTriFunction<T1,T2,T3,R>>	safeSupplier() Safe instance supplier.
static <T1,T2,T3,R> LSupplier<LTriFunction<T1,T2,T3,R>>	safeSupplier(LSupplier<LTriFunction<T1,T2,T3,R>> supplier) Safe supplier.
default R	shovingApply(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(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default LTriConsumer<T1,T2,T3>	thenConsume(LConsumer<? super R> after) Combines two functions together in a order.
default LTriPredicate<T1,T2,T3>	thenToBool(LPredicate<? super R> after) Combines two functions together in a order.
default LToIntTriFunction<T1,T2,T3>	thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.
static <T1,T2,T3,R> void	times(int max_i, T1 a1, T2 a2, T3 a3, LTriFunction<T1,T2,T3,R> func) From-To.
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	triFunc(LTriFunction<T1,T2,T3,R> 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,R> LTriFunction<T1,T2,T3,R>	triFuncThrowing(ExF<Throwable> exF)
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	triFuncThrowing(String message, ExMF<Throwable> exF)
static <T1,T2,T3,R> R	tryApply(T1 a1, T2 a2, T3 a3, LTriFunction<T1,T2,T3,R> func)
static <T1,T2,T3,R> R	tryApply(T1 a1, T2 a2, T3 a3, LTriFunction<T1,T2,T3,R> func, ExWF<RuntimeException> exF)
static <T1,T2,T3,R> R	tryApply(T1 a1, T2 a2, T3 a3, LTriFunction<T1,T2,T3,R> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static <T1,T2,T3,R> R	tryApplyThen(T1 a1, T2 a2, T3 a3, LTriFunction<T1,T2,T3,R> func, LFunction<Throwable,R> handler)
default LTriFunction<T1,T2,T3,R>	trying(ExWF<RuntimeException> exF)
default LTriFunction<T1,T2,T3,R>	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LTriFunction<T1,T2,T3,R>	tryingThen(LFunction<Throwable,R> handler)
default R	tupleApply(LTriple<T1,T2,T3> args)
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	uncurry(LFunction<T1,LFunction<T2,LFunction<T3,R>>> func)
default LTriFunction	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

NULL_VALUE_MESSAGE_SUPPLIER

static final LSupplier<String> NULL_VALUE_MESSAGE_SUPPLIER

Method Detail

apply

@Nullable
default R apply(T1 a1,
                           T2 a2,
                           T3 a3)

applyX

R applyX(T1 a1,
         T2 a2,
         T3 a3)
  throws Throwable

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

Throws:

Throwable

tupleApply

default R tupleApply(LTriple<T1,T2,T3> args)

handlingApply

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

Function call that handles exceptions according to the instructions.

handling

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

apply

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

trying

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

apply

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

trying

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

applyThen

default R applyThen(T1 a1,
                    T2 a2,
                    T3 a3,
                    @Nonnull
                    LFunction<Throwable,R> handler)

tryingThen

default LTriFunction<T1,T2,T3,R> tryingThen(@Nonnull
                                            LFunction<Throwable,R> handler)

nestingApply

default R nestingApply(T1 a1,
                       T2 a2,
                       T3 a3)

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

shovingApply

default R shovingApply(T1 a1,
                       T2 a2,
                       T3 a3)

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

handlingApply

static <T1,T2,T3,R> R handlingApply(T1 a1,
                                    T2 a2,
                                    T3 a3,
                                    LTriFunction<T1,T2,T3,R> func,
                                    HandlingInstructions<Throwable,RuntimeException> handling)

tryApply

static <T1,T2,T3,R> R tryApply(T1 a1,
                               T2 a2,
                               T3 a3,
                               LTriFunction<T1,T2,T3,R> func)

tryApply

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

tryApply

static <T1,T2,T3,R> R tryApply(T1 a1,
                               T2 a2,
                               T3 a3,
                               LTriFunction<T1,T2,T3,R> func,
                               @Nonnull
                               ExWF<RuntimeException> exF)

tryApplyThen

static <T1,T2,T3,R> R tryApplyThen(T1 a1,
                                   T2 a2,
                                   T3 a3,
                                   LTriFunction<T1,T2,T3,R> func,
                                   @Nonnull
                                   LFunction<Throwable,R> handler)

failSafeApply

default R failSafeApply(T1 a1,
                        T2 a2,
                        T3 a3,
                        @Nonnull
                        LTriFunction<T1,T2,T3,R> failSafe)

failSafeApply

static <T1,T2,T3,R> R failSafeApply(T1 a1,
                                    T2 a2,
                                    T3 a3,
                                    LTriFunction<T1,T2,T3,R> func,
                                    @Nonnull
                                    LTriFunction<T1,T2,T3,R> failSafe)

failSafe

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

nonNullApply

@Nonnull
default R nonNullApply(T1 a1,
                                 T2 a2,
                                 T3 a3)

Function call that 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,R> void fromTo(int min_i,
                                int max_i,
                                T1 a1,
                                T2 a2,
                                T3 a3,
                                LTriFunction<T1,T2,T3,R> func)

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

fromTill

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

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

times

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

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

lShrink

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

lShrinkc

default LBiFunction<T2,T3,R> lShrinkc(T1 a1)

lShrinked

static <T2,T3,R,T1> LBiFunction<T2,T3,R> lShrinked(LBiFunction<T2,T3,T1> left,
                                                   LTriFunction<T1,T2,T3,R> func)

lShrinkedc

static <T2,T3,R,T1> LBiFunction<T2,T3,R> lShrinkedc(T1 a1,
                                                    LTriFunction<T1,T2,T3,R> func)

rShrink

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

rShrinkc

default LBiFunction<T1,T2,R> rShrinkc(T3 a3)

rShrinked

static <T1,T2,R,T3> LBiFunction<T1,T2,R> rShrinked(LBiFunction<T1,T2,T3> right,
                                                   LTriFunction<T1,T2,T3,R> func)

rShrinkedc

static <T1,T2,R,T3> LBiFunction<T1,T2,R> rShrinkedc(T3 a3,
                                                    LTriFunction<T1,T2,T3,R> func)

uncurry

static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R> uncurry(LFunction<T1,LFunction<T2,LFunction<T3,R>>> func)

untyped

default LTriFunction untyped()

Cast that removes generics.

cast

default <V2,V3,V4,V5> LTriFunction<V2,V3,V4,V5> cast()

Cast that replace generics.

cast

static <V2,V3,V4,V5,T1,T2,T3,R> LTriFunction<V2,V3,V4,V5> cast(LTriFunction<T1,T2,T3,R> function)

Cast that replace generics.

capture

default LSupplier<R> capture(T1 a1,
                             T2 a2,
                             T3 a3)

Captures arguments but delays the evaluation.

constant

static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R> constant(R r)

Creates function that always returns the same value.

apply1st

@Nonnull
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R> apply1st(@Nonnull
                                                                LFunction<T1,R> func)

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

apply2nd

@Nonnull
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R> apply2nd(@Nonnull
                                                                LFunction<T2,R> func)

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

apply3rd

@Nonnull
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R> apply3rd(@Nonnull
                                                                LFunction<T3,R> func)

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

triFunc

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

triFuncThrowing

@Nonnull
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R> triFuncThrowing(@Nonnull
                                                                       ExF<Throwable> exF)

triFuncThrowing

@Nonnull
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R> triFuncThrowing(String message,
                                                                       @Nonnull
                                                                       ExMF<Throwable> exF)

obj0Obj2Obj1Func

@Nonnull
static <T1,T3,T2,R> LTriFunction.LObj0Obj2Obj1Func<T1,T3,T2,R> obj0Obj2Obj1Func(@Nonnull
                                                                                          LTriFunction.LObj0Obj2Obj1Func<T1,T3,T2,R> lambda)

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

obj1BiObj2Func

@Nonnull
static <T2,T1,T3,R> LTriFunction.LObj1BiObj2Func<T2,T1,T3,R> obj1BiObj2Func(@Nonnull
                                                                                      LTriFunction.LObj1BiObj2Func<T2,T1,T3,R> lambda)

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

obj1Obj2Obj0Func

@Nonnull
static <T2,T3,T1,R> LTriFunction.LObj1Obj2Obj0Func<T2,T3,T1,R> obj1Obj2Obj0Func(@Nonnull
                                                                                          LTriFunction.LObj1Obj2Obj0Func<T2,T3,T1,R> lambda)

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

obj2Obj0Obj1Func

@Nonnull
static <T3,T1,T2,R> LTriFunction.LObj2Obj0Obj1Func<T3,T1,T2,R> obj2Obj0Obj1Func(@Nonnull
                                                                                          LTriFunction.LObj2Obj0Obj1Func<T3,T1,T2,R> lambda)

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

biObj1Obj0Func

@Nonnull
static <T3,T2,T1,R> LTriFunction.LBiObj1Obj0Func<T3,T2,T1,R> biObj1Obj0Func(@Nonnull
                                                                                      LTriFunction.LBiObj1Obj0Func<T3,T2,T1,R> 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,R> R call(T1 a1,
                           T2 a2,
                           T3 a3,
                           @Nonnull
                           LTriFunction<T1,T2,T3,R> lambda)

safe

@Nonnull
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R> safe()

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

safeSupplier

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

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

safe

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

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

safeSupplier

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

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

compose

@Nonnull
default <V1,V2,V3> LTriFunction<V1,V2,V3,R> 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,R> LTriFunction<V1,V2,V3,R> composed(@Nonnull
                                                               LFunction<? super V1,? extends T1> before1,
                                                               @Nonnull
                                                               LFunction<? super V2,? extends T2> before2,
                                                               @Nonnull
                                                               LFunction<? super V3,? extends T3> before3,
                                                               LTriFunction<T1,T2,T3,R> after)

then

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

Combines two functions together in a order.

thenConsume

@Nonnull
default LTriConsumer<T1,T2,T3> thenConsume(@Nonnull
                                                     LConsumer<? super R> after)

Combines two functions together in a order.

before

@Nonnull
default LTriFunction<T1,T2,T3,R> before(@Nonnull
                                                  LTriConsumer<? super T1,? super T2,? super T3> before)

after

@Nonnull
default LTriFunction<T1,T2,T3,R> after(@Nonnull
                                                 LConsumer<? super R> after)

thenToInt

@Nonnull
default LToIntTriFunction<T1,T2,T3> thenToInt(@Nonnull
                                                        LToIntFunction<? super R> after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LTriPredicate<T1,T2,T3> thenToBool(@Nonnull
                                                     LPredicate<? super R> after)

Combines two functions together in a order.

nonNullable

@Nonnull
default LTriFunction<T1,T2,T3,R> nonNullable()

Converts to function that makes sure that the result is not null.

produce

static <T1,T2,T3,R> R produce(T1 a1,
                              T2 a2,
                              T3 a3)

Does nothing (LTriFunction) Function

forEach

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,
                                LConsumer<? super R> 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,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,
                                   LConsumer<? super R> 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,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,
                                   LConsumer<? super R> 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,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,
                                      LConsumer<? super R> 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,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,
                                   LConsumer<? super R> 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,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,
                                      LConsumer<? super R> 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,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,
                                      LConsumer<? super R> 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,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,
                                         LConsumer<? super R> 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.