LBiObjFltFunction (magma-func 2.0.0 API)

All Superinterfaces:

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

All Known Subinterfaces:

LBiObjFltFunction.LFlt2Obj0Obj1Func<T1,T2,R>, LBiObjFltFunction.LFlt2Obj1Obj0Func<T2,T1,R>, LBiObjFltFunction.LObj0Flt2Obj1Func<T1,T2,R>, LBiObjFltFunction.LObj1Flt2Obj0Func<T2,T1,R>, LBiObjFltFunction.LObj1Obj0Flt2Func<T2,T1,R>

All Known Implementing Classes:

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

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static class`	`LBiObjFltFunction.LBiObjFltFunctionSingle<T1,T2,R>`
`static interface`	`LBiObjFltFunction.LFlt2Obj0Obj1Func<T1,T2,R>` Permutation of LBiObjFltFunction for method references.
`static interface`	`LBiObjFltFunction.LFlt2Obj1Obj0Func<T2,T1,R>` Permutation of LBiObjFltFunction for method references.
`static interface`	`LBiObjFltFunction.LObj0Flt2Obj1Func<T1,T2,R>` Permutation of LBiObjFltFunction for method references.
`static interface`	`LBiObjFltFunction.LObj1Flt2Obj0Func<T2,T1,R>` Permutation of LBiObjFltFunction for method references.
`static interface`	`LBiObjFltFunction.LObj1Obj0Flt2Func<T2,T1,R>` Permutation of LBiObjFltFunction for method references.

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

Fields
Modifier and Type	Field and Description
`static String`	`DESCRIPTION`
`static LSupplier<String>`	`NULL_VALUE_MESSAGE_SUPPLIER`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default LBiObjFltFunction<T1,T2,R>`	`after(LConsumer<? super R> after)`
`default R`	`apply(T1 a1, T2 a2, float a3)`
`default R`	`apply(T1 a1, T2 a2, float a3, ExWF<RuntimeException> exF)`
`default R`	`apply(T1 a1, T2 a2, float a3, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static <T1,T2,R> LBiObjFltFunction<T1,T2,R>`	`apply1st(LFunction<T1,R> func)` Captures single parameter function into this interface where only 1st parameter will be used.
`static <T1,T2,R> LBiObjFltFunction<T1,T2,R>`	`apply2nd(LFunction<T2,R> func)` Captures single parameter function into this interface where only 2nd parameter will be used.
`static <T1,T2,R> LBiObjFltFunction<T1,T2,R>`	`apply3rd(LFltFunction<R> func)` Captures single parameter function into this interface where only 3rd parameter will be used.
`default R`	`applyThen(T1 a1, T2 a2, float a3, LFunction<Throwable,R> handler)`
`R`	`applyX(T1 a1, T2 a2, float a3)` Implement this, but call apply(T1 a1,T2 a2,float a3)
`default LBiObjFltFunction<T1,T2,R>`	`before(LBiObjFltConsumer<? super T1,? super T2> before)`
`static <T1,T2,R> LBiObjFltFunction<T1,T2,R>`	`biObjFltFunc(LBiObjFltFunction<T1,T2,R> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`default <V1,V2,V3> LTriFunction<V1,V2,V3,R>`	`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.
`static <T1,T2,R> LBiObjFltFunction<T1,T2,R>`	`biObjFltFuncThrowing(ExF<Throwable> exF)`
`static <T1,T2,R> LBiObjFltFunction<T1,T2,R>`	`biObjFltFuncThrowing(String message, ExMF<Throwable> exF)`
`static <T1,T2,R> R`	`call(T1 a1, T2 a2, float a3, LBiObjFltFunction<T1,T2,R> lambda)`
`default LSupplier<R>`	`capture(T1 a1, T2 a2, float a3)` Captures arguments but delays the evaluation.
`default <V2,V3,V4> LBiObjFltFunction<V2,V3,V4>`	`cast()` Cast that replace generics.
`static <V2,V3,V4,T1,T2,R> LBiObjFltFunction<V2,V3,V4>`	`cast(LBiObjFltFunction<T1,T2,R> function)` Cast that replace generics.
`default <V1,V2> LBiObjFltFunction<V1,V2,R>`	`compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFltUnaryOperator before3)` Allows to manipulate the domain of the function.
`static <V1,V2,T1,T2,R> LBiObjFltFunction<V1,V2,R>`	`composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFltUnaryOperator before3, LBiObjFltFunction<T1,T2,R> after)`
`static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>`	`composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3, LBiObjFltFunction<T1,T2,R> after)`
`static <T1,T2,R> LBiObjFltFunction<T1,T2,R>`	`constant(R r)` Creates function that always returns the same value.
`static <T1,T2,R> LBiObjFltFunction<T1,T2,R>`	`failSafe(LBiObjFltFunction<T1,T2,R> func, LBiObjFltFunction<T1,T2,R> failSafe)`
`default R`	`failSafeApply(T1 a1, T2 a2, float a3, LBiObjFltFunction<T1,T2,R> failSafe)`
`static <T1,T2,R> R`	`failSafeApply(T1 a1, T2 a2, float a3, LBiObjFltFunction<T1,T2,R> func, LBiObjFltFunction<T1,T2,R> failSafe)`
`static <T1,T2,R> LBiObjFltFunction.LFlt2Obj0Obj1Func<T1,T2,R>`	`flt2Obj0Obj1Func(LBiObjFltFunction.LFlt2Obj0Obj1Func<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 <T2,T1,R> LBiObjFltFunction.LFlt2Obj1Obj0Func<T2,T1,R>`	`flt2Obj1Obj0Func(LBiObjFltFunction.LFlt2Obj1Obj0Func<T2,T1,R> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`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.aFloat> 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,R> void`	`fromTill(int min_i, int max_i, T1 a1, T2 a2, float a3, LBiObjFltFunction<T1,T2,R> func)` From-To.
`static <T1,T2,R> void`	`fromTo(int min_i, int max_i, T1 a1, T2 a2, float a3, LBiObjFltFunction<T1,T2,R> func)` From-To.
`default String`	`functionalInterfaceDescription()` Returns description of the functional interface.
`default LBiObjFltFunction<T1,T2,R>`	`handling(HandlingInstructions<Throwable,RuntimeException> handling)`
`default R`	`handlingApply(T1 a1, T2 a2, float a3, HandlingInstructions<Throwable,RuntimeException> handling)` Function call that handles exceptions according to the instructions.
`static <T1,T2,R> R`	`handlingApply(T1 a1, T2 a2, float a3, LBiObjFltFunction<T1,T2,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.aFloat> 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.aFloat> 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.aFloat> 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.aFloat> 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.aFloat> 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.aFloat> 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.aFloat> sa3, C3 source3, LConsumer<? super R> consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`default LObjFltFunction<T2,R>`	`lShrink(LObjFltFunction<T2,T1> left)`
`default LObjFltFunction<T2,R>`	`lShrinkc(T1 a1)`
`static <T2,R,T1> LObjFltFunction<T2,R>`	`lShrinked(LObjFltFunction<T2,T1> left, LBiObjFltFunction<T1,T2,R> func)`
`static <T2,R,T1> LObjFltFunction<T2,R>`	`lShrinkedc(T1 a1, LBiObjFltFunction<T1,T2,R> func)`
`default R`	`nestingApply(T1 a1, T2 a2, float a3)` Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
`default LBiObjFltFunction<T1,T2,R>`	`nonNullable()` Converts to function that makes sure that the result is not null.
`default R`	`nonNullApply(T1 a1, T2 a2, float a3)` Function call that ensures the result is not null
`static <T1,T2,R> LBiObjFltFunction.LObj0Flt2Obj1Func<T1,T2,R>`	`obj0Flt2Obj1Func(LBiObjFltFunction.LObj0Flt2Obj1Func<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 <T2,T1,R> LBiObjFltFunction.LObj1Flt2Obj0Func<T2,T1,R>`	`obj1Flt2Obj0Func(LBiObjFltFunction.LObj1Flt2Obj0Func<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 <T2,T1,R> LBiObjFltFunction.LObj1Obj0Flt2Func<T2,T1,R>`	`obj1Obj0Flt2Func(LBiObjFltFunction.LObj1Obj0Flt2Func<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,R> R`	`produce(float a3, T1 a1, T2 a2)` Does nothing (LBiObjFltFunction.LFlt2Obj0Obj1Func) Function
`static <T1,T2,R> R`	`produce(T1 a1, float a3, T2 a2)` Does nothing (LBiObjFltFunction.LObj0Flt2Obj1Func) Function
`static <T1,T2,R> R`	`produce(T1 a1, T2 a2, float a3)` Does nothing (LBiObjFltFunction) Function
`static <T1,T2,R> LBiObjFltFunction<T1,T2,R>`	`recursive(LFunction<LBiObjFltFunction<T1,T2,R>,LBiObjFltFunction<T1,T2,R>> selfLambda)`
`default LBiFunction<T1,T2,R>`	`rShrink(LToFltBiFunction<T1,T2> right)`
`default LBiFunction<T1,T2,R>`	`rShrinkc(float a3)`
`static <T1,T2,R> LBiFunction<T1,T2,R>`	`rShrinked(LToFltBiFunction<T1,T2> right, LBiObjFltFunction<T1,T2,R> func)`
`static <T1,T2,R> LBiFunction<T1,T2,R>`	`rShrinkedc(float a3, LBiObjFltFunction<T1,T2,R> func)`
`static <T1,T2,R> LBiObjFltFunction<T1,T2,R>`	`safe()` Safe instance.
`static <T1,T2,R> LBiObjFltFunction<T1,T2,R>`	`safe(LBiObjFltFunction<T1,T2,R> other)` Safe wrapping.
`static <T1,T2,R> LSupplier<LBiObjFltFunction<T1,T2,R>>`	`safeSupplier()` Safe instance supplier.
`static <T1,T2,R> LSupplier<LBiObjFltFunction<T1,T2,R>>`	`safeSupplier(LSupplier<LBiObjFltFunction<T1,T2,R>> supplier)` Safe supplier.
`default R`	`shovingApply(T1 a1, T2 a2, float a3)` Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
`default <V> LBiObjFltFunction<T1,T2,V>`	`then(LFunction<? super R,? extends V> after)` Combines two functions together in a order.
`default LBiObjFltConsumer<T1,T2>`	`thenConsume(LConsumer<? super R> after)` Combines two functions together in a order.
`default LBiObjFltPredicate<T1,T2>`	`thenToBool(LPredicate<? super R> after)` Combines two functions together in a order.
`static <T1,T2,R> void`	`times(int max_i, T1 a1, T2 a2, float a3, LBiObjFltFunction<T1,T2,R> func)` From-To.
`static <T1,T2,R> R`	`tryApply(T1 a1, T2 a2, float a3, LBiObjFltFunction<T1,T2,R> func)`
`static <T1,T2,R> R`	`tryApply(T1 a1, T2 a2, float a3, LBiObjFltFunction<T1,T2,R> func, ExWF<RuntimeException> exF)`
`static <T1,T2,R> R`	`tryApply(T1 a1, T2 a2, float a3, LBiObjFltFunction<T1,T2,R> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static <T1,T2,R> R`	`tryApplyThen(T1 a1, T2 a2, float a3, LBiObjFltFunction<T1,T2,R> func, LFunction<Throwable,R> handler)`
`default LBiObjFltFunction<T1,T2,R>`	`trying(ExWF<RuntimeException> exF)`
`default LBiObjFltFunction<T1,T2,R>`	`trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default LBiObjFltFunction<T1,T2,R>`	`tryingThen(LFunction<Throwable,R> handler)`
`default R`	`tupleApply(LBiObjFltTriple<T1,T2> args)`
`static <T1,T2,R> LBiObjFltFunction<T1,T2,R>`	`uncurry(LFunction<T1,LFunction<T2,LFltFunction<R>>> func)`
`default LBiObjFltFunction`	`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,
                           float a3)

applyX

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

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

Throws:: Throwable

tupleApply

default R tupleApply(LBiObjFltTriple<T1,T2> args)

handlingApply

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

Function call that handles exceptions according to the instructions.

handling

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

apply

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

trying

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

apply

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

trying

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

applyThen

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

tryingThen

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

nestingApply

default R nestingApply(T1 a1,
                       T2 a2,
                       float 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,
                       float a3)

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

handlingApply

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

tryApply

static <T1,T2,R> R tryApply(T1 a1,
                            T2 a2,
                            float a3,
                            LBiObjFltFunction<T1,T2,R> func)

tryApply

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

tryApply

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

tryApplyThen

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

failSafeApply

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

failSafeApply

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

failSafe

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

nonNullApply

@Nonnull
default R nonNullApply(T1 a1,
                                 T2 a2,
                                 float 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,R> void fromTo(int min_i,
                             int max_i,
                             T1 a1,
                             T2 a2,
                             float a3,
                             LBiObjFltFunction<T1,T2,R> func)

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

fromTill

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

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

times

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

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

lShrink

default LObjFltFunction<T2,R> lShrink(LObjFltFunction<T2,T1> left)

lShrinkc

default LObjFltFunction<T2,R> lShrinkc(T1 a1)

lShrinked

static <T2,R,T1> LObjFltFunction<T2,R> lShrinked(LObjFltFunction<T2,T1> left,
                                                 LBiObjFltFunction<T1,T2,R> func)

lShrinkedc

static <T2,R,T1> LObjFltFunction<T2,R> lShrinkedc(T1 a1,
                                                  LBiObjFltFunction<T1,T2,R> func)

rShrink

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

rShrinkc

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

rShrinked

static <T1,T2,R> LBiFunction<T1,T2,R> rShrinked(LToFltBiFunction<T1,T2> right,
                                                LBiObjFltFunction<T1,T2,R> func)

rShrinkedc

static <T1,T2,R> LBiFunction<T1,T2,R> rShrinkedc(float a3,
                                                 LBiObjFltFunction<T1,T2,R> func)

uncurry

static <T1,T2,R> LBiObjFltFunction<T1,T2,R> uncurry(LFunction<T1,LFunction<T2,LFltFunction<R>>> func)

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

cast

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

Cast that replace generics.

cast

static <V2,V3,V4,T1,T2,R> LBiObjFltFunction<V2,V3,V4> cast(LBiObjFltFunction<T1,T2,R> function)

Cast that replace generics.

capture

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

Captures arguments but delays the evaluation.

constant

static <T1,T2,R> LBiObjFltFunction<T1,T2,R> constant(R r)

Creates function that always returns the same value.

apply1st

@Nonnull
static <T1,T2,R> LBiObjFltFunction<T1,T2,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,R> LBiObjFltFunction<T1,T2,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,R> LBiObjFltFunction<T1,T2,R> apply3rd(@Nonnull
                                                               LFltFunction<R> func)

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

biObjFltFunc

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

biObjFltFuncThrowing

@Nonnull
static <T1,T2,R> LBiObjFltFunction<T1,T2,R> biObjFltFuncThrowing(@Nonnull
                                                                           ExF<Throwable> exF)

biObjFltFuncThrowing

@Nonnull
static <T1,T2,R> LBiObjFltFunction<T1,T2,R> biObjFltFuncThrowing(String message,
                                                                           @Nonnull
                                                                           ExMF<Throwable> exF)

obj0Flt2Obj1Func

@Nonnull
static <T1,T2,R> LBiObjFltFunction.LObj0Flt2Obj1Func<T1,T2,R> obj0Flt2Obj1Func(@Nonnull
                                                                                         LBiObjFltFunction.LObj0Flt2Obj1Func<T1,T2,R> lambda)

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

obj1Obj0Flt2Func

@Nonnull
static <T2,T1,R> LBiObjFltFunction.LObj1Obj0Flt2Func<T2,T1,R> obj1Obj0Flt2Func(@Nonnull
                                                                                         LBiObjFltFunction.LObj1Obj0Flt2Func<T2,T1,R> lambda)

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

obj1Flt2Obj0Func

@Nonnull
static <T2,T1,R> LBiObjFltFunction.LObj1Flt2Obj0Func<T2,T1,R> obj1Flt2Obj0Func(@Nonnull
                                                                                         LBiObjFltFunction.LObj1Flt2Obj0Func<T2,T1,R> lambda)

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

flt2Obj0Obj1Func

@Nonnull
static <T1,T2,R> LBiObjFltFunction.LFlt2Obj0Obj1Func<T1,T2,R> flt2Obj0Obj1Func(@Nonnull
                                                                                         LBiObjFltFunction.LFlt2Obj0Obj1Func<T1,T2,R> lambda)

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

flt2Obj1Obj0Func

@Nonnull
static <T2,T1,R> LBiObjFltFunction.LFlt2Obj1Obj0Func<T2,T1,R> flt2Obj1Obj0Func(@Nonnull
                                                                                         LBiObjFltFunction.LFlt2Obj1Obj0Func<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,R> R call(T1 a1,
                        T2 a2,
                        float a3,
                        @Nonnull
                        LBiObjFltFunction<T1,T2,R> lambda)

safe
```
@Nonnull
static <T1,T2,R> LBiObjFltFunction<T1,T2,R> safe()
```
Safe instance. That always returns the same value (as produce).

safeSupplier

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

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

safe

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

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

safeSupplier

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

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

compose

@Nonnull
default <V1,V2> LBiObjFltFunction<V1,V2,R> compose(@Nonnull
                                                             LFunction<? super V1,? extends T1> before1,
                                                             @Nonnull
                                                             LFunction<? super V2,? extends T2> before2,
                                                             @Nonnull
                                                             LFltUnaryOperator before3)

Allows to manipulate the domain of the function.

composed

static <V1,V2,T1,T2,R> LBiObjFltFunction<V1,V2,R> composed(@Nonnull
                                                           LFunction<? super V1,? extends T1> before1,
                                                           @Nonnull
                                                           LFunction<? super V2,? extends T2> before2,
                                                           @Nonnull
                                                           LFltUnaryOperator before3,
                                                           LBiObjFltFunction<T1,T2,R> after)

biObjFltFuncCompose

@Nonnull
default <V1,V2,V3> LTriFunction<V1,V2,V3,R> biObjFltFuncCompose(@Nonnull
                                                                          LFunction<? super V1,? extends T1> before1,
                                                                          @Nonnull
                                                                          LFunction<? super V2,? extends T2> before2,
                                                                          @Nonnull
                                                                          LToFltFunction<? super V3> before3)

Allows to manipulate the domain of the function.

composed

static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R> composed(@Nonnull
                                                            LFunction<? super V1,? extends T1> before1,
                                                            @Nonnull
                                                            LFunction<? super V2,? extends T2> before2,
                                                            @Nonnull
                                                            LToFltFunction<? super V3> before3,
                                                            LBiObjFltFunction<T1,T2,R> after)

then

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

Combines two functions together in a order.

thenConsume

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

Combines two functions together in a order.

before

@Nonnull
default LBiObjFltFunction<T1,T2,R> before(@Nonnull
                                                    LBiObjFltConsumer<? super T1,? super T2> before)

after

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

thenToBool

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

Combines two functions together in a order.

nonNullable
```
@Nonnull
default LBiObjFltFunction<T1,T2,R> nonNullable()
```
Converts to function that makes sure that the result is not null.

produce

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

Does nothing (LBiObjFltFunction) Function

produce

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

Does nothing (LBiObjFltFunction.LObj0Flt2Obj1Func) Function

produce

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

Does nothing (LBiObjFltFunction.LFlt2Obj0Obj1Func) Function