Uses of Interface
eu.lunisolar.magma.func.function.LTriFunction

Packages that use LTriFunction

Package	Description
eu.lunisolar.magma.func.function
eu.lunisolar.magma.func.function.from
eu.lunisolar.magma.func.function.to
eu.lunisolar.magma.func.operator.ternary
eu.lunisolar.magma.func.predicate

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

Subinterfaces of LTriFunction in eu.lunisolar.magma.func.function

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.

Classes in eu.lunisolar.magma.func.function that implement LTriFunction

Modifier and Type	Class and Description
static class	LTriFunction.LTriFunctionSingle<T1,T2,T3,R>

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

Modifier and Type	Method and Description
default LTriFunction<T1,T2,T3,R>	LTriFunction.after(LConsumer<? super R> after)
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	LTriFunction.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>	LTriFunction.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>	LTriFunction.apply3rd(LFunction<T3,R> func) Captures single parameter function into this interface where only 3rd parameter will be used.
default LTriFunction<T1,T2,T3,R>	LTriFunction.before(LTriConsumer<? super T1,? super T2,? super T3> before)
default <V2,V3,V4,V5> LTriFunction<V2,V3,V4,V5>	LTriFunction.cast() Cast that replace generics.
static <V2,V3,V4,V5,T1,T2,T3,R> LTriFunction<V2,V3,V4,V5>	LTriFunction.cast(LTriFunction<T1,T2,T3,R> function) Cast that replace generics.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LTriFunction.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>	LTriFunction.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>	LTriFunction.constant(R r) Creates function that always returns the same value.
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	LTriFunction.failSafe(LTriFunction<T1,T2,T3,R> func, LTriFunction<T1,T2,T3,R> failSafe)
default LTriFunction<T1,T2,T3,R>	LTriFunction.handling(HandlingInstructions<Throwable,RuntimeException> handling)
default LTriFunction<T1,T2,T3,R>	LTriFunction.nonNullable() Converts to function that makes sure that the result is not null.
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	LTriFunction.recursive(LFunction<LTriFunction<T1,T2,T3,R>,LTriFunction<T1,T2,T3,R>> selfLambda)
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	LTriFunction.safe() Safe instance.
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	LTriFunction.safe(LTriFunction<T1,T2,T3,R> other) Safe wrapping.
default <V> LTriFunction<T1,T2,T3,V>	LTriFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	LTriFunction.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>	LTriFunction.triFuncThrowing(ExF<Throwable> exF)
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	LTriFunction.triFuncThrowing(String message, ExMF<Throwable> exF)
default LTriFunction<T1,T2,T3,R>	LTriFunction.trying(ExWF<RuntimeException> exF)
default LTriFunction<T1,T2,T3,R>	LTriFunction.trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LTriFunction<T1,T2,T3,R>	LTriFunction.tryingThen(LFunction<Throwable,R> handler)
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	LTriFunction.uncurry(LFunction<T1,LFunction<T2,LFunction<T3,R>>> func)
default LTriFunction	LTriFunction.untyped() Cast that removes generics.
LTriFunction<T1,T2,T3,R>	LTriFunction.LTriFunctionSingle.value()

Methods in eu.lunisolar.magma.func.function that return types with arguments of type LTriFunction

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

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

Modifier and Type	Method and Description
static <T1,T2,T3,R> R	LTriFunction.call(T1 a1, T2 a2, T3 a3, LTriFunction<T1,T2,T3,R> lambda)
static <V2,V3,V4,V5,T1,T2,T3,R> LTriFunction<V2,V3,V4,V5>	LTriFunction.cast(LTriFunction<T1,T2,T3,R> function) Cast that replace generics.
static <V1,V2,V3,T1,T2,T3,R> LTriFunction<V1,V2,V3,R>	LTriFunction.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>	LTriFunction.failSafe(LTriFunction<T1,T2,T3,R> func, LTriFunction<T1,T2,T3,R> failSafe)
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	LTriFunction.failSafe(LTriFunction<T1,T2,T3,R> func, LTriFunction<T1,T2,T3,R> failSafe)
default R	LTriFunction.failSafeApply(T1 a1, T2 a2, T3 a3, LTriFunction<T1,T2,T3,R> failSafe)
static <T1,T2,T3,R> R	LTriFunction.failSafeApply(T1 a1, T2 a2, T3 a3, LTriFunction<T1,T2,T3,R> func, LTriFunction<T1,T2,T3,R> failSafe)
static <T1,T2,T3,R> R	LTriFunction.failSafeApply(T1 a1, T2 a2, T3 a3, LTriFunction<T1,T2,T3,R> func, LTriFunction<T1,T2,T3,R> failSafe)
static <T1,T2,T3,R> void	LTriFunction.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	LTriFunction.fromTo(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> R	LTriFunction.handlingApply(T1 a1, T2 a2, T3 a3, LTriFunction<T1,T2,T3,R> func, HandlingInstructions<Throwable,RuntimeException> handling)
static <T2,T3,R,T1> LBiFunction<T2,T3,R>	LTriFunction.lShrinked(LBiFunction<T2,T3,T1> left, LTriFunction<T1,T2,T3,R> func)
static <T2,T3,R,T1> LBiFunction<T2,T3,R>	LTriFunction.lShrinkedc(T1 a1, LTriFunction<T1,T2,T3,R> func)
static <T1,T2,R,T3> LBiFunction<T1,T2,R>	LTriFunction.rShrinked(LBiFunction<T1,T2,T3> right, LTriFunction<T1,T2,T3,R> func)
static <T1,T2,R,T3> LBiFunction<T1,T2,R>	LTriFunction.rShrinkedc(T3 a3, LTriFunction<T1,T2,T3,R> func)
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	LTriFunction.safe(LTriFunction<T1,T2,T3,R> other) Safe wrapping.
static <T1,T2,T3,R> void	LTriFunction.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>	LTriFunction.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> R	LTriFunction.tryApply(T1 a1, T2 a2, T3 a3, LTriFunction<T1,T2,T3,R> func)
static <T1,T2,T3,R> R	LTriFunction.tryApply(T1 a1, T2 a2, T3 a3, LTriFunction<T1,T2,T3,R> func, ExWF<RuntimeException> exF)
static <T1,T2,T3,R> R	LTriFunction.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	LTriFunction.tryApplyThen(T1 a1, T2 a2, T3 a3, LTriFunction<T1,T2,T3,R> func, LFunction<Throwable,R> handler)

Method parameters in eu.lunisolar.magma.func.function with type arguments of type LTriFunction

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

Uses of LTriFunction in eu.lunisolar.magma.func.function.from

Methods in eu.lunisolar.magma.func.function.from that return LTriFunction

Modifier and Type	Method and Description
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjBoolFunction.biObjBoolFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LPredicate<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjByteFunction.biObjByteFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjCharFunction.biObjCharFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToCharFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjDblFunction.biObjDblFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjFltFunction.biObjFltFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjIntFunction.biObjIntFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToIntFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjLongFunction.biObjLongFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjSrtFunction.biObjSrtFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3) Allows to manipulate the domain of the function.
static <V1,V2,V3,T,R> LTriFunction<V1,V2,V3,R>	LObjIntBoolFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LPredicate<? super V3> before3, LObjIntBoolFunction<T,R> after)
static <V1,V2,V3,T,R> LTriFunction<V1,V2,V3,R>	LObjIntByteFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToByteFunction<? super V3> before3, LObjIntByteFunction<T,R> after)
static <V1,V2,V3,T,R> LTriFunction<V1,V2,V3,R>	LObjIntCharFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToCharFunction<? super V3> before3, LObjIntCharFunction<T,R> after)
static <V1,V2,V3,T,R> LTriFunction<V1,V2,V3,R>	LObjIntDblFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToDblFunction<? super V3> before3, LObjIntDblFunction<T,R> after)
static <V1,V2,V3,T,R> LTriFunction<V1,V2,V3,R>	LObjIntFltFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToFltFunction<? super V3> before3, LObjIntFltFunction<T,R> after)
static <V1,V2,V3,T,R> LTriFunction<V1,V2,V3,R>	LObjBiIntFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToIntFunction<? super V3> before3, LObjBiIntFunction<T,R> after)
static <V1,V2,V3,T,R> LTriFunction<V1,V2,V3,R>	LObjIntLongFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToLongFunction<? super V3> before3, LObjIntLongFunction<T,R> after)
static <V1,V2,V3,T,R> LTriFunction<V1,V2,V3,R>	LObjIntSrtFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToSrtFunction<? super V3> before3, LObjIntSrtFunction<T,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjBoolFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LPredicate<? super V3> before3, LBiObjBoolFunction<T1,T2,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjByteFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3, LBiObjByteFunction<T1,T2,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjCharFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToCharFunction<? super V3> before3, LBiObjCharFunction<T1,T2,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjDblFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblFunction<? super V3> before3, LBiObjDblFunction<T1,T2,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjFltFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3, LBiObjFltFunction<T1,T2,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjIntFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToIntFunction<? super V3> before3, LBiObjIntFunction<T1,T2,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjLongFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3, LBiObjLongFunction<T1,T2,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjSrtFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3, LBiObjSrtFunction<T1,T2,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LObjIntObjFunction.composed(LFunction<? super V1,? extends T1> before1, LToIntFunction<? super V2> before2, LFunction<? super V3,? extends T2> before3, LObjIntObjFunction<T1,T2,R> after)
static <V1,V2,V3,R> LTriFunction<V1,V2,V3,R>	LTriBoolFunction.composed(LPredicate<? super V1> before1, LPredicate<? super V2> before2, LPredicate<? super V3> before3, LTriBoolFunction<R> after)
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LObjBiIntFunction.objBiIntFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToIntFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LObjIntBoolFunction.objIntBoolFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LPredicate<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LObjIntByteFunction.objIntByteFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToByteFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LObjIntCharFunction.objIntCharFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToCharFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LObjIntDblFunction.objIntDblFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToDblFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LObjIntFltFunction.objIntFltFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToFltFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LObjIntLongFunction.objIntLongFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToLongFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LObjIntObjFunction.objIntObjFuncCompose(LFunction<? super V1,? extends T1> before1, LToIntFunction<? super V2> before2, LFunction<? super V3,? extends T2> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LObjIntSrtFunction.objIntSrtFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToSrtFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LTriBoolFunction.triBoolFuncCompose(LPredicate<? super V1> before1, LPredicate<? super V2> before2, LPredicate<? super V3> before3) Allows to manipulate the domain of the function.

Uses of LTriFunction in eu.lunisolar.magma.func.function.to

Methods in eu.lunisolar.magma.func.function.to that return LTriFunction

Modifier and Type	Method and Description
default <V> LTriFunction<T1,T2,T3,V>	LToIntTriFunction.then(LIntFunction<? extends V> after) Combines two functions together in a order.

Uses of LTriFunction in eu.lunisolar.magma.func.operator.ternary

Subinterfaces of LTriFunction in eu.lunisolar.magma.func.operator.ternary

Modifier and Type	Interface and Description
interface	LTernaryOperator<T> Non-throwing functional interface (lambda) LTernaryOperator for Java 8.

Classes in eu.lunisolar.magma.func.operator.ternary that implement LTriFunction

Modifier and Type	Class and Description
static class	LTernaryOperator.LTernaryOperatorSingle<T>

Methods in eu.lunisolar.magma.func.operator.ternary that return LTriFunction

Modifier and Type	Method and Description
default <V> LTriFunction<T,T,T,V>	LTernaryOperator.then(LFunction<? super T,? extends V> after) Combines two functions together in a order.

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

Methods in eu.lunisolar.magma.func.predicate that return LTriFunction

Modifier and Type	Method and Description
default <V> LTriFunction<T1,T2,T3,V>	LTriPredicate.boolToTriFunc(LBoolFunction<? extends V> after) Combines two functions together in a order.