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

Packages that use LToIntFunction

Package	Description
eu.lunisolar.magma.func	Functional interfaces / lambdas
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.ternary
eu.lunisolar.magma.func.operator.unary
eu.lunisolar.magma.func.predicate
eu.lunisolar.magma.func.supplier
eu.lunisolar.magma.func.tuple

Uses of LToIntFunction in eu.lunisolar.magma.func

Fields in eu.lunisolar.magma.func declared as LToIntFunction

Modifier and Type	Field and Description
static LToIntFunction	SA.UNKNOWN_SIZE

Methods in eu.lunisolar.magma.func that return LToIntFunction

Modifier and Type	Method and Description
LToIntFunction<C>	IA.The.genericSizeFunc()
LToIntFunction	IA.The.sizeFunc()

Methods in eu.lunisolar.magma.func with parameters of type LToIntFunction

Modifier and Type	Method and Description
static <C,E extends aType> IA<C,E>	IA.iA(LToIntFunction<C> size, OiFunction<C,E> oi, TieConsumer<C,E> tie)
static <C,I,E extends aType> SA<C,I,E>	SA.sA(LToIntFunction<C> sizeFunc, LFunction<C,I> adapter, LPredicate<I> tester, OFunction<I,E> getter, TeConsumer<C,E> consumer)

Constructors in eu.lunisolar.magma.func with parameters of type LToIntFunction

Constructor and Description
The(LToIntFunction<C> sizeFunc, LFunction<C,I> adapter, LPredicate<I> tester, OFunction<I,E> getter, TeConsumer<C,E> consumer)
The(LToIntFunction<C> size, OiFunction<C,E> getter, TieConsumer<C,E> setter)

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

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

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

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

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

Modifier and Type	Method and Description
default <V1,V2> LBiConsumer<V1,V2>	LBiIntConsumer.biIntConsCompose(LToIntFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LBiIntConsumer.biIntConsCompose(LToIntFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LBoolIntConsumer.boolIntConsCompose(LPredicate<? super V1> before1, LToIntFunction<? 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.
default <V1,V2> LBiConsumer<V1,V2>	LCharIntConsumer.charIntConsCompose(LToCharFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
static <V1,V2> LBiConsumer<V1,V2>	LBoolIntConsumer.composed(LPredicate<? super V1> before1, LToIntFunction<? super V2> before2, LBoolIntConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LByteIntConsumer.composed(LToByteFunction<? super V1> before1, LToIntFunction<? super V2> before2, LByteIntConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LCharIntConsumer.composed(LToCharFunction<? super V1> before1, LToIntFunction<? super V2> before2, LCharIntConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LDblIntConsumer.composed(LToDblFunction<? super V1> before1, LToIntFunction<? super V2> before2, LDblIntConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LFltIntConsumer.composed(LToFltFunction<? super V1> before1, LToIntFunction<? super V2> before2, LFltIntConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LBiIntConsumer.composed(LToIntFunction<? super V1> before1, LToIntFunction<? super V2> before2, LBiIntConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LBiIntConsumer.composed(LToIntFunction<? super V1> before1, LToIntFunction<? super V2> before2, LBiIntConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LLongIntConsumer.composed(LToLongFunction<? super V1> before1, LToIntFunction<? super V2> before2, LLongIntConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LSrtIntConsumer.composed(LToSrtFunction<? super V1> before1, LToIntFunction<? super V2> before2, LSrtIntConsumer after)
default <V1,V2> LBiConsumer<V1,V2>	LDblIntConsumer.dblIntConsCompose(LToDblFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LFltIntConsumer.fltIntConsCompose(LToFltFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LLongIntConsumer.longIntConsCompose(LToLongFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
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 LToIntFunction in eu.lunisolar.magma.func.consumer.primitives.obj

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

Modifier and Type	Method and Description
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjIntConsumer.biObjIntConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToIntFunction<? super V3> before3) Allows to manipulate the domain of the function.
static <V1,V2,T> LBiConsumer<V1,V2>	LObjIntConsumer.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LObjIntConsumer<T> after)
static <V1,V2,V3,T> LTriConsumer<V1,V2,V3>	LTieBoolConsumer.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LPredicate<? super V3> before3, LTieBoolConsumer<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,T> LTriConsumer<V1,V2,V3>	LTieCharConsumer.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToCharFunction<? super V3> before3, LTieCharConsumer<T> after)
static <V1,V2,V3,T> LTriConsumer<V1,V2,V3>	LTieDblConsumer.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToDblFunction<? super V3> before3, LTieDblConsumer<T> after)
static <V1,V2,V3,T> LTriConsumer<V1,V2,V3>	LTieFltConsumer.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToFltFunction<? super V3> before3, LTieFltConsumer<T> after)
static <V1,V2,V3,T> LTriConsumer<V1,V2,V3>	LTieIntConsumer.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToIntFunction<? super V3> before3, LTieIntConsumer<T> after)
static <V1,V2,V3,T> LTriConsumer<V1,V2,V3>	LTieIntConsumer.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToIntFunction<? super V3> before3, LTieIntConsumer<T> after)
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,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,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjIntConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToIntFunction<? super V3> before3, LBiObjIntConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LTieConsumer.composed(LFunction<? super V1,? extends T1> before1, LToIntFunction<? super V2> before2, LFunction<? super V3,? extends T2> before3, LTieConsumer<T1,T2> after)
default <V1,V2> LBiConsumer<V1,V2>	LObjIntConsumer.objIntConsCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default LConsumer<T>	LObjIntConsumer.rShrink(LToIntFunction<T> right)
static <T> LConsumer<T>	LObjIntConsumer.rShrinked(LToIntFunction<T> right, LObjIntConsumer<T> func)
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LTieBoolConsumer.tieBoolConsCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LPredicate<? super V3> before3) Allows to manipulate the domain of the function.
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.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LTieCharConsumer.tieCharConsCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToCharFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LTieConsumer.tieConsCompose(LFunction<? super V1,? extends T1> before1, LToIntFunction<? super V2> before2, LFunction<? super V3,? extends T2> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LTieDblConsumer.tieDblConsCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToDblFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LTieFltConsumer.tieFltConsCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToFltFunction<? super V3> before3) Allows to manipulate the domain of the function.
static <T,SRC> int	LTieIntConsumer.tieForEach(int sStart, int tStart, T trg1, SRC src3, LPredicate<SRC> srcTest3, LToIntFunction<SRC> srcAcc3, LTieIntConsumer<? 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>	LTieIntConsumer.tieIntConsCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToIntFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LTieIntConsumer.tieIntConsCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToIntFunction<? super V3> before3) Allows to manipulate the domain of the function.
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.
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 LToIntFunction in eu.lunisolar.magma.func.function

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

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

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

Modifier and Type	Method and Description
default LToIntTriFunction<T1,T2,T3>	LTriFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.
default LToIntFunction<T>	LFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.
default LToIntBiFunction<T1,T2>	LBiFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.

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

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

Modifier and Type	Method and Description
default <V> LToIntFunction<V>	LBoolToIntFunction.boolToIntFuncCompose(LPredicate<? 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> LToIntFunction<V>	LCharToIntFunction.charToIntFuncCompose(LToCharFunction<? super V> before) Allows to manipulate the domain of the function.
static <V> LToIntFunction<V>	LBoolToIntFunction.composed(LPredicate<? super V> before, LBoolToIntFunction after)
static <V> LToIntFunction<V>	LByteToIntFunction.composed(LToByteFunction<? super V> before, LByteToIntFunction after)
static <V> LToIntFunction<V>	LCharToIntFunction.composed(LToCharFunction<? super V> before, LCharToIntFunction after)
static <V> LToIntFunction<V>	LDblToIntFunction.composed(LToDblFunction<? super V> before, LDblToIntFunction after)
static <V> LToIntFunction<V>	LFltToIntFunction.composed(LToFltFunction<? super V> before, LFltToIntFunction after)
static <V> LToIntFunction<V>	LLongToIntFunction.composed(LToLongFunction<? super V> before, LLongToIntFunction after)
static <V> LToIntFunction<V>	LSrtToIntFunction.composed(LToSrtFunction<? super V> before, LSrtToIntFunction after)
default <V> LToIntFunction<V>	LDblToIntFunction.dblToIntFuncCompose(LToDblFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToIntFunction<V>	LFltToIntFunction.fltToIntFuncCompose(LToFltFunction<? 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> LToIntFunction<V>	LSrtToIntFunction.srtToIntFuncCompose(LToSrtFunction<? super V> before) Allows to manipulate the domain of the function.

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

Modifier and Type	Method and Description
default int	LBoolToIntFunction.applyAsIntThen(boolean a, LToIntFunction<Throwable> handler)
default int	LByteToIntFunction.applyAsIntThen(byte a, LToIntFunction<Throwable> handler)
default int	LCharToIntFunction.applyAsIntThen(char a, LToIntFunction<Throwable> handler)
default int	LDblToIntFunction.applyAsIntThen(double a, LToIntFunction<Throwable> handler)
default int	LFltToIntFunction.applyAsIntThen(float a, LToIntFunction<Throwable> handler)
default int	LLongToIntFunction.applyAsIntThen(long a, LToIntFunction<Throwable> handler)
default int	LSrtToIntFunction.applyAsIntThen(short a, LToIntFunction<Throwable> handler)
static <V> LToByteFunction<V>	LIntToByteFunction.composed(LToIntFunction<? super V> before, LIntToByteFunction after)
static <V> LToCharFunction<V>	LIntToCharFunction.composed(LToIntFunction<? super V> before, LIntToCharFunction after)
static <V> LToDblFunction<V>	LIntToDblFunction.composed(LToIntFunction<? super V> before, LIntToDblFunction after)
static <V> LToFltFunction<V>	LIntToFltFunction.composed(LToIntFunction<? super V> before, LIntToFltFunction after)
static <V> LToLongFunction<V>	LIntToLongFunction.composed(LToIntFunction<? super V> before, LIntToLongFunction after)
static <V> LToSrtFunction<V>	LIntToSrtFunction.composed(LToIntFunction<? super V> before, LIntToSrtFunction after)
default <V> LToByteFunction<V>	LIntToByteFunction.intToByteFuncCompose(LToIntFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToCharFunction<V>	LIntToCharFunction.intToCharFuncCompose(LToIntFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToDblFunction<V>	LIntToDblFunction.intToDblFuncCompose(LToIntFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToFltFunction<V>	LIntToFltFunction.intToFltFuncCompose(LToIntFunction<? 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> LToSrtFunction<V>	LIntToSrtFunction.intToSrtFuncCompose(LToIntFunction<? super V> before) Allows to manipulate the domain of the function.
static int	LBoolToIntFunction.tryApplyAsIntThen(boolean a, LBoolToIntFunction func, LToIntFunction<Throwable> handler)
static int	LByteToIntFunction.tryApplyAsIntThen(byte a, LByteToIntFunction func, LToIntFunction<Throwable> handler)
static int	LCharToIntFunction.tryApplyAsIntThen(char a, LCharToIntFunction func, LToIntFunction<Throwable> handler)
static int	LDblToIntFunction.tryApplyAsIntThen(double a, LDblToIntFunction func, LToIntFunction<Throwable> handler)
static int	LFltToIntFunction.tryApplyAsIntThen(float a, LFltToIntFunction func, LToIntFunction<Throwable> handler)
static int	LLongToIntFunction.tryApplyAsIntThen(long a, LLongToIntFunction func, LToIntFunction<Throwable> handler)
static int	LSrtToIntFunction.tryApplyAsIntThen(short a, LSrtToIntFunction func, LToIntFunction<Throwable> handler)
default LSrtToIntFunction	LSrtToIntFunction.tryingThen(LToIntFunction<Throwable> handler)
default LLongToIntFunction	LLongToIntFunction.tryingThen(LToIntFunction<Throwable> handler)
default LFltToIntFunction	LFltToIntFunction.tryingThen(LToIntFunction<Throwable> handler)
default LDblToIntFunction	LDblToIntFunction.tryingThen(LToIntFunction<Throwable> handler)
default LCharToIntFunction	LCharToIntFunction.tryingThen(LToIntFunction<Throwable> handler)
default LByteToIntFunction	LByteToIntFunction.tryingThen(LToIntFunction<Throwable> handler)
default LBoolToIntFunction	LBoolToIntFunction.tryingThen(LToIntFunction<Throwable> handler)

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

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

Modifier and Type	Method and Description
default <V1,V2> LBiFunction<V1,V2,R>	LBiIntFunction.biIntFuncCompose(LToIntFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LBiIntFunction.biIntFuncCompose(LToIntFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjIntFunction.biObjIntFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToIntFunction<? super V3> before3) Allows to manipulate the domain of the function.
static <V1,V2,T,R> LBiFunction<V1,V2,R>	LOiFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LOiFunction<T,R> after)
static <V1,V2,V3,T,R> LTriFunction<V1,V2,V3,R>	LObjIntBoolFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LPredicate<? super V3> before3, LObjIntBoolFunction<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,T,R> LTriFunction<V1,V2,V3,R>	LObjIntCharFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToCharFunction<? super V3> before3, LObjIntCharFunction<T,R> after)
static <V1,V2,V3,T,R> LTriFunction<V1,V2,V3,R>	LObjIntDblFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToDblFunction<? super V3> before3, LObjIntDblFunction<T,R> after)
static <V1,V2,V3,T,R> LTriFunction<V1,V2,V3,R>	LObjIntFltFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToFltFunction<? super V3> before3, LObjIntFltFunction<T,R> after)
static <V1,V2,V3,T,R> LTriFunction<V1,V2,V3,R>	LObjBiIntFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToIntFunction<? super V3> before3, LObjBiIntFunction<T,R> after)
static <V1,V2,V3,T,R> LTriFunction<V1,V2,V3,R>	LObjBiIntFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToIntFunction<? super V3> before3, LObjBiIntFunction<T,R> after)
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,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,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjIntFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToIntFunction<? super V3> before3, LBiObjIntFunction<T1,T2,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LObjIntObjFunction.composed(LFunction<? super V1,? extends T1> before1, LToIntFunction<? super V2> before2, LFunction<? super V3,? extends T2> before3, LObjIntObjFunction<T1,T2,R> after)
static <V,R> LFunction<V,R>	LIntFunction.composed(LToIntFunction<? super V> before, LIntFunction<R> after)
static <V1,V2,R> LBiFunction<V1,V2,R>	LBiIntFunction.composed(LToIntFunction<? super V1> before1, LToIntFunction<? super V2> before2, LBiIntFunction<R> after)
static <V1,V2,R> LBiFunction<V1,V2,R>	LBiIntFunction.composed(LToIntFunction<? super V1> before1, LToIntFunction<? super V2> before2, LBiIntFunction<R> after)
default <V> LFunction<V,R>	LIntFunction.intFuncCompose(LToIntFunction<? super V> before) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LObjBiIntFunction.objBiIntFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToIntFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LObjBiIntFunction.objBiIntFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToIntFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LObjIntBoolFunction.objIntBoolFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LPredicate<? super V3> before3) 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 <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LObjIntCharFunction.objIntCharFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToCharFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LObjIntDblFunction.objIntDblFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToDblFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LObjIntFltFunction.objIntFltFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToFltFunction<? super V3> before3) 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,V3> LTriFunction<V1,V2,V3,R>	LObjIntObjFunction.objIntObjFuncCompose(LFunction<? super V1,? extends T1> before1, LToIntFunction<? super V2> before2, LFunction<? super V3,? extends T2> before3) Allows to manipulate the domain of the function.
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>	LOiFunction.oiFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default LFunction<T,R>	LOiFunction.rShrink(LToIntFunction<T> right)
static <T,R> LFunction<T,R>	LOiFunction.rShrinked(LToIntFunction<T> right, LOiFunction<T,R> func)
default LSrtToIntFunction	LSrtFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.
default LOiToIntFunction<T>	LOiFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.
default LTieSrtFunction<T>	LObjIntSrtFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.
default LTieFunction<T1,T2>	LObjIntObjFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.
default LTieLongFunction<T>	LObjIntLongFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.
default LTieFltFunction<T>	LObjIntFltFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.
default LTieDblFunction<T>	LObjIntDblFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.
default LTieCharFunction<T>	LObjIntCharFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.
default LTieByteFunction<T>	LObjIntByteFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.
default LTieBoolFunction<T>	LObjIntBoolFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.
default LTieIntFunction<T>	LObjBiIntFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.
default LLongToIntFunction	LLongFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.
default LIntUnaryOperator	LIntFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.
default LFltToIntFunction	LFltFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.
default LDblToIntFunction	LDblFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.
default LCharToIntFunction	LCharFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.
default LByteToIntFunction	LByteFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.
default LBoolToIntFunction	LBoolFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.
default LIntBinaryOperator	LBiIntFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.

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

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

Modifier and Type	Class and Description
static class	LToIntFunction.LToIntFunctionSingle<T>

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

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

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

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

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

Modifier and Type	Method and Description
static <T> LTieSrtFunction<T>	LTieSrtFunction.apply1stAsInt(LToIntFunction<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LTieLongFunction<T>	LTieLongFunction.apply1stAsInt(LToIntFunction<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LTieIntFunction<T>	LTieIntFunction.apply1stAsInt(LToIntFunction<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LTieFltFunction<T>	LTieFltFunction.apply1stAsInt(LToIntFunction<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LTieDblFunction<T>	LTieDblFunction.apply1stAsInt(LToIntFunction<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LTieCharFunction<T>	LTieCharFunction.apply1stAsInt(LToIntFunction<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LTieByteFunction<T>	LTieByteFunction.apply1stAsInt(LToIntFunction<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LTieBoolFunction<T>	LTieBoolFunction.apply1stAsInt(LToIntFunction<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LOiToIntFunction<T>	LOiToIntFunction.apply1stAsInt(LToIntFunction<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LToIntBiFunction<T1,T2>	LToIntBiFunction.apply1stAsInt(LToIntFunction<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LTieFunction<T1,T2>	LTieFunction.apply1stAsInt(LToIntFunction<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3>	LToIntTriFunction.apply1stAsInt(LToIntFunction<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LToIntBiFunction<T1,T2>	LToIntBiFunction.apply2ndAsInt(LToIntFunction<T2> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3>	LToIntTriFunction.apply2ndAsInt(LToIntFunction<T2> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2> LTieFunction<T1,T2>	LTieFunction.apply3rdAsInt(LToIntFunction<T2> func) Captures single parameter function into this interface where only 3rd parameter will be used.
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3>	LToIntTriFunction.apply3rdAsInt(LToIntFunction<T3> func) Captures single parameter function into this interface where only 3rd parameter will be used.
default int	LTieFunction.applyAsIntThen(T1 a1, int a2, T2 a3, LToIntFunction<Throwable> handler)
default int	LToIntBiFunction.applyAsIntThen(T1 a1, T2 a2, LToIntFunction<Throwable> handler)
default int	LToIntTriFunction.applyAsIntThen(T1 a1, T2 a2, T3 a3, LToIntFunction<Throwable> handler)
default int	LTieBoolFunction.applyAsIntThen(T a1, int a2, boolean a3, LToIntFunction<Throwable> handler)
default int	LTieByteFunction.applyAsIntThen(T a1, int a2, byte a3, LToIntFunction<Throwable> handler)
default int	LTieCharFunction.applyAsIntThen(T a1, int a2, char a3, LToIntFunction<Throwable> handler)
default int	LTieDblFunction.applyAsIntThen(T a1, int a2, double a3, LToIntFunction<Throwable> handler)
default int	LTieFltFunction.applyAsIntThen(T a1, int a2, float a3, LToIntFunction<Throwable> handler)
default int	LTieIntFunction.applyAsIntThen(T a1, int a2, int a3, LToIntFunction<Throwable> handler)
default int	LTieLongFunction.applyAsIntThen(T a1, int a2, long a3, LToIntFunction<Throwable> handler)
default int	LOiToIntFunction.applyAsIntThen(T a1, int a2, LToIntFunction<Throwable> handler)
default int	LTieSrtFunction.applyAsIntThen(T a1, int a2, short a3, LToIntFunction<Throwable> handler)
default int	LToIntFunction.applyAsIntThen(T a, LToIntFunction<Throwable> handler)
static <T> int	LToIntFunction.call(T a, LToIntFunction<T> lambda)
static <V2,T> LToIntFunction<V2>	LToIntFunction.cast(LToIntFunction<T> function) Cast that replace generics.
static <V,T> LToIntFunction<V>	LToIntFunction.composed(LFunction<? super V,? extends T> before, LToIntFunction<T> after)
static <V1,V2,T> LToByteBiFunction<V1,V2>	LOiToByteFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LOiToByteFunction<T> after)
static <V1,V2,T> LToCharBiFunction<V1,V2>	LOiToCharFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LOiToCharFunction<T> after)
static <V1,V2,T> LToDblBiFunction<V1,V2>	LOiToDblFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LOiToDblFunction<T> after)
static <V1,V2,T> LToFltBiFunction<V1,V2>	LOiToFltFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LOiToFltFunction<T> after)
static <V1,V2,T> LToIntBiFunction<V1,V2>	LOiToIntFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LOiToIntFunction<T> after)
static <V1,V2,T> LToLongBiFunction<V1,V2>	LOiToLongFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LOiToLongFunction<T> after)
static <V1,V2,T> LToSrtBiFunction<V1,V2>	LOiToSrtFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LOiToSrtFunction<T> after)
static <V1,V2,V3,T> LToIntTriFunction<V1,V2,V3>	LTieBoolFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LPredicate<? super V3> before3, LTieBoolFunction<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 <V1,V2,V3,T> LToIntTriFunction<V1,V2,V3>	LTieCharFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToCharFunction<? super V3> before3, LTieCharFunction<T> after)
static <V1,V2,V3,T> LToIntTriFunction<V1,V2,V3>	LTieDblFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToDblFunction<? super V3> before3, LTieDblFunction<T> after)
static <V1,V2,V3,T> LToIntTriFunction<V1,V2,V3>	LTieFltFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToFltFunction<? super V3> before3, LTieFltFunction<T> after)
static <V1,V2,V3,T> LToIntTriFunction<V1,V2,V3>	LTieIntFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToIntFunction<? super V3> before3, LTieIntFunction<T> after)
static <V1,V2,V3,T> LToIntTriFunction<V1,V2,V3>	LTieIntFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToIntFunction<? super V3> before3, LTieIntFunction<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 <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 <V1,V2,V3,T1,T2> LToIntTriFunction<V1,V2,V3>	LTieFunction.composed(LFunction<? super V1,? extends T1> before1, LToIntFunction<? super V2> before2, LFunction<? super V3,? extends T2> before3, LTieFunction<T1,T2> after)
static <T> LToIntFunction<T>	LToIntFunction.failSafe(LToIntFunction<T> func, LToIntFunction<T> failSafe)
static <T> LToIntFunction<T>	LToIntFunction.failSafe(LToIntFunction<T> func, LToIntFunction<T> failSafe)
default int	LToIntFunction.failSafeApplyAsInt(T a, LToIntFunction<T> failSafe)
static <T> int	LToIntFunction.failSafeApplyAsInt(T a, LToIntFunction<T> func, LToIntFunction<T> failSafe)
static <T> int	LToIntFunction.failSafeApplyAsInt(T a, LToIntFunction<T> func, LToIntFunction<T> failSafe)
static <T> void	LToIntFunction.fromTill(int min_i, int max_i, T a, LToIntFunction<T> func) From-To.
static <T> void	LToIntFunction.fromTo(int min_i, int max_i, T a, LToIntFunction<T> func) From-To.
static <T> int	LToIntFunction.handlingApplyAsInt(T a, LToIntFunction<T> func, HandlingInstructions<Throwable,RuntimeException> handling)
default <V1,V2> LToByteBiFunction<V1,V2>	LOiToByteFunction.oiToByteFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToCharBiFunction<V1,V2>	LOiToCharFunction.oiToCharFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToDblBiFunction<V1,V2>	LOiToDblFunction.oiToDblFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToFltBiFunction<V1,V2>	LOiToFltFunction.oiToFltFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToIntBiFunction<V1,V2>	LOiToIntFunction.oiToIntFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToLongBiFunction<V1,V2>	LOiToLongFunction.oiToLongFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToSrtBiFunction<V1,V2>	LOiToSrtFunction.oiToSrtFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default LToSrtFunction<T>	LOiToSrtFunction.rShrink(LToIntFunction<T> right)
default LToLongFunction<T>	LOiToLongFunction.rShrink(LToIntFunction<T> right)
default LToIntFunction<T>	LOiToIntFunction.rShrink(LToIntFunction<T> right)
default LToFltFunction<T>	LOiToFltFunction.rShrink(LToIntFunction<T> right)
default LToDblFunction<T>	LOiToDblFunction.rShrink(LToIntFunction<T> right)
default LToCharFunction<T>	LOiToCharFunction.rShrink(LToIntFunction<T> right)
default LToByteFunction<T>	LOiToByteFunction.rShrink(LToIntFunction<T> right)
static <T> LToByteFunction<T>	LOiToByteFunction.rShrinked(LToIntFunction<T> right, LOiToByteFunction<T> func)
static <T> LToCharFunction<T>	LOiToCharFunction.rShrinked(LToIntFunction<T> right, LOiToCharFunction<T> func)
static <T> LToDblFunction<T>	LOiToDblFunction.rShrinked(LToIntFunction<T> right, LOiToDblFunction<T> func)
static <T> LToFltFunction<T>	LOiToFltFunction.rShrinked(LToIntFunction<T> right, LOiToFltFunction<T> func)
static <T> LToIntFunction<T>	LOiToIntFunction.rShrinked(LToIntFunction<T> right, LOiToIntFunction<T> func)
static <T> LToLongFunction<T>	LOiToLongFunction.rShrinked(LToIntFunction<T> right, LOiToLongFunction<T> func)
static <T> LToSrtFunction<T>	LOiToSrtFunction.rShrinked(LToIntFunction<T> right, LOiToSrtFunction<T> func)
static <T> LToIntFunction<T>	LToIntFunction.safe(LToIntFunction<T> other) Safe wrapping.
default <V1,V2,V3> LToIntTriFunction<V1,V2,V3>	LTieBoolFunction.tieBoolFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LPredicate<? super V3> before3) Allows to manipulate the domain of the function.
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.
default <V1,V2,V3> LToIntTriFunction<V1,V2,V3>	LTieCharFunction.tieCharFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToCharFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LToIntTriFunction<V1,V2,V3>	LTieDblFunction.tieDblFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToDblFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LToIntTriFunction<V1,V2,V3>	LTieFltFunction.tieFltFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToFltFunction<? super V3> before3) Allows to manipulate the domain of the function.
static <T,SRC> int	LTieIntFunction.tieForEach(int sStart, int tStart, T trg1, SRC src3, LPredicate<SRC> srcTest3, LToIntFunction<SRC> srcAcc3, LTieIntFunction<? 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>	LTieFunction.tieFuncCompose(LFunction<? super V1,? extends T1> before1, LToIntFunction<? super V2> before2, LFunction<? super V3,? extends T2> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LToIntTriFunction<V1,V2,V3>	LTieIntFunction.tieIntFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToIntFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LToIntTriFunction<V1,V2,V3>	LTieIntFunction.tieIntFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToIntFunction<? super V3> before3) Allows to manipulate the domain of the function.
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.
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	LToIntFunction.times(int max_i, T a, LToIntFunction<T> func) From-To.
static <T> LToIntFunction<T>	LToIntFunction.toIntFunc(LToIntFunction<T> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T> int	LToIntFunction.tryApplyAsInt(T a, LToIntFunction<T> func)
static <T> int	LToIntFunction.tryApplyAsInt(T a, LToIntFunction<T> func, ExWF<RuntimeException> exF)
static <T> int	LToIntFunction.tryApplyAsInt(T a, LToIntFunction<T> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static <T1,T2> int	LTieFunction.tryApplyAsIntThen(T1 a1, int a2, T2 a3, LTieFunction<T1,T2> func, LToIntFunction<Throwable> handler)
static <T1,T2> int	LToIntBiFunction.tryApplyAsIntThen(T1 a1, T2 a2, LToIntBiFunction<T1,T2> func, LToIntFunction<Throwable> handler)
static <T1,T2,T3> int	LToIntTriFunction.tryApplyAsIntThen(T1 a1, T2 a2, T3 a3, LToIntTriFunction<T1,T2,T3> func, LToIntFunction<Throwable> handler)
static <T> int	LTieBoolFunction.tryApplyAsIntThen(T a1, int a2, boolean a3, LTieBoolFunction<T> func, LToIntFunction<Throwable> handler)
static <T> int	LTieByteFunction.tryApplyAsIntThen(T a1, int a2, byte a3, LTieByteFunction<T> func, LToIntFunction<Throwable> handler)
static <T> int	LTieCharFunction.tryApplyAsIntThen(T a1, int a2, char a3, LTieCharFunction<T> func, LToIntFunction<Throwable> handler)
static <T> int	LTieDblFunction.tryApplyAsIntThen(T a1, int a2, double a3, LTieDblFunction<T> func, LToIntFunction<Throwable> handler)
static <T> int	LTieFltFunction.tryApplyAsIntThen(T a1, int a2, float a3, LTieFltFunction<T> func, LToIntFunction<Throwable> handler)
static <T> int	LTieIntFunction.tryApplyAsIntThen(T a1, int a2, int a3, LTieIntFunction<T> func, LToIntFunction<Throwable> handler)
static <T> int	LOiToIntFunction.tryApplyAsIntThen(T a1, int a2, LOiToIntFunction<T> func, LToIntFunction<Throwable> handler)
static <T> int	LTieLongFunction.tryApplyAsIntThen(T a1, int a2, long a3, LTieLongFunction<T> func, LToIntFunction<Throwable> handler)
static <T> int	LTieSrtFunction.tryApplyAsIntThen(T a1, int a2, short a3, LTieSrtFunction<T> func, LToIntFunction<Throwable> handler)
static <T> int	LToIntFunction.tryApplyAsIntThen(T a, LToIntFunction<T> func, LToIntFunction<Throwable> handler)
static <T> int	LToIntFunction.tryApplyAsIntThen(T a, LToIntFunction<T> func, LToIntFunction<Throwable> handler)
default LToIntTriFunction<T1,T2,T3>	LToIntTriFunction.tryingThen(LToIntFunction<Throwable> handler)
default LToIntFunction<T>	LToIntFunction.tryingThen(LToIntFunction<Throwable> handler)
default LToIntBiFunction<T1,T2>	LToIntBiFunction.tryingThen(LToIntFunction<Throwable> handler)
default LTieSrtFunction<T>	LTieSrtFunction.tryingThen(LToIntFunction<Throwable> handler)
default LTieLongFunction<T>	LTieLongFunction.tryingThen(LToIntFunction<Throwable> handler)
default LTieIntFunction<T>	LTieIntFunction.tryingThen(LToIntFunction<Throwable> handler)
default LTieFunction<T1,T2>	LTieFunction.tryingThen(LToIntFunction<Throwable> handler)
default LTieFltFunction<T>	LTieFltFunction.tryingThen(LToIntFunction<Throwable> handler)
default LTieDblFunction<T>	LTieDblFunction.tryingThen(LToIntFunction<Throwable> handler)
default LTieCharFunction<T>	LTieCharFunction.tryingThen(LToIntFunction<Throwable> handler)
default LTieByteFunction<T>	LTieByteFunction.tryingThen(LToIntFunction<Throwable> handler)
default LTieBoolFunction<T>	LTieBoolFunction.tryingThen(LToIntFunction<Throwable> handler)
default LOiToIntFunction<T>	LOiToIntFunction.tryingThen(LToIntFunction<Throwable> handler)

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

Modifier and Type	Method and Description
static <T> LToIntFunction<T>	LToIntFunction.recursive(LFunction<LToIntFunction<T>,LToIntFunction<T>> selfLambda)
static <T> LToIntFunction<T>	LToIntFunction.recursive(LFunction<LToIntFunction<T>,LToIntFunction<T>> selfLambda)
static <T> LSupplier<LToIntFunction<T>>	LToIntFunction.safeSupplier(LSupplier<LToIntFunction<T>> supplier) Safe supplier.
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3>	LToIntTriFunction.uncurry(LFunction<T1,LFunction<T2,LToIntFunction<T3>>> func)
static <T1,T2> LTieFunction<T1,T2>	LTieFunction.uncurry(LFunction<T1,LIntFunction<LToIntFunction<T2>>> func)
static <T1,T2> LToIntBiFunction<T1,T2>	LToIntBiFunction.uncurry(LFunction<T1,LToIntFunction<T2>> func)

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

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

Modifier and Type	Method and Description
default int	LIntBinaryOperator.applyAsIntThen(int a1, int a2, LToIntFunction<Throwable> handler)
static <V1,V2> LToIntBiFunction<V1,V2>	LIntBinaryOperator.composed(LToIntFunction<? super V1> before1, LToIntFunction<? super V2> before2, LIntBinaryOperator after)
static <V1,V2> LToIntBiFunction<V1,V2>	LIntBinaryOperator.composed(LToIntFunction<? super V1> before1, LToIntFunction<? super V2> before2, LIntBinaryOperator after)
default <V1,V2> LToIntBiFunction<V1,V2>	LIntBinaryOperator.intBinaryOpCompose(LToIntFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToIntBiFunction<V1,V2>	LIntBinaryOperator.intBinaryOpCompose(LToIntFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default LToIntBiFunction<T,T>	LBinaryOperator.thenToInt(LToIntFunction<? super T> after) Combines two functions together in a order.
static int	LIntBinaryOperator.tryApplyAsIntThen(int a1, int a2, LIntBinaryOperator func, LToIntFunction<Throwable> handler)
default LIntBinaryOperator	LIntBinaryOperator.tryingThen(LToIntFunction<Throwable> handler)

Uses of LToIntFunction in eu.lunisolar.magma.func.operator.ternary

Methods in eu.lunisolar.magma.func.operator.ternary with parameters of type LToIntFunction

Modifier and Type	Method and Description
default LToIntTriFunction<T,T,T>	LTernaryOperator.thenToInt(LToIntFunction<? super T> after) Combines two functions together in a order.

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

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

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

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

Modifier and Type	Method and Description
default int	LIntUnaryOperator.applyAsIntThen(int a, LToIntFunction<Throwable> handler)
static <V> LToIntFunction<V>	LIntUnaryOperator.composed(LToIntFunction<? super V> before, LIntUnaryOperator after)
default <V> LToIntFunction<V>	LIntUnaryOperator.intUnaryOpCompose(LToIntFunction<? super V> before) Allows to manipulate the domain of the function.
default LToIntFunction<T>	LUnaryOperator.thenToInt(LToIntFunction<? super T> after) Combines two functions together in a order.
static int	LIntUnaryOperator.tryApplyAsIntThen(int a, LIntUnaryOperator func, LToIntFunction<Throwable> handler)
default LIntUnaryOperator	LIntUnaryOperator.tryingThen(LToIntFunction<Throwable> handler)

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

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

Modifier and Type	Method and Description
default LToIntFunction<T>	LPredicate.boolToToIntFunc(LBoolToIntFunction after) Combines two functions together in a order.

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

Modifier and Type	Method and Description
default <V1,V2> LBiPredicate<V1,V2>	LBiIntPredicate.biIntPredCompose(LToIntFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiPredicate<V1,V2>	LBiIntPredicate.biIntPredCompose(LToIntFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjIntPredicate.biObjIntPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToIntFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiPredicate<V1,V2>	LBoolIntPredicate.boolIntPredCompose(LPredicate<? super V1> before1, LToIntFunction<? super V2> before2) 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 <V1,V2> LBiPredicate<V1,V2>	LCharIntPredicate.charIntPredCompose(LToCharFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
static <V1,V2,T> LBiPredicate<V1,V2>	LObjIntPredicate.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LObjIntPredicate<T> after)
static <V1,V2,V3,T> LTriPredicate<V1,V2,V3>	LObjIntBoolPredicate.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LPredicate<? super V3> before3, LObjIntBoolPredicate<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,T> LTriPredicate<V1,V2,V3>	LObjIntCharPredicate.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToCharFunction<? super V3> before3, LObjIntCharPredicate<T> after)
static <V1,V2,V3,T> LTriPredicate<V1,V2,V3>	LObjIntDblPredicate.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToDblFunction<? super V3> before3, LObjIntDblPredicate<T> after)
static <V1,V2,V3,T> LTriPredicate<V1,V2,V3>	LObjIntFltPredicate.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToFltFunction<? super V3> before3, LObjIntFltPredicate<T> after)
static <V1,V2,V3,T> LTriPredicate<V1,V2,V3>	LObjBiIntPredicate.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToIntFunction<? super V3> before3, LObjBiIntPredicate<T> after)
static <V1,V2,V3,T> LTriPredicate<V1,V2,V3>	LObjBiIntPredicate.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToIntFunction<? super V3> before3, LObjBiIntPredicate<T> after)
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,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,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjIntPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToIntFunction<? super V3> before3, LBiObjIntPredicate<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LObjIntObjPredicate.composed(LFunction<? super V1,? extends T1> before1, LToIntFunction<? super V2> before2, LFunction<? super V3,? extends T2> before3, LObjIntObjPredicate<T1,T2> after)
static <V1,V2> LBiPredicate<V1,V2>	LBoolIntPredicate.composed(LPredicate<? super V1> before1, LToIntFunction<? super V2> before2, LBoolIntPredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LByteIntPredicate.composed(LToByteFunction<? super V1> before1, LToIntFunction<? super V2> before2, LByteIntPredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LCharIntPredicate.composed(LToCharFunction<? super V1> before1, LToIntFunction<? super V2> before2, LCharIntPredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LDblIntPredicate.composed(LToDblFunction<? super V1> before1, LToIntFunction<? super V2> before2, LDblIntPredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LFltIntPredicate.composed(LToFltFunction<? super V1> before1, LToIntFunction<? super V2> before2, LFltIntPredicate after)
static <V> LPredicate<V>	LIntPredicate.composed(LToIntFunction<? super V> before, LIntPredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LBiIntPredicate.composed(LToIntFunction<? super V1> before1, LToIntFunction<? super V2> before2, LBiIntPredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LBiIntPredicate.composed(LToIntFunction<? super V1> before1, LToIntFunction<? super V2> before2, LBiIntPredicate 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>	LSrtIntPredicate.composed(LToSrtFunction<? super V1> before1, LToIntFunction<? super V2> before2, LSrtIntPredicate after)
default <V1,V2> LBiPredicate<V1,V2>	LDblIntPredicate.dblIntPredCompose(LToDblFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiPredicate<V1,V2>	LFltIntPredicate.fltIntPredCompose(LToFltFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V> LPredicate<V>	LIntPredicate.intPredCompose(LToIntFunction<? super V> before) Allows to manipulate the domain of the function.
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 <V1,V2,V3> LTriPredicate<V1,V2,V3>	LObjBiIntPredicate.objBiIntPredCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToIntFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LObjBiIntPredicate.objBiIntPredCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToIntFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LObjIntBoolPredicate.objIntBoolPredCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LPredicate<? super V3> before3) 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 <V1,V2,V3> LTriPredicate<V1,V2,V3>	LObjIntCharPredicate.objIntCharPredCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToCharFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LObjIntDblPredicate.objIntDblPredCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToDblFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LObjIntFltPredicate.objIntFltPredCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToFltFunction<? super V3> before3) 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,V3> LTriPredicate<V1,V2,V3>	LObjIntObjPredicate.objIntObjPredCompose(LFunction<? super V1,? extends T1> before1, LToIntFunction<? super V2> before2, LFunction<? super V3,? extends T2> before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiPredicate<V1,V2>	LObjIntPredicate.objIntPredCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
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 LPredicate<T>	LObjIntPredicate.rShrink(LToIntFunction<T> right)
static <T> LPredicate<T>	LObjIntPredicate.rShrinked(LToIntFunction<T> right, LObjIntPredicate<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.

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

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

Modifier and Type	Method and Description
default int	LIntSupplier.getAsIntThen(LToIntFunction<Throwable> handler)
default LIntSupplier	LSupplier.toIntSup(LToIntFunction<? super T> after) Combines two functions together in a order.
static int	LIntSupplier.tryGetAsIntThen(LIntSupplier func, LToIntFunction<Throwable> handler)
default LIntSupplier	LIntSupplier.tryingThen(LToIntFunction<Throwable> handler)

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

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

Modifier and Type	Method and Description
<R> LIntPair.MutIntPair	LIntPair.MutIntPair.setFirstIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LIntPair.MutCompIntPair	LIntPair.MutCompIntPair.setFirstIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LSrtIntPair.MutSrtIntPair	LSrtIntPair.MutSrtIntPair.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LSrtIntPair.MutCompSrtIntPair	LSrtIntPair.MutCompSrtIntPair.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntSrtTriple.MutObjIntSrtTriple<T>	LObjIntSrtTriple.MutObjIntSrtTriple.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntSrtTriple.MutCompObjIntSrtTriple<T>	LObjIntSrtTriple.MutCompObjIntSrtTriple.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntPair.MutObjIntPair<T>	LObjIntPair.MutObjIntPair.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntPair.MutCompObjIntPair<T>	LObjIntPair.MutCompObjIntPair.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntObjTriple.MutObjIntObjTriple<T1,T2>	LObjIntObjTriple.MutObjIntObjTriple.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntObjTriple.MutCompObjIntObjTriple<T1,T2>	LObjIntObjTriple.MutCompObjIntObjTriple.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntLongTriple.MutObjIntLongTriple<T>	LObjIntLongTriple.MutObjIntLongTriple.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntLongTriple.MutCompObjIntLongTriple<T>	LObjIntLongTriple.MutCompObjIntLongTriple.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntFltTriple.MutObjIntFltTriple<T>	LObjIntFltTriple.MutObjIntFltTriple.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntFltTriple.MutCompObjIntFltTriple<T>	LObjIntFltTriple.MutCompObjIntFltTriple.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntDblTriple.MutObjIntDblTriple<T>	LObjIntDblTriple.MutObjIntDblTriple.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntDblTriple.MutCompObjIntDblTriple<T>	LObjIntDblTriple.MutCompObjIntDblTriple.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntCharTriple.MutObjIntCharTriple<T>	LObjIntCharTriple.MutObjIntCharTriple.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntCharTriple.MutCompObjIntCharTriple<T>	LObjIntCharTriple.MutCompObjIntCharTriple.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntByteTriple.MutObjIntByteTriple<T>	LObjIntByteTriple.MutObjIntByteTriple.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntByteTriple.MutCompObjIntByteTriple<T>	LObjIntByteTriple.MutCompObjIntByteTriple.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntBoolTriple.MutObjIntBoolTriple<T>	LObjIntBoolTriple.MutObjIntBoolTriple.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntBoolTriple.MutCompObjIntBoolTriple<T>	LObjIntBoolTriple.MutCompObjIntBoolTriple.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjBiIntTriple.MutObjBiIntTriple<T>	LObjBiIntTriple.MutObjBiIntTriple.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjBiIntTriple.MutCompObjBiIntTriple<T>	LObjBiIntTriple.MutCompObjBiIntTriple.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LLongIntPair.MutLongIntPair	LLongIntPair.MutLongIntPair.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LLongIntPair.MutCompLongIntPair	LLongIntPair.MutCompLongIntPair.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LIntPair.MutIntPair	LIntPair.MutIntPair.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LIntPair.MutCompIntPair	LIntPair.MutCompIntPair.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LFltIntPair.MutFltIntPair	LFltIntPair.MutFltIntPair.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LFltIntPair.MutCompFltIntPair	LFltIntPair.MutCompFltIntPair.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LDblIntPair.MutDblIntPair	LDblIntPair.MutDblIntPair.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LDblIntPair.MutCompDblIntPair	LDblIntPair.MutCompDblIntPair.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LCharIntPair.MutCharIntPair	LCharIntPair.MutCharIntPair.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LCharIntPair.MutCompCharIntPair	LCharIntPair.MutCompCharIntPair.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LByteIntPair.MutByteIntPair	LByteIntPair.MutByteIntPair.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LByteIntPair.MutCompByteIntPair	LByteIntPair.MutCompByteIntPair.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBoolIntPair.MutBoolIntPair	LBoolIntPair.MutBoolIntPair.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBoolIntPair.MutCompBoolIntPair	LBoolIntPair.MutCompBoolIntPair.setSecondIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjBiIntTriple.MutObjBiIntTriple<T>	LObjBiIntTriple.MutObjBiIntTriple.setThirdIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjBiIntTriple.MutCompObjBiIntTriple<T>	LObjBiIntTriple.MutCompObjBiIntTriple.setThirdIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjIntTriple.MutBiObjIntTriple<T1,T2>	LBiObjIntTriple.MutBiObjIntTriple.setThirdIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjIntTriple.MutCompBiObjIntTriple<T1,T2>	LBiObjIntTriple.MutCompBiObjIntTriple.setThirdIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LIntSingle.MutIntSingle	LIntSingle.MutIntSingle.setValueIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LIntSingle.MutCompIntSingle	LIntSingle.MutCompIntSingle.setValueIfArgNotNull(R arg, LToIntFunction<R> func) Sets value derived from non-null argument, only if argument is not null.