LToDblBiFunction (magma-func 2.0.0 API)

All Superinterfaces:

Codomain<aType.aDouble>, Domain, Domain2<aType.a<T1>,aType.a<T2>>, Formattable, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>, java.util.function.ToDoubleBiFunction<T1,T2>

All Known Subinterfaces:

LToDblBiFunction.LToDblObj1Obj0Func<T2,T1>

All Known Implementing Classes:

LToDblBiFunction.LToDblBiFunctionSingle
```
@FunctionalInterface
public interface LToDblBiFunction<T1,T2>
extends java.util.function.ToDoubleBiFunction<T1,T2>, MetaFunction, MetaInterface.NonThrowing, Codomain<aType.aDouble>, Domain2<aType.a<T1>,aType.a<T2>>
```
Non-throwing functional interface (lambda) LToDblBiFunction for Java 8.
Type: function
Domain (lvl: 2): T1 a1,T2 a2
Co-domain: double

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static class`	`LToDblBiFunction.LToDblBiFunctionSingle<T1,T2>`
`static interface`	`LToDblBiFunction.LToDblObj1Obj0Func<T2,T1>` Permutation of LToDblBiFunction 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

Fields
Modifier and Type	Field and Description
`static String`	`DESCRIPTION`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`static <T1,T2> LToDblBiFunction<T1,T2>`	`apply1stAsDbl(LToDblFunction<T1> func)` Captures single parameter function into this interface where only 1st parameter will be used.
`static <T1,T2> LToDblBiFunction<T1,T2>`	`apply2ndAsDbl(LToDblFunction<T2> func)` Captures single parameter function into this interface where only 2nd parameter will be used.
`default double`	`applyAsDbl(T1 a1, T2 a2)`
`default double`	`applyAsDbl(T1 a1, T2 a2, ExWF<RuntimeException> exF)`
`default double`	`applyAsDbl(T1 a1, T2 a2, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default double`	`applyAsDblThen(T1 a1, T2 a2, LToDblFunction<Throwable> handler)`
`double`	`applyAsDblX(T1 a1, T2 a2)` Implement this, but call applyAsDbl(T1 a1,T2 a2)
`default double`	`applyAsDouble(T1 a1, T2 a2)` Deprecated. Calling this method via LToDblBiFunction interface should be discouraged.
`static <T1,T2> double`	`call(T1 a1, T2 a2, LToDblBiFunction<T1,T2> lambda)`
`default LDblSupplier`	`capture(T1 a1, T2 a2)` Captures arguments but delays the evaluation.
`default <V2,V3> LToDblBiFunction<V2,V3>`	`cast()` Cast that replace generics.
`static <V2,V3,T1,T2> LToDblBiFunction<V2,V3>`	`cast(LToDblBiFunction<T1,T2> function)` Cast that replace generics.
`default <V1,V2> LToDblBiFunction<V1,V2>`	`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> LToDblBiFunction<V1,V2>`	`composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblBiFunction<T1,T2> after)`
`static <T1,T2> LToDblBiFunction<T1,T2>`	`constant(double r)` Creates function that always returns the same value.
`static <T1,T2> LToDblBiFunction<T1,T2>`	`failSafe(LToDblBiFunction<T1,T2> func, LToDblBiFunction<T1,T2> failSafe)`
`default double`	`failSafeApplyAsDbl(T1 a1, T2 a2, LToDblBiFunction<T1,T2> failSafe)`
`static <T1,T2> double`	`failSafeApplyAsDbl(T1 a1, T2 a2, LToDblBiFunction<T1,T2> func, LToDblBiFunction<T1,T2> failSafe)`
`default <C1,C2> void`	`forEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, LDblConsumer consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`static <T1,T2> void`	`fromTill(int min_i, int max_i, T1 a1, T2 a2, LToDblBiFunction<T1,T2> func)` From-To.
`static <T1,T2> void`	`fromTo(int min_i, int max_i, T1 a1, T2 a2, LToDblBiFunction<T1,T2> func)` From-To.
`default String`	`functionalInterfaceDescription()` Returns description of the functional interface.
`default LToDblBiFunction<T1,T2>`	`handling(HandlingInstructions<Throwable,RuntimeException> handling)`
`default double`	`handlingApplyAsDbl(T1 a1, T2 a2, HandlingInstructions<Throwable,RuntimeException> handling)` Function call that handles exceptions according to the instructions.
`static <T1,T2> double`	`handlingApplyAsDbl(T1 a1, T2 a2, LToDblBiFunction<T1,T2> func, HandlingInstructions<Throwable,RuntimeException> handling)`
`default <C1,C2,I2> void`	`iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, LDblConsumer consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`default <C1,I1,C2> void`	`iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, LDblConsumer consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`default <C1,I1,C2,I2> void`	`iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, LDblConsumer consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`default LToDblFunction<T2>`	`lShrink(LFunction<T2,T1> left)`
`default LToDblFunction<T2>`	`lShrinkc(T1 a1)`
`static <T2,T1> LToDblFunction<T2>`	`lShrinked(LFunction<T2,T1> left, LToDblBiFunction<T1,T2> func)`
`static <T2,T1> LToDblFunction<T2>`	`lShrinkedc(T1 a1, LToDblBiFunction<T1,T2> func)`
`default double`	`nestingApplyAsDbl(T1 a1, T2 a2)` Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
`default double`	`nonNullApplyAsDbl(T1 a1, T2 a2)` Just to mirror the method: Ensures the result is not null
`static <T1,T2> double`	`produceDouble(T1 a1, T2 a2)` Does nothing (LToDblBiFunction) Function
`static <T1,T2> LToDblBiFunction<T1,T2>`	`recursive(LFunction<LToDblBiFunction<T1,T2>,LToDblBiFunction<T1,T2>> selfLambda)`
`default LToDblFunction<T1>`	`rShrink(LFunction<T1,T2> right)`
`default LToDblFunction<T1>`	`rShrinkc(T2 a2)`
`static <T1,T2> LToDblFunction<T1>`	`rShrinked(LFunction<T1,T2> right, LToDblBiFunction<T1,T2> func)`
`static <T1,T2> LToDblFunction<T1>`	`rShrinkedc(T2 a2, LToDblBiFunction<T1,T2> func)`
`static <T1,T2> LToDblBiFunction<T1,T2>`	`safe()` Safe instance.
`static <T1,T2> LToDblBiFunction<T1,T2>`	`safe(LToDblBiFunction<T1,T2> other)` Safe wrapping.
`static <T1,T2> LSupplier<LToDblBiFunction<T1,T2>>`	`safeSupplier()` Safe instance supplier.
`static <T1,T2> LSupplier<LToDblBiFunction<T1,T2>>`	`safeSupplier(LSupplier<LToDblBiFunction<T1,T2>> supplier)` Safe supplier.
`default double`	`shovingApplyAsDbl(T1 a1, T2 a2)` Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
`default <V> LBiFunction<T1,T2,V>`	`then(LDblFunction<? extends V> after)` Combines two functions together in a order.
`default LBiPredicate<T1,T2>`	`thenToBool(LDblPredicate after)` Combines two functions together in a order.
`default LToByteBiFunction<T1,T2>`	`thenToByte(LDblToByteFunction after)` Combines two functions together in a order.
`default LToCharBiFunction<T1,T2>`	`thenToChar(LDblToCharFunction after)` Combines two functions together in a order.
`default LToDblBiFunction<T1,T2>`	`thenToDbl(LDblUnaryOperator after)` Combines two functions together in a order.
`default LToFltBiFunction<T1,T2>`	`thenToFlt(LDblToFltFunction after)` Combines two functions together in a order.
`default LToIntBiFunction<T1,T2>`	`thenToInt(LDblToIntFunction after)` Combines two functions together in a order.
`default LToLongBiFunction<T1,T2>`	`thenToLong(LDblToLongFunction after)` Combines two functions together in a order.
`default LToSrtBiFunction<T1,T2>`	`thenToSrt(LDblToSrtFunction after)` Combines two functions together in a order.
`static <T1,T2> void`	`times(int max_i, T1 a1, T2 a2, LToDblBiFunction<T1,T2> func)` From-To.
`static <T1,T2> LToDblBiFunction<T1,T2>`	`toDblBiFunc(LToDblBiFunction<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> LToDblBiFunction<T1,T2>`	`toDblBiFuncThrowing(ExF<Throwable> exF)`
`static <T1,T2> LToDblBiFunction<T1,T2>`	`toDblBiFuncThrowing(String message, ExMF<Throwable> exF)`
`static <T2,T1> LToDblBiFunction.LToDblObj1Obj0Func<T2,T1>`	`toDblObj1Obj0Func(LToDblBiFunction.LToDblObj1Obj0Func<T2,T1> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`static <T1,T2> double`	`tryApplyAsDbl(T1 a1, T2 a2, LToDblBiFunction<T1,T2> func)`
`static <T1,T2> double`	`tryApplyAsDbl(T1 a1, T2 a2, LToDblBiFunction<T1,T2> func, ExWF<RuntimeException> exF)`
`static <T1,T2> double`	`tryApplyAsDbl(T1 a1, T2 a2, LToDblBiFunction<T1,T2> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static <T1,T2> double`	`tryApplyAsDblThen(T1 a1, T2 a2, LToDblBiFunction<T1,T2> func, LToDblFunction<Throwable> handler)`
`default LToDblBiFunction<T1,T2>`	`trying(ExWF<RuntimeException> exF)`
`default LToDblBiFunction<T1,T2>`	`trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default LToDblBiFunction<T1,T2>`	`tryingThen(LToDblFunction<Throwable> handler)`
`default double`	`tupleApplyAsDbl(LPair<T1,T2> args)`
`static <T1,T2> LToDblBiFunction<T1,T2>`	`uncurry(LFunction<T1,LToDblFunction<T2>> func)`
`default LToDblBiFunction`	`untyped()` Cast that removes generics.
`static <T1,T2> LToDblBiFunction<T1,T2>`	`wrap(java.util.function.ToDoubleBiFunction<T1,T2> other)` Wraps JRE instance.

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

Method Detail

applyAsDouble
```
@Deprecated
default double applyAsDouble(T1 a1,
                                          T2 a2)
```
Deprecated. Calling this method via LToDblBiFunction interface should be discouraged.

Default implementation for JRE method that calls exception nesting method.

Specified by:

applyAsDouble in interface java.util.function.ToDoubleBiFunction<T1,T2>

applyAsDbl

default double applyAsDbl(T1 a1,
                          T2 a2)

applyAsDblX

double applyAsDblX(T1 a1,
                   T2 a2)
            throws Throwable

Implement this, but call applyAsDbl(T1 a1,T2 a2)

Throws:: Throwable

tupleApplyAsDbl

default double tupleApplyAsDbl(LPair<T1,T2> args)

handlingApplyAsDbl

default double handlingApplyAsDbl(T1 a1,
                                  T2 a2,
                                  HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

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

applyAsDbl

default double applyAsDbl(T1 a1,
                          T2 a2,
                          @Nonnull
                          ExWMF<RuntimeException> exF,
                          @Nonnull
                          String newMessage,
                          @Nullable
                          Object... messageParams)

trying

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

applyAsDbl

default double applyAsDbl(T1 a1,
                          T2 a2,
                          @Nonnull
                          ExWF<RuntimeException> exF)

trying

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

applyAsDblThen

default double applyAsDblThen(T1 a1,
                              T2 a2,
                              @Nonnull
                              LToDblFunction<Throwable> handler)

tryingThen

default LToDblBiFunction<T1,T2> tryingThen(@Nonnull
                                           LToDblFunction<Throwable> handler)

nestingApplyAsDbl
```
default double nestingApplyAsDbl(T1 a1,
                                 T2 a2)
```
Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.

shovingApplyAsDbl
```
default double shovingApplyAsDbl(T1 a1,
                                 T2 a2)
```
Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.

handlingApplyAsDbl

static <T1,T2> double handlingApplyAsDbl(T1 a1,
                                         T2 a2,
                                         LToDblBiFunction<T1,T2> func,
                                         HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsDbl

static <T1,T2> double tryApplyAsDbl(T1 a1,
                                    T2 a2,
                                    LToDblBiFunction<T1,T2> func)

tryApplyAsDbl

static <T1,T2> double tryApplyAsDbl(T1 a1,
                                    T2 a2,
                                    LToDblBiFunction<T1,T2> func,
                                    @Nonnull
                                    ExWMF<RuntimeException> exF,
                                    @Nonnull
                                    String newMessage,
                                    @Nullable
                                    Object... messageParams)

tryApplyAsDbl

static <T1,T2> double tryApplyAsDbl(T1 a1,
                                    T2 a2,
                                    LToDblBiFunction<T1,T2> func,
                                    @Nonnull
                                    ExWF<RuntimeException> exF)

tryApplyAsDblThen

static <T1,T2> double tryApplyAsDblThen(T1 a1,
                                        T2 a2,
                                        LToDblBiFunction<T1,T2> func,
                                        @Nonnull
                                        LToDblFunction<Throwable> handler)

failSafeApplyAsDbl

default double failSafeApplyAsDbl(T1 a1,
                                  T2 a2,
                                  @Nonnull
                                  LToDblBiFunction<T1,T2> failSafe)

failSafeApplyAsDbl

static <T1,T2> double failSafeApplyAsDbl(T1 a1,
                                         T2 a2,
                                         LToDblBiFunction<T1,T2> func,
                                         @Nonnull
                                         LToDblBiFunction<T1,T2> failSafe)

failSafe

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

nonNullApplyAsDbl

default double nonNullApplyAsDbl(T1 a1,
                                 T2 a2)

Just to mirror the method: 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> void fromTo(int min_i,
                           int max_i,
                           T1 a1,
                           T2 a2,
                           LToDblBiFunction<T1,T2> func)

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

fromTill

static <T1,T2> void fromTill(int min_i,
                             int max_i,
                             T1 a1,
                             T2 a2,
                             LToDblBiFunction<T1,T2> func)

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

times

static <T1,T2> void times(int max_i,
                          T1 a1,
                          T2 a2,
                          LToDblBiFunction<T1,T2> func)

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

lShrink

default LToDblFunction<T2> lShrink(LFunction<T2,T1> left)

lShrinkc

default LToDblFunction<T2> lShrinkc(T1 a1)

lShrinked

static <T2,T1> LToDblFunction<T2> lShrinked(LFunction<T2,T1> left,
                                            LToDblBiFunction<T1,T2> func)

lShrinkedc

static <T2,T1> LToDblFunction<T2> lShrinkedc(T1 a1,
                                             LToDblBiFunction<T1,T2> func)

rShrink

default LToDblFunction<T1> rShrink(LFunction<T1,T2> right)

rShrinkc

default LToDblFunction<T1> rShrinkc(T2 a2)

rShrinked

static <T1,T2> LToDblFunction<T1> rShrinked(LFunction<T1,T2> right,
                                            LToDblBiFunction<T1,T2> func)

rShrinkedc

static <T1,T2> LToDblFunction<T1> rShrinkedc(T2 a2,
                                             LToDblBiFunction<T1,T2> func)

uncurry

static <T1,T2> LToDblBiFunction<T1,T2> uncurry(LFunction<T1,LToDblFunction<T2>> func)

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

cast

default <V2,V3> LToDblBiFunction<V2,V3> cast()

Cast that replace generics.

cast

static <V2,V3,T1,T2> LToDblBiFunction<V2,V3> cast(LToDblBiFunction<T1,T2> function)

Cast that replace generics.

capture

default LDblSupplier capture(T1 a1,
                             T2 a2)

Captures arguments but delays the evaluation.

constant

static <T1,T2> LToDblBiFunction<T1,T2> constant(double r)

Creates function that always returns the same value.

apply1stAsDbl

@Nonnull
static <T1,T2> LToDblBiFunction<T1,T2> apply1stAsDbl(@Nonnull
                                                               LToDblFunction<T1> func)

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

apply2ndAsDbl

@Nonnull
static <T1,T2> LToDblBiFunction<T1,T2> apply2ndAsDbl(@Nonnull
                                                               LToDblFunction<T2> func)

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

toDblBiFunc

@Nonnull
static <T1,T2> LToDblBiFunction<T1,T2> toDblBiFunc(@Nonnull
                                                             LToDblBiFunction<T1,T2> 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> LToDblBiFunction<T1,T2> recursive(@Nonnull
                                                           LFunction<LToDblBiFunction<T1,T2>,LToDblBiFunction<T1,T2>> selfLambda)

toDblBiFuncThrowing

@Nonnull
static <T1,T2> LToDblBiFunction<T1,T2> toDblBiFuncThrowing(@Nonnull
                                                                     ExF<Throwable> exF)

toDblBiFuncThrowing

@Nonnull
static <T1,T2> LToDblBiFunction<T1,T2> toDblBiFuncThrowing(String message,
                                                                     @Nonnull
                                                                     ExMF<Throwable> exF)

toDblObj1Obj0Func

@Nonnull
static <T2,T1> LToDblBiFunction.LToDblObj1Obj0Func<T2,T1> toDblObj1Obj0Func(@Nonnull
                                                                                      LToDblBiFunction.LToDblObj1Obj0Func<T2,T1> 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> double call(T1 a1,
                           T2 a2,
                           @Nonnull
                           LToDblBiFunction<T1,T2> lambda)

wrap

@Nonnull
static <T1,T2> LToDblBiFunction<T1,T2> wrap(java.util.function.ToDoubleBiFunction<T1,T2> other)

Wraps JRE instance.

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

safeSupplier

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

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

safe

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

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

safeSupplier

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

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

compose

@Nonnull
default <V1,V2> LToDblBiFunction<V1,V2> compose(@Nonnull
                                                          LFunction<? super V1,? extends T1> before1,
                                                          @Nonnull
                                                          LFunction<? super V2,? extends T2> before2)

Allows to manipulate the domain of the function.