LDblUnaryOperator (magma-func 2.0.0 API)

All Superinterfaces:

Codomain<aType.aDouble>, Domain, Domain1<aType.aDouble>, java.util.function.DoubleUnaryOperator, Formattable, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>, MetaOperator

All Known Implementing Classes:

LDblUnaryOperator.LDblUnaryOperatorSingle
```
@FunctionalInterface
public interface LDblUnaryOperator
extends java.util.function.DoubleUnaryOperator, MetaOperator, MetaInterface.NonThrowing, Codomain<aType.aDouble>, Domain1<aType.aDouble>
```
Non-throwing functional interface (lambda) LDblUnaryOperator for Java 8.
Type: operator
Domain (lvl: 1): double a
Co-domain: double

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class LDblUnaryOperator.LDblUnaryOperatorSingle
- Nested classes/interfaces inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface
  MetaInterface.NonThrowing, MetaInterface.Throwing<X>

Nested Classes
Modifier and Type	Interface and Description
`static class`	`LDblUnaryOperator.LDblUnaryOperatorSingle`

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
`default double`	`applyAsDbl(double a)`
`default double`	`applyAsDbl(double a, ExWF<RuntimeException> exF)`
`default double`	`applyAsDbl(double a, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default double`	`applyAsDblThen(double a, LToDblFunction<Throwable> handler)`
`double`	`applyAsDblX(double a)` Implement this, but call applyAsDbl(double a)
`default double`	`applyAsDouble(double a)` Deprecated. Calling this method via LDblUnaryOperator interface should be discouraged.
`static double`	`call(double a, LDblUnaryOperator lambda)`
`default LDblSupplier`	`capture(double a)` Captures arguments but delays the evaluation.
`default LDblUnaryOperator`	`compose(LDblUnaryOperator before)` Allows to manipulate the domain of the function.
`static LDblUnaryOperator`	`composed(LDblUnaryOperator before, LDblUnaryOperator after)`
`static <V> LToDblFunction<V>`	`composed(LToDblFunction<? super V> before, LDblUnaryOperator after)`
`static LDblUnaryOperator`	`constant(double r)` Creates function that always returns the same value.
`static LDblUnaryOperator`	`dblUnaryOp(LDblUnaryOperator lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`default <V> LToDblFunction<V>`	`dblUnaryOpCompose(LToDblFunction<? super V> before)` Allows to manipulate the domain of the function.
`static LDblUnaryOperator`	`dblUnaryOpThrowing(ExF<Throwable> exF)`
`static LDblUnaryOperator`	`dblUnaryOpThrowing(String message, ExMF<Throwable> exF)`
`static LDblUnaryOperator`	`failSafe(LDblUnaryOperator func, LDblUnaryOperator failSafe)`
`default double`	`failSafeApplyAsDbl(double a, LDblUnaryOperator failSafe)`
`static double`	`failSafeApplyAsDbl(double a, LDblUnaryOperator func, LDblUnaryOperator failSafe)`
`default <C0> void`	`forEach(IndexedRead<C0,aType.aDouble> ia, C0 source, LDblConsumer consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`static void`	`fromTill(int min_i, int max_i, double a, LDblUnaryOperator func)` From-To.
`static void`	`fromTo(int min_i, int max_i, double a, LDblUnaryOperator func)` From-To.
`default String`	`functionalInterfaceDescription()` Returns description of the functional interface.
`default LDblUnaryOperator`	`handling(HandlingInstructions<Throwable,RuntimeException> handling)`
`default double`	`handlingApplyAsDbl(double a, HandlingInstructions<Throwable,RuntimeException> handling)` Function call that handles exceptions according to the instructions.
`static double`	`handlingApplyAsDbl(double a, LDblUnaryOperator func, HandlingInstructions<Throwable,RuntimeException> handling)`
`static LDblUnaryOperator`	`identity()` Returns a function that always returns its input argument.
`default <C0,I0> void`	`iterate(SequentialRead<C0,I0,aType.aDouble> sa, C0 source, LDblConsumer consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`default double`	`nestingApplyAsDbl(double a)` Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
`default double`	`nonNullApplyAsDbl(double a)` Just to mirror the method: Ensures the result is not null
`static double`	`produceDouble(double a)` Does nothing (LDblUnaryOperator) Operator
`static LDblUnaryOperator`	`recursive(LFunction<LDblUnaryOperator,LDblUnaryOperator> selfLambda)`
`static LDblUnaryOperator`	`safe()` Safe instance.
`static LDblUnaryOperator`	`safe(LDblUnaryOperator other)` Safe wrapping.
`static LSupplier<LDblUnaryOperator>`	`safeSupplier()` Safe instance supplier.
`static LSupplier<LDblUnaryOperator>`	`safeSupplier(LSupplier<LDblUnaryOperator> supplier)` Safe supplier.
`default double`	`shovingApplyAsDbl(double a)` Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
`default <V> LDblFunction<V>`	`then(LDblFunction<? extends V> after)` Combines two functions together in a order.
`default LDblPredicate`	`thenToBool(LDblPredicate after)` Combines two functions together in a order.
`default LDblToByteFunction`	`thenToByte(LDblToByteFunction after)` Combines two functions together in a order.
`default LDblToCharFunction`	`thenToChar(LDblToCharFunction after)` Combines two functions together in a order.
`default LDblUnaryOperator`	`thenToDbl(LDblUnaryOperator after)` Combines two functions together in a order.
`default LDblToFltFunction`	`thenToFlt(LDblToFltFunction after)` Combines two functions together in a order.
`default LDblToIntFunction`	`thenToInt(LDblToIntFunction after)` Combines two functions together in a order.
`default LDblToLongFunction`	`thenToLong(LDblToLongFunction after)` Combines two functions together in a order.
`default LDblToSrtFunction`	`thenToSrt(LDblToSrtFunction after)` Combines two functions together in a order.
`static void`	`times(int max_i, double a, LDblUnaryOperator func)` From-To.
`static double`	`tryApplyAsDbl(double a, LDblUnaryOperator func)`
`static double`	`tryApplyAsDbl(double a, LDblUnaryOperator func, ExWF<RuntimeException> exF)`
`static double`	`tryApplyAsDbl(double a, LDblUnaryOperator func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static double`	`tryApplyAsDblThen(double a, LDblUnaryOperator func, LToDblFunction<Throwable> handler)`
`default LDblUnaryOperator`	`trying(ExWF<RuntimeException> exF)`
`default LDblUnaryOperator`	`trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default LDblUnaryOperator`	`tryingThen(LToDblFunction<Throwable> handler)`
`default double`	`tupleApplyAsDbl(LDblSingle args)`
`static LDblUnaryOperator`	`wrap(java.util.function.DoubleUnaryOperator other)` Wraps JRE instance.

Methods inherited from interface java.util.function.DoubleUnaryOperator
andThen, compose

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.type.MetaOperator
isOperator

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, isPredicate, isSupplier

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

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(double a)
```
Deprecated. Calling this method via LDblUnaryOperator interface should be discouraged.

Default implementation for JRE method that calls exception nesting method.

Specified by:

applyAsDouble in interface java.util.function.DoubleUnaryOperator

applyAsDbl
```
default double applyAsDbl(double a)
```

applyAsDblX
```
double applyAsDblX(double a)
            throws Throwable
```
Implement this, but call applyAsDbl(double a)

Throws:

Throwable

tupleApplyAsDbl

default double tupleApplyAsDbl(LDblSingle args)

handlingApplyAsDbl

default double handlingApplyAsDbl(double a,
                                  HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

default LDblUnaryOperator handling(HandlingInstructions<Throwable,RuntimeException> handling)

applyAsDbl

default double applyAsDbl(double a,
                          @Nonnull
                          ExWMF<RuntimeException> exF,
                          @Nonnull
                          String newMessage,
                          @Nullable
                          Object... messageParams)

trying

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

applyAsDbl

default double applyAsDbl(double a,
                          @Nonnull
                          ExWF<RuntimeException> exF)

trying

default LDblUnaryOperator trying(@Nonnull
                                 ExWF<RuntimeException> exF)

applyAsDblThen

default double applyAsDblThen(double a,
                              @Nonnull
                              LToDblFunction<Throwable> handler)

tryingThen

default LDblUnaryOperator tryingThen(@Nonnull
                                     LToDblFunction<Throwable> handler)

nestingApplyAsDbl
```
default double nestingApplyAsDbl(double a)
```
Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.

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

handlingApplyAsDbl

static double handlingApplyAsDbl(double a,
                                 LDblUnaryOperator func,
                                 HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsDbl

static double tryApplyAsDbl(double a,
                            LDblUnaryOperator func)

tryApplyAsDbl

static double tryApplyAsDbl(double a,
                            LDblUnaryOperator func,
                            @Nonnull
                            ExWMF<RuntimeException> exF,
                            @Nonnull
                            String newMessage,
                            @Nullable
                            Object... messageParams)

tryApplyAsDbl

static double tryApplyAsDbl(double a,
                            LDblUnaryOperator func,
                            @Nonnull
                            ExWF<RuntimeException> exF)

tryApplyAsDblThen

static double tryApplyAsDblThen(double a,
                                LDblUnaryOperator func,
                                @Nonnull
                                LToDblFunction<Throwable> handler)

failSafeApplyAsDbl

default double failSafeApplyAsDbl(double a,
                                  @Nonnull
                                  LDblUnaryOperator failSafe)

failSafeApplyAsDbl

static double failSafeApplyAsDbl(double a,
                                 LDblUnaryOperator func,
                                 @Nonnull
                                 LDblUnaryOperator failSafe)

failSafe

static LDblUnaryOperator failSafe(LDblUnaryOperator func,
                                  @Nonnull
                                  LDblUnaryOperator failSafe)

nonNullApplyAsDbl
```
default double nonNullApplyAsDbl(double a)
```
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 void fromTo(int min_i,
                   int max_i,
                   double a,
                   LDblUnaryOperator func)

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

fromTill

static void fromTill(int min_i,
                     int max_i,
                     double a,
                     LDblUnaryOperator func)

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

times

static void times(int max_i,
                  double a,
                  LDblUnaryOperator func)

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

capture
```
default LDblSupplier capture(double a)
```
Captures arguments but delays the evaluation.

constant
```
static LDblUnaryOperator constant(double r)
```
Creates function that always returns the same value.

dblUnaryOp

@Nonnull
static LDblUnaryOperator dblUnaryOp(@Nonnull
                                              LDblUnaryOperator lambda)

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

recursive

@Nonnull
static LDblUnaryOperator recursive(@Nonnull
                                             LFunction<LDblUnaryOperator,LDblUnaryOperator> selfLambda)

dblUnaryOpThrowing

@Nonnull
static LDblUnaryOperator dblUnaryOpThrowing(@Nonnull
                                                      ExF<Throwable> exF)

dblUnaryOpThrowing

@Nonnull
static LDblUnaryOperator dblUnaryOpThrowing(String message,
                                                      @Nonnull
                                                      ExMF<Throwable> exF)

call

static double call(double a,
                   @Nonnull
                   LDblUnaryOperator lambda)

wrap

@Nonnull
static LDblUnaryOperator wrap(java.util.function.DoubleUnaryOperator other)

Wraps JRE instance.

safe
```
@Nonnull
static LDblUnaryOperator safe()
```
Safe instance. That always returns the same value (as produceDouble).

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

safe

@Nonnull
static LDblUnaryOperator safe(@Nullable
                                        LDblUnaryOperator other)

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

safeSupplier

@Nonnull
static LSupplier<LDblUnaryOperator> safeSupplier(@Nullable
                                                           LSupplier<LDblUnaryOperator> supplier)

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

compose

@Nonnull
default LDblUnaryOperator compose(@Nonnull
                                            LDblUnaryOperator before)

Allows to manipulate the domain of the function.

composed

static LDblUnaryOperator composed(@Nonnull
                                  LDblUnaryOperator before,
                                  LDblUnaryOperator after)

dblUnaryOpCompose

@Nonnull
default <V> LToDblFunction<V> dblUnaryOpCompose(@Nonnull
                                                          LToDblFunction<? super V> before)

Allows to manipulate the domain of the function.