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

Packages that use LToSrtFunction

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 LToSrtFunction in eu.lunisolar.magma.func.consumer.primitives

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

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

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

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

Modifier and Type	Method and Description
default <V1,V2> LBiConsumer<V1,V2>	LBiSrtConsumer.biSrtConsCompose(LToSrtFunction<? super V1> before1, LToSrtFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LBiSrtConsumer.biSrtConsCompose(LToSrtFunction<? super V1> before1, LToSrtFunction<? super V2> before2) Allows to manipulate the domain of the function.
static <V1,V2> LBiConsumer<V1,V2>	LSrtIntConsumer.composed(LToSrtFunction<? super V1> before1, LToIntFunction<? super V2> before2, LSrtIntConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LBiSrtConsumer.composed(LToSrtFunction<? super V1> before1, LToSrtFunction<? super V2> before2, LBiSrtConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LBiSrtConsumer.composed(LToSrtFunction<? super V1> before1, LToSrtFunction<? super V2> before2, LBiSrtConsumer after)
default <V1,V2> LBiConsumer<V1,V2>	LSrtIntConsumer.srtIntConsCompose(LToSrtFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.

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

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

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

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

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

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

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

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

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

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

Modifier and Type	Method and Description
default <V> LToSrtFunction<V>	LBoolToSrtFunction.boolToSrtFuncCompose(LPredicate<? 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.
default <V> LToSrtFunction<V>	LCharToSrtFunction.charToSrtFuncCompose(LToCharFunction<? super V> before) Allows to manipulate the domain of the function.
static <V> LToSrtFunction<V>	LBoolToSrtFunction.composed(LPredicate<? super V> before, LBoolToSrtFunction after)
static <V> LToSrtFunction<V>	LByteToSrtFunction.composed(LToByteFunction<? super V> before, LByteToSrtFunction after)
static <V> LToSrtFunction<V>	LCharToSrtFunction.composed(LToCharFunction<? super V> before, LCharToSrtFunction after)
static <V> LToSrtFunction<V>	LDblToSrtFunction.composed(LToDblFunction<? super V> before, LDblToSrtFunction after)
static <V> LToSrtFunction<V>	LFltToSrtFunction.composed(LToFltFunction<? super V> before, LFltToSrtFunction after)
static <V> LToSrtFunction<V>	LIntToSrtFunction.composed(LToIntFunction<? super V> before, LIntToSrtFunction after)
static <V> LToSrtFunction<V>	LLongToSrtFunction.composed(LToLongFunction<? super V> before, LLongToSrtFunction after)
default <V> LToSrtFunction<V>	LDblToSrtFunction.dblToSrtFuncCompose(LToDblFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToSrtFunction<V>	LFltToSrtFunction.fltToSrtFuncCompose(LToFltFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToSrtFunction<V>	LIntToSrtFunction.intToSrtFuncCompose(LToIntFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToSrtFunction<V>	LLongToSrtFunction.longToSrtFuncCompose(LToLongFunction<? super V> before) Allows to manipulate the domain of the function.

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

Modifier and Type	Method and Description
default short	LBoolToSrtFunction.applyAsSrtThen(boolean a, LToSrtFunction<Throwable> handler)
default short	LByteToSrtFunction.applyAsSrtThen(byte a, LToSrtFunction<Throwable> handler)
default short	LCharToSrtFunction.applyAsSrtThen(char a, LToSrtFunction<Throwable> handler)
default short	LDblToSrtFunction.applyAsSrtThen(double a, LToSrtFunction<Throwable> handler)
default short	LFltToSrtFunction.applyAsSrtThen(float a, LToSrtFunction<Throwable> handler)
default short	LIntToSrtFunction.applyAsSrtThen(int a, LToSrtFunction<Throwable> handler)
default short	LLongToSrtFunction.applyAsSrtThen(long a, LToSrtFunction<Throwable> handler)
static <V> LToByteFunction<V>	LSrtToByteFunction.composed(LToSrtFunction<? super V> before, LSrtToByteFunction after)
static <V> LToCharFunction<V>	LSrtToCharFunction.composed(LToSrtFunction<? super V> before, LSrtToCharFunction after)
static <V> LToDblFunction<V>	LSrtToDblFunction.composed(LToSrtFunction<? super V> before, LSrtToDblFunction after)
static <V> LToFltFunction<V>	LSrtToFltFunction.composed(LToSrtFunction<? super V> before, LSrtToFltFunction after)
static <V> LToIntFunction<V>	LSrtToIntFunction.composed(LToSrtFunction<? super V> before, LSrtToIntFunction after)
static <V> LToLongFunction<V>	LSrtToLongFunction.composed(LToSrtFunction<? super V> before, LSrtToLongFunction after)
default <V> LToByteFunction<V>	LSrtToByteFunction.srtToByteFuncCompose(LToSrtFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToCharFunction<V>	LSrtToCharFunction.srtToCharFuncCompose(LToSrtFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToDblFunction<V>	LSrtToDblFunction.srtToDblFuncCompose(LToSrtFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToFltFunction<V>	LSrtToFltFunction.srtToFltFuncCompose(LToSrtFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToIntFunction<V>	LSrtToIntFunction.srtToIntFuncCompose(LToSrtFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToLongFunction<V>	LSrtToLongFunction.srtToLongFuncCompose(LToSrtFunction<? super V> before) Allows to manipulate the domain of the function.
static short	LBoolToSrtFunction.tryApplyAsSrtThen(boolean a, LBoolToSrtFunction func, LToSrtFunction<Throwable> handler)
static short	LByteToSrtFunction.tryApplyAsSrtThen(byte a, LByteToSrtFunction func, LToSrtFunction<Throwable> handler)
static short	LCharToSrtFunction.tryApplyAsSrtThen(char a, LCharToSrtFunction func, LToSrtFunction<Throwable> handler)
static short	LDblToSrtFunction.tryApplyAsSrtThen(double a, LDblToSrtFunction func, LToSrtFunction<Throwable> handler)
static short	LFltToSrtFunction.tryApplyAsSrtThen(float a, LFltToSrtFunction func, LToSrtFunction<Throwable> handler)
static short	LIntToSrtFunction.tryApplyAsSrtThen(int a, LIntToSrtFunction func, LToSrtFunction<Throwable> handler)
static short	LLongToSrtFunction.tryApplyAsSrtThen(long a, LLongToSrtFunction func, LToSrtFunction<Throwable> handler)
default LLongToSrtFunction	LLongToSrtFunction.tryingThen(LToSrtFunction<Throwable> handler)
default LIntToSrtFunction	LIntToSrtFunction.tryingThen(LToSrtFunction<Throwable> handler)
default LFltToSrtFunction	LFltToSrtFunction.tryingThen(LToSrtFunction<Throwable> handler)
default LDblToSrtFunction	LDblToSrtFunction.tryingThen(LToSrtFunction<Throwable> handler)
default LCharToSrtFunction	LCharToSrtFunction.tryingThen(LToSrtFunction<Throwable> handler)
default LByteToSrtFunction	LByteToSrtFunction.tryingThen(LToSrtFunction<Throwable> handler)
default LBoolToSrtFunction	LBoolToSrtFunction.tryingThen(LToSrtFunction<Throwable> handler)

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

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

Modifier and Type	Method and Description
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjSrtFunction.biObjSrtFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LBiSrtFunction.biSrtFuncCompose(LToSrtFunction<? super V1> before1, LToSrtFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LBiSrtFunction.biSrtFuncCompose(LToSrtFunction<? super V1> before1, LToSrtFunction<? super V2> before2) Allows to manipulate the domain of the function.
static <V1,V2,V3,T,R> LTriFunction<V1,V2,V3,R>	LObjIntSrtFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToSrtFunction<? super V3> before3, LObjIntSrtFunction<T,R> after)
static <V1,V2,T,R> LBiFunction<V1,V2,R>	LObjSrtFunction.composed(LFunction<? super V1,? extends T> before1, LToSrtFunction<? super V2> before2, LObjSrtFunction<T,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjSrtFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3, LBiObjSrtFunction<T1,T2,R> after)
static <V,R> LFunction<V,R>	LSrtFunction.composed(LToSrtFunction<? super V> before, LSrtFunction<R> after)
static <V1,V2,R> LBiFunction<V1,V2,R>	LBiSrtFunction.composed(LToSrtFunction<? super V1> before1, LToSrtFunction<? super V2> before2, LBiSrtFunction<R> after)
static <V1,V2,R> LBiFunction<V1,V2,R>	LBiSrtFunction.composed(LToSrtFunction<? super V1> before1, LToSrtFunction<? super V2> before2, LBiSrtFunction<R> after)
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LObjIntSrtFunction.objIntSrtFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToSrtFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LObjSrtFunction.objSrtFuncCompose(LFunction<? super V1,? extends T> before1, LToSrtFunction<? super V2> before2) Allows to manipulate the domain of the function.
default LFunction<T,R>	LObjSrtFunction.rShrink(LToSrtFunction<T> right)
static <T,R> LFunction<T,R>	LObjSrtFunction.rShrinked(LToSrtFunction<T> right, LObjSrtFunction<T,R> func)
default <V> LFunction<V,R>	LSrtFunction.srtFuncCompose(LToSrtFunction<? super V> before) Allows to manipulate the domain of the function.
default LSrtUnaryOperator	LSrtFunction.thenToSrt(LToSrtFunction<? super R> after) Combines two functions together in a order.
default LOiToSrtFunction<T>	LOiFunction.thenToSrt(LToSrtFunction<? super R> after) Combines two functions together in a order.
default LLongToSrtFunction	LLongFunction.thenToSrt(LToSrtFunction<? super R> after) Combines two functions together in a order.
default LIntToSrtFunction	LIntFunction.thenToSrt(LToSrtFunction<? super R> after) Combines two functions together in a order.
default LFltToSrtFunction	LFltFunction.thenToSrt(LToSrtFunction<? super R> after) Combines two functions together in a order.
default LDblToSrtFunction	LDblFunction.thenToSrt(LToSrtFunction<? super R> after) Combines two functions together in a order.
default LCharToSrtFunction	LCharFunction.thenToSrt(LToSrtFunction<? super R> after) Combines two functions together in a order.
default LByteToSrtFunction	LByteFunction.thenToSrt(LToSrtFunction<? super R> after) Combines two functions together in a order.
default LBoolToSrtFunction	LBoolFunction.thenToSrt(LToSrtFunction<? super R> after) Combines two functions together in a order.
default LSrtBinaryOperator	LBiSrtFunction.thenToSrt(LToSrtFunction<? super R> after) Combines two functions together in a order.

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

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

Modifier and Type	Class and Description
static class	LToSrtFunction.LToSrtFunctionSingle<T>

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

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

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

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

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

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

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

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

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

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

Modifier and Type	Method and Description
default short	LSrtBinaryOperator.applyAsSrtThen(short a1, short a2, LToSrtFunction<Throwable> handler)
static <V1,V2> LToSrtBiFunction<V1,V2>	LSrtBinaryOperator.composed(LToSrtFunction<? super V1> before1, LToSrtFunction<? super V2> before2, LSrtBinaryOperator after)
static <V1,V2> LToSrtBiFunction<V1,V2>	LSrtBinaryOperator.composed(LToSrtFunction<? super V1> before1, LToSrtFunction<? super V2> before2, LSrtBinaryOperator after)
default <V1,V2> LToSrtBiFunction<V1,V2>	LSrtBinaryOperator.srtBinaryOpCompose(LToSrtFunction<? super V1> before1, LToSrtFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToSrtBiFunction<V1,V2>	LSrtBinaryOperator.srtBinaryOpCompose(LToSrtFunction<? super V1> before1, LToSrtFunction<? super V2> before2) Allows to manipulate the domain of the function.
default LToSrtBiFunction<T,T>	LBinaryOperator.thenToSrt(LToSrtFunction<? super T> after) Combines two functions together in a order.
static short	LSrtBinaryOperator.tryApplyAsSrtThen(short a1, short a2, LSrtBinaryOperator func, LToSrtFunction<Throwable> handler)
default LSrtBinaryOperator	LSrtBinaryOperator.tryingThen(LToSrtFunction<Throwable> handler)

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

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

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

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

Modifier and Type	Method and Description
default short	LSrtUnaryOperator.applyAsSrtThen(short a, LToSrtFunction<Throwable> handler)
static <V> LToSrtFunction<V>	LSrtUnaryOperator.composed(LToSrtFunction<? super V> before, LSrtUnaryOperator after)
default <V> LToSrtFunction<V>	LSrtUnaryOperator.srtUnaryOpCompose(LToSrtFunction<? super V> before) Allows to manipulate the domain of the function.
default LToSrtFunction<T>	LUnaryOperator.thenToSrt(LToSrtFunction<? super T> after) Combines two functions together in a order.
static short	LSrtUnaryOperator.tryApplyAsSrtThen(short a, LSrtUnaryOperator func, LToSrtFunction<Throwable> handler)
default LSrtUnaryOperator	LSrtUnaryOperator.tryingThen(LToSrtFunction<Throwable> handler)

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

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

Modifier and Type	Method and Description
default LToSrtFunction<T>	LPredicate.boolToToSrtFunc(LBoolToSrtFunction after) Combines two functions together in a order.

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

Modifier and Type	Method and Description
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjSrtPredicate.biObjSrtPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiPredicate<V1,V2>	LBiSrtPredicate.biSrtPredCompose(LToSrtFunction<? super V1> before1, LToSrtFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiPredicate<V1,V2>	LBiSrtPredicate.biSrtPredCompose(LToSrtFunction<? super V1> before1, LToSrtFunction<? super V2> before2) Allows to manipulate the domain of the function.
static <V1,V2,V3,T> LTriPredicate<V1,V2,V3>	LObjIntSrtPredicate.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToSrtFunction<? super V3> before3, LObjIntSrtPredicate<T> after)
static <V1,V2,T> LBiPredicate<V1,V2>	LObjSrtPredicate.composed(LFunction<? super V1,? extends T> before1, LToSrtFunction<? super V2> before2, LObjSrtPredicate<T> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjSrtPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3, LBiObjSrtPredicate<T1,T2> after)
static <V> LPredicate<V>	LSrtPredicate.composed(LToSrtFunction<? super V> before, LSrtPredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LSrtIntPredicate.composed(LToSrtFunction<? super V1> before1, LToIntFunction<? super V2> before2, LSrtIntPredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LBiSrtPredicate.composed(LToSrtFunction<? super V1> before1, LToSrtFunction<? super V2> before2, LBiSrtPredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LBiSrtPredicate.composed(LToSrtFunction<? super V1> before1, LToSrtFunction<? super V2> before2, LBiSrtPredicate after)
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LObjIntSrtPredicate.objIntSrtPredCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToSrtFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiPredicate<V1,V2>	LObjSrtPredicate.objSrtPredCompose(LFunction<? super V1,? extends T> before1, LToSrtFunction<? super V2> before2) Allows to manipulate the domain of the function.
default LPredicate<T>	LObjSrtPredicate.rShrink(LToSrtFunction<T> right)
static <T> LPredicate<T>	LObjSrtPredicate.rShrinked(LToSrtFunction<T> right, LObjSrtPredicate<T> func)
default <V1,V2> LBiPredicate<V1,V2>	LSrtIntPredicate.srtIntPredCompose(LToSrtFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V> LPredicate<V>	LSrtPredicate.srtPredCompose(LToSrtFunction<? super V> before) Allows to manipulate the domain of the function.

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

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

Modifier and Type	Method and Description
default short	LSrtSupplier.getAsSrtThen(LToSrtFunction<Throwable> handler)
default LSrtSupplier	LSupplier.toSrtSup(LToSrtFunction<? super T> after) Combines two functions together in a order.
static short	LSrtSupplier.tryGetAsSrtThen(LSrtSupplier func, LToSrtFunction<Throwable> handler)
default LSrtSupplier	LSrtSupplier.tryingThen(LToSrtFunction<Throwable> handler)

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

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

Modifier and Type	Method and Description
<R> LSrtPair.MutSrtPair	LSrtPair.MutSrtPair.setFirstIfArgNotNull(R arg, LToSrtFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LSrtPair.MutCompSrtPair	LSrtPair.MutCompSrtPair.setFirstIfArgNotNull(R arg, LToSrtFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LSrtIntPair.MutSrtIntPair	LSrtIntPair.MutSrtIntPair.setFirstIfArgNotNull(R arg, LToSrtFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LSrtIntPair.MutCompSrtIntPair	LSrtIntPair.MutCompSrtIntPair.setFirstIfArgNotNull(R arg, LToSrtFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LSrtPair.MutSrtPair	LSrtPair.MutSrtPair.setSecondIfArgNotNull(R arg, LToSrtFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LSrtPair.MutCompSrtPair	LSrtPair.MutCompSrtPair.setSecondIfArgNotNull(R arg, LToSrtFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjSrtPair.MutObjSrtPair<T>	LObjSrtPair.MutObjSrtPair.setSecondIfArgNotNull(R arg, LToSrtFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjSrtPair.MutCompObjSrtPair<T>	LObjSrtPair.MutCompObjSrtPair.setSecondIfArgNotNull(R arg, LToSrtFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntSrtTriple.MutObjIntSrtTriple<T>	LObjIntSrtTriple.MutObjIntSrtTriple.setThirdIfArgNotNull(R arg, LToSrtFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntSrtTriple.MutCompObjIntSrtTriple<T>	LObjIntSrtTriple.MutCompObjIntSrtTriple.setThirdIfArgNotNull(R arg, LToSrtFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjSrtTriple.MutBiObjSrtTriple<T1,T2>	LBiObjSrtTriple.MutBiObjSrtTriple.setThirdIfArgNotNull(R arg, LToSrtFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjSrtTriple.MutCompBiObjSrtTriple<T1,T2>	LBiObjSrtTriple.MutCompBiObjSrtTriple.setThirdIfArgNotNull(R arg, LToSrtFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LSrtSingle.MutSrtSingle	LSrtSingle.MutSrtSingle.setValueIfArgNotNull(R arg, LToSrtFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LSrtSingle.MutCompSrtSingle	LSrtSingle.MutCompSrtSingle.setValueIfArgNotNull(R arg, LToSrtFunction<R> func) Sets value derived from non-null argument, only if argument is not null.