LIntToFltFunction (magma-func 2.0.0 API)

All Superinterfaces:

Codomain<aType.aFloat>, Domain, Domain1<aType.aInt>, Formattable, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>

All Known Implementing Classes:

LIntToFltFunction.LIntToFltFunctionSingle
```
@FunctionalInterface
public interface LIntToFltFunction
extends MetaFunction, MetaInterface.NonThrowing, Codomain<aType.aFloat>, Domain1<aType.aInt>
```
Non-throwing functional interface (lambda) LIntToFltFunction for Java 8.
Type: function
Domain (lvl: 1): int a
Co-domain: float

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class LIntToFltFunction.LIntToFltFunctionSingle
- 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`	`LIntToFltFunction.LIntToFltFunctionSingle`

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 float`	`applyAsFlt(int a)`
`default float`	`applyAsFlt(int a, ExWF<RuntimeException> exF)`
`default float`	`applyAsFlt(int a, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default float`	`applyAsFltThen(int a, LToFltFunction<Throwable> handler)`
`float`	`applyAsFltX(int a)` Implement this, but call applyAsFlt(int a)
`static float`	`call(int a, LIntToFltFunction lambda)`
`default LFltSupplier`	`capture(int a)` Captures arguments but delays the evaluation.
`default LIntToFltFunction`	`compose(LIntUnaryOperator before)` Allows to manipulate the domain of the function.
`static LIntToFltFunction`	`composed(LIntUnaryOperator before, LIntToFltFunction after)`
`static <V> LToFltFunction<V>`	`composed(LToIntFunction<? super V> before, LIntToFltFunction after)`
`static LIntToFltFunction`	`constant(float r)` Creates function that always returns the same value.
`static LIntToFltFunction`	`failSafe(LIntToFltFunction func, LIntToFltFunction failSafe)`
`default float`	`failSafeApplyAsFlt(int a, LIntToFltFunction failSafe)`
`static float`	`failSafeApplyAsFlt(int a, LIntToFltFunction func, LIntToFltFunction failSafe)`
`default <C0> void`	`forEach(IndexedRead<C0,aType.aInt> ia, C0 source, LFltConsumer consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`static void`	`fromTill(int min_a, int max_a, LIntToFltFunction func)` From-To.
`static void`	`fromTo(int min_a, int max_a, LIntToFltFunction func)` From-To.
`default String`	`functionalInterfaceDescription()` Returns description of the functional interface.
`default LIntToFltFunction`	`handling(HandlingInstructions<Throwable,RuntimeException> handling)`
`default float`	`handlingApplyAsFlt(int a, HandlingInstructions<Throwable,RuntimeException> handling)` Function call that handles exceptions according to the instructions.
`static float`	`handlingApplyAsFlt(int a, LIntToFltFunction func, HandlingInstructions<Throwable,RuntimeException> handling)`
`static LIntToFltFunction`	`intToFltFunc(LIntToFltFunction lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`default <V> LToFltFunction<V>`	`intToFltFuncCompose(LToIntFunction<? super V> before)` Allows to manipulate the domain of the function.
`static LIntToFltFunction`	`intToFltFuncThrowing(ExF<Throwable> exF)`
`static LIntToFltFunction`	`intToFltFuncThrowing(String message, ExMF<Throwable> exF)`
`default <C0,I0> void`	`iterate(SequentialRead<C0,I0,aType.aInt> sa, C0 source, LFltConsumer consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`default float`	`nestingApplyAsFlt(int a)` Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
`default float`	`nonNullApplyAsFlt(int a)` Just to mirror the method: Ensures the result is not null
`static float`	`produceFloat(int a)` Does nothing (LIntToFltFunction) Function
`static LIntToFltFunction`	`recursive(LFunction<LIntToFltFunction,LIntToFltFunction> selfLambda)`
`static LIntToFltFunction`	`safe()` Safe instance.
`static LIntToFltFunction`	`safe(LIntToFltFunction other)` Safe wrapping.
`static LSupplier<LIntToFltFunction>`	`safeSupplier()` Safe instance supplier.
`static LSupplier<LIntToFltFunction>`	`safeSupplier(LSupplier<LIntToFltFunction> supplier)` Safe supplier.
`default float`	`shovingApplyAsFlt(int a)` Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
`default <V> LIntFunction<V>`	`then(LFltFunction<? extends V> after)` Combines two functions together in a order.
`default LIntPredicate`	`thenToBool(LFltPredicate after)` Combines two functions together in a order.
`default LIntToByteFunction`	`thenToByte(LFltToByteFunction after)` Combines two functions together in a order.
`default LIntToCharFunction`	`thenToChar(LFltToCharFunction after)` Combines two functions together in a order.
`default LIntToDblFunction`	`thenToDbl(LFltToDblFunction after)` Combines two functions together in a order.
`default LIntToFltFunction`	`thenToFlt(LFltUnaryOperator after)` Combines two functions together in a order.
`default LIntUnaryOperator`	`thenToInt(LFltToIntFunction after)` Combines two functions together in a order.
`default LIntToLongFunction`	`thenToLong(LFltToLongFunction after)` Combines two functions together in a order.
`default LIntToSrtFunction`	`thenToSrt(LFltToSrtFunction after)` Combines two functions together in a order.
`static void`	`times(int max_a, LIntToFltFunction func)` From-To.
`static float`	`tryApplyAsFlt(int a, LIntToFltFunction func)`
`static float`	`tryApplyAsFlt(int a, LIntToFltFunction func, ExWF<RuntimeException> exF)`
`static float`	`tryApplyAsFlt(int a, LIntToFltFunction func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static float`	`tryApplyAsFltThen(int a, LIntToFltFunction func, LToFltFunction<Throwable> handler)`
`default LIntToFltFunction`	`trying(ExWF<RuntimeException> exF)`
`default LIntToFltFunction`	`trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default LIntToFltFunction`	`tryingThen(LToFltFunction<Throwable> handler)`
`default float`	`tupleApplyAsFlt(LIntSingle 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

applyAsFlt
```
default float applyAsFlt(int a)
```

applyAsFltX
```
float applyAsFltX(int a)
           throws Throwable
```
Implement this, but call applyAsFlt(int a)

Throws:

Throwable

tupleApplyAsFlt

default float tupleApplyAsFlt(LIntSingle args)

handlingApplyAsFlt

default float handlingApplyAsFlt(int a,
                                 HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

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

applyAsFlt

default float applyAsFlt(int a,
                         @Nonnull
                         ExWMF<RuntimeException> exF,
                         @Nonnull
                         String newMessage,
                         @Nullable
                         Object... messageParams)

trying

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

applyAsFlt

default float applyAsFlt(int a,
                         @Nonnull
                         ExWF<RuntimeException> exF)

trying

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

applyAsFltThen

default float applyAsFltThen(int a,
                             @Nonnull
                             LToFltFunction<Throwable> handler)

tryingThen

default LIntToFltFunction tryingThen(@Nonnull
                                     LToFltFunction<Throwable> handler)

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

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

handlingApplyAsFlt

static float handlingApplyAsFlt(int a,
                                LIntToFltFunction func,
                                HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsFlt

static float tryApplyAsFlt(int a,
                           LIntToFltFunction func)

tryApplyAsFlt

static float tryApplyAsFlt(int a,
                           LIntToFltFunction func,
                           @Nonnull
                           ExWMF<RuntimeException> exF,
                           @Nonnull
                           String newMessage,
                           @Nullable
                           Object... messageParams)

tryApplyAsFlt

static float tryApplyAsFlt(int a,
                           LIntToFltFunction func,
                           @Nonnull
                           ExWF<RuntimeException> exF)

tryApplyAsFltThen

static float tryApplyAsFltThen(int a,
                               LIntToFltFunction func,
                               @Nonnull
                               LToFltFunction<Throwable> handler)

failSafeApplyAsFlt

default float failSafeApplyAsFlt(int a,
                                 @Nonnull
                                 LIntToFltFunction failSafe)

failSafeApplyAsFlt

static float failSafeApplyAsFlt(int a,
                                LIntToFltFunction func,
                                @Nonnull
                                LIntToFltFunction failSafe)

failSafe

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

nonNullApplyAsFlt
```
default float nonNullApplyAsFlt(int 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_a,
                   int max_a,
                   LIntToFltFunction func)

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

fromTill

static void fromTill(int min_a,
                     int max_a,
                     LIntToFltFunction func)

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

times

static void times(int max_a,
                  LIntToFltFunction func)

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

capture
```
default LFltSupplier capture(int a)
```
Captures arguments but delays the evaluation.

constant
```
static LIntToFltFunction constant(float r)
```
Creates function that always returns the same value.

intToFltFunc

@Nonnull
static LIntToFltFunction intToFltFunc(@Nonnull
                                                LIntToFltFunction lambda)

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

recursive

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

intToFltFuncThrowing

@Nonnull
static LIntToFltFunction intToFltFuncThrowing(@Nonnull
                                                        ExF<Throwable> exF)

intToFltFuncThrowing

@Nonnull
static LIntToFltFunction intToFltFuncThrowing(String message,
                                                        @Nonnull
                                                        ExMF<Throwable> exF)

call

static float call(int a,
                  @Nonnull
                  LIntToFltFunction lambda)

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

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

safe

@Nonnull
static LIntToFltFunction safe(@Nullable
                                        LIntToFltFunction other)

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

safeSupplier

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

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

compose

@Nonnull
default LIntToFltFunction compose(@Nonnull
                                            LIntUnaryOperator before)

Allows to manipulate the domain of the function.

composed

static LIntToFltFunction composed(@Nonnull
                                  LIntUnaryOperator before,
                                  LIntToFltFunction after)

intToFltFuncCompose

@Nonnull
default <V> LToFltFunction<V> intToFltFuncCompose(@Nonnull
                                                            LToIntFunction<? super V> before)

Allows to manipulate the domain of the function.