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

Packages that use LToLongFunction

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

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

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

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

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

Modifier and Type	Method and Description
default <V1,V2> LBiConsumer<V1,V2>	LBiLongConsumer.biLongConsCompose(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LBiLongConsumer.biLongConsCompose(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2) Allows to manipulate the domain of the function.
static <V1,V2> LBiConsumer<V1,V2>	LLongIntConsumer.composed(LToLongFunction<? super V1> before1, LToIntFunction<? super V2> before2, LLongIntConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LBiLongConsumer.composed(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2, LBiLongConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LBiLongConsumer.composed(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2, LBiLongConsumer after)
default <V1,V2> LBiConsumer<V1,V2>	LLongIntConsumer.longIntConsCompose(LToLongFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.

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

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

Modifier and Type	Method and Description
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjLongConsumer.biObjLongConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3) Allows to manipulate the domain of the function.
static <V1,V2,V3,T> LTriConsumer<V1,V2,V3>	LTieLongConsumer.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToLongFunction<? super V3> before3, LTieLongConsumer<T> after)
static <V1,V2,T> LBiConsumer<V1,V2>	LObjLongConsumer.composed(LFunction<? super V1,? extends T> before1, LToLongFunction<? super V2> before2, LObjLongConsumer<T> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjLongConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3, LBiObjLongConsumer<T1,T2> after)
default <V1,V2> LBiConsumer<V1,V2>	LObjLongConsumer.objLongConsCompose(LFunction<? super V1,? extends T> before1, LToLongFunction<? super V2> before2) Allows to manipulate the domain of the function.
default LConsumer<T>	LObjLongConsumer.rShrink(LToLongFunction<T> right)
static <T> LConsumer<T>	LObjLongConsumer.rShrinked(LToLongFunction<T> right, LObjLongConsumer<T> func)
static <T,SRC> int	LTieLongConsumer.tieForEach(int sStart, int tStart, T trg1, SRC src3, LPredicate<SRC> srcTest3, LToLongFunction<SRC> srcAcc3, LTieLongConsumer<? 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>	LTieLongConsumer.tieLongConsCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToLongFunction<? super V3> before3) Allows to manipulate the domain of the function.

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

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

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

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

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

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

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

Modifier and Type	Method and Description
default <V> LToLongFunction<V>	LBoolToLongFunction.boolToLongFuncCompose(LPredicate<? 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> LToLongFunction<V>	LCharToLongFunction.charToLongFuncCompose(LToCharFunction<? super V> before) Allows to manipulate the domain of the function.
static <V> LToLongFunction<V>	LBoolToLongFunction.composed(LPredicate<? super V> before, LBoolToLongFunction after)
static <V> LToLongFunction<V>	LByteToLongFunction.composed(LToByteFunction<? super V> before, LByteToLongFunction after)
static <V> LToLongFunction<V>	LCharToLongFunction.composed(LToCharFunction<? super V> before, LCharToLongFunction after)
static <V> LToLongFunction<V>	LDblToLongFunction.composed(LToDblFunction<? super V> before, LDblToLongFunction after)
static <V> LToLongFunction<V>	LFltToLongFunction.composed(LToFltFunction<? super V> before, LFltToLongFunction after)
static <V> LToLongFunction<V>	LIntToLongFunction.composed(LToIntFunction<? super V> before, LIntToLongFunction after)
static <V> LToLongFunction<V>	LSrtToLongFunction.composed(LToSrtFunction<? super V> before, LSrtToLongFunction after)
default <V> LToLongFunction<V>	LDblToLongFunction.dblToLongFuncCompose(LToDblFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToLongFunction<V>	LFltToLongFunction.fltToLongFuncCompose(LToFltFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToLongFunction<V>	LIntToLongFunction.intToLongFuncCompose(LToIntFunction<? 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.

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

Modifier and Type	Method and Description
default long	LBoolToLongFunction.applyAsLongThen(boolean a, LToLongFunction<Throwable> handler)
default long	LByteToLongFunction.applyAsLongThen(byte a, LToLongFunction<Throwable> handler)
default long	LCharToLongFunction.applyAsLongThen(char a, LToLongFunction<Throwable> handler)
default long	LDblToLongFunction.applyAsLongThen(double a, LToLongFunction<Throwable> handler)
default long	LFltToLongFunction.applyAsLongThen(float a, LToLongFunction<Throwable> handler)
default long	LIntToLongFunction.applyAsLongThen(int a, LToLongFunction<Throwable> handler)
default long	LSrtToLongFunction.applyAsLongThen(short a, LToLongFunction<Throwable> handler)
static <V> LToByteFunction<V>	LLongToByteFunction.composed(LToLongFunction<? super V> before, LLongToByteFunction after)
static <V> LToCharFunction<V>	LLongToCharFunction.composed(LToLongFunction<? super V> before, LLongToCharFunction after)
static <V> LToDblFunction<V>	LLongToDblFunction.composed(LToLongFunction<? super V> before, LLongToDblFunction after)
static <V> LToFltFunction<V>	LLongToFltFunction.composed(LToLongFunction<? super V> before, LLongToFltFunction after)
static <V> LToIntFunction<V>	LLongToIntFunction.composed(LToLongFunction<? super V> before, LLongToIntFunction after)
static <V> LToSrtFunction<V>	LLongToSrtFunction.composed(LToLongFunction<? super V> before, LLongToSrtFunction after)
default <V> LToByteFunction<V>	LLongToByteFunction.longToByteFuncCompose(LToLongFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToCharFunction<V>	LLongToCharFunction.longToCharFuncCompose(LToLongFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToDblFunction<V>	LLongToDblFunction.longToDblFuncCompose(LToLongFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToFltFunction<V>	LLongToFltFunction.longToFltFuncCompose(LToLongFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToIntFunction<V>	LLongToIntFunction.longToIntFuncCompose(LToLongFunction<? 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.
static long	LBoolToLongFunction.tryApplyAsLongThen(boolean a, LBoolToLongFunction func, LToLongFunction<Throwable> handler)
static long	LByteToLongFunction.tryApplyAsLongThen(byte a, LByteToLongFunction func, LToLongFunction<Throwable> handler)
static long	LCharToLongFunction.tryApplyAsLongThen(char a, LCharToLongFunction func, LToLongFunction<Throwable> handler)
static long	LDblToLongFunction.tryApplyAsLongThen(double a, LDblToLongFunction func, LToLongFunction<Throwable> handler)
static long	LFltToLongFunction.tryApplyAsLongThen(float a, LFltToLongFunction func, LToLongFunction<Throwable> handler)
static long	LIntToLongFunction.tryApplyAsLongThen(int a, LIntToLongFunction func, LToLongFunction<Throwable> handler)
static long	LSrtToLongFunction.tryApplyAsLongThen(short a, LSrtToLongFunction func, LToLongFunction<Throwable> handler)
default LSrtToLongFunction	LSrtToLongFunction.tryingThen(LToLongFunction<Throwable> handler)
default LIntToLongFunction	LIntToLongFunction.tryingThen(LToLongFunction<Throwable> handler)
default LFltToLongFunction	LFltToLongFunction.tryingThen(LToLongFunction<Throwable> handler)
default LDblToLongFunction	LDblToLongFunction.tryingThen(LToLongFunction<Throwable> handler)
default LCharToLongFunction	LCharToLongFunction.tryingThen(LToLongFunction<Throwable> handler)
default LByteToLongFunction	LByteToLongFunction.tryingThen(LToLongFunction<Throwable> handler)
default LBoolToLongFunction	LBoolToLongFunction.tryingThen(LToLongFunction<Throwable> handler)

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

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

Modifier and Type	Method and Description
default <V1,V2> LBiFunction<V1,V2,R>	LBiLongFunction.biLongFuncCompose(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LBiLongFunction.biLongFuncCompose(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjLongFunction.biObjLongFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3) Allows to manipulate the domain of the function.
static <V1,V2,V3,T,R> LTriFunction<V1,V2,V3,R>	LObjIntLongFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToLongFunction<? super V3> before3, LObjIntLongFunction<T,R> after)
static <V1,V2,T,R> LBiFunction<V1,V2,R>	LObjLongFunction.composed(LFunction<? super V1,? extends T> before1, LToLongFunction<? super V2> before2, LObjLongFunction<T,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjLongFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3, LBiObjLongFunction<T1,T2,R> after)
static <V,R> LFunction<V,R>	LLongFunction.composed(LToLongFunction<? super V> before, LLongFunction<R> after)
static <V1,V2,R> LBiFunction<V1,V2,R>	LBiLongFunction.composed(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2, LBiLongFunction<R> after)
static <V1,V2,R> LBiFunction<V1,V2,R>	LBiLongFunction.composed(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2, LBiLongFunction<R> after)
default <V> LFunction<V,R>	LLongFunction.longFuncCompose(LToLongFunction<? super V> before) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LObjIntLongFunction.objIntLongFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToLongFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LObjLongFunction.objLongFuncCompose(LFunction<? super V1,? extends T> before1, LToLongFunction<? super V2> before2) Allows to manipulate the domain of the function.
default LFunction<T,R>	LObjLongFunction.rShrink(LToLongFunction<T> right)
static <T,R> LFunction<T,R>	LObjLongFunction.rShrinked(LToLongFunction<T> right, LObjLongFunction<T,R> func)
default LSrtToLongFunction	LSrtFunction.thenToLong(LToLongFunction<? super R> after) Combines two functions together in a order.
default LOiToLongFunction<T>	LOiFunction.thenToLong(LToLongFunction<? super R> after) Combines two functions together in a order.
default LLongUnaryOperator	LLongFunction.thenToLong(LToLongFunction<? super R> after) Combines two functions together in a order.
default LIntToLongFunction	LIntFunction.thenToLong(LToLongFunction<? super R> after) Combines two functions together in a order.
default LFltToLongFunction	LFltFunction.thenToLong(LToLongFunction<? super R> after) Combines two functions together in a order.
default LDblToLongFunction	LDblFunction.thenToLong(LToLongFunction<? super R> after) Combines two functions together in a order.
default LCharToLongFunction	LCharFunction.thenToLong(LToLongFunction<? super R> after) Combines two functions together in a order.
default LByteToLongFunction	LByteFunction.thenToLong(LToLongFunction<? super R> after) Combines two functions together in a order.
default LBoolToLongFunction	LBoolFunction.thenToLong(LToLongFunction<? super R> after) Combines two functions together in a order.
default LLongBinaryOperator	LBiLongFunction.thenToLong(LToLongFunction<? super R> after) Combines two functions together in a order.

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

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

Modifier and Type	Class and Description
static class	LToLongFunction.LToLongFunctionSingle<T>

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

Modifier and Type	Method and Description
default <V2> LToLongFunction<V2>	LToLongFunction.cast() Cast that replace generics.
static <V2,T> LToLongFunction<V2>	LToLongFunction.cast(LToLongFunction<T> function) Cast that replace generics.
default <V> LToLongFunction<V>	LToLongFunction.compose(LFunction<? super V,? extends T> before) Allows to manipulate the domain of the function.
static <V,T> LToLongFunction<V>	LToLongFunction.composed(LFunction<? super V,? extends T> before, LToLongFunction<T> after)
static <T> LToLongFunction<T>	LToLongFunction.constant(long r) Creates function that always returns the same value.
static <T> LToLongFunction<T>	LToLongFunction.failSafe(LToLongFunction<T> func, LToLongFunction<T> failSafe)
default LToLongFunction<T>	LToLongFunction.handling(HandlingInstructions<Throwable,RuntimeException> handling)
default LToLongFunction<T2>	LToLongBiFunction.lShrink(LFunction<T2,T1> left)
default LToLongFunction<T2>	LToLongBiFunction.lShrinkc(T1 a1)
static <T2,T1> LToLongFunction<T2>	LToLongBiFunction.lShrinked(LFunction<T2,T1> left, LToLongBiFunction<T1,T2> func)
static <T2,T1> LToLongFunction<T2>	LToLongBiFunction.lShrinkedc(T1 a1, LToLongBiFunction<T1,T2> func)
static <T> LToLongFunction<T>	LToLongFunction.recursive(LFunction<LToLongFunction<T>,LToLongFunction<T>> selfLambda)
default LToLongFunction<T1>	LToLongBiFunction.rShrink(LFunction<T1,T2> right)
default LToLongFunction<T>	LOiToLongFunction.rShrink(LToIntFunction<T> right)
default LToLongFunction<T>	LOiToLongFunction.rShrinkc(int a2)
default LToLongFunction<T1>	LToLongBiFunction.rShrinkc(T2 a2)
static <T1,T2> LToLongFunction<T1>	LToLongBiFunction.rShrinked(LFunction<T1,T2> right, LToLongBiFunction<T1,T2> func)
static <T> LToLongFunction<T>	LOiToLongFunction.rShrinked(LToIntFunction<T> right, LOiToLongFunction<T> func)
static <T> LToLongFunction<T>	LOiToLongFunction.rShrinkedc(int a2, LOiToLongFunction<T> func)
static <T1,T2> LToLongFunction<T1>	LToLongBiFunction.rShrinkedc(T2 a2, LToLongBiFunction<T1,T2> func)
static <T> LToLongFunction<T>	LToLongFunction.safe() Safe instance.
static <T> LToLongFunction<T>	LToLongFunction.safe(LToLongFunction<T> other) Safe wrapping.
default LToLongFunction<T>	LToByteFunction.thenToLong(LByteToLongFunction after) Combines two functions together in a order.
default LToLongFunction<T>	LToCharFunction.thenToLong(LCharToLongFunction after) Combines two functions together in a order.
default LToLongFunction<T>	LToDblFunction.thenToLong(LDblToLongFunction after) Combines two functions together in a order.
default LToLongFunction<T>	LToFltFunction.thenToLong(LFltToLongFunction after) Combines two functions together in a order.
default LToLongFunction<T>	LToIntFunction.thenToLong(LIntToLongFunction after) Combines two functions together in a order.
default LToLongFunction<T>	LToLongFunction.thenToLong(LLongUnaryOperator after) Combines two functions together in a order.
default LToLongFunction<T>	LToSrtFunction.thenToLong(LSrtToLongFunction after) Combines two functions together in a order.
static <T> LToLongFunction<T>	LToLongFunction.toLongFunc(LToLongFunction<T> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T> LToLongFunction<T>	LToLongFunction.toLongFuncThrowing(ExF<Throwable> exF)
static <T> LToLongFunction<T>	LToLongFunction.toLongFuncThrowing(String message, ExMF<Throwable> exF)
default LToLongFunction<T>	LToLongFunction.trying(ExWF<RuntimeException> exF)
default LToLongFunction<T>	LToLongFunction.trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LToLongFunction<T>	LToLongFunction.tryingThen(LToLongFunction<Throwable> handler)
default LToLongFunction	LToLongFunction.untyped() Cast that removes generics.
LToLongFunction<T>	LToLongFunction.LToLongFunctionSingle.value()
static <T> LToLongFunction<T>	LToLongFunction.wrap(java.util.function.ToLongFunction<T> other) Wraps JRE instance.

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

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

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

Modifier and Type	Method and Description
static <T> LOiToLongFunction<T>	LOiToLongFunction.apply1stAsLong(LToLongFunction<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LToLongBiFunction<T1,T2>	LToLongBiFunction.apply1stAsLong(LToLongFunction<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LToLongBiFunction<T1,T2>	LToLongBiFunction.apply2ndAsLong(LToLongFunction<T2> func) Captures single parameter function into this interface where only 2nd parameter will be used.
default long	LToLongBiFunction.applyAsLongThen(T1 a1, T2 a2, LToLongFunction<Throwable> handler)
default long	LOiToLongFunction.applyAsLongThen(T a1, int a2, LToLongFunction<Throwable> handler)
default long	LToLongFunction.applyAsLongThen(T a, LToLongFunction<Throwable> handler)
static <T> long	LToLongFunction.call(T a, LToLongFunction<T> lambda)
static <V2,T> LToLongFunction<V2>	LToLongFunction.cast(LToLongFunction<T> function) Cast that replace generics.
static <V,T> LToLongFunction<V>	LToLongFunction.composed(LFunction<? super V,? extends T> before, LToLongFunction<T> after)
static <V1,V2,V3,T> LToIntTriFunction<V1,V2,V3>	LTieLongFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToLongFunction<? super V3> before3, LTieLongFunction<T> after)
static <T> LToLongFunction<T>	LToLongFunction.failSafe(LToLongFunction<T> func, LToLongFunction<T> failSafe)
static <T> LToLongFunction<T>	LToLongFunction.failSafe(LToLongFunction<T> func, LToLongFunction<T> failSafe)
default long	LToLongFunction.failSafeApplyAsLong(T a, LToLongFunction<T> failSafe)
static <T> long	LToLongFunction.failSafeApplyAsLong(T a, LToLongFunction<T> func, LToLongFunction<T> failSafe)
static <T> long	LToLongFunction.failSafeApplyAsLong(T a, LToLongFunction<T> func, LToLongFunction<T> failSafe)
static <T> void	LToLongFunction.fromTill(int min_i, int max_i, T a, LToLongFunction<T> func) From-To.
static <T> void	LToLongFunction.fromTo(int min_i, int max_i, T a, LToLongFunction<T> func) From-To.
static <T> long	LToLongFunction.handlingApplyAsLong(T a, LToLongFunction<T> func, HandlingInstructions<Throwable,RuntimeException> handling)
static <T> LToLongFunction<T>	LToLongFunction.safe(LToLongFunction<T> other) Safe wrapping.
static <T,SRC> int	LTieLongFunction.tieForEach(int sStart, int tStart, T trg1, SRC src3, LPredicate<SRC> srcTest3, LToLongFunction<SRC> srcAcc3, LTieLongFunction<? 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>	LTieLongFunction.tieLongFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToLongFunction<? super V3> before3) Allows to manipulate the domain of the function.
static <T> void	LToLongFunction.times(int max_i, T a, LToLongFunction<T> func) From-To.
static <T> LToLongFunction<T>	LToLongFunction.toLongFunc(LToLongFunction<T> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T> long	LToLongFunction.tryApplyAsLong(T a, LToLongFunction<T> func)
static <T> long	LToLongFunction.tryApplyAsLong(T a, LToLongFunction<T> func, ExWF<RuntimeException> exF)
static <T> long	LToLongFunction.tryApplyAsLong(T a, LToLongFunction<T> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static <T1,T2> long	LToLongBiFunction.tryApplyAsLongThen(T1 a1, T2 a2, LToLongBiFunction<T1,T2> func, LToLongFunction<Throwable> handler)
static <T> long	LOiToLongFunction.tryApplyAsLongThen(T a1, int a2, LOiToLongFunction<T> func, LToLongFunction<Throwable> handler)
static <T> long	LToLongFunction.tryApplyAsLongThen(T a, LToLongFunction<T> func, LToLongFunction<Throwable> handler)
static <T> long	LToLongFunction.tryApplyAsLongThen(T a, LToLongFunction<T> func, LToLongFunction<Throwable> handler)
default LToLongFunction<T>	LToLongFunction.tryingThen(LToLongFunction<Throwable> handler)
default LToLongBiFunction<T1,T2>	LToLongBiFunction.tryingThen(LToLongFunction<Throwable> handler)
default LOiToLongFunction<T>	LOiToLongFunction.tryingThen(LToLongFunction<Throwable> handler)

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

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

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

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

Modifier and Type	Method and Description
default long	LLongBinaryOperator.applyAsLongThen(long a1, long a2, LToLongFunction<Throwable> handler)
static <V1,V2> LToLongBiFunction<V1,V2>	LLongBinaryOperator.composed(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2, LLongBinaryOperator after)
static <V1,V2> LToLongBiFunction<V1,V2>	LLongBinaryOperator.composed(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2, LLongBinaryOperator after)
default <V1,V2> LToLongBiFunction<V1,V2>	LLongBinaryOperator.longBinaryOpCompose(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToLongBiFunction<V1,V2>	LLongBinaryOperator.longBinaryOpCompose(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2) Allows to manipulate the domain of the function.
default LToLongBiFunction<T,T>	LBinaryOperator.thenToLong(LToLongFunction<? super T> after) Combines two functions together in a order.
static long	LLongBinaryOperator.tryApplyAsLongThen(long a1, long a2, LLongBinaryOperator func, LToLongFunction<Throwable> handler)
default LLongBinaryOperator	LLongBinaryOperator.tryingThen(LToLongFunction<Throwable> handler)

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

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

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

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

Modifier and Type	Method and Description
default long	LLongUnaryOperator.applyAsLongThen(long a, LToLongFunction<Throwable> handler)
static <V> LToLongFunction<V>	LLongUnaryOperator.composed(LToLongFunction<? super V> before, LLongUnaryOperator after)
default <V> LToLongFunction<V>	LLongUnaryOperator.longUnaryOpCompose(LToLongFunction<? super V> before) Allows to manipulate the domain of the function.
default LToLongFunction<T>	LUnaryOperator.thenToLong(LToLongFunction<? super T> after) Combines two functions together in a order.
static long	LLongUnaryOperator.tryApplyAsLongThen(long a, LLongUnaryOperator func, LToLongFunction<Throwable> handler)
default LLongUnaryOperator	LLongUnaryOperator.tryingThen(LToLongFunction<Throwable> handler)

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

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

Modifier and Type	Method and Description
default LToLongFunction<T>	LPredicate.boolToToLongFunc(LBoolToLongFunction after) Combines two functions together in a order.

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

Modifier and Type	Method and Description
default <V1,V2> LBiPredicate<V1,V2>	LBiLongPredicate.biLongPredCompose(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiPredicate<V1,V2>	LBiLongPredicate.biLongPredCompose(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjLongPredicate.biObjLongPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3) Allows to manipulate the domain of the function.
static <V1,V2,V3,T> LTriPredicate<V1,V2,V3>	LObjIntLongPredicate.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToLongFunction<? super V3> before3, LObjIntLongPredicate<T> after)
static <V1,V2,T> LBiPredicate<V1,V2>	LObjLongPredicate.composed(LFunction<? super V1,? extends T> before1, LToLongFunction<? super V2> before2, LObjLongPredicate<T> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjLongPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3, LBiObjLongPredicate<T1,T2> after)
static <V> LPredicate<V>	LLongPredicate.composed(LToLongFunction<? super V> before, LLongPredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LLongIntPredicate.composed(LToLongFunction<? super V1> before1, LToIntFunction<? super V2> before2, LLongIntPredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LBiLongPredicate.composed(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2, LBiLongPredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LBiLongPredicate.composed(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2, LBiLongPredicate after)
default <V1,V2> LBiPredicate<V1,V2>	LLongIntPredicate.longIntPredCompose(LToLongFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V> LPredicate<V>	LLongPredicate.longPredCompose(LToLongFunction<? super V> before) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LObjIntLongPredicate.objIntLongPredCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToLongFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiPredicate<V1,V2>	LObjLongPredicate.objLongPredCompose(LFunction<? super V1,? extends T> before1, LToLongFunction<? super V2> before2) Allows to manipulate the domain of the function.
default LPredicate<T>	LObjLongPredicate.rShrink(LToLongFunction<T> right)
static <T> LPredicate<T>	LObjLongPredicate.rShrinked(LToLongFunction<T> right, LObjLongPredicate<T> func)

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

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

Modifier and Type	Method and Description
default long	LLongSupplier.getAsLongThen(LToLongFunction<Throwable> handler)
default LLongSupplier	LSupplier.toLongSup(LToLongFunction<? super T> after) Combines two functions together in a order.
static long	LLongSupplier.tryGetAsLongThen(LLongSupplier func, LToLongFunction<Throwable> handler)
default LLongSupplier	LLongSupplier.tryingThen(LToLongFunction<Throwable> handler)

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

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

Modifier and Type	Method and Description
<R> LLongPair.MutLongPair	LLongPair.MutLongPair.setFirstIfArgNotNull(R arg, LToLongFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LLongPair.MutCompLongPair	LLongPair.MutCompLongPair.setFirstIfArgNotNull(R arg, LToLongFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LLongIntPair.MutLongIntPair	LLongIntPair.MutLongIntPair.setFirstIfArgNotNull(R arg, LToLongFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LLongIntPair.MutCompLongIntPair	LLongIntPair.MutCompLongIntPair.setFirstIfArgNotNull(R arg, LToLongFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjLongPair.MutObjLongPair<T>	LObjLongPair.MutObjLongPair.setSecondIfArgNotNull(R arg, LToLongFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjLongPair.MutCompObjLongPair<T>	LObjLongPair.MutCompObjLongPair.setSecondIfArgNotNull(R arg, LToLongFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LLongPair.MutLongPair	LLongPair.MutLongPair.setSecondIfArgNotNull(R arg, LToLongFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LLongPair.MutCompLongPair	LLongPair.MutCompLongPair.setSecondIfArgNotNull(R arg, LToLongFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntLongTriple.MutObjIntLongTriple<T>	LObjIntLongTriple.MutObjIntLongTriple.setThirdIfArgNotNull(R arg, LToLongFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntLongTriple.MutCompObjIntLongTriple<T>	LObjIntLongTriple.MutCompObjIntLongTriple.setThirdIfArgNotNull(R arg, LToLongFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjLongTriple.MutBiObjLongTriple<T1,T2>	LBiObjLongTriple.MutBiObjLongTriple.setThirdIfArgNotNull(R arg, LToLongFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjLongTriple.MutCompBiObjLongTriple<T1,T2>	LBiObjLongTriple.MutCompBiObjLongTriple.setThirdIfArgNotNull(R arg, LToLongFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LLongSingle.MutLongSingle	LLongSingle.MutLongSingle.setValueIfArgNotNull(R arg, LToLongFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LLongSingle.MutCompLongSingle	LLongSingle.MutCompLongSingle.setValueIfArgNotNull(R arg, LToLongFunction<R> func) Sets value derived from non-null argument, only if argument is not null.