eu.lunisolar.magma.func.operator.unary

Interface LFltUnaryOperator

All Superinterfaces:

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

All Known Implementing Classes:

LFltUnaryOperator.LFltUnaryOperatorSingle

@FunctionalInterface
public interface LFltUnaryOperator
extends MetaOperator, MetaInterface.NonThrowing, Codomain<aType.aFloat>, Domain1<aType.aFloat>

Non-throwing functional interface (lambda) LFltUnaryOperator for Java 8.

Type: operator

Domain (lvl: 1): float a

Co-domain: float

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LFltUnaryOperator.LFltUnaryOperatorSingle

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

Method Summary

Modifier and Type	Method and Description
default float	applyAsFlt(float a)
default float	applyAsFlt(float a, ExWF<RuntimeException> exF)
default float	applyAsFlt(float a, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default float	applyAsFltThen(float a, LToFltFunction<Throwable> handler)
float	applyAsFltX(float a) Implement this, but call applyAsFlt(float a)
static float	call(float a, LFltUnaryOperator lambda)
default LFltSupplier	capture(float a) Captures arguments but delays the evaluation.
default LFltUnaryOperator	compose(LFltUnaryOperator before) Allows to manipulate the domain of the function.
static LFltUnaryOperator	composed(LFltUnaryOperator before, LFltUnaryOperator after)
static <V> LToFltFunction<V>	composed(LToFltFunction<? super V> before, LFltUnaryOperator after)
static LFltUnaryOperator	constant(float r) Creates function that always returns the same value.
static LFltUnaryOperator	failSafe(LFltUnaryOperator func, LFltUnaryOperator failSafe)
default float	failSafeApplyAsFlt(float a, LFltUnaryOperator failSafe)
static float	failSafeApplyAsFlt(float a, LFltUnaryOperator func, LFltUnaryOperator failSafe)
static LFltUnaryOperator	fltUnaryOp(LFltUnaryOperator 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>	fltUnaryOpCompose(LToFltFunction<? super V> before) Allows to manipulate the domain of the function.
static LFltUnaryOperator	fltUnaryOpThrowing(ExF<Throwable> exF)
static LFltUnaryOperator	fltUnaryOpThrowing(String message, ExMF<Throwable> exF)
default <C0> void	forEach(IndexedRead<C0,aType.aFloat> 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_i, int max_i, float a, LFltUnaryOperator func) From-To.
static void	fromTo(int min_i, int max_i, float a, LFltUnaryOperator func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LFltUnaryOperator	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default float	handlingApplyAsFlt(float a, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static float	handlingApplyAsFlt(float a, LFltUnaryOperator func, HandlingInstructions<Throwable,RuntimeException> handling)
static LFltUnaryOperator	identity() Returns a function that always returns its input argument.
default <C0,I0> void	iterate(SequentialRead<C0,I0,aType.aFloat> sa, C0 source, LFltConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default float	nestingApplyAsFlt(float a) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default float	nonNullApplyAsFlt(float a) Just to mirror the method: Ensures the result is not null
static float	produceFloat(float a) Does nothing (LFltUnaryOperator) Operator
static LFltUnaryOperator	recursive(LFunction<LFltUnaryOperator,LFltUnaryOperator> selfLambda)
static LFltUnaryOperator	safe() Safe instance.
static LFltUnaryOperator	safe(LFltUnaryOperator other) Safe wrapping.
static LSupplier<LFltUnaryOperator>	safeSupplier() Safe instance supplier.
static LSupplier<LFltUnaryOperator>	safeSupplier(LSupplier<LFltUnaryOperator> supplier) Safe supplier.
default float	shovingApplyAsFlt(float a) Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
default <V> LFltFunction<V>	then(LFltFunction<? extends V> after) Combines two functions together in a order.
default LFltPredicate	thenToBool(LFltPredicate after) Combines two functions together in a order.
default LFltToByteFunction	thenToByte(LFltToByteFunction after) Combines two functions together in a order.
default LFltToCharFunction	thenToChar(LFltToCharFunction after) Combines two functions together in a order.
default LFltToDblFunction	thenToDbl(LFltToDblFunction after) Combines two functions together in a order.
default LFltUnaryOperator	thenToFlt(LFltUnaryOperator after) Combines two functions together in a order.
default LFltToIntFunction	thenToInt(LFltToIntFunction after) Combines two functions together in a order.
default LFltToLongFunction	thenToLong(LFltToLongFunction after) Combines two functions together in a order.
default LFltToSrtFunction	thenToSrt(LFltToSrtFunction after) Combines two functions together in a order.
static void	times(int max_i, float a, LFltUnaryOperator func) From-To.
static float	tryApplyAsFlt(float a, LFltUnaryOperator func)
static float	tryApplyAsFlt(float a, LFltUnaryOperator func, ExWF<RuntimeException> exF)
static float	tryApplyAsFlt(float a, LFltUnaryOperator func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static float	tryApplyAsFltThen(float a, LFltUnaryOperator func, LToFltFunction<Throwable> handler)
default LFltUnaryOperator	trying(ExWF<RuntimeException> exF)
default LFltUnaryOperator	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LFltUnaryOperator	tryingThen(LToFltFunction<Throwable> handler)
default float	tupleApplyAsFlt(LFltSingle args)

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

applyAsFlt

default float applyAsFlt(float a)

applyAsFltX

float applyAsFltX(float a)
           throws Throwable

Implement this, but call applyAsFlt(float a)

Throws:

Throwable

tupleApplyAsFlt

default float tupleApplyAsFlt(LFltSingle args)

handlingApplyAsFlt

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

Function call that handles exceptions according to the instructions.

handling

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

applyAsFlt

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

trying

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

applyAsFlt

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

trying

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

applyAsFltThen

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

tryingThen

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

nestingApplyAsFlt

default float nestingApplyAsFlt(float a)

Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.

shovingApplyAsFlt

default float shovingApplyAsFlt(float a)

Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.

handlingApplyAsFlt

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

tryApplyAsFlt

static float tryApplyAsFlt(float a,
                           LFltUnaryOperator func)

tryApplyAsFlt

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

tryApplyAsFlt

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

tryApplyAsFltThen

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

failSafeApplyAsFlt

default float failSafeApplyAsFlt(float a,
                                 @Nonnull
                                 LFltUnaryOperator failSafe)

failSafeApplyAsFlt

static float failSafeApplyAsFlt(float a,
                                LFltUnaryOperator func,
                                @Nonnull
                                LFltUnaryOperator failSafe)

failSafe

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

nonNullApplyAsFlt

default float nonNullApplyAsFlt(float 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,
                   float a,
                   LFltUnaryOperator func)

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

fromTill

static void fromTill(int min_i,
                     int max_i,
                     float a,
                     LFltUnaryOperator func)

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

times

static void times(int max_i,
                  float a,
                  LFltUnaryOperator func)

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

capture

default LFltSupplier capture(float a)

Captures arguments but delays the evaluation.

constant

static LFltUnaryOperator constant(float r)

Creates function that always returns the same value.

fltUnaryOp

@Nonnull
static LFltUnaryOperator fltUnaryOp(@Nonnull
                                              LFltUnaryOperator lambda)

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

recursive

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

fltUnaryOpThrowing

@Nonnull
static LFltUnaryOperator fltUnaryOpThrowing(@Nonnull
                                                      ExF<Throwable> exF)

fltUnaryOpThrowing

@Nonnull
static LFltUnaryOperator fltUnaryOpThrowing(String message,
                                                      @Nonnull
                                                      ExMF<Throwable> exF)

call

static float call(float a,
                  @Nonnull
                  LFltUnaryOperator lambda)

safe

@Nonnull
static LFltUnaryOperator safe()

Safe instance. That always returns the same value (as produceFloat).

safeSupplier

@Nonnull
static LSupplier<LFltUnaryOperator> safeSupplier()

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

safe

@Nonnull
static LFltUnaryOperator safe(@Nullable
                                        LFltUnaryOperator other)

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

safeSupplier

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

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

compose

@Nonnull
default LFltUnaryOperator compose(@Nonnull
                                            LFltUnaryOperator before)

Allows to manipulate the domain of the function.

composed

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

fltUnaryOpCompose

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

Allows to manipulate the domain of the function.

composed

static <V> LToFltFunction<V> composed(@Nonnull
                                      LToFltFunction<? super V> before,
                                      LFltUnaryOperator after)

then

@Nonnull
default <V> LFltFunction<V> then(@Nonnull
                                           LFltFunction<? extends V> after)

Combines two functions together in a order.

thenToByte

@Nonnull
default LFltToByteFunction thenToByte(@Nonnull
                                                LFltToByteFunction after)

Combines two functions together in a order.

thenToSrt

@Nonnull
default LFltToSrtFunction thenToSrt(@Nonnull
                                              LFltToSrtFunction after)

Combines two functions together in a order.

thenToInt

@Nonnull
default LFltToIntFunction thenToInt(@Nonnull
                                              LFltToIntFunction after)

Combines two functions together in a order.

thenToLong

@Nonnull
default LFltToLongFunction thenToLong(@Nonnull
                                                LFltToLongFunction after)

Combines two functions together in a order.

thenToFlt

@Nonnull
default LFltUnaryOperator thenToFlt(@Nonnull
                                              LFltUnaryOperator after)

Combines two functions together in a order.

thenToDbl

@Nonnull
default LFltToDblFunction thenToDbl(@Nonnull
                                              LFltToDblFunction after)

Combines two functions together in a order.

thenToChar

@Nonnull
default LFltToCharFunction thenToChar(@Nonnull
                                                LFltToCharFunction after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LFltPredicate thenToBool(@Nonnull
                                           LFltPredicate after)

Combines two functions together in a order.

identity

@Nonnull
static LFltUnaryOperator identity()

Returns a function that always returns its input argument.

produceFloat

static float produceFloat(float a)

Does nothing (LFltUnaryOperator) Operator

forEach

default <C0> void forEach(IndexedRead<C0,aType.aFloat> ia,
                          C0 source,
                          LFltConsumer consumer)

For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method is not expected.

iterate

default <C0,I0> void iterate(SequentialRead<C0,I0,aType.aFloat> sa,
                             C0 source,
                             LFltConsumer consumer)

For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method depends highly on the arguments.