Uses of Interface
eu.lunisolar.magma.func.function.to.LToByteFunction

Packages that use LToByteFunction

Package	Description
eu.lunisolar.magma.func.consumer.primitives
eu.lunisolar.magma.func.consumer.primitives.bi
eu.lunisolar.magma.func.consumer.primitives.obj
eu.lunisolar.magma.func.function
eu.lunisolar.magma.func.function.conversion
eu.lunisolar.magma.func.function.from
eu.lunisolar.magma.func.function.to
eu.lunisolar.magma.func.operator.binary
eu.lunisolar.magma.func.operator.unary
eu.lunisolar.magma.func.predicate
eu.lunisolar.magma.func.supplier
eu.lunisolar.magma.func.tuple

Uses of LToByteFunction in eu.lunisolar.magma.func.consumer.primitives

Methods in eu.lunisolar.magma.func.consumer.primitives with parameters of type LToByteFunction

Modifier and Type	Method and Description
default <V> LConsumer<V>	LByteConsumer.byteConsCompose(LToByteFunction<? super V> before) Allows to manipulate the domain of the function.
static <V> LConsumer<V>	LByteConsumer.composed(LToByteFunction<? super V> before, LByteConsumer after)

Uses of LToByteFunction in eu.lunisolar.magma.func.consumer.primitives.bi

Methods in eu.lunisolar.magma.func.consumer.primitives.bi with parameters of type LToByteFunction

Modifier and Type	Method and Description
default <V1,V2> LBiConsumer<V1,V2>	LBiByteConsumer.biByteConsCompose(LToByteFunction<? super V1> before1, LToByteFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LBiByteConsumer.biByteConsCompose(LToByteFunction<? super V1> before1, LToByteFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LByteIntConsumer.byteIntConsCompose(LToByteFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
static <V1,V2> LBiConsumer<V1,V2>	LBiByteConsumer.composed(LToByteFunction<? super V1> before1, LToByteFunction<? super V2> before2, LBiByteConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LBiByteConsumer.composed(LToByteFunction<? super V1> before1, LToByteFunction<? super V2> before2, LBiByteConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LByteIntConsumer.composed(LToByteFunction<? super V1> before1, LToIntFunction<? super V2> before2, LByteIntConsumer after)

Uses of LToByteFunction in eu.lunisolar.magma.func.consumer.primitives.obj

Methods in eu.lunisolar.magma.func.consumer.primitives.obj with parameters of type LToByteFunction

Modifier and Type	Method and Description
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjByteConsumer.biObjByteConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3) Allows to manipulate the domain of the function.
static <V1,V2,T> LBiConsumer<V1,V2>	LObjByteConsumer.composed(LFunction<? super V1,? extends T> before1, LToByteFunction<? super V2> before2, LObjByteConsumer<T> after)
static <V1,V2,V3,T> LTriConsumer<V1,V2,V3>	LTieByteConsumer.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToByteFunction<? super V3> before3, LTieByteConsumer<T> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjByteConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3, LBiObjByteConsumer<T1,T2> after)
default <V1,V2> LBiConsumer<V1,V2>	LObjByteConsumer.objByteConsCompose(LFunction<? super V1,? extends T> before1, LToByteFunction<? super V2> before2) Allows to manipulate the domain of the function.
default LConsumer<T>	LObjByteConsumer.rShrink(LToByteFunction<T> right)
static <T> LConsumer<T>	LObjByteConsumer.rShrinked(LToByteFunction<T> right, LObjByteConsumer<T> func)
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LTieByteConsumer.tieByteConsCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToByteFunction<? super V3> before3) Allows to manipulate the domain of the function.
static <T,SRC> int	LTieByteConsumer.tieForEach(int sStart, int tStart, T trg1, SRC src3, LPredicate<SRC> srcTest3, LToByteFunction<SRC> srcAcc3, LTieByteConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).

Uses of LToByteFunction in eu.lunisolar.magma.func.function

Methods in eu.lunisolar.magma.func.function that return LToByteFunction

Modifier and Type	Method and Description
default LToByteFunction<T>	LFunction.thenToByte(LToByteFunction<? super R> after) Combines two functions together in a order.

Methods in eu.lunisolar.magma.func.function with parameters of type LToByteFunction

Modifier and Type	Method and Description
default LToByteFunction<T>	LFunction.thenToByte(LToByteFunction<? super R> after) Combines two functions together in a order.
default LToByteBiFunction<T1,T2>	LBiFunction.thenToByte(LToByteFunction<? super R> after) Combines two functions together in a order.

Uses of LToByteFunction in eu.lunisolar.magma.func.function.conversion

Methods in eu.lunisolar.magma.func.function.conversion that return LToByteFunction

Modifier and Type	Method and Description
default <V> LToByteFunction<V>	LBoolToByteFunction.boolToByteFuncCompose(LPredicate<? super V> before) Allows to manipulate the domain of the function.
default <V> LToByteFunction<V>	LCharToByteFunction.charToByteFuncCompose(LToCharFunction<? super V> before) Allows to manipulate the domain of the function.
static <V> LToByteFunction<V>	LBoolToByteFunction.composed(LPredicate<? super V> before, LBoolToByteFunction after)
static <V> LToByteFunction<V>	LCharToByteFunction.composed(LToCharFunction<? super V> before, LCharToByteFunction after)
static <V> LToByteFunction<V>	LDblToByteFunction.composed(LToDblFunction<? super V> before, LDblToByteFunction after)
static <V> LToByteFunction<V>	LFltToByteFunction.composed(LToFltFunction<? super V> before, LFltToByteFunction after)
static <V> LToByteFunction<V>	LIntToByteFunction.composed(LToIntFunction<? super V> before, LIntToByteFunction after)
static <V> LToByteFunction<V>	LLongToByteFunction.composed(LToLongFunction<? super V> before, LLongToByteFunction after)
static <V> LToByteFunction<V>	LSrtToByteFunction.composed(LToSrtFunction<? super V> before, LSrtToByteFunction after)
default <V> LToByteFunction<V>	LDblToByteFunction.dblToByteFuncCompose(LToDblFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToByteFunction<V>	LFltToByteFunction.fltToByteFuncCompose(LToFltFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToByteFunction<V>	LIntToByteFunction.intToByteFuncCompose(LToIntFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToByteFunction<V>	LLongToByteFunction.longToByteFuncCompose(LToLongFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToByteFunction<V>	LSrtToByteFunction.srtToByteFuncCompose(LToSrtFunction<? super V> before) Allows to manipulate the domain of the function.

Methods in eu.lunisolar.magma.func.function.conversion with parameters of type LToByteFunction

Modifier and Type	Method and Description
default byte	LBoolToByteFunction.applyAsByteThen(boolean a, LToByteFunction<Throwable> handler)
default byte	LCharToByteFunction.applyAsByteThen(char a, LToByteFunction<Throwable> handler)
default byte	LDblToByteFunction.applyAsByteThen(double a, LToByteFunction<Throwable> handler)
default byte	LFltToByteFunction.applyAsByteThen(float a, LToByteFunction<Throwable> handler)
default byte	LIntToByteFunction.applyAsByteThen(int a, LToByteFunction<Throwable> handler)
default byte	LLongToByteFunction.applyAsByteThen(long a, LToByteFunction<Throwable> handler)
default byte	LSrtToByteFunction.applyAsByteThen(short a, LToByteFunction<Throwable> handler)
default <V> LToCharFunction<V>	LByteToCharFunction.byteToCharFuncCompose(LToByteFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToDblFunction<V>	LByteToDblFunction.byteToDblFuncCompose(LToByteFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToFltFunction<V>	LByteToFltFunction.byteToFltFuncCompose(LToByteFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToIntFunction<V>	LByteToIntFunction.byteToIntFuncCompose(LToByteFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToLongFunction<V>	LByteToLongFunction.byteToLongFuncCompose(LToByteFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToSrtFunction<V>	LByteToSrtFunction.byteToSrtFuncCompose(LToByteFunction<? super V> before) Allows to manipulate the domain of the function.
static <V> LToCharFunction<V>	LByteToCharFunction.composed(LToByteFunction<? super V> before, LByteToCharFunction after)
static <V> LToDblFunction<V>	LByteToDblFunction.composed(LToByteFunction<? super V> before, LByteToDblFunction after)
static <V> LToFltFunction<V>	LByteToFltFunction.composed(LToByteFunction<? super V> before, LByteToFltFunction after)
static <V> LToIntFunction<V>	LByteToIntFunction.composed(LToByteFunction<? super V> before, LByteToIntFunction after)
static <V> LToLongFunction<V>	LByteToLongFunction.composed(LToByteFunction<? super V> before, LByteToLongFunction after)
static <V> LToSrtFunction<V>	LByteToSrtFunction.composed(LToByteFunction<? super V> before, LByteToSrtFunction after)
static byte	LBoolToByteFunction.tryApplyAsByteThen(boolean a, LBoolToByteFunction func, LToByteFunction<Throwable> handler)
static byte	LCharToByteFunction.tryApplyAsByteThen(char a, LCharToByteFunction func, LToByteFunction<Throwable> handler)
static byte	LDblToByteFunction.tryApplyAsByteThen(double a, LDblToByteFunction func, LToByteFunction<Throwable> handler)
static byte	LFltToByteFunction.tryApplyAsByteThen(float a, LFltToByteFunction func, LToByteFunction<Throwable> handler)
static byte	LIntToByteFunction.tryApplyAsByteThen(int a, LIntToByteFunction func, LToByteFunction<Throwable> handler)
static byte	LLongToByteFunction.tryApplyAsByteThen(long a, LLongToByteFunction func, LToByteFunction<Throwable> handler)
static byte	LSrtToByteFunction.tryApplyAsByteThen(short a, LSrtToByteFunction func, LToByteFunction<Throwable> handler)
default LSrtToByteFunction	LSrtToByteFunction.tryingThen(LToByteFunction<Throwable> handler)
default LLongToByteFunction	LLongToByteFunction.tryingThen(LToByteFunction<Throwable> handler)
default LIntToByteFunction	LIntToByteFunction.tryingThen(LToByteFunction<Throwable> handler)
default LFltToByteFunction	LFltToByteFunction.tryingThen(LToByteFunction<Throwable> handler)
default LDblToByteFunction	LDblToByteFunction.tryingThen(LToByteFunction<Throwable> handler)
default LCharToByteFunction	LCharToByteFunction.tryingThen(LToByteFunction<Throwable> handler)
default LBoolToByteFunction	LBoolToByteFunction.tryingThen(LToByteFunction<Throwable> handler)

Uses of LToByteFunction in eu.lunisolar.magma.func.function.from

Methods in eu.lunisolar.magma.func.function.from with parameters of type LToByteFunction

Modifier and Type	Method and Description
default <V1,V2> LBiFunction<V1,V2,R>	LBiByteFunction.biByteFuncCompose(LToByteFunction<? super V1> before1, LToByteFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LBiByteFunction.biByteFuncCompose(LToByteFunction<? super V1> before1, LToByteFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjByteFunction.biObjByteFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V> LFunction<V,R>	LByteFunction.byteFuncCompose(LToByteFunction<? super V> before) Allows to manipulate the domain of the function.
static <V1,V2,T,R> LBiFunction<V1,V2,R>	LObjByteFunction.composed(LFunction<? super V1,? extends T> before1, LToByteFunction<? super V2> before2, LObjByteFunction<T,R> after)
static <V1,V2,V3,T,R> LTriFunction<V1,V2,V3,R>	LObjIntByteFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToByteFunction<? super V3> before3, LObjIntByteFunction<T,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjByteFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3, LBiObjByteFunction<T1,T2,R> after)
static <V,R> LFunction<V,R>	LByteFunction.composed(LToByteFunction<? super V> before, LByteFunction<R> after)
static <V1,V2,R> LBiFunction<V1,V2,R>	LBiByteFunction.composed(LToByteFunction<? super V1> before1, LToByteFunction<? super V2> before2, LBiByteFunction<R> after)
static <V1,V2,R> LBiFunction<V1,V2,R>	LBiByteFunction.composed(LToByteFunction<? super V1> before1, LToByteFunction<? super V2> before2, LBiByteFunction<R> after)
default <V1,V2> LBiFunction<V1,V2,R>	LObjByteFunction.objByteFuncCompose(LFunction<? super V1,? extends T> before1, LToByteFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LObjIntByteFunction.objIntByteFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToByteFunction<? super V3> before3) Allows to manipulate the domain of the function.
default LFunction<T,R>	LObjByteFunction.rShrink(LToByteFunction<T> right)
static <T,R> LFunction<T,R>	LObjByteFunction.rShrinked(LToByteFunction<T> right, LObjByteFunction<T,R> func)
default LSrtToByteFunction	LSrtFunction.thenToByte(LToByteFunction<? super R> after) Combines two functions together in a order.
default LOiToByteFunction<T>	LOiFunction.thenToByte(LToByteFunction<? super R> after) Combines two functions together in a order.
default LLongToByteFunction	LLongFunction.thenToByte(LToByteFunction<? super R> after) Combines two functions together in a order.
default LIntToByteFunction	LIntFunction.thenToByte(LToByteFunction<? super R> after) Combines two functions together in a order.
default LFltToByteFunction	LFltFunction.thenToByte(LToByteFunction<? super R> after) Combines two functions together in a order.
default LDblToByteFunction	LDblFunction.thenToByte(LToByteFunction<? super R> after) Combines two functions together in a order.
default LCharToByteFunction	LCharFunction.thenToByte(LToByteFunction<? super R> after) Combines two functions together in a order.
default LByteUnaryOperator	LByteFunction.thenToByte(LToByteFunction<? super R> after) Combines two functions together in a order.
default LBoolToByteFunction	LBoolFunction.thenToByte(LToByteFunction<? super R> after) Combines two functions together in a order.
default LByteBinaryOperator	LBiByteFunction.thenToByte(LToByteFunction<? super R> after) Combines two functions together in a order.

Uses of LToByteFunction in eu.lunisolar.magma.func.function.to

Classes in eu.lunisolar.magma.func.function.to that implement LToByteFunction

Modifier and Type	Class and Description
static class	LToByteFunction.LToByteFunctionSingle<T>

Methods in eu.lunisolar.magma.func.function.to that return LToByteFunction

Modifier and Type	Method and Description
default <V2> LToByteFunction<V2>	LToByteFunction.cast() Cast that replace generics.
static <V2,T> LToByteFunction<V2>	LToByteFunction.cast(LToByteFunction<T> function) Cast that replace generics.
default <V> LToByteFunction<V>	LToByteFunction.compose(LFunction<? super V,? extends T> before) Allows to manipulate the domain of the function.
static <V,T> LToByteFunction<V>	LToByteFunction.composed(LFunction<? super V,? extends T> before, LToByteFunction<T> after)
static <T> LToByteFunction<T>	LToByteFunction.constant(byte r) Creates function that always returns the same value.
static <T> LToByteFunction<T>	LToByteFunction.failSafe(LToByteFunction<T> func, LToByteFunction<T> failSafe)
default LToByteFunction<T>	LToByteFunction.handling(HandlingInstructions<Throwable,RuntimeException> handling)
default LToByteFunction<T2>	LToByteBiFunction.lShrink(LFunction<T2,T1> left)
default LToByteFunction<T2>	LToByteBiFunction.lShrinkc(T1 a1)
static <T2,T1> LToByteFunction<T2>	LToByteBiFunction.lShrinked(LFunction<T2,T1> left, LToByteBiFunction<T1,T2> func)
static <T2,T1> LToByteFunction<T2>	LToByteBiFunction.lShrinkedc(T1 a1, LToByteBiFunction<T1,T2> func)
static <T> LToByteFunction<T>	LToByteFunction.recursive(LFunction<LToByteFunction<T>,LToByteFunction<T>> selfLambda)
default LToByteFunction<T1>	LToByteBiFunction.rShrink(LFunction<T1,T2> right)
default LToByteFunction<T>	LOiToByteFunction.rShrink(LToIntFunction<T> right)
default LToByteFunction<T>	LOiToByteFunction.rShrinkc(int a2)
default LToByteFunction<T1>	LToByteBiFunction.rShrinkc(T2 a2)
static <T1,T2> LToByteFunction<T1>	LToByteBiFunction.rShrinked(LFunction<T1,T2> right, LToByteBiFunction<T1,T2> func)
static <T> LToByteFunction<T>	LOiToByteFunction.rShrinked(LToIntFunction<T> right, LOiToByteFunction<T> func)
static <T> LToByteFunction<T>	LOiToByteFunction.rShrinkedc(int a2, LOiToByteFunction<T> func)
static <T1,T2> LToByteFunction<T1>	LToByteBiFunction.rShrinkedc(T2 a2, LToByteBiFunction<T1,T2> func)
static <T> LToByteFunction<T>	LToByteFunction.safe() Safe instance.
static <T> LToByteFunction<T>	LToByteFunction.safe(LToByteFunction<T> other) Safe wrapping.
default LToByteFunction<T>	LToByteFunction.thenToByte(LByteUnaryOperator after) Combines two functions together in a order.
default LToByteFunction<T>	LToCharFunction.thenToByte(LCharToByteFunction after) Combines two functions together in a order.
default LToByteFunction<T>	LToDblFunction.thenToByte(LDblToByteFunction after) Combines two functions together in a order.
default LToByteFunction<T>	LToFltFunction.thenToByte(LFltToByteFunction after) Combines two functions together in a order.
default LToByteFunction<T>	LToIntFunction.thenToByte(LIntToByteFunction after) Combines two functions together in a order.
default LToByteFunction<T>	LToLongFunction.thenToByte(LLongToByteFunction after) Combines two functions together in a order.
default LToByteFunction<T>	LToSrtFunction.thenToByte(LSrtToByteFunction after) Combines two functions together in a order.
static <T> LToByteFunction<T>	LToByteFunction.toByteFunc(LToByteFunction<T> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T> LToByteFunction<T>	LToByteFunction.toByteFuncThrowing(ExF<Throwable> exF)
static <T> LToByteFunction<T>	LToByteFunction.toByteFuncThrowing(String message, ExMF<Throwable> exF)
default LToByteFunction<T>	LToByteFunction.trying(ExWF<RuntimeException> exF)
default LToByteFunction<T>	LToByteFunction.trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LToByteFunction<T>	LToByteFunction.tryingThen(LToByteFunction<Throwable> handler)
default LToByteFunction	LToByteFunction.untyped() Cast that removes generics.
LToByteFunction<T>	LToByteFunction.LToByteFunctionSingle.value()

Methods in eu.lunisolar.magma.func.function.to that return types with arguments of type LToByteFunction

Modifier and Type	Method and Description
static <T> LSupplier<LToByteFunction<T>>	LToByteFunction.safeSupplier() Safe instance supplier.
static <T> LSupplier<LToByteFunction<T>>	LToByteFunction.safeSupplier(LSupplier<LToByteFunction<T>> supplier) Safe supplier.

Methods in eu.lunisolar.magma.func.function.to with parameters of type LToByteFunction

Modifier and Type	Method and Description
static <T> LOiToByteFunction<T>	LOiToByteFunction.apply1stAsByte(LToByteFunction<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LToByteBiFunction<T1,T2>	LToByteBiFunction.apply1stAsByte(LToByteFunction<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LToByteBiFunction<T1,T2>	LToByteBiFunction.apply2ndAsByte(LToByteFunction<T2> func) Captures single parameter function into this interface where only 2nd parameter will be used.
default byte	LToByteBiFunction.applyAsByteThen(T1 a1, T2 a2, LToByteFunction<Throwable> handler)
default byte	LOiToByteFunction.applyAsByteThen(T a1, int a2, LToByteFunction<Throwable> handler)
default byte	LToByteFunction.applyAsByteThen(T a, LToByteFunction<Throwable> handler)
static <T> byte	LToByteFunction.call(T a, LToByteFunction<T> lambda)
static <V2,T> LToByteFunction<V2>	LToByteFunction.cast(LToByteFunction<T> function) Cast that replace generics.
static <V,T> LToByteFunction<V>	LToByteFunction.composed(LFunction<? super V,? extends T> before, LToByteFunction<T> after)
static <V1,V2,V3,T> LToIntTriFunction<V1,V2,V3>	LTieByteFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToByteFunction<? super V3> before3, LTieByteFunction<T> after)
static <T> LToByteFunction<T>	LToByteFunction.failSafe(LToByteFunction<T> func, LToByteFunction<T> failSafe)
static <T> LToByteFunction<T>	LToByteFunction.failSafe(LToByteFunction<T> func, LToByteFunction<T> failSafe)
default byte	LToByteFunction.failSafeApplyAsByte(T a, LToByteFunction<T> failSafe)
static <T> byte	LToByteFunction.failSafeApplyAsByte(T a, LToByteFunction<T> func, LToByteFunction<T> failSafe)
static <T> byte	LToByteFunction.failSafeApplyAsByte(T a, LToByteFunction<T> func, LToByteFunction<T> failSafe)
static <T> void	LToByteFunction.fromTill(int min_i, int max_i, T a, LToByteFunction<T> func) From-To.
static <T> void	LToByteFunction.fromTo(int min_i, int max_i, T a, LToByteFunction<T> func) From-To.
static <T> byte	LToByteFunction.handlingApplyAsByte(T a, LToByteFunction<T> func, HandlingInstructions<Throwable,RuntimeException> handling)
static <T> LToByteFunction<T>	LToByteFunction.safe(LToByteFunction<T> other) Safe wrapping.
default <V1,V2,V3> LToIntTriFunction<V1,V2,V3>	LTieByteFunction.tieByteFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToByteFunction<? super V3> before3) Allows to manipulate the domain of the function.
static <T,SRC> int	LTieByteFunction.tieForEach(int sStart, int tStart, T trg1, SRC src3, LPredicate<SRC> srcTest3, LToByteFunction<SRC> srcAcc3, LTieByteFunction<? super T> consumer) For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
static <T> void	LToByteFunction.times(int max_i, T a, LToByteFunction<T> func) From-To.
static <T> LToByteFunction<T>	LToByteFunction.toByteFunc(LToByteFunction<T> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T> byte	LToByteFunction.tryApplyAsByte(T a, LToByteFunction<T> func)
static <T> byte	LToByteFunction.tryApplyAsByte(T a, LToByteFunction<T> func, ExWF<RuntimeException> exF)
static <T> byte	LToByteFunction.tryApplyAsByte(T a, LToByteFunction<T> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static <T1,T2> byte	LToByteBiFunction.tryApplyAsByteThen(T1 a1, T2 a2, LToByteBiFunction<T1,T2> func, LToByteFunction<Throwable> handler)
static <T> byte	LOiToByteFunction.tryApplyAsByteThen(T a1, int a2, LOiToByteFunction<T> func, LToByteFunction<Throwable> handler)
static <T> byte	LToByteFunction.tryApplyAsByteThen(T a, LToByteFunction<T> func, LToByteFunction<Throwable> handler)
static <T> byte	LToByteFunction.tryApplyAsByteThen(T a, LToByteFunction<T> func, LToByteFunction<Throwable> handler)
default LToByteFunction<T>	LToByteFunction.tryingThen(LToByteFunction<Throwable> handler)
default LToByteBiFunction<T1,T2>	LToByteBiFunction.tryingThen(LToByteFunction<Throwable> handler)
default LOiToByteFunction<T>	LOiToByteFunction.tryingThen(LToByteFunction<Throwable> handler)

Method parameters in eu.lunisolar.magma.func.function.to with type arguments of type LToByteFunction

Modifier and Type	Method and Description
static <T> LToByteFunction<T>	LToByteFunction.recursive(LFunction<LToByteFunction<T>,LToByteFunction<T>> selfLambda)
static <T> LToByteFunction<T>	LToByteFunction.recursive(LFunction<LToByteFunction<T>,LToByteFunction<T>> selfLambda)
static <T> LSupplier<LToByteFunction<T>>	LToByteFunction.safeSupplier(LSupplier<LToByteFunction<T>> supplier) Safe supplier.
static <T1,T2> LToByteBiFunction<T1,T2>	LToByteBiFunction.uncurry(LFunction<T1,LToByteFunction<T2>> func)

Uses of LToByteFunction in eu.lunisolar.magma.func.operator.binary

Methods in eu.lunisolar.magma.func.operator.binary with parameters of type LToByteFunction

Modifier and Type	Method and Description
default byte	LByteBinaryOperator.applyAsByteThen(byte a1, byte a2, LToByteFunction<Throwable> handler)
default <V1,V2> LToByteBiFunction<V1,V2>	LByteBinaryOperator.byteBinaryOpCompose(LToByteFunction<? super V1> before1, LToByteFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToByteBiFunction<V1,V2>	LByteBinaryOperator.byteBinaryOpCompose(LToByteFunction<? super V1> before1, LToByteFunction<? super V2> before2) Allows to manipulate the domain of the function.
static <V1,V2> LToByteBiFunction<V1,V2>	LByteBinaryOperator.composed(LToByteFunction<? super V1> before1, LToByteFunction<? super V2> before2, LByteBinaryOperator after)
static <V1,V2> LToByteBiFunction<V1,V2>	LByteBinaryOperator.composed(LToByteFunction<? super V1> before1, LToByteFunction<? super V2> before2, LByteBinaryOperator after)
default LToByteBiFunction<T,T>	LBinaryOperator.thenToByte(LToByteFunction<? super T> after) Combines two functions together in a order.
static byte	LByteBinaryOperator.tryApplyAsByteThen(byte a1, byte a2, LByteBinaryOperator func, LToByteFunction<Throwable> handler)
default LByteBinaryOperator	LByteBinaryOperator.tryingThen(LToByteFunction<Throwable> handler)

Uses of LToByteFunction in eu.lunisolar.magma.func.operator.unary

Methods in eu.lunisolar.magma.func.operator.unary that return LToByteFunction

Modifier and Type	Method and Description
default <V> LToByteFunction<V>	LByteUnaryOperator.byteUnaryOpCompose(LToByteFunction<? super V> before) Allows to manipulate the domain of the function.
static <V> LToByteFunction<V>	LByteUnaryOperator.composed(LToByteFunction<? super V> before, LByteUnaryOperator after)
default LToByteFunction<T>	LUnaryOperator.thenToByte(LToByteFunction<? super T> after) Combines two functions together in a order.

Methods in eu.lunisolar.magma.func.operator.unary with parameters of type LToByteFunction

Modifier and Type	Method and Description
default byte	LByteUnaryOperator.applyAsByteThen(byte a, LToByteFunction<Throwable> handler)
default <V> LToByteFunction<V>	LByteUnaryOperator.byteUnaryOpCompose(LToByteFunction<? super V> before) Allows to manipulate the domain of the function.
static <V> LToByteFunction<V>	LByteUnaryOperator.composed(LToByteFunction<? super V> before, LByteUnaryOperator after)
default LToByteFunction<T>	LUnaryOperator.thenToByte(LToByteFunction<? super T> after) Combines two functions together in a order.
static byte	LByteUnaryOperator.tryApplyAsByteThen(byte a, LByteUnaryOperator func, LToByteFunction<Throwable> handler)
default LByteUnaryOperator	LByteUnaryOperator.tryingThen(LToByteFunction<Throwable> handler)

Uses of LToByteFunction in eu.lunisolar.magma.func.predicate

Methods in eu.lunisolar.magma.func.predicate that return LToByteFunction

Modifier and Type	Method and Description
default LToByteFunction<T>	LPredicate.boolToToByteFunc(LBoolToByteFunction after) Combines two functions together in a order.

Methods in eu.lunisolar.magma.func.predicate with parameters of type LToByteFunction

Modifier and Type	Method and Description
default <V1,V2> LBiPredicate<V1,V2>	LBiBytePredicate.biBytePredCompose(LToByteFunction<? super V1> before1, LToByteFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiPredicate<V1,V2>	LBiBytePredicate.biBytePredCompose(LToByteFunction<? super V1> before1, LToByteFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjBytePredicate.biObjBytePredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiPredicate<V1,V2>	LByteIntPredicate.byteIntPredCompose(LToByteFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V> LPredicate<V>	LBytePredicate.bytePredCompose(LToByteFunction<? super V> before) Allows to manipulate the domain of the function.
static <V1,V2,T> LBiPredicate<V1,V2>	LObjBytePredicate.composed(LFunction<? super V1,? extends T> before1, LToByteFunction<? super V2> before2, LObjBytePredicate<T> after)
static <V1,V2,V3,T> LTriPredicate<V1,V2,V3>	LObjIntBytePredicate.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToByteFunction<? super V3> before3, LObjIntBytePredicate<T> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjBytePredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3, LBiObjBytePredicate<T1,T2> after)
static <V> LPredicate<V>	LBytePredicate.composed(LToByteFunction<? super V> before, LBytePredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LBiBytePredicate.composed(LToByteFunction<? super V1> before1, LToByteFunction<? super V2> before2, LBiBytePredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LBiBytePredicate.composed(LToByteFunction<? super V1> before1, LToByteFunction<? super V2> before2, LBiBytePredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LByteIntPredicate.composed(LToByteFunction<? super V1> before1, LToIntFunction<? super V2> before2, LByteIntPredicate after)
default <V1,V2> LBiPredicate<V1,V2>	LObjBytePredicate.objBytePredCompose(LFunction<? super V1,? extends T> before1, LToByteFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LObjIntBytePredicate.objIntBytePredCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToByteFunction<? super V3> before3) Allows to manipulate the domain of the function.
default LPredicate<T>	LObjBytePredicate.rShrink(LToByteFunction<T> right)
static <T> LPredicate<T>	LObjBytePredicate.rShrinked(LToByteFunction<T> right, LObjBytePredicate<T> func)

Uses of LToByteFunction in eu.lunisolar.magma.func.supplier

Methods in eu.lunisolar.magma.func.supplier with parameters of type LToByteFunction

Modifier and Type	Method and Description
default byte	LByteSupplier.getAsByteThen(LToByteFunction<Throwable> handler)
default LByteSupplier	LSupplier.toByteSup(LToByteFunction<? super T> after) Combines two functions together in a order.
static byte	LByteSupplier.tryGetAsByteThen(LByteSupplier func, LToByteFunction<Throwable> handler)
default LByteSupplier	LByteSupplier.tryingThen(LToByteFunction<Throwable> handler)

Uses of LToByteFunction in eu.lunisolar.magma.func.tuple

Methods in eu.lunisolar.magma.func.tuple with parameters of type LToByteFunction

Modifier and Type	Method and Description
<R> LBytePair.MutBytePair	LBytePair.MutBytePair.setFirstIfArgNotNull(R arg, LToByteFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBytePair.MutCompBytePair	LBytePair.MutCompBytePair.setFirstIfArgNotNull(R arg, LToByteFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LByteIntPair.MutByteIntPair	LByteIntPair.MutByteIntPair.setFirstIfArgNotNull(R arg, LToByteFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LByteIntPair.MutCompByteIntPair	LByteIntPair.MutCompByteIntPair.setFirstIfArgNotNull(R arg, LToByteFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjBytePair.MutObjBytePair<T>	LObjBytePair.MutObjBytePair.setSecondIfArgNotNull(R arg, LToByteFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjBytePair.MutCompObjBytePair<T>	LObjBytePair.MutCompObjBytePair.setSecondIfArgNotNull(R arg, LToByteFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBytePair.MutBytePair	LBytePair.MutBytePair.setSecondIfArgNotNull(R arg, LToByteFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBytePair.MutCompBytePair	LBytePair.MutCompBytePair.setSecondIfArgNotNull(R arg, LToByteFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntByteTriple.MutObjIntByteTriple<T>	LObjIntByteTriple.MutObjIntByteTriple.setThirdIfArgNotNull(R arg, LToByteFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntByteTriple.MutCompObjIntByteTriple<T>	LObjIntByteTriple.MutCompObjIntByteTriple.setThirdIfArgNotNull(R arg, LToByteFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjByteTriple.MutBiObjByteTriple<T1,T2>	LBiObjByteTriple.MutBiObjByteTriple.setThirdIfArgNotNull(R arg, LToByteFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjByteTriple.MutCompBiObjByteTriple<T1,T2>	LBiObjByteTriple.MutCompBiObjByteTriple.setThirdIfArgNotNull(R arg, LToByteFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LByteSingle.MutByteSingle	LByteSingle.MutByteSingle.setValueIfArgNotNull(R arg, LToByteFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LByteSingle.MutCompByteSingle	LByteSingle.MutCompByteSingle.setValueIfArgNotNull(R arg, LToByteFunction<R> func) Sets value derived from non-null argument, only if argument is not null.