@FunctionalInterface public interface LByteToFltFunction extends MetaFunction, MetaInterface.NonThrowing, Codomain<aType.aFloat>, Domain1<aType.aByte>
Non-throwing functional interface (lambda) LByteToFltFunction for Java 8.
Type: function
Domain (lvl: 1): byte a
Co-domain: float
| Modifier and Type | Interface and Description |
|---|---|
static class |
LByteToFltFunction.LByteToFltFunctionSingle |
MetaInterface.NonThrowing, MetaInterface.Throwing<X>| Modifier and Type | Field and Description |
|---|---|
static String |
DESCRIPTION |
| Modifier and Type | Method and Description |
|---|---|
default float |
applyAsFlt(byte a) |
default float |
applyAsFlt(byte a,
ExWF<RuntimeException> exF) |
default float |
applyAsFlt(byte a,
ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
default float |
applyAsFltThen(byte a,
LToFltFunction<Throwable> handler) |
float |
applyAsFltX(byte a)
Implement this, but call applyAsFlt(byte a)
|
static LByteToFltFunction |
byteToFltFunc(LByteToFltFunction 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> |
byteToFltFuncCompose(LToByteFunction<? super V> before)
Allows to manipulate the domain of the function.
|
static LByteToFltFunction |
byteToFltFuncThrowing(ExF<Throwable> exF) |
static LByteToFltFunction |
byteToFltFuncThrowing(String message,
ExMF<Throwable> exF) |
static float |
call(byte a,
LByteToFltFunction lambda) |
default LFltSupplier |
capture(byte a)
Captures arguments but delays the evaluation.
|
default LByteToFltFunction |
compose(LByteUnaryOperator before)
Allows to manipulate the domain of the function.
|
static LByteToFltFunction |
composed(LByteUnaryOperator before,
LByteToFltFunction after) |
static <V> LToFltFunction<V> |
composed(LToByteFunction<? super V> before,
LByteToFltFunction after) |
static LByteToFltFunction |
constant(float r)
Creates function that always returns the same value.
|
static LByteToFltFunction |
failSafe(LByteToFltFunction func,
LByteToFltFunction failSafe) |
default float |
failSafeApplyAsFlt(byte a,
LByteToFltFunction failSafe) |
static float |
failSafeApplyAsFlt(byte a,
LByteToFltFunction func,
LByteToFltFunction failSafe) |
default <C0> void |
forEach(IndexedRead<C0,aType.aByte> 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,
byte a,
LByteToFltFunction func)
From-To.
|
static void |
fromTo(int min_i,
int max_i,
byte a,
LByteToFltFunction func)
From-To.
|
default String |
functionalInterfaceDescription()
Returns description of the functional interface.
|
default LByteToFltFunction |
handling(HandlingInstructions<Throwable,RuntimeException> handling) |
default float |
handlingApplyAsFlt(byte a,
HandlingInstructions<Throwable,RuntimeException> handling)
Function call that handles exceptions according to the instructions.
|
static float |
handlingApplyAsFlt(byte a,
LByteToFltFunction func,
HandlingInstructions<Throwable,RuntimeException> handling) |
default <C0,I0> void |
iterate(SequentialRead<C0,I0,aType.aByte> sa,
C0 source,
LFltConsumer consumer)
For each element (or tuple) from arguments, calls the function and passes the result to consumer.
|
default float |
nestingApplyAsFlt(byte a)
Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
|
default float |
nonNullApplyAsFlt(byte a)
Just to mirror the method: Ensures the result is not null
|
static float |
produceFloat(byte a)
Does nothing (LByteToFltFunction) Function
|
static LByteToFltFunction |
recursive(LFunction<LByteToFltFunction,LByteToFltFunction> selfLambda) |
static LByteToFltFunction |
safe()
Safe instance.
|
static LByteToFltFunction |
safe(LByteToFltFunction other)
Safe wrapping.
|
static LSupplier<LByteToFltFunction> |
safeSupplier()
Safe instance supplier.
|
static LSupplier<LByteToFltFunction> |
safeSupplier(LSupplier<LByteToFltFunction> supplier)
Safe supplier.
|
default float |
shovingApplyAsFlt(byte a)
Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
|
default <V> LByteFunction<V> |
then(LFltFunction<? extends V> after)
Combines two functions together in a order.
|
default LBytePredicate |
thenToBool(LFltPredicate after)
Combines two functions together in a order.
|
default LByteUnaryOperator |
thenToByte(LFltToByteFunction after)
Combines two functions together in a order.
|
default LByteToCharFunction |
thenToChar(LFltToCharFunction after)
Combines two functions together in a order.
|
default LByteToDblFunction |
thenToDbl(LFltToDblFunction after)
Combines two functions together in a order.
|
default LByteToFltFunction |
thenToFlt(LFltUnaryOperator after)
Combines two functions together in a order.
|
default LByteToIntFunction |
thenToInt(LFltToIntFunction after)
Combines two functions together in a order.
|
default LByteToLongFunction |
thenToLong(LFltToLongFunction after)
Combines two functions together in a order.
|
default LByteToSrtFunction |
thenToSrt(LFltToSrtFunction after)
Combines two functions together in a order.
|
static void |
times(int max_i,
byte a,
LByteToFltFunction func)
From-To.
|
static float |
tryApplyAsFlt(byte a,
LByteToFltFunction func) |
static float |
tryApplyAsFlt(byte a,
LByteToFltFunction func,
ExWF<RuntimeException> exF) |
static float |
tryApplyAsFlt(byte a,
LByteToFltFunction func,
ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
static float |
tryApplyAsFltThen(byte a,
LByteToFltFunction func,
LToFltFunction<Throwable> handler) |
default LByteToFltFunction |
trying(ExWF<RuntimeException> exF) |
default LByteToFltFunction |
trying(ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
default LByteToFltFunction |
tryingThen(LToFltFunction<Throwable> handler) |
default float |
tupleApplyAsFlt(LByteSingle args) |
isFunctionformatTo, isAction, isConsumer, isOperator, isPredicate, isSupplierisThrowingstatic final String DESCRIPTION
default float applyAsFlt(byte a)
float applyAsFltX(byte a)
throws Throwable
Implement this, but call applyAsFlt(byte a)
Throwabledefault float tupleApplyAsFlt(LByteSingle args)
default float handlingApplyAsFlt(byte a,
HandlingInstructions<Throwable,RuntimeException> handling)
Function call that handles exceptions according to the instructions.
default LByteToFltFunction handling(HandlingInstructions<Throwable,RuntimeException> handling)
default float applyAsFlt(byte a,
@Nonnull
ExWMF<RuntimeException> exF,
@Nonnull
String newMessage,
@Nullable
Object... messageParams)
default LByteToFltFunction trying(@Nonnull ExWMF<RuntimeException> exF, @Nonnull String newMessage, @Nullable Object... messageParams)
default float applyAsFlt(byte a,
@Nonnull
ExWF<RuntimeException> exF)
default LByteToFltFunction trying(@Nonnull ExWF<RuntimeException> exF)
default float applyAsFltThen(byte a,
@Nonnull
LToFltFunction<Throwable> handler)
default LByteToFltFunction tryingThen(@Nonnull LToFltFunction<Throwable> handler)
default float nestingApplyAsFlt(byte a)
Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default float shovingApplyAsFlt(byte a)
Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
static float handlingApplyAsFlt(byte a,
LByteToFltFunction func,
HandlingInstructions<Throwable,RuntimeException> handling)
static float tryApplyAsFlt(byte a,
LByteToFltFunction func)
static float tryApplyAsFlt(byte a,
LByteToFltFunction func,
@Nonnull
ExWMF<RuntimeException> exF,
@Nonnull
String newMessage,
@Nullable
Object... messageParams)
static float tryApplyAsFlt(byte a,
LByteToFltFunction func,
@Nonnull
ExWF<RuntimeException> exF)
static float tryApplyAsFltThen(byte a,
LByteToFltFunction func,
@Nonnull
LToFltFunction<Throwable> handler)
default float failSafeApplyAsFlt(byte a,
@Nonnull
LByteToFltFunction failSafe)
static float failSafeApplyAsFlt(byte a,
LByteToFltFunction func,
@Nonnull
LByteToFltFunction failSafe)
static LByteToFltFunction failSafe(LByteToFltFunction func, @Nonnull LByteToFltFunction failSafe)
default float nonNullApplyAsFlt(byte a)
Just to mirror the method: Ensures the result is not null
@Nonnull default String functionalInterfaceDescription()
Returns description of the functional interface.
functionalInterfaceDescription in interface MetaFunctionalInterfacestatic void fromTo(int min_i,
int max_i,
byte a,
LByteToFltFunction func)
From-To. Intended to be used with non-capturing lambda.
static void fromTill(int min_i,
int max_i,
byte a,
LByteToFltFunction func)
From-To. Intended to be used with non-capturing lambda.
static void times(int max_i,
byte a,
LByteToFltFunction func)
From-To. Intended to be used with non-capturing lambda.
default LFltSupplier capture(byte a)
Captures arguments but delays the evaluation.
static LByteToFltFunction constant(float r)
Creates function that always returns the same value.
@Nonnull static LByteToFltFunction byteToFltFunc(@Nonnull LByteToFltFunction lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
@Nonnull static LByteToFltFunction recursive(@Nonnull LFunction<LByteToFltFunction,LByteToFltFunction> selfLambda)
@Nonnull static LByteToFltFunction byteToFltFuncThrowing(@Nonnull ExF<Throwable> exF)
@Nonnull static LByteToFltFunction byteToFltFuncThrowing(String message, @Nonnull ExMF<Throwable> exF)
static float call(byte a,
@Nonnull
LByteToFltFunction lambda)
@Nonnull static LByteToFltFunction safe()
Safe instance. That always returns the same value (as produceFloat).
@Nonnull static LSupplier<LByteToFltFunction> safeSupplier()
Safe instance supplier. Returns supplier of safe() instance.
@Nonnull static LByteToFltFunction safe(@Nullable LByteToFltFunction other)
Safe wrapping. Either argument function is returned (if it is not null) or safe() instance.
@Nonnull static LSupplier<LByteToFltFunction> safeSupplier(@Nullable LSupplier<LByteToFltFunction> supplier)
Safe supplier. Either argument supplier is returned (if it is not null) or supplier of safe() instance.
@Nonnull default LByteToFltFunction compose(@Nonnull LByteUnaryOperator before)
Allows to manipulate the domain of the function.
static LByteToFltFunction composed(@Nonnull LByteUnaryOperator before, LByteToFltFunction after)
@Nonnull default <V> LToFltFunction<V> byteToFltFuncCompose(@Nonnull LToByteFunction<? super V> before)
Allows to manipulate the domain of the function.
static <V> LToFltFunction<V> composed(@Nonnull LToByteFunction<? super V> before, LByteToFltFunction after)
@Nonnull default <V> LByteFunction<V> then(@Nonnull LFltFunction<? extends V> after)
Combines two functions together in a order.
@Nonnull default LByteUnaryOperator thenToByte(@Nonnull LFltToByteFunction after)
Combines two functions together in a order.
@Nonnull default LByteToSrtFunction thenToSrt(@Nonnull LFltToSrtFunction after)
Combines two functions together in a order.
@Nonnull default LByteToIntFunction thenToInt(@Nonnull LFltToIntFunction after)
Combines two functions together in a order.
@Nonnull default LByteToLongFunction thenToLong(@Nonnull LFltToLongFunction after)
Combines two functions together in a order.
@Nonnull default LByteToFltFunction thenToFlt(@Nonnull LFltUnaryOperator after)
Combines two functions together in a order.
@Nonnull default LByteToDblFunction thenToDbl(@Nonnull LFltToDblFunction after)
Combines two functions together in a order.
@Nonnull default LByteToCharFunction thenToChar(@Nonnull LFltToCharFunction after)
Combines two functions together in a order.
@Nonnull default LBytePredicate thenToBool(@Nonnull LFltPredicate after)
Combines two functions together in a order.
static float produceFloat(byte a)
Does nothing (LByteToFltFunction) Function
default <C0> void forEach(IndexedRead<C0,aType.aByte> 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.
default <C0,I0> void iterate(SequentialRead<C0,I0,aType.aByte> 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.
Copyright © 2019. All rights reserved.