Uses of Interface
eu.lunisolar.magma.func.function.to.LToIntBiFunction

Packages that use LToIntBiFunction

Package	Description
eu.lunisolar.magma.func.consumer.primitives.obj
eu.lunisolar.magma.func.function
eu.lunisolar.magma.func.function.from
eu.lunisolar.magma.func.function.to
eu.lunisolar.magma.func.operator.binary
eu.lunisolar.magma.func.predicate

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

Methods in eu.lunisolar.magma.func.consumer.primitives.obj with parameters of type LToIntBiFunction

Modifier and Type	Method and Description
default LBiConsumer<T1,T2>	LBiObjIntConsumer.rShrink(LToIntBiFunction<T1,T2> right)
static <T1,T2> LBiConsumer<T1,T2>	LBiObjIntConsumer.rShrinked(LToIntBiFunction<T1,T2> right, LBiObjIntConsumer<T1,T2> func)

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

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

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

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

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

Modifier and Type	Method and Description
default LBiFunction<T1,T2,R>	LBiObjIntFunction.rShrink(LToIntBiFunction<T1,T2> right)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiObjIntFunction.rShrinked(LToIntBiFunction<T1,T2> right, LBiObjIntFunction<T1,T2,R> func)

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

Subinterfaces of LToIntBiFunction in eu.lunisolar.magma.func.function.to

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

Classes in eu.lunisolar.magma.func.function.to that implement LToIntBiFunction

Modifier and Type	Class and Description
static class	LToIntBiFunction.LToIntBiFunctionSingle<T1,T2>

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

Modifier and Type	Method and Description
static <T1,T2> LToIntBiFunction<T1,T2>	LToIntBiFunction.apply1stAsInt(LToIntFunction<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LToIntBiFunction<T1,T2>	LToIntBiFunction.apply2ndAsInt(LToIntFunction<T2> func) Captures single parameter function into this interface where only 2nd parameter will be used.
default <V2,V3> LToIntBiFunction<V2,V3>	LToIntBiFunction.cast() Cast that replace generics.
static <V2,V3,T1,T2> LToIntBiFunction<V2,V3>	LToIntBiFunction.cast(LToIntBiFunction<T1,T2> function) Cast that replace generics.
default <V1,V2> LToIntBiFunction<V1,V2>	LToIntBiFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
static <V1,V2,T> LToIntBiFunction<V1,V2>	LOiToIntFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LOiToIntFunction<T> after)
static <V1,V2,T1,T2> LToIntBiFunction<V1,V2>	LToIntBiFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToIntBiFunction<T1,T2> after)
static <T1,T2> LToIntBiFunction<T1,T2>	LToIntBiFunction.constant(int r) Creates function that always returns the same value.
static <T1,T2> LToIntBiFunction<T1,T2>	LToIntBiFunction.failSafe(LToIntBiFunction<T1,T2> func, LToIntBiFunction<T1,T2> failSafe)
default LToIntBiFunction<T1,T2>	LToIntBiFunction.handling(HandlingInstructions<Throwable,RuntimeException> handling)
default LToIntBiFunction<T2,T3>	LToIntTriFunction.lShrink(LBiFunction<T2,T3,T1> left)
default LToIntBiFunction<T2,T3>	LToIntTriFunction.lShrinkc(T1 a1)
static <T2,T3,T1> LToIntBiFunction<T2,T3>	LToIntTriFunction.lShrinked(LBiFunction<T2,T3,T1> left, LToIntTriFunction<T1,T2,T3> func)
static <T2,T3,T1> LToIntBiFunction<T2,T3>	LToIntTriFunction.lShrinkedc(T1 a1, LToIntTriFunction<T1,T2,T3> func)
default <V1,V2> LToIntBiFunction<V1,V2>	LOiToIntFunction.oiToIntFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
static <T1,T2> LToIntBiFunction<T1,T2>	LToIntBiFunction.recursive(LFunction<LToIntBiFunction<T1,T2>,LToIntBiFunction<T1,T2>> selfLambda)
default LToIntBiFunction<T1,T2>	LToIntTriFunction.rShrink(LBiFunction<T1,T2,T3> right)
default LToIntBiFunction<T1,T2>	LToIntTriFunction.rShrinkc(T3 a3)
static <T1,T2,T3> LToIntBiFunction<T1,T2>	LToIntTriFunction.rShrinked(LBiFunction<T1,T2,T3> right, LToIntTriFunction<T1,T2,T3> func)
static <T1,T2,T3> LToIntBiFunction<T1,T2>	LToIntTriFunction.rShrinkedc(T3 a3, LToIntTriFunction<T1,T2,T3> func)
static <T1,T2> LToIntBiFunction<T1,T2>	LToIntBiFunction.safe() Safe instance.
static <T1,T2> LToIntBiFunction<T1,T2>	LToIntBiFunction.safe(LToIntBiFunction<T1,T2> other) Safe wrapping.
default LToIntBiFunction<T1,T2>	LToByteBiFunction.thenToInt(LByteToIntFunction after) Combines two functions together in a order.
default LToIntBiFunction<T1,T2>	LToCharBiFunction.thenToInt(LCharToIntFunction after) Combines two functions together in a order.
default LToIntBiFunction<T1,T2>	LToDblBiFunction.thenToInt(LDblToIntFunction after) Combines two functions together in a order.
default LToIntBiFunction<T1,T2>	LToFltBiFunction.thenToInt(LFltToIntFunction after) Combines two functions together in a order.
default LToIntBiFunction<T1,T2>	LToIntBiFunction.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
default LToIntBiFunction<T1,T2>	LToLongBiFunction.thenToInt(LLongToIntFunction after) Combines two functions together in a order.
default LToIntBiFunction<T1,T2>	LToSrtBiFunction.thenToInt(LSrtToIntFunction after) Combines two functions together in a order.
static <T1,T2> LToIntBiFunction<T1,T2>	LToIntBiFunction.toIntBiFunc(LToIntBiFunction<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> LToIntBiFunction<T1,T2>	LToIntBiFunction.toIntBiFuncThrowing(ExF<Throwable> exF)
static <T1,T2> LToIntBiFunction<T1,T2>	LToIntBiFunction.toIntBiFuncThrowing(String message, ExMF<Throwable> exF)
default LToIntBiFunction<T1,T2>	LToIntBiFunction.trying(ExWF<RuntimeException> exF)
default LToIntBiFunction<T1,T2>	LToIntBiFunction.trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LToIntBiFunction<T1,T2>	LToIntBiFunction.tryingThen(LToIntFunction<Throwable> handler)
static <T1,T2> LToIntBiFunction<T1,T2>	LToIntBiFunction.uncurry(LFunction<T1,LToIntFunction<T2>> func)
default LToIntBiFunction	LToIntBiFunction.untyped() Cast that removes generics.
LToIntBiFunction<T1,T2>	LToIntBiFunction.LToIntBiFunctionSingle.value()
static <T1,T2> LToIntBiFunction<T1,T2>	LToIntBiFunction.wrap(java.util.function.ToIntBiFunction<T1,T2> other) Wraps JRE instance.

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

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

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

Modifier and Type	Method and Description
static <T1,T2> int	LToIntBiFunction.call(T1 a1, T2 a2, LToIntBiFunction<T1,T2> lambda)
static <V2,V3,T1,T2> LToIntBiFunction<V2,V3>	LToIntBiFunction.cast(LToIntBiFunction<T1,T2> function) Cast that replace generics.
static <V1,V2,T1,T2> LToIntBiFunction<V1,V2>	LToIntBiFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToIntBiFunction<T1,T2> after)
static <T1,T2> LToIntBiFunction<T1,T2>	LToIntBiFunction.failSafe(LToIntBiFunction<T1,T2> func, LToIntBiFunction<T1,T2> failSafe)
static <T1,T2> LToIntBiFunction<T1,T2>	LToIntBiFunction.failSafe(LToIntBiFunction<T1,T2> func, LToIntBiFunction<T1,T2> failSafe)
default int	LToIntBiFunction.failSafeApplyAsInt(T1 a1, T2 a2, LToIntBiFunction<T1,T2> failSafe)
static <T1,T2> int	LToIntBiFunction.failSafeApplyAsInt(T1 a1, T2 a2, LToIntBiFunction<T1,T2> func, LToIntBiFunction<T1,T2> failSafe)
static <T1,T2> int	LToIntBiFunction.failSafeApplyAsInt(T1 a1, T2 a2, LToIntBiFunction<T1,T2> func, LToIntBiFunction<T1,T2> failSafe)
static <T1,T2> void	LToIntBiFunction.fromTill(int min_i, int max_i, T1 a1, T2 a2, LToIntBiFunction<T1,T2> func) From-To.
static <T1,T2> void	LToIntBiFunction.fromTo(int min_i, int max_i, T1 a1, T2 a2, LToIntBiFunction<T1,T2> func) From-To.
static <T1,T2> int	LToIntBiFunction.handlingApplyAsInt(T1 a1, T2 a2, LToIntBiFunction<T1,T2> func, HandlingInstructions<Throwable,RuntimeException> handling)
static <T2,T1> LToIntFunction<T2>	LToIntBiFunction.lShrinked(LFunction<T2,T1> left, LToIntBiFunction<T1,T2> func)
static <T2,T1> LToIntFunction<T2>	LToIntBiFunction.lShrinkedc(T1 a1, LToIntBiFunction<T1,T2> func)
static <T1,T2> LToIntFunction<T1>	LToIntBiFunction.rShrinked(LFunction<T1,T2> right, LToIntBiFunction<T1,T2> func)
static <T1,T2> LToIntFunction<T1>	LToIntBiFunction.rShrinkedc(T2 a2, LToIntBiFunction<T1,T2> func)
static <T1,T2> LToIntBiFunction<T1,T2>	LToIntBiFunction.safe(LToIntBiFunction<T1,T2> other) Safe wrapping.
static <T1,T2> void	LToIntBiFunction.times(int max_i, T1 a1, T2 a2, LToIntBiFunction<T1,T2> func) From-To.
static <T1,T2> LToIntBiFunction<T1,T2>	LToIntBiFunction.toIntBiFunc(LToIntBiFunction<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> int	LToIntBiFunction.tryApplyAsInt(T1 a1, T2 a2, LToIntBiFunction<T1,T2> func)
static <T1,T2> int	LToIntBiFunction.tryApplyAsInt(T1 a1, T2 a2, LToIntBiFunction<T1,T2> func, ExWF<RuntimeException> exF)
static <T1,T2> int	LToIntBiFunction.tryApplyAsInt(T1 a1, T2 a2, LToIntBiFunction<T1,T2> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static <T1,T2> int	LToIntBiFunction.tryApplyAsIntThen(T1 a1, T2 a2, LToIntBiFunction<T1,T2> func, LToIntFunction<Throwable> handler)

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

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

Uses of LToIntBiFunction in eu.lunisolar.magma.func.operator.binary

Methods in eu.lunisolar.magma.func.operator.binary that return LToIntBiFunction

Modifier and Type	Method and Description
static <V1,V2> LToIntBiFunction<V1,V2>	LIntBinaryOperator.composed(LToIntFunction<? super V1> before1, LToIntFunction<? super V2> before2, LIntBinaryOperator after)
default <V1,V2> LToIntBiFunction<V1,V2>	LIntBinaryOperator.intBinaryOpCompose(LToIntFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default LToIntBiFunction<T,T>	LBinaryOperator.thenToInt(LToIntFunction<? super T> after) Combines two functions together in a order.

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

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

Modifier and Type	Method and Description
default LToIntBiFunction<T1,T2>	LBiPredicate.boolToToIntBiFunc(LBoolToIntFunction after) Combines two functions together in a order.

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

Modifier and Type	Method and Description
default <V> int	LPredicate.doIf(V a1, T a2, LToIntBiFunction<V,? super T> consumer) 2
default LBiPredicate<T1,T2>	LBiObjIntPredicate.rShrink(LToIntBiFunction<T1,T2> right)
static <T1,T2> LBiPredicate<T1,T2>	LBiObjIntPredicate.rShrinked(LToIntBiFunction<T1,T2> right, LBiObjIntPredicate<T1,T2> func)