LDblToCharFunction (magma-func 2.0.0 API)

All Superinterfaces:

Codomain<aType.aChar>, Domain, Domain1<aType.aDouble>, Formattable, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>

All Known Implementing Classes:

LDblToCharFunction.LDblToCharFunctionSingle
```
@FunctionalInterface
public interface LDblToCharFunction
extends MetaFunction, MetaInterface.NonThrowing, Codomain<aType.aChar>, Domain1<aType.aDouble>
```
Non-throwing functional interface (lambda) LDblToCharFunction for Java 8.
Type: function
Domain (lvl: 1): double a
Co-domain: char

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class LDblToCharFunction.LDblToCharFunctionSingle
- 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`	`LDblToCharFunction.LDblToCharFunctionSingle`

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
`default char`	`applyAsChar(double a)`
`default char`	`applyAsChar(double a, ExWF<RuntimeException> exF)`
`default char`	`applyAsChar(double a, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default char`	`applyAsCharThen(double a, LToCharFunction<Throwable> handler)`
`char`	`applyAsCharX(double a)` Implement this, but call applyAsChar(double a)
`static char`	`call(double a, LDblToCharFunction lambda)`
`default LCharSupplier`	`capture(double a)` Captures arguments but delays the evaluation.
`default LDblToCharFunction`	`compose(LDblUnaryOperator before)` Allows to manipulate the domain of the function.
`static LDblToCharFunction`	`composed(LDblUnaryOperator before, LDblToCharFunction after)`
`static <V> LToCharFunction<V>`	`composed(LToDblFunction<? super V> before, LDblToCharFunction after)`
`static LDblToCharFunction`	`constant(char r)` Creates function that always returns the same value.
`static LDblToCharFunction`	`dblToCharFunc(LDblToCharFunction lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`default <V> LToCharFunction<V>`	`dblToCharFuncCompose(LToDblFunction<? super V> before)` Allows to manipulate the domain of the function.
`static LDblToCharFunction`	`dblToCharFuncThrowing(ExF<Throwable> exF)`
`static LDblToCharFunction`	`dblToCharFuncThrowing(String message, ExMF<Throwable> exF)`
`static LDblToCharFunction`	`failSafe(LDblToCharFunction func, LDblToCharFunction failSafe)`
`default char`	`failSafeApplyAsChar(double a, LDblToCharFunction failSafe)`
`static char`	`failSafeApplyAsChar(double a, LDblToCharFunction func, LDblToCharFunction failSafe)`
`default <C0> void`	`forEach(IndexedRead<C0,aType.aDouble> ia, C0 source, LCharConsumer 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, LDblToCharFunction func)` From-To.
`static void`	`fromTo(int min_i, int max_i, double a, LDblToCharFunction func)` From-To.
`default String`	`functionalInterfaceDescription()` Returns description of the functional interface.
`default LDblToCharFunction`	`handling(HandlingInstructions<Throwable,RuntimeException> handling)`
`default char`	`handlingApplyAsChar(double a, HandlingInstructions<Throwable,RuntimeException> handling)` Function call that handles exceptions according to the instructions.
`static char`	`handlingApplyAsChar(double a, LDblToCharFunction func, HandlingInstructions<Throwable,RuntimeException> handling)`
`default <C0,I0> void`	`iterate(SequentialRead<C0,I0,aType.aDouble> sa, C0 source, LCharConsumer consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`default char`	`nestingApplyAsChar(double a)` Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
`default char`	`nonNullApplyAsChar(double a)` Just to mirror the method: Ensures the result is not null
`static char`	`produceChar(double a)` Does nothing (LDblToCharFunction) Function
`static LDblToCharFunction`	`recursive(LFunction<LDblToCharFunction,LDblToCharFunction> selfLambda)`
`static LDblToCharFunction`	`safe()` Safe instance.
`static LDblToCharFunction`	`safe(LDblToCharFunction other)` Safe wrapping.
`static LSupplier<LDblToCharFunction>`	`safeSupplier()` Safe instance supplier.
`static LSupplier<LDblToCharFunction>`	`safeSupplier(LSupplier<LDblToCharFunction> supplier)` Safe supplier.
`default char`	`shovingApplyAsChar(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(LCharFunction<? extends V> after)` Combines two functions together in a order.
`default LDblPredicate`	`thenToBool(LCharPredicate after)` Combines two functions together in a order.
`default LDblToByteFunction`	`thenToByte(LCharToByteFunction after)` Combines two functions together in a order.
`default LDblToCharFunction`	`thenToChar(LCharUnaryOperator after)` Combines two functions together in a order.
`default LDblUnaryOperator`	`thenToDbl(LCharToDblFunction after)` Combines two functions together in a order.
`default LDblToFltFunction`	`thenToFlt(LCharToFltFunction after)` Combines two functions together in a order.
`default LDblToIntFunction`	`thenToInt(LCharToIntFunction after)` Combines two functions together in a order.
`default LDblToLongFunction`	`thenToLong(LCharToLongFunction after)` Combines two functions together in a order.
`default LDblToSrtFunction`	`thenToSrt(LCharToSrtFunction after)` Combines two functions together in a order.
`static void`	`times(int max_i, double a, LDblToCharFunction func)` From-To.
`static char`	`tryApplyAsChar(double a, LDblToCharFunction func)`
`static char`	`tryApplyAsChar(double a, LDblToCharFunction func, ExWF<RuntimeException> exF)`
`static char`	`tryApplyAsChar(double a, LDblToCharFunction func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static char`	`tryApplyAsCharThen(double a, LDblToCharFunction func, LToCharFunction<Throwable> handler)`
`default LDblToCharFunction`	`trying(ExWF<RuntimeException> exF)`
`default LDblToCharFunction`	`trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default LDblToCharFunction`	`tryingThen(LToCharFunction<Throwable> handler)`
`default char`	`tupleApplyAsChar(LDblSingle args)`

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

applyAsChar
```
default char applyAsChar(double a)
```

applyAsCharX
```
char applyAsCharX(double a)
           throws Throwable
```
Implement this, but call applyAsChar(double a)

Throws:

Throwable

tupleApplyAsChar

default char tupleApplyAsChar(LDblSingle args)

handlingApplyAsChar

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

Function call that handles exceptions according to the instructions.

handling

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

applyAsChar

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

trying

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

applyAsChar

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

trying

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

applyAsCharThen

default char applyAsCharThen(double a,
                             @Nonnull
                             LToCharFunction<Throwable> handler)

tryingThen

default LDblToCharFunction tryingThen(@Nonnull
                                      LToCharFunction<Throwable> handler)

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

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

handlingApplyAsChar

static char handlingApplyAsChar(double a,
                                LDblToCharFunction func,
                                HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsChar

static char tryApplyAsChar(double a,
                           LDblToCharFunction func)

tryApplyAsChar

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

tryApplyAsChar

static char tryApplyAsChar(double a,
                           LDblToCharFunction func,
                           @Nonnull
                           ExWF<RuntimeException> exF)

tryApplyAsCharThen

static char tryApplyAsCharThen(double a,
                               LDblToCharFunction func,
                               @Nonnull
                               LToCharFunction<Throwable> handler)

failSafeApplyAsChar

default char failSafeApplyAsChar(double a,
                                 @Nonnull
                                 LDblToCharFunction failSafe)

failSafeApplyAsChar

static char failSafeApplyAsChar(double a,
                                LDblToCharFunction func,
                                @Nonnull
                                LDblToCharFunction failSafe)

failSafe

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

nonNullApplyAsChar
```
default char nonNullApplyAsChar(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,
                   LDblToCharFunction func)

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

fromTill

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

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

times

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

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

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

constant
```
static LDblToCharFunction constant(char r)
```
Creates function that always returns the same value.

dblToCharFunc

@Nonnull
static LDblToCharFunction dblToCharFunc(@Nonnull
                                                  LDblToCharFunction lambda)

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

recursive

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

dblToCharFuncThrowing

@Nonnull
static LDblToCharFunction dblToCharFuncThrowing(@Nonnull
                                                          ExF<Throwable> exF)

dblToCharFuncThrowing

@Nonnull
static LDblToCharFunction dblToCharFuncThrowing(String message,
                                                          @Nonnull
                                                          ExMF<Throwable> exF)

call

static char call(double a,
                 @Nonnull
                 LDblToCharFunction lambda)

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

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

safe

@Nonnull
static LDblToCharFunction safe(@Nullable
                                         LDblToCharFunction other)

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

safeSupplier

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

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

compose

@Nonnull
default LDblToCharFunction compose(@Nonnull
                                             LDblUnaryOperator before)

Allows to manipulate the domain of the function.

composed

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

dblToCharFuncCompose

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

Allows to manipulate the domain of the function.