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

Packages that use LBiFunction

Package	Description
eu.lunisolar.magma.func.consumer
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 LBiFunction in eu.lunisolar.magma.func.consumer

Methods in eu.lunisolar.magma.func.consumer with parameters of type LBiFunction

Modifier and Type	Method and Description
default LBiConsumer<T2,T3>	LTriConsumer.lShrink(LBiFunction<T2,T3,T1> left)
static <T2,T3,T1> LBiConsumer<T2,T3>	LTriConsumer.lShrinked(LBiFunction<T2,T3,T1> left, LTriConsumer<T1,T2,T3> func)
default LBiConsumer<T1,T2>	LTriConsumer.rShrink(LBiFunction<T1,T2,T3> right)
static <T1,T2,T3> LBiConsumer<T1,T2>	LTriConsumer.rShrinked(LBiFunction<T1,T2,T3> right, LTriConsumer<T1,T2,T3> func)

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

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

Modifier and Type	Interface and Description
static interface	LBiFunction.LObj1Obj0Func<T2,T1,R> Permutation of LBiFunction for method references.

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

Modifier and Type	Class and Description
static class	LBiFunction.LBiFunctionSingle<T1,T2,R>

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

Modifier and Type	Method and Description
default LBiFunction<T1,T2,R>	LBiFunction.after(LConsumer<? super R> after)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiFunction.apply1st(LFunction<T1,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiFunction.apply2nd(LFunction<T2,R> func) Captures single parameter function into this interface where only 2nd parameter will be used.
default LBiFunction<T1,T2,R>	LBiFunction.before(LBiConsumer<? super T1,? super T2> before)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiFunction.biFunc(LBiFunction<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,R> LBiFunction<T1,T2,R>	LBiFunction.biFuncThrowing(ExF<Throwable> exF)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiFunction.biFuncThrowing(String message, ExMF<Throwable> exF)
default <V2,V3,V4> LBiFunction<V2,V3,V4>	LBiFunction.cast() Cast that replace generics.
static <V2,V3,V4,T1,T2,R> LBiFunction<V2,V3,V4>	LBiFunction.cast(LBiFunction<T1,T2,R> function) Cast that replace generics.
default <V1,V2> LBiFunction<V1,V2,R>	LBiFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
static <V1,V2,T1,T2,R> LBiFunction<V1,V2,R>	LBiFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LBiFunction<T1,T2,R> after)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiFunction.constant(R r) Creates function that always returns the same value.
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiFunction.failSafe(LBiFunction<T1,T2,R> func, LBiFunction<T1,T2,R> failSafe)
default LBiFunction<T1,T2,R>	LBiFunction.handling(HandlingInstructions<Throwable,RuntimeException> handling)
default LBiFunction<T2,T3,R>	LTriFunction.lShrink(LBiFunction<T2,T3,T1> left)
default LBiFunction<T2,T3,R>	LTriFunction.lShrinkc(T1 a1)
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)
default LBiFunction<T1,T2,R>	LBiFunction.nonNullable() Converts to function that makes sure that the result is not null.
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiFunction.recursive(LFunction<LBiFunction<T1,T2,R>,LBiFunction<T1,T2,R>> selfLambda)
default LBiFunction<T1,T2,R>	LTriFunction.rShrink(LBiFunction<T1,T2,T3> right)
default LBiFunction<T1,T2,R>	LTriFunction.rShrinkc(T3 a3)
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,R> LBiFunction<T1,T2,R>	LBiFunction.safe() Safe instance.
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiFunction.safe(LBiFunction<T1,T2,R> other) Safe wrapping.
default <V> LBiFunction<T1,T2,V>	LBiFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default LBiFunction<T1,T2,R>	LBiFunction.trying(ExWF<RuntimeException> exF)
default LBiFunction<T1,T2,R>	LBiFunction.trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LBiFunction<T1,T2,R>	LBiFunction.tryingThen(LFunction<Throwable,R> handler)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiFunction.uncurry(LFunction<T1,LFunction<T2,R>> func)
default LBiFunction	LBiFunction.untyped() Cast that removes generics.
LBiFunction<T1,T2,R>	LBiFunction.LBiFunctionSingle.value()
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiFunction.wrap(java.util.function.BiFunction<T1,T2,R> other) Wraps JRE instance.

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

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

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

Modifier and Type	Method and Description
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiFunction.biFunc(LBiFunction<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,R> R	LBiFunction.call(T1 a1, T2 a2, LBiFunction<T1,T2,R> lambda)
static <V2,V3,V4,T1,T2,R> LBiFunction<V2,V3,V4>	LBiFunction.cast(LBiFunction<T1,T2,R> function) Cast that replace generics.
static <V1,V2,T1,T2,R> LBiFunction<V1,V2,R>	LBiFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LBiFunction<T1,T2,R> after)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiFunction.failSafe(LBiFunction<T1,T2,R> func, LBiFunction<T1,T2,R> failSafe)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiFunction.failSafe(LBiFunction<T1,T2,R> func, LBiFunction<T1,T2,R> failSafe)
default R	LBiFunction.failSafeApply(T1 a1, T2 a2, LBiFunction<T1,T2,R> failSafe)
static <T1,T2,R> R	LBiFunction.failSafeApply(T1 a1, T2 a2, LBiFunction<T1,T2,R> func, LBiFunction<T1,T2,R> failSafe)
static <T1,T2,R> R	LBiFunction.failSafeApply(T1 a1, T2 a2, LBiFunction<T1,T2,R> func, LBiFunction<T1,T2,R> failSafe)
static <T1,T2,R> void	LBiFunction.fromTill(int min_i, int max_i, T1 a1, T2 a2, LBiFunction<T1,T2,R> func) From-To.
static <T1,T2,R> void	LBiFunction.fromTo(int min_i, int max_i, T1 a1, T2 a2, LBiFunction<T1,T2,R> func) From-To.
static <T1,T2,R> R	LBiFunction.handlingApply(T1 a1, T2 a2, LBiFunction<T1,T2,R> func, HandlingInstructions<Throwable,RuntimeException> handling)
default LBiFunction<T2,T3,R>	LTriFunction.lShrink(LBiFunction<T2,T3,T1> left)
static <T2,T3,R,T1> LBiFunction<T2,T3,R>	LTriFunction.lShrinked(LBiFunction<T2,T3,T1> left, LTriFunction<T1,T2,T3,R> func)
static <T2,R,T1> LFunction<T2,R>	LBiFunction.lShrinked(LFunction<T2,T1> left, LBiFunction<T1,T2,R> func)
static <T2,R,T1> LFunction<T2,R>	LBiFunction.lShrinkedc(T1 a1, LBiFunction<T1,T2,R> func)
default LBiFunction<T1,T2,R>	LTriFunction.rShrink(LBiFunction<T1,T2,T3> right)
static <T1,T2,R,T3> LBiFunction<T1,T2,R>	LTriFunction.rShrinked(LBiFunction<T1,T2,T3> right, LTriFunction<T1,T2,T3,R> func)
static <T1,R,T2> LFunction<T1,R>	LBiFunction.rShrinked(LFunction<T1,T2> right, LBiFunction<T1,T2,R> func)
static <T1,R,T2> LFunction<T1,R>	LBiFunction.rShrinkedc(T2 a2, LBiFunction<T1,T2,R> func)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiFunction.safe(LBiFunction<T1,T2,R> other) Safe wrapping.
static <T1,T2,R> void	LBiFunction.times(int max_i, T1 a1, T2 a2, LBiFunction<T1,T2,R> func) From-To.
static <T1,T2,R> R	LBiFunction.tryApply(T1 a1, T2 a2, LBiFunction<T1,T2,R> func)
static <T1,T2,R> R	LBiFunction.tryApply(T1 a1, T2 a2, LBiFunction<T1,T2,R> func, ExWF<RuntimeException> exF)
static <T1,T2,R> R	LBiFunction.tryApply(T1 a1, T2 a2, LBiFunction<T1,T2,R> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static <T1,T2,R> R	LBiFunction.tryApplyThen(T1 a1, T2 a2, LBiFunction<T1,T2,R> func, LFunction<Throwable,R> handler)

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

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

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

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

Modifier and Type	Method and Description
default <V1,V2> LBiFunction<V1,V2,R>	LBiBoolFunction.biBoolFuncCompose(LPredicate<? super V1> before1, LPredicate<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LBiByteFunction.biByteFuncCompose(LToByteFunction<? super V1> before1, LToByteFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LBiCharFunction.biCharFuncCompose(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LBiDblFunction.biDblFuncCompose(LToDblFunction<? super V1> before1, LToDblFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LBiFltFunction.biFltFuncCompose(LToFltFunction<? super V1> before1, LToFltFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LBiIntFunction.biIntFuncCompose(LToIntFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LBiLongFunction.biLongFuncCompose(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LBiSrtFunction.biSrtFuncCompose(LToSrtFunction<? super V1> before1, LToSrtFunction<? super V2> before2) Allows to manipulate the domain of the function.
static <V1,V2,T,R> LBiFunction<V1,V2,R>	LObjBoolFunction.composed(LFunction<? super V1,? extends T> before1, LPredicate<? super V2> before2, LObjBoolFunction<T,R> after)
static <V1,V2,T,R> LBiFunction<V1,V2,R>	LObjByteFunction.composed(LFunction<? super V1,? extends T> before1, LToByteFunction<? super V2> before2, LObjByteFunction<T,R> after)
static <V1,V2,T,R> LBiFunction<V1,V2,R>	LObjCharFunction.composed(LFunction<? super V1,? extends T> before1, LToCharFunction<? super V2> before2, LObjCharFunction<T,R> after)
static <V1,V2,T,R> LBiFunction<V1,V2,R>	LObjDblFunction.composed(LFunction<? super V1,? extends T> before1, LToDblFunction<? super V2> before2, LObjDblFunction<T,R> after)
static <V1,V2,T,R> LBiFunction<V1,V2,R>	LObjFltFunction.composed(LFunction<? super V1,? extends T> before1, LToFltFunction<? super V2> before2, LObjFltFunction<T,R> after)
static <V1,V2,T,R> LBiFunction<V1,V2,R>	LOiFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LOiFunction<T,R> after)
static <V1,V2,T,R> LBiFunction<V1,V2,R>	LObjLongFunction.composed(LFunction<? super V1,? extends T> before1, LToLongFunction<? super V2> before2, LObjLongFunction<T,R> after)
static <V1,V2,T,R> LBiFunction<V1,V2,R>	LObjSrtFunction.composed(LFunction<? super V1,? extends T> before1, LToSrtFunction<? super V2> before2, LObjSrtFunction<T,R> after)
static <V1,V2,R> LBiFunction<V1,V2,R>	LBiBoolFunction.composed(LPredicate<? super V1> before1, LPredicate<? super V2> before2, LBiBoolFunction<R> after)
static <V1,V2,R> LBiFunction<V1,V2,R>	LBiByteFunction.composed(LToByteFunction<? super V1> before1, LToByteFunction<? super V2> before2, LBiByteFunction<R> after)
static <V1,V2,R> LBiFunction<V1,V2,R>	LBiCharFunction.composed(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2, LBiCharFunction<R> after)
static <V1,V2,R> LBiFunction<V1,V2,R>	LBiDblFunction.composed(LToDblFunction<? super V1> before1, LToDblFunction<? super V2> before2, LBiDblFunction<R> after)
static <V1,V2,R> LBiFunction<V1,V2,R>	LBiFltFunction.composed(LToFltFunction<? super V1> before1, LToFltFunction<? super V2> before2, LBiFltFunction<R> after)
static <V1,V2,R> LBiFunction<V1,V2,R>	LBiIntFunction.composed(LToIntFunction<? super V1> before1, LToIntFunction<? super V2> before2, LBiIntFunction<R> after)
static <V1,V2,R> LBiFunction<V1,V2,R>	LBiLongFunction.composed(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2, LBiLongFunction<R> after)
static <V1,V2,R> LBiFunction<V1,V2,R>	LBiSrtFunction.composed(LToSrtFunction<? super V1> before1, LToSrtFunction<? super V2> before2, LBiSrtFunction<R> after)
default <V1,V2> LBiFunction<V1,V2,R>	LObjBoolFunction.objBoolFuncCompose(LFunction<? super V1,? extends T> before1, LPredicate<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LObjByteFunction.objByteFuncCompose(LFunction<? super V1,? extends T> before1, LToByteFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LObjCharFunction.objCharFuncCompose(LFunction<? super V1,? extends T> before1, LToCharFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LObjDblFunction.objDblFuncCompose(LFunction<? super V1,? extends T> before1, LToDblFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LObjFltFunction.objFltFuncCompose(LFunction<? super V1,? extends T> before1, LToFltFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LObjLongFunction.objLongFuncCompose(LFunction<? super V1,? extends T> before1, LToLongFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LObjSrtFunction.objSrtFuncCompose(LFunction<? super V1,? extends T> before1, LToSrtFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LOiFunction.oiFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default LBiFunction<T1,T2,R>	LBiObjBoolFunction.rShrink(LBiPredicate<T1,T2> right)
default LBiFunction<T1,T2,R>	LBiObjByteFunction.rShrink(LToByteBiFunction<T1,T2> right)
default LBiFunction<T1,T2,R>	LBiObjCharFunction.rShrink(LToCharBiFunction<T1,T2> right)
default LBiFunction<T1,T2,R>	LBiObjDblFunction.rShrink(LToDblBiFunction<T1,T2> right)
default LBiFunction<T1,T2,R>	LBiObjFltFunction.rShrink(LToFltBiFunction<T1,T2> right)
default LBiFunction<T1,T2,R>	LBiObjIntFunction.rShrink(LToIntBiFunction<T1,T2> right)
default LBiFunction<T1,T2,R>	LBiObjLongFunction.rShrink(LToLongBiFunction<T1,T2> right)
default LBiFunction<T1,T2,R>	LBiObjSrtFunction.rShrink(LToSrtBiFunction<T1,T2> right)
default LBiFunction<T1,T2,R>	LBiObjBoolFunction.rShrinkc(boolean a3)
default LBiFunction<T1,T2,R>	LBiObjByteFunction.rShrinkc(byte a3)
default LBiFunction<T1,T2,R>	LBiObjCharFunction.rShrinkc(char a3)
default LBiFunction<T1,T2,R>	LBiObjDblFunction.rShrinkc(double a3)
default LBiFunction<T1,T2,R>	LBiObjFltFunction.rShrinkc(float a3)
default LBiFunction<T1,T2,R>	LBiObjIntFunction.rShrinkc(int a3)
default LBiFunction<T1,T2,R>	LBiObjLongFunction.rShrinkc(long a3)
default LBiFunction<T1,T2,R>	LBiObjSrtFunction.rShrinkc(short a3)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiObjBoolFunction.rShrinked(LBiPredicate<T1,T2> right, LBiObjBoolFunction<T1,T2,R> func)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiObjByteFunction.rShrinked(LToByteBiFunction<T1,T2> right, LBiObjByteFunction<T1,T2,R> func)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiObjCharFunction.rShrinked(LToCharBiFunction<T1,T2> right, LBiObjCharFunction<T1,T2,R> func)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiObjDblFunction.rShrinked(LToDblBiFunction<T1,T2> right, LBiObjDblFunction<T1,T2,R> func)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiObjFltFunction.rShrinked(LToFltBiFunction<T1,T2> right, LBiObjFltFunction<T1,T2,R> func)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiObjIntFunction.rShrinked(LToIntBiFunction<T1,T2> right, LBiObjIntFunction<T1,T2,R> func)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiObjLongFunction.rShrinked(LToLongBiFunction<T1,T2> right, LBiObjLongFunction<T1,T2,R> func)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiObjSrtFunction.rShrinked(LToSrtBiFunction<T1,T2> right, LBiObjSrtFunction<T1,T2,R> func)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiObjBoolFunction.rShrinkedc(boolean a3, LBiObjBoolFunction<T1,T2,R> func)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiObjByteFunction.rShrinkedc(byte a3, LBiObjByteFunction<T1,T2,R> func)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiObjCharFunction.rShrinkedc(char a3, LBiObjCharFunction<T1,T2,R> func)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiObjDblFunction.rShrinkedc(double a3, LBiObjDblFunction<T1,T2,R> func)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiObjFltFunction.rShrinkedc(float a3, LBiObjFltFunction<T1,T2,R> func)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiObjIntFunction.rShrinkedc(int a3, LBiObjIntFunction<T1,T2,R> func)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiObjLongFunction.rShrinkedc(long a3, LBiObjLongFunction<T1,T2,R> func)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiObjSrtFunction.rShrinkedc(short a3, LBiObjSrtFunction<T1,T2,R> func)

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

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

Modifier and Type	Method and Description
default <V> LBiFunction<T1,T2,V>	LToByteBiFunction.then(LByteFunction<? extends V> after) Combines two functions together in a order.
default <V> LBiFunction<T1,T2,V>	LToCharBiFunction.then(LCharFunction<? extends V> after) Combines two functions together in a order.
default <V> LBiFunction<T1,T2,V>	LToDblBiFunction.then(LDblFunction<? extends V> after) Combines two functions together in a order.
default <V> LBiFunction<T1,T2,V>	LToFltBiFunction.then(LFltFunction<? extends V> after) Combines two functions together in a order.
default <V> LBiFunction<T1,T2,V>	LToIntBiFunction.then(LIntFunction<? extends V> after) Combines two functions together in a order.
default <V> LBiFunction<T1,T2,V>	LToLongBiFunction.then(LLongFunction<? extends V> after) Combines two functions together in a order.
default <V> LBiFunction<T1,T2,V>	LToSrtBiFunction.then(LSrtFunction<? extends V> after) Combines two functions together in a order.

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

Modifier and Type	Method and Description
default LToIntBiFunction<T2,T3>	LToIntTriFunction.lShrink(LBiFunction<T2,T3,T1> left)
static <T2,T3,T1> LToIntBiFunction<T2,T3>	LToIntTriFunction.lShrinked(LBiFunction<T2,T3,T1> left, LToIntTriFunction<T1,T2,T3> func)
default LToIntBiFunction<T1,T2>	LToIntTriFunction.rShrink(LBiFunction<T1,T2,T3> right)
static <T1,T2,T3> LToIntBiFunction<T1,T2>	LToIntTriFunction.rShrinked(LBiFunction<T1,T2,T3> right, LToIntTriFunction<T1,T2,T3> func)

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

Subinterfaces of LBiFunction in eu.lunisolar.magma.func.operator.binary

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

Classes in eu.lunisolar.magma.func.operator.binary that implement LBiFunction

Modifier and Type	Class and Description
static class	LBinaryOperator.LBinaryOperatorSingle<T>

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

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

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

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

Modifier and Type	Method and Description
default <V> LBiFunction<T1,T2,V>	LBiPredicate.boolToBiFunc(LBoolFunction<? extends V> after) Combines two functions together in a order.

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

Modifier and Type	Method and Description
default LBiPredicate<T2,T3>	LTriPredicate.lShrink(LBiFunction<T2,T3,T1> left)
static <T2,T3,T1> LBiPredicate<T2,T3>	LTriPredicate.lShrinked(LBiFunction<T2,T3,T1> left, LTriPredicate<T1,T2,T3> func)
default LBiPredicate<T1,T2>	LTriPredicate.rShrink(LBiFunction<T1,T2,T3> right)
static <T1,T2,T3> LBiPredicate<T1,T2>	LTriPredicate.rShrinked(LBiFunction<T1,T2,T3> right, LTriPredicate<T1,T2,T3> func)