Uses of Interface
eu.lunisolar.magma.func.function.from.LIntFunction

Packages that use LIntFunction

Package	Description
eu.lunisolar.magma.func.consumer.primitives.bi
eu.lunisolar.magma.func.consumer.primitives.obj
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

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

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

Modifier and Type	Method and Description
static LBiIntConsumer	LBiIntConsumer.uncurry(LIntFunction<LIntConsumer> func)

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

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

Modifier and Type	Method and Description
default LIntConsumer	LObjIntConsumer.lShrink(LIntFunction<T> left)
static <T> LIntConsumer	LObjIntConsumer.lShrinked(LIntFunction<T> left, LObjIntConsumer<T> func)
static <T,C3> T	LTieBoolConsumer.ntiForEach(LIntFunction<T> trgFactory1, IndexedRead<C3,aType.aBool> ia3, C3 source3, LTieBoolConsumer<? super T> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH_NEW: FOR, [SourcePurpose{arg=T trg1, type=SIZE_FACTORY}, SourcePurpose{arg=boolean a3, type=IA}, SourcePurpose{arg=LTieBoolConsumer<? super T> consumer, type=CONST}]
static <T,C3> T	LTieByteConsumer.ntiForEach(LIntFunction<T> trgFactory1, IndexedRead<C3,aType.aByte> ia3, C3 source3, LTieByteConsumer<? super T> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH_NEW: FOR, [SourcePurpose{arg=T trg1, type=SIZE_FACTORY}, SourcePurpose{arg=byte a3, type=IA}, SourcePurpose{arg=LTieByteConsumer<? super T> consumer, type=CONST}]
static <T,C3> T	LTieCharConsumer.ntiForEach(LIntFunction<T> trgFactory1, IndexedRead<C3,aType.aChar> ia3, C3 source3, LTieCharConsumer<? super T> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH_NEW: FOR, [SourcePurpose{arg=T trg1, type=SIZE_FACTORY}, SourcePurpose{arg=char a3, type=IA}, SourcePurpose{arg=LTieCharConsumer<? super T> consumer, type=CONST}]
static <T,C3> T	LTieDblConsumer.ntiForEach(LIntFunction<T> trgFactory1, IndexedRead<C3,aType.aDouble> ia3, C3 source3, LTieDblConsumer<? super T> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH_NEW: FOR, [SourcePurpose{arg=T trg1, type=SIZE_FACTORY}, SourcePurpose{arg=double a3, type=IA}, SourcePurpose{arg=LTieDblConsumer<? super T> consumer, type=CONST}]
static <T,C3> T	LTieFltConsumer.ntiForEach(LIntFunction<T> trgFactory1, IndexedRead<C3,aType.aFloat> ia3, C3 source3, LTieFltConsumer<? super T> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH_NEW: FOR, [SourcePurpose{arg=T trg1, type=SIZE_FACTORY}, SourcePurpose{arg=float a3, type=IA}, SourcePurpose{arg=LTieFltConsumer<? super T> consumer, type=CONST}]
static <T,C3> T	LTieIntConsumer.ntiForEach(LIntFunction<T> trgFactory1, IndexedRead<C3,aType.aInt> ia3, C3 source3, LTieIntConsumer<? super T> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH_NEW: FOR, [SourcePurpose{arg=T trg1, type=SIZE_FACTORY}, SourcePurpose{arg=int a3, type=IA}, SourcePurpose{arg=LTieIntConsumer<? super T> consumer, type=CONST}]
static <T,C3> T	LTieLongConsumer.ntiForEach(LIntFunction<T> trgFactory1, IndexedRead<C3,aType.aLong> ia3, C3 source3, LTieLongConsumer<? super T> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH_NEW: FOR, [SourcePurpose{arg=T trg1, type=SIZE_FACTORY}, SourcePurpose{arg=long a3, type=IA}, SourcePurpose{arg=LTieLongConsumer<? super T> consumer, type=CONST}]
static <T,C3> T	LTieSrtConsumer.ntiForEach(LIntFunction<T> trgFactory1, IndexedRead<C3,aType.aShort> ia3, C3 source3, LTieSrtConsumer<? super T> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH_NEW: FOR, [SourcePurpose{arg=T trg1, type=SIZE_FACTORY}, SourcePurpose{arg=short a3, type=IA}, SourcePurpose{arg=LTieSrtConsumer<? super T> consumer, type=CONST}]
static <T1,C3,T2> T1	LTieConsumer.ntiForEach(LIntFunction<T1> trgFactory1, IndexedRead<C3,aType.a<T2>> ia3, C3 source3, LTieConsumer<? super T1,? super T2> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH_NEW: FOR, [SourcePurpose{arg=T1 trg1, type=SIZE_FACTORY}, SourcePurpose{arg=T2 a3, type=IA}, SourcePurpose{arg=LTieConsumer<? super T1,? super T2> consumer, type=CONST}]

Method parameters in eu.lunisolar.magma.func.consumer.primitives.obj with type arguments of type LIntFunction

Modifier and Type	Method and Description
static <T1,T2> LTieConsumer<T1,T2>	LTieConsumer.uncurry(LFunction<T1,LIntFunction<LConsumer<T2>>> func)
static <T> LTieBoolConsumer<T>	LTieBoolConsumer.uncurry(LFunction<T,LIntFunction<LBoolConsumer>> func)
static <T> LTieByteConsumer<T>	LTieByteConsumer.uncurry(LFunction<T,LIntFunction<LByteConsumer>> func)
static <T> LTieCharConsumer<T>	LTieCharConsumer.uncurry(LFunction<T,LIntFunction<LCharConsumer>> func)
static <T> LTieDblConsumer<T>	LTieDblConsumer.uncurry(LFunction<T,LIntFunction<LDblConsumer>> func)
static <T> LTieFltConsumer<T>	LTieFltConsumer.uncurry(LFunction<T,LIntFunction<LFltConsumer>> func)
static <T> LTieIntConsumer<T>	LTieIntConsumer.uncurry(LFunction<T,LIntFunction<LIntConsumer>> func)
static <T> LTieLongConsumer<T>	LTieLongConsumer.uncurry(LFunction<T,LIntFunction<LLongConsumer>> func)
static <T> LTieSrtConsumer<T>	LTieSrtConsumer.uncurry(LFunction<T,LIntFunction<LSrtConsumer>> func)

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

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

Modifier and Type	Method and Description
default <V> LIntFunction<V>	LIntToByteFunction.then(LByteFunction<? extends V> after) Combines two functions together in a order.
default <V> LIntFunction<V>	LIntToCharFunction.then(LCharFunction<? extends V> after) Combines two functions together in a order.
default <V> LIntFunction<V>	LIntToDblFunction.then(LDblFunction<? extends V> after) Combines two functions together in a order.
default <V> LIntFunction<V>	LIntToFltFunction.then(LFltFunction<? extends V> after) Combines two functions together in a order.
default <V> LIntFunction<V>	LIntToLongFunction.then(LLongFunction<? extends V> after) Combines two functions together in a order.
default <V> LIntFunction<V>	LIntToSrtFunction.then(LSrtFunction<? extends V> after) Combines two functions together in a order.

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

Modifier and Type	Method and Description
default <V> LSrtFunction<V>	LSrtToIntFunction.then(LIntFunction<? extends V> after) Combines two functions together in a order.
default <V> LLongFunction<V>	LLongToIntFunction.then(LIntFunction<? extends V> after) Combines two functions together in a order.
default <V> LFltFunction<V>	LFltToIntFunction.then(LIntFunction<? extends V> after) Combines two functions together in a order.
default <V> LDblFunction<V>	LDblToIntFunction.then(LIntFunction<? extends V> after) Combines two functions together in a order.
default <V> LCharFunction<V>	LCharToIntFunction.then(LIntFunction<? extends V> after) Combines two functions together in a order.
default <V> LByteFunction<V>	LByteToIntFunction.then(LIntFunction<? extends V> after) Combines two functions together in a order.
default <V> LBoolFunction<V>	LBoolToIntFunction.then(LIntFunction<? extends V> after) Combines two functions together in a order.

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

Classes in eu.lunisolar.magma.func.function.from that implement LIntFunction

Modifier and Type	Class and Description
static class	LIntFunction.LIntFunctionSingle<R>

Methods in eu.lunisolar.magma.func.function.from that return LIntFunction

Modifier and Type	Method and Description
default LIntFunction<R>	LIntFunction.after(LConsumer<? super R> after)
default LIntFunction<R>	LIntFunction.before(LIntConsumer before)
default <V2> LIntFunction<V2>	LIntFunction.cast() Cast that replace generics.
static <V2,R> LIntFunction<V2>	LIntFunction.cast(LIntFunction<R> function) Cast that replace generics.
default LIntFunction<R>	LIntFunction.compose(LIntUnaryOperator before) Allows to manipulate the domain of the function.
static <R> LIntFunction<R>	LIntFunction.composed(LIntUnaryOperator before, LIntFunction<R> after)
static <R> LIntFunction<R>	LIntFunction.constant(R r) Creates function that always returns the same value.
static <R> LIntFunction<R>	LIntFunction.failSafe(LIntFunction<R> func, LIntFunction<R> failSafe)
default LIntFunction<R>	LIntFunction.handling(HandlingInstructions<Throwable,RuntimeException> handling)
static <R> LIntFunction<R>	LIntFunction.intFunc(LIntFunction<R> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <R> LIntFunction<R>	LIntFunction.intFuncThrowing(ExF<Throwable> exF)
static <R> LIntFunction<R>	LIntFunction.intFuncThrowing(String message, ExMF<Throwable> exF)
default LIntFunction<R>	LOiFunction.lShrink(LIntFunction<T> left)
default LIntFunction<R>	LBiIntFunction.lShrink(LIntUnaryOperator left)
default LIntFunction<R>	LBiIntFunction.lShrinkc(int a1)
default LIntFunction<R>	LOiFunction.lShrinkc(T a1)
static <R,T> LIntFunction<R>	LOiFunction.lShrinked(LIntFunction<T> left, LOiFunction<T,R> func)
static <R> LIntFunction<R>	LBiIntFunction.lShrinked(LIntUnaryOperator left, LBiIntFunction<R> func)
static <R> LIntFunction<R>	LBiIntFunction.lShrinkedc(int a1, LBiIntFunction<R> func)
static <R,T> LIntFunction<R>	LOiFunction.lShrinkedc(T a1, LOiFunction<T,R> func)
default LIntFunction<R>	LIntFunction.nonNullable() Converts to function that makes sure that the result is not null.
static <R> LIntFunction<R>	LIntFunction.recursive(LFunction<LIntFunction<R>,LIntFunction<R>> selfLambda)
default LIntFunction<R>	LBiIntFunction.rShrink(LIntUnaryOperator right)
default LIntFunction<R>	LBiIntFunction.rShrinkc(int a2)
static <R> LIntFunction<R>	LBiIntFunction.rShrinked(LIntUnaryOperator right, LBiIntFunction<R> func)
static <R> LIntFunction<R>	LBiIntFunction.rShrinkedc(int a2, LBiIntFunction<R> func)
static <R> LIntFunction<R>	LIntFunction.safe() Safe instance.
static <R> LIntFunction<R>	LIntFunction.safe(LIntFunction<R> other) Safe wrapping.
default <V> LIntFunction<V>	LIntFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default LIntFunction<R>	LIntFunction.trying(ExWF<RuntimeException> exF)
default LIntFunction<R>	LIntFunction.trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LIntFunction<R>	LIntFunction.tryingThen(LFunction<Throwable,R> handler)
default LIntFunction	LIntFunction.untyped() Cast that removes generics.
LIntFunction<R>	LIntFunction.LIntFunctionSingle.value()
static <R> LIntFunction<R>	LIntFunction.wrap(java.util.function.IntFunction<R> other) Wraps JRE instance.

Methods in eu.lunisolar.magma.func.function.from that return types with arguments of type LIntFunction

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

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

Modifier and Type	Method and Description
static <R> LBiIntFunction<R>	LBiIntFunction.apply1st(LIntFunction<R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <R> LBiIntFunction<R>	LBiIntFunction.apply2nd(LIntFunction<R> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2,R> LObjIntObjFunction<T1,T2,R>	LObjIntObjFunction.apply2nd(LIntFunction<R> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T,R> LOiFunction<T,R>	LOiFunction.apply2nd(LIntFunction<R> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T,R> LObjIntSrtFunction<T,R>	LObjIntSrtFunction.apply2nd(LIntFunction<R> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T,R> LObjIntLongFunction<T,R>	LObjIntLongFunction.apply2nd(LIntFunction<R> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T,R> LObjIntFltFunction<T,R>	LObjIntFltFunction.apply2nd(LIntFunction<R> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T,R> LObjIntDblFunction<T,R>	LObjIntDblFunction.apply2nd(LIntFunction<R> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T,R> LObjIntCharFunction<T,R>	LObjIntCharFunction.apply2nd(LIntFunction<R> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T,R> LObjIntByteFunction<T,R>	LObjIntByteFunction.apply2nd(LIntFunction<R> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T,R> LObjIntBoolFunction<T,R>	LObjIntBoolFunction.apply2nd(LIntFunction<R> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T,R> LObjBiIntFunction<T,R>	LObjBiIntFunction.apply2nd(LIntFunction<R> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2,R> LBiObjIntFunction<T1,T2,R>	LBiObjIntFunction.apply3rd(LIntFunction<R> func) Captures single parameter function into this interface where only 3rd parameter will be used.
static <T,R> LObjBiIntFunction<T,R>	LObjBiIntFunction.apply3rd(LIntFunction<R> func) Captures single parameter function into this interface where only 3rd parameter will be used.
static <R> R	LIntFunction.call(int a, LIntFunction<R> lambda)
static <V2,R> LIntFunction<V2>	LIntFunction.cast(LIntFunction<R> function) Cast that replace generics.
static <R> LIntFunction<R>	LIntFunction.composed(LIntUnaryOperator before, LIntFunction<R> after)
static <V,R> LFunction<V,R>	LIntFunction.composed(LToIntFunction<? super V> before, LIntFunction<R> after)
static <R> LIntFunction<R>	LIntFunction.failSafe(LIntFunction<R> func, LIntFunction<R> failSafe)
static <R> LIntFunction<R>	LIntFunction.failSafe(LIntFunction<R> func, LIntFunction<R> failSafe)
default R	LIntFunction.failSafeApply(int a, LIntFunction<R> failSafe)
static <R> R	LIntFunction.failSafeApply(int a, LIntFunction<R> func, LIntFunction<R> failSafe)
static <R> R	LIntFunction.failSafeApply(int a, LIntFunction<R> func, LIntFunction<R> failSafe)
static <R> void	LIntFunction.fromTill(int min_a, int max_a, LIntFunction<R> func) From-To.
static <R> void	LIntFunction.fromTo(int min_a, int max_a, LIntFunction<R> func) From-To.
static <R> R	LIntFunction.handlingApply(int a, LIntFunction<R> func, HandlingInstructions<Throwable,RuntimeException> handling)
static <R> LIntFunction<R>	LIntFunction.intFunc(LIntFunction<R> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
default LIntFunction<R>	LOiFunction.lShrink(LIntFunction<T> left)
static <R,T> LIntFunction<R>	LOiFunction.lShrinked(LIntFunction<T> left, LOiFunction<T,R> func)
static <R> LIntFunction<R>	LIntFunction.safe(LIntFunction<R> other) Safe wrapping.
static <R> void	LIntFunction.times(int max_a, LIntFunction<R> func) From-To.
static <R> R	LIntFunction.tryApply(int a, LIntFunction<R> func)
static <R> R	LIntFunction.tryApply(int a, LIntFunction<R> func, ExWF<RuntimeException> exF)
static <R> R	LIntFunction.tryApply(int a, LIntFunction<R> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static <R> R	LIntFunction.tryApplyThen(int a, LIntFunction<R> func, LFunction<Throwable,R> handler)
static <R> LBiIntFunction<R>	LBiIntFunction.uncurry(LIntFunction<LIntFunction<R>> func)

Method parameters in eu.lunisolar.magma.func.function.from with type arguments of type LIntFunction

Modifier and Type	Method and Description
static <R> LIntFunction<R>	LIntFunction.recursive(LFunction<LIntFunction<R>,LIntFunction<R>> selfLambda)
static <R> LIntFunction<R>	LIntFunction.recursive(LFunction<LIntFunction<R>,LIntFunction<R>> selfLambda)
static <R> LSupplier<LIntFunction<R>>	LIntFunction.safeSupplier(LSupplier<LIntFunction<R>> supplier) Safe supplier.
static <T1,T2,R> LBiObjIntFunction<T1,T2,R>	LBiObjIntFunction.uncurry(LFunction<T1,LFunction<T2,LIntFunction<R>>> func)
static <T1,T2,R> LObjIntObjFunction<T1,T2,R>	LObjIntObjFunction.uncurry(LFunction<T1,LIntFunction<LFunction<T2,R>>> func)
static <T,R> LObjIntBoolFunction<T,R>	LObjIntBoolFunction.uncurry(LFunction<T,LIntFunction<LBoolFunction<R>>> func)
static <T,R> LObjIntByteFunction<T,R>	LObjIntByteFunction.uncurry(LFunction<T,LIntFunction<LByteFunction<R>>> func)
static <T,R> LObjIntCharFunction<T,R>	LObjIntCharFunction.uncurry(LFunction<T,LIntFunction<LCharFunction<R>>> func)
static <T,R> LObjIntDblFunction<T,R>	LObjIntDblFunction.uncurry(LFunction<T,LIntFunction<LDblFunction<R>>> func)
static <T,R> LObjIntFltFunction<T,R>	LObjIntFltFunction.uncurry(LFunction<T,LIntFunction<LFltFunction<R>>> func)
static <T,R> LObjBiIntFunction<T,R>	LObjBiIntFunction.uncurry(LFunction<T,LIntFunction<LIntFunction<R>>> func)
static <T,R> LObjBiIntFunction<T,R>	LObjBiIntFunction.uncurry(LFunction<T,LIntFunction<LIntFunction<R>>> func)
static <T,R> LObjIntLongFunction<T,R>	LObjIntLongFunction.uncurry(LFunction<T,LIntFunction<LLongFunction<R>>> func)
static <T,R> LObjIntSrtFunction<T,R>	LObjIntSrtFunction.uncurry(LFunction<T,LIntFunction<LSrtFunction<R>>> func)
static <T,R> LOiFunction<T,R>	LOiFunction.uncurry(LFunction<T,LIntFunction<R>> func)
static <R> LBiIntFunction<R>	LBiIntFunction.uncurry(LIntFunction<LIntFunction<R>> func)

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

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

Modifier and Type	Method and Description
default LIntToSrtFunction	LOiToSrtFunction.lShrink(LIntFunction<T> left)
default LIntToLongFunction	LOiToLongFunction.lShrink(LIntFunction<T> left)
default LIntUnaryOperator	LOiToIntFunction.lShrink(LIntFunction<T> left)
default LIntToFltFunction	LOiToFltFunction.lShrink(LIntFunction<T> left)
default LIntToDblFunction	LOiToDblFunction.lShrink(LIntFunction<T> left)
default LIntToCharFunction	LOiToCharFunction.lShrink(LIntFunction<T> left)
default LIntToByteFunction	LOiToByteFunction.lShrink(LIntFunction<T> left)
static <T> LIntToByteFunction	LOiToByteFunction.lShrinked(LIntFunction<T> left, LOiToByteFunction<T> func)
static <T> LIntToCharFunction	LOiToCharFunction.lShrinked(LIntFunction<T> left, LOiToCharFunction<T> func)
static <T> LIntToDblFunction	LOiToDblFunction.lShrinked(LIntFunction<T> left, LOiToDblFunction<T> func)
static <T> LIntToFltFunction	LOiToFltFunction.lShrinked(LIntFunction<T> left, LOiToFltFunction<T> func)
static <T> LIntUnaryOperator	LOiToIntFunction.lShrinked(LIntFunction<T> left, LOiToIntFunction<T> func)
static <T> LIntToLongFunction	LOiToLongFunction.lShrinked(LIntFunction<T> left, LOiToLongFunction<T> func)
static <T> LIntToSrtFunction	LOiToSrtFunction.lShrinked(LIntFunction<T> left, LOiToSrtFunction<T> func)
static <T,C3> T	LTieBoolFunction.ntiForEach(LIntFunction<T> trgFactory1, IndexedRead<C3,aType.aBool> ia3, C3 source3, LTieBoolFunction<? super T> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH_NEW: FOR, [SourcePurpose{arg=T trg1, type=SIZE_FACTORY}, SourcePurpose{arg=boolean a3, type=IA}, SourcePurpose{arg=LTieBoolFunction<? super T> consumer, type=CONST}]
static <T,C3> T	LTieByteFunction.ntiForEach(LIntFunction<T> trgFactory1, IndexedRead<C3,aType.aByte> ia3, C3 source3, LTieByteFunction<? super T> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH_NEW: FOR, [SourcePurpose{arg=T trg1, type=SIZE_FACTORY}, SourcePurpose{arg=byte a3, type=IA}, SourcePurpose{arg=LTieByteFunction<? super T> consumer, type=CONST}]
static <T,C3> T	LTieCharFunction.ntiForEach(LIntFunction<T> trgFactory1, IndexedRead<C3,aType.aChar> ia3, C3 source3, LTieCharFunction<? super T> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH_NEW: FOR, [SourcePurpose{arg=T trg1, type=SIZE_FACTORY}, SourcePurpose{arg=char a3, type=IA}, SourcePurpose{arg=LTieCharFunction<? super T> consumer, type=CONST}]
static <T,C3> T	LTieDblFunction.ntiForEach(LIntFunction<T> trgFactory1, IndexedRead<C3,aType.aDouble> ia3, C3 source3, LTieDblFunction<? super T> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH_NEW: FOR, [SourcePurpose{arg=T trg1, type=SIZE_FACTORY}, SourcePurpose{arg=double a3, type=IA}, SourcePurpose{arg=LTieDblFunction<? super T> consumer, type=CONST}]
static <T,C3> T	LTieFltFunction.ntiForEach(LIntFunction<T> trgFactory1, IndexedRead<C3,aType.aFloat> ia3, C3 source3, LTieFltFunction<? super T> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH_NEW: FOR, [SourcePurpose{arg=T trg1, type=SIZE_FACTORY}, SourcePurpose{arg=float a3, type=IA}, SourcePurpose{arg=LTieFltFunction<? super T> consumer, type=CONST}]
static <T,C3> T	LTieIntFunction.ntiForEach(LIntFunction<T> trgFactory1, IndexedRead<C3,aType.aInt> ia3, C3 source3, LTieIntFunction<? super T> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH_NEW: FOR, [SourcePurpose{arg=T trg1, type=SIZE_FACTORY}, SourcePurpose{arg=int a3, type=IA}, SourcePurpose{arg=LTieIntFunction<? super T> consumer, type=CONST}]
static <T,C3> T	LTieLongFunction.ntiForEach(LIntFunction<T> trgFactory1, IndexedRead<C3,aType.aLong> ia3, C3 source3, LTieLongFunction<? super T> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH_NEW: FOR, [SourcePurpose{arg=T trg1, type=SIZE_FACTORY}, SourcePurpose{arg=long a3, type=IA}, SourcePurpose{arg=LTieLongFunction<? super T> consumer, type=CONST}]
static <T,C3> T	LTieSrtFunction.ntiForEach(LIntFunction<T> trgFactory1, IndexedRead<C3,aType.aShort> ia3, C3 source3, LTieSrtFunction<? super T> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH_NEW: FOR, [SourcePurpose{arg=T trg1, type=SIZE_FACTORY}, SourcePurpose{arg=short a3, type=IA}, SourcePurpose{arg=LTieSrtFunction<? super T> consumer, type=CONST}]
static <T1,C3,T2> T1	LTieFunction.ntiForEach(LIntFunction<T1> trgFactory1, IndexedRead<C3,aType.a<T2>> ia3, C3 source3, LTieFunction<? super T1,? super T2> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH_NEW: FOR, [SourcePurpose{arg=T1 trg1, type=SIZE_FACTORY}, SourcePurpose{arg=T2 a3, type=IA}, SourcePurpose{arg=LTieFunction<? super T1,? super T2> consumer, type=CONST}]
default <V> LTriFunction<T1,T2,T3,V>	LToIntTriFunction.then(LIntFunction<? extends V> after) Combines two functions together in a order.
default <V> LFunction<T,V>	LToIntFunction.then(LIntFunction<? extends V> after) Combines two functions together in a order.
default <V> LBiFunction<T1,T2,V>	LToIntBiFunction.then(LIntFunction<? extends V> after) Combines two functions together in a order.
default <V> LObjIntSrtFunction<T,V>	LTieSrtFunction.then(LIntFunction<? extends V> after) Combines two functions together in a order.
default <V> LObjIntLongFunction<T,V>	LTieLongFunction.then(LIntFunction<? extends V> after) Combines two functions together in a order.
default <V> LObjBiIntFunction<T,V>	LTieIntFunction.then(LIntFunction<? extends V> after) Combines two functions together in a order.
default <V> LObjIntObjFunction<T1,T2,V>	LTieFunction.then(LIntFunction<? extends V> after) Combines two functions together in a order.
default <V> LObjIntFltFunction<T,V>	LTieFltFunction.then(LIntFunction<? extends V> after) Combines two functions together in a order.
default <V> LObjIntDblFunction<T,V>	LTieDblFunction.then(LIntFunction<? extends V> after) Combines two functions together in a order.
default <V> LObjIntCharFunction<T,V>	LTieCharFunction.then(LIntFunction<? extends V> after) Combines two functions together in a order.
default <V> LObjIntByteFunction<T,V>	LTieByteFunction.then(LIntFunction<? extends V> after) Combines two functions together in a order.
default <V> LObjIntBoolFunction<T,V>	LTieBoolFunction.then(LIntFunction<? extends V> after) Combines two functions together in a order.
default <V> LOiFunction<T,V>	LOiToIntFunction.then(LIntFunction<? extends V> after) Combines two functions together in a order.

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

Modifier and Type	Method and Description
static <T1,T2> LTieFunction<T1,T2>	LTieFunction.uncurry(LFunction<T1,LIntFunction<LToIntFunction<T2>>> func)
static <T> LTieBoolFunction<T>	LTieBoolFunction.uncurry(LFunction<T,LIntFunction<LBoolToIntFunction>> func)
static <T> LTieByteFunction<T>	LTieByteFunction.uncurry(LFunction<T,LIntFunction<LByteToIntFunction>> func)
static <T> LTieCharFunction<T>	LTieCharFunction.uncurry(LFunction<T,LIntFunction<LCharToIntFunction>> func)
static <T> LTieDblFunction<T>	LTieDblFunction.uncurry(LFunction<T,LIntFunction<LDblToIntFunction>> func)
static <T> LTieFltFunction<T>	LTieFltFunction.uncurry(LFunction<T,LIntFunction<LFltToIntFunction>> func)
static <T> LTieIntFunction<T>	LTieIntFunction.uncurry(LFunction<T,LIntFunction<LIntUnaryOperator>> func)
static <T> LTieLongFunction<T>	LTieLongFunction.uncurry(LFunction<T,LIntFunction<LLongToIntFunction>> func)
static <T> LTieSrtFunction<T>	LTieSrtFunction.uncurry(LFunction<T,LIntFunction<LSrtToIntFunction>> func)

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

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

Modifier and Type	Method and Description
default <V> LBiIntFunction<V>	LIntBinaryOperator.then(LIntFunction<? extends V> after) Combines two functions together in a order.
static LIntBinaryOperator	LIntBinaryOperator.uncurry(LIntFunction<LIntUnaryOperator> func)

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

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

Modifier and Type	Method and Description
default <V> LIntFunction<V>	LIntUnaryOperator.then(LIntFunction<? extends V> after) Combines two functions together in a order.

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

Modifier and Type	Method and Description
default <V> LIntFunction<V>	LIntUnaryOperator.then(LIntFunction<? extends V> after) Combines two functions together in a order.

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

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

Modifier and Type	Method and Description
default <V> LIntFunction<V>	LIntPredicate.boolToIntFunc(LBoolFunction<? extends V> after) Combines two functions together in a order.

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

Modifier and Type	Method and Description
default LIntPredicate	LObjIntPredicate.lShrink(LIntFunction<T> left)
static <T> LIntPredicate	LObjIntPredicate.lShrinked(LIntFunction<T> left, LObjIntPredicate<T> func)
static LBiIntPredicate	LBiIntPredicate.uncurry(LIntFunction<LIntPredicate> func)

Method parameters in eu.lunisolar.magma.func.predicate with type arguments of type LIntFunction

Modifier and Type	Method and Description
static <T1,T2> LObjIntObjPredicate<T1,T2>	LObjIntObjPredicate.uncurry(LFunction<T1,LIntFunction<LPredicate<T2>>> func)
static <T> LObjIntBytePredicate<T>	LObjIntBytePredicate.uncurry(LFunction<T,LIntFunction<LBytePredicate>> func)
static <T> LObjIntCharPredicate<T>	LObjIntCharPredicate.uncurry(LFunction<T,LIntFunction<LCharPredicate>> func)
static <T> LObjIntDblPredicate<T>	LObjIntDblPredicate.uncurry(LFunction<T,LIntFunction<LDblPredicate>> func)
static <T> LObjIntFltPredicate<T>	LObjIntFltPredicate.uncurry(LFunction<T,LIntFunction<LFltPredicate>> func)
static <T> LObjBiIntPredicate<T>	LObjBiIntPredicate.uncurry(LFunction<T,LIntFunction<LIntPredicate>> func)
static <T> LObjIntBoolPredicate<T>	LObjIntBoolPredicate.uncurry(LFunction<T,LIntFunction<LLogicalOperator>> func)
static <T> LObjIntLongPredicate<T>	LObjIntLongPredicate.uncurry(LFunction<T,LIntFunction<LLongPredicate>> func)
static <T> LObjIntSrtPredicate<T>	LObjIntSrtPredicate.uncurry(LFunction<T,LIntFunction<LSrtPredicate>> func)

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

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

Modifier and Type	Method and Description
default <V> LSupplier<V>	LIntSupplier.toSup(LIntFunction<? extends V> after) Combines two functions together in a order.