LOiToDblFunction (magma-func 2.0.0 API)

All Superinterfaces:

Codomain<aType.aDouble>, Domain, Domain2<aType.a<T>,aType.aInt>, Formattable, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>, OiFunction<T,aType.aDouble>

All Known Subinterfaces:

LOiToDblFunction.LIntObjToDblFunc<T>

All Known Implementing Classes:

LOiToDblFunction.LOiToDblFunctionSingle
```
@FunctionalInterface
public interface LOiToDblFunction<T>
extends MetaFunction, MetaInterface.NonThrowing, OiFunction<T,aType.aDouble>, Codomain<aType.aDouble>, Domain2<aType.a<T>,aType.aInt>
```
Non-throwing functional interface (lambda) LOiToDblFunction for Java 8.
Type: function
Domain (lvl: 2): T a1,int a2
Co-domain: double
Special case of function that corresponds to expressions like (list, index) -> List::get

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static interface`	`LOiToDblFunction.LIntObjToDblFunc<T>` Permutation of LOiToDblFunction for method references.
`static class`	`LOiToDblFunction.LOiToDblFunctionSingle<T>`

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
Modifier and Type	Method and Description
`static <T> LOiToDblFunction<T>`	`apply1stAsDbl(LToDblFunction<T> func)` Captures single parameter function into this interface where only 1st parameter will be used.
`static <T> LOiToDblFunction<T>`	`apply2ndAsDbl(LIntToDblFunction func)` Captures single parameter function into this interface where only 2nd parameter will be used.
`default double`	`applyAsDbl(T a1, int a2)`
`default double`	`applyAsDbl(T a1, int a2, ExWF<RuntimeException> exF)`
`default double`	`applyAsDbl(T a1, int a2, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default double`	`applyAsDblThen(T a1, int a2, LToDblFunction<Throwable> handler)`
`double`	`applyAsDblX(T a1, int a2)` Implement this, but call applyAsDbl(T a1,int a2)
`static <T> double`	`call(T a1, int a2, LOiToDblFunction<T> lambda)`
`default LDblSupplier`	`capture(T a1, int a2)` Captures arguments but delays the evaluation.
`default <V2> LOiToDblFunction<V2>`	`cast()` Cast that replace generics.
`static <V2,T> LOiToDblFunction<V2>`	`cast(LOiToDblFunction<T> function)` Cast that replace generics.
`default <V1> LOiToDblFunction<V1>`	`compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2)` Allows to manipulate the domain of the function.
`static <V1,T> LOiToDblFunction<V1>`	`composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LOiToDblFunction<T> after)`
`static <V1,V2,T> LToDblBiFunction<V1,V2>`	`composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LOiToDblFunction<T> after)`
`static <T> LOiToDblFunction<T>`	`constant(double r)` Creates function that always returns the same value.
`static <T> LOiToDblFunction<T>`	`failSafe(LOiToDblFunction<T> func, LOiToDblFunction<T> failSafe)`
`default double`	`failSafeApplyAsDbl(T a1, int a2, LOiToDblFunction<T> failSafe)`
`static <T> double`	`failSafeApplyAsDbl(T a1, int a2, LOiToDblFunction<T> func, LOiToDblFunction<T> failSafe)`
`default <C1,C2> void`	`forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, LDblConsumer consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`static <T> void`	`fromTill(int min_a2, int max_a2, T a1, LOiToDblFunction<T> func)` From-To.
`static <T> void`	`fromTo(int min_a2, int max_a2, T a1, LOiToDblFunction<T> func)` From-To.
`default String`	`functionalInterfaceDescription()` Returns description of the functional interface.
`default LOiToDblFunction<T>`	`handling(HandlingInstructions<Throwable,RuntimeException> handling)`
`default double`	`handlingApplyAsDbl(T a1, int a2, HandlingInstructions<Throwable,RuntimeException> handling)` Function call that handles exceptions according to the instructions.
`static <T> double`	`handlingApplyAsDbl(T a1, int a2, LOiToDblFunction<T> func, HandlingInstructions<Throwable,RuntimeException> handling)`
`static <T> LOiToDblFunction.LIntObjToDblFunc<T>`	`intObjToDblFunc(LOiToDblFunction.LIntObjToDblFunc<T> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`default <C1,C2,I2> void`	`iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> 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<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> 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<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, LDblConsumer consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`default LIntToDblFunction`	`lShrink(LIntFunction<T> left)`
`default LIntToDblFunction`	`lShrinkc(T a1)`
`static <T> LIntToDblFunction`	`lShrinked(LIntFunction<T> left, LOiToDblFunction<T> func)`
`static <T> LIntToDblFunction`	`lShrinkedc(T a1, LOiToDblFunction<T> func)`
`default double`	`nestingApplyAsDbl(T a1, int a2)` Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
`default double`	`nonNullApplyAsDbl(T a1, int a2)` Just to mirror the method: Ensures the result is not null
`static <T> LOiToDblFunction<T>`	`oiToDblFunc(LOiToDblFunction<T> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`default <V1,V2> LToDblBiFunction<V1,V2>`	`oiToDblFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2)` Allows to manipulate the domain of the function.
`static <T> LOiToDblFunction<T>`	`oiToDblFuncThrowing(ExF<Throwable> exF)`
`static <T> LOiToDblFunction<T>`	`oiToDblFuncThrowing(String message, ExMF<Throwable> exF)`
`static <T> double`	`produceDouble(int a2, T a1)` Does nothing (LOiToDblFunction.LIntObjToDblFunc) Function
`static <T> double`	`produceDouble(T a1, int a2)` Does nothing (LOiToDblFunction) Function
`static <T> LOiToDblFunction<T>`	`recursive(LFunction<LOiToDblFunction<T>,LOiToDblFunction<T>> selfLambda)`
`default LToDblFunction<T>`	`rShrink(LToIntFunction<T> right)`
`default LToDblFunction<T>`	`rShrinkc(int a2)`
`static <T> LToDblFunction<T>`	`rShrinked(LToIntFunction<T> right, LOiToDblFunction<T> func)`
`static <T> LToDblFunction<T>`	`rShrinkedc(int a2, LOiToDblFunction<T> func)`
`static <T> LOiToDblFunction<T>`	`safe()` Safe instance.
`static <T> LOiToDblFunction<T>`	`safe(LOiToDblFunction<T> other)` Safe wrapping.
`static <T> LSupplier<LOiToDblFunction<T>>`	`safeSupplier()` Safe instance supplier.
`static <T> LSupplier<LOiToDblFunction<T>>`	`safeSupplier(LSupplier<LOiToDblFunction<T>> supplier)` Safe supplier.
`default double`	`shovingApplyAsDbl(T a1, int a2)` Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
`default <V> LOiFunction<T,V>`	`then(LDblFunction<? extends V> after)` Combines two functions together in a order.
`default LObjIntPredicate<T>`	`thenToBool(LDblPredicate after)` Combines two functions together in a order.
`default LOiToByteFunction<T>`	`thenToByte(LDblToByteFunction after)` Combines two functions together in a order.
`default LOiToCharFunction<T>`	`thenToChar(LDblToCharFunction after)` Combines two functions together in a order.
`default LOiToDblFunction<T>`	`thenToDbl(LDblUnaryOperator after)` Combines two functions together in a order.
`default LOiToFltFunction<T>`	`thenToFlt(LDblToFltFunction after)` Combines two functions together in a order.
`default LOiToIntFunction<T>`	`thenToInt(LDblToIntFunction after)` Combines two functions together in a order.
`default LOiToLongFunction<T>`	`thenToLong(LDblToLongFunction after)` Combines two functions together in a order.
`default LOiToSrtFunction<T>`	`thenToSrt(LDblToSrtFunction after)` Combines two functions together in a order.
`static <T> void`	`times(int max_a2, T a1, LOiToDblFunction<T> func)` From-To.
`static <T> double`	`tryApplyAsDbl(T a1, int a2, LOiToDblFunction<T> func)`
`static <T> double`	`tryApplyAsDbl(T a1, int a2, LOiToDblFunction<T> func, ExWF<RuntimeException> exF)`
`static <T> double`	`tryApplyAsDbl(T a1, int a2, LOiToDblFunction<T> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static <T> double`	`tryApplyAsDblThen(T a1, int a2, LOiToDblFunction<T> func, LToDblFunction<Throwable> handler)`
`default LOiToDblFunction<T>`	`trying(ExWF<RuntimeException> exF)`
`default LOiToDblFunction<T>`	`trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default LOiToDblFunction<T>`	`tryingThen(LToDblFunction<Throwable> handler)`
`default double`	`tupleApplyAsDbl(LObjIntPair<T> args)`
`static <T> LOiToDblFunction<T>`	`uncurry(LFunction<T,LIntToDblFunction> func)`
`default LOiToDblFunction`	`untyped()` Cast that removes generics.

Methods inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface.NonThrowing
isThrowing

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

Field Detail
- DESCRIPTION
```
static final String DESCRIPTION
```
  See Also:
  
  Constant Field Values

Method Detail

applyAsDbl

default double applyAsDbl(T a1,
                          int a2)

applyAsDblX

double applyAsDblX(T a1,
                   int a2)
            throws Throwable

Implement this, but call applyAsDbl(T a1,int a2)

Throws:: Throwable

tupleApplyAsDbl

default double tupleApplyAsDbl(LObjIntPair<T> args)

handlingApplyAsDbl

default double handlingApplyAsDbl(T a1,
                                  int a2,
                                  HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

default LOiToDblFunction<T> handling(HandlingInstructions<Throwable,RuntimeException> handling)

applyAsDbl

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

trying

default LOiToDblFunction<T> trying(@Nonnull
                                   ExWMF<RuntimeException> exF,
                                   @Nonnull
                                   String newMessage,
                                   @Nullable
                                   Object... messageParams)

applyAsDbl

default double applyAsDbl(T a1,
                          int a2,
                          @Nonnull
                          ExWF<RuntimeException> exF)

trying

default LOiToDblFunction<T> trying(@Nonnull
                                   ExWF<RuntimeException> exF)

applyAsDblThen

default double applyAsDblThen(T a1,
                              int a2,
                              @Nonnull
                              LToDblFunction<Throwable> handler)

tryingThen

default LOiToDblFunction<T> tryingThen(@Nonnull
                                       LToDblFunction<Throwable> handler)

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

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

handlingApplyAsDbl

static <T> double handlingApplyAsDbl(T a1,
                                     int a2,
                                     LOiToDblFunction<T> func,
                                     HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsDbl

static <T> double tryApplyAsDbl(T a1,
                                int a2,
                                LOiToDblFunction<T> func)

tryApplyAsDbl

static <T> double tryApplyAsDbl(T a1,
                                int a2,
                                LOiToDblFunction<T> func,
                                @Nonnull
                                ExWMF<RuntimeException> exF,
                                @Nonnull
                                String newMessage,
                                @Nullable
                                Object... messageParams)

tryApplyAsDbl

static <T> double tryApplyAsDbl(T a1,
                                int a2,
                                LOiToDblFunction<T> func,
                                @Nonnull
                                ExWF<RuntimeException> exF)

tryApplyAsDblThen

static <T> double tryApplyAsDblThen(T a1,
                                    int a2,
                                    LOiToDblFunction<T> func,
                                    @Nonnull
                                    LToDblFunction<Throwable> handler)

failSafeApplyAsDbl

default double failSafeApplyAsDbl(T a1,
                                  int a2,
                                  @Nonnull
                                  LOiToDblFunction<T> failSafe)

failSafeApplyAsDbl

static <T> double failSafeApplyAsDbl(T a1,
                                     int a2,
                                     LOiToDblFunction<T> func,
                                     @Nonnull
                                     LOiToDblFunction<T> failSafe)

failSafe

static <T> LOiToDblFunction<T> failSafe(LOiToDblFunction<T> func,
                                        @Nonnull
                                        LOiToDblFunction<T> failSafe)

nonNullApplyAsDbl

default double nonNullApplyAsDbl(T a1,
                                 int 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 <T> void fromTo(int min_a2,
                       int max_a2,
                       T a1,
                       LOiToDblFunction<T> func)

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

fromTill

static <T> void fromTill(int min_a2,
                         int max_a2,
                         T a1,
                         LOiToDblFunction<T> func)

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

times

static <T> void times(int max_a2,
                      T a1,
                      LOiToDblFunction<T> func)

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

lShrink

default LIntToDblFunction lShrink(LIntFunction<T> left)

lShrinkc

default LIntToDblFunction lShrinkc(T a1)

lShrinked

static <T> LIntToDblFunction lShrinked(LIntFunction<T> left,
                                       LOiToDblFunction<T> func)

lShrinkedc

static <T> LIntToDblFunction lShrinkedc(T a1,
                                        LOiToDblFunction<T> func)

rShrink

default LToDblFunction<T> rShrink(LToIntFunction<T> right)

rShrinkc

default LToDblFunction<T> rShrinkc(int a2)

rShrinked

static <T> LToDblFunction<T> rShrinked(LToIntFunction<T> right,
                                       LOiToDblFunction<T> func)

rShrinkedc

static <T> LToDblFunction<T> rShrinkedc(int a2,
                                        LOiToDblFunction<T> func)

uncurry

static <T> LOiToDblFunction<T> uncurry(LFunction<T,LIntToDblFunction> func)

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

cast

default <V2> LOiToDblFunction<V2> cast()

Cast that replace generics.

cast

static <V2,T> LOiToDblFunction<V2> cast(LOiToDblFunction<T> function)

Cast that replace generics.

capture

default LDblSupplier capture(T a1,
                             int a2)

Captures arguments but delays the evaluation.

constant
```
static <T> LOiToDblFunction<T> constant(double r)
```
Creates function that always returns the same value.

apply1stAsDbl

@Nonnull
static <T> LOiToDblFunction<T> apply1stAsDbl(@Nonnull
                                                       LToDblFunction<T> func)

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

apply2ndAsDbl

@Nonnull
static <T> LOiToDblFunction<T> apply2ndAsDbl(@Nonnull
                                                       LIntToDblFunction func)

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

oiToDblFunc

@Nonnull
static <T> LOiToDblFunction<T> oiToDblFunc(@Nonnull
                                                     LOiToDblFunction<T> lambda)

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

recursive

@Nonnull
static <T> LOiToDblFunction<T> recursive(@Nonnull
                                                   LFunction<LOiToDblFunction<T>,LOiToDblFunction<T>> selfLambda)

oiToDblFuncThrowing

@Nonnull
static <T> LOiToDblFunction<T> oiToDblFuncThrowing(@Nonnull
                                                             ExF<Throwable> exF)

oiToDblFuncThrowing

@Nonnull
static <T> LOiToDblFunction<T> oiToDblFuncThrowing(String message,
                                                             @Nonnull
                                                             ExMF<Throwable> exF)

intObjToDblFunc

@Nonnull
static <T> LOiToDblFunction.LIntObjToDblFunc<T> intObjToDblFunc(@Nonnull
                                                                          LOiToDblFunction.LIntObjToDblFunc<T> lambda)

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

call

static <T> double call(T a1,
                       int a2,
                       @Nonnull
                       LOiToDblFunction<T> lambda)

safe
```
@Nonnull
static <T> LOiToDblFunction<T> safe()
```
Safe instance. That always returns the same value (as produceDouble).

safeSupplier
```
@Nonnull
static <T> LSupplier<LOiToDblFunction<T>> safeSupplier()
```
Safe instance supplier. Returns supplier of safe() instance.

safe

@Nonnull
static <T> LOiToDblFunction<T> safe(@Nullable
                                              LOiToDblFunction<T> other)

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

safeSupplier

@Nonnull
static <T> LSupplier<LOiToDblFunction<T>> safeSupplier(@Nullable
                                                                 LSupplier<LOiToDblFunction<T>> supplier)

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

compose

@Nonnull
default <V1> LOiToDblFunction<V1> compose(@Nonnull
                                                    LFunction<? super V1,? extends T> before1,
                                                    @Nonnull
                                                    LIntUnaryOperator before2)

Allows to manipulate the domain of the function.

composed

static <V1,T> LOiToDblFunction<V1> composed(@Nonnull
                                            LFunction<? super V1,? extends T> before1,
                                            @Nonnull
                                            LIntUnaryOperator before2,
                                            LOiToDblFunction<T> after)

oiToDblFuncCompose

@Nonnull
default <V1,V2> LToDblBiFunction<V1,V2> oiToDblFuncCompose(@Nonnull
                                                                     LFunction<? super V1,? extends T> before1,
                                                                     @Nonnull
                                                                     LToIntFunction<? super V2> before2)

Allows to manipulate the domain of the function.