Uses of Interface
eu.lunisolar.magma.func.function.LFunction

Packages that use LFunction

Package	Description
eu.lunisolar.magma.func	Functional interfaces / lambdas
eu.lunisolar.magma.func.action
eu.lunisolar.magma.func.consumer
eu.lunisolar.magma.func.consumer.primitives
eu.lunisolar.magma.func.consumer.primitives.bi
eu.lunisolar.magma.func.consumer.primitives.obj
eu.lunisolar.magma.func.consumer.primitives.tri
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 LFunction in eu.lunisolar.magma.func

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

Modifier and Type	Method and Description
LFunction<C,I>	SA.The.genericAdapter()

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

Modifier and Type	Method and Description
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 LFunction

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

Uses of LFunction in eu.lunisolar.magma.func.action

Methods in eu.lunisolar.magma.func.action with parameters of type LFunction

Modifier and Type	Method and Description
static LAction	LAction.recursive(LFunction<LAction,LAction> selfLambda)

Uses of LFunction in eu.lunisolar.magma.func.consumer

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

Modifier and Type	Method and Description
default <V> LConsumer<V>	LConsumer.compose(LFunction<? super V,? extends T> before) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LBiConsumer.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LBiConsumer.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LTriConsumer.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LTriConsumer.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LTriConsumer.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3) Allows to manipulate the domain of the function.
static <V,T> LConsumer<V>	LConsumer.composed(LFunction<? super V,? extends T> before, LConsumer<T> after)
static <V1,V2,T1,T2> LBiConsumer<V1,V2>	LBiConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LBiConsumer<T1,T2> after)
static <V1,V2,T1,T2> LBiConsumer<V1,V2>	LBiConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LBiConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2,T3> LTriConsumer<V1,V2,V3>	LTriConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3, LTriConsumer<T1,T2,T3> after)
static <V1,V2,V3,T1,T2,T3> LTriConsumer<V1,V2,V3>	LTriConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3, LTriConsumer<T1,T2,T3> after)
static <V1,V2,V3,T1,T2,T3> LTriConsumer<V1,V2,V3>	LTriConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3, LTriConsumer<T1,T2,T3> after)
default LConsumer<T2>	LBiConsumer.lShrink(LFunction<T2,T1> left)
static <T2,T1> LConsumer<T2>	LBiConsumer.lShrinked(LFunction<T2,T1> left, LBiConsumer<T1,T2> func)
static <T1,T2> LBiConsumer<T1,T2>	LBiConsumer.recursive(LFunction<LBiConsumer<T1,T2>,LBiConsumer<T1,T2>> selfLambda)
static <T> LConsumer<T>	LConsumer.recursive(LFunction<LConsumer<T>,LConsumer<T>> selfLambda)
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.recursive(LFunction<LTriConsumer<T1,T2,T3>,LTriConsumer<T1,T2,T3>> selfLambda)
default LConsumer<T1>	LBiConsumer.rShrink(LFunction<T1,T2> right)
static <T1,T2> LConsumer<T1>	LBiConsumer.rShrinked(LFunction<T1,T2> right, LBiConsumer<T1,T2> func)
static <T1,T2> LBiConsumer<T1,T2>	LBiConsumer.uncurry(LFunction<T1,LConsumer<T2>> func)
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.uncurry(LFunction<T1,LFunction<T2,LConsumer<T3>>> func)

Method parameters in eu.lunisolar.magma.func.consumer with type arguments of type LFunction

Modifier and Type	Method and Description
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.uncurry(LFunction<T1,LFunction<T2,LConsumer<T3>>> func)

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

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

Modifier and Type	Method and Description
static LBoolConsumer	LBoolConsumer.recursive(LFunction<LBoolConsumer,LBoolConsumer> selfLambda)
static LByteConsumer	LByteConsumer.recursive(LFunction<LByteConsumer,LByteConsumer> selfLambda)
static LCharConsumer	LCharConsumer.recursive(LFunction<LCharConsumer,LCharConsumer> selfLambda)
static LDblConsumer	LDblConsumer.recursive(LFunction<LDblConsumer,LDblConsumer> selfLambda)
static LFltConsumer	LFltConsumer.recursive(LFunction<LFltConsumer,LFltConsumer> selfLambda)
static LIntConsumer	LIntConsumer.recursive(LFunction<LIntConsumer,LIntConsumer> selfLambda)
static LLongConsumer	LLongConsumer.recursive(LFunction<LLongConsumer,LLongConsumer> selfLambda)
static LSrtConsumer	LSrtConsumer.recursive(LFunction<LSrtConsumer,LSrtConsumer> selfLambda)

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

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

Modifier and Type	Method and Description
static LBiBoolConsumer	LBiBoolConsumer.recursive(LFunction<LBiBoolConsumer,LBiBoolConsumer> selfLambda)
static LBiByteConsumer	LBiByteConsumer.recursive(LFunction<LBiByteConsumer,LBiByteConsumer> selfLambda)
static LBiCharConsumer	LBiCharConsumer.recursive(LFunction<LBiCharConsumer,LBiCharConsumer> selfLambda)
static LBiDblConsumer	LBiDblConsumer.recursive(LFunction<LBiDblConsumer,LBiDblConsumer> selfLambda)
static LBiFltConsumer	LBiFltConsumer.recursive(LFunction<LBiFltConsumer,LBiFltConsumer> selfLambda)
static LBiIntConsumer	LBiIntConsumer.recursive(LFunction<LBiIntConsumer,LBiIntConsumer> selfLambda)
static LBiLongConsumer	LBiLongConsumer.recursive(LFunction<LBiLongConsumer,LBiLongConsumer> selfLambda)
static LBiSrtConsumer	LBiSrtConsumer.recursive(LFunction<LBiSrtConsumer,LBiSrtConsumer> selfLambda)
static LBoolIntConsumer	LBoolIntConsumer.recursive(LFunction<LBoolIntConsumer,LBoolIntConsumer> selfLambda)
static LByteIntConsumer	LByteIntConsumer.recursive(LFunction<LByteIntConsumer,LByteIntConsumer> selfLambda)
static LCharIntConsumer	LCharIntConsumer.recursive(LFunction<LCharIntConsumer,LCharIntConsumer> selfLambda)
static LDblIntConsumer	LDblIntConsumer.recursive(LFunction<LDblIntConsumer,LDblIntConsumer> selfLambda)
static LFltIntConsumer	LFltIntConsumer.recursive(LFunction<LFltIntConsumer,LFltIntConsumer> selfLambda)
static LLongIntConsumer	LLongIntConsumer.recursive(LFunction<LLongIntConsumer,LLongIntConsumer> selfLambda)
static LSrtIntConsumer	LSrtIntConsumer.recursive(LFunction<LSrtIntConsumer,LSrtIntConsumer> selfLambda)

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

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

Modifier and Type	Method and Description
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjBoolConsumer.biObjBoolConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LPredicate<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjBoolConsumer.biObjBoolConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LPredicate<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjByteConsumer.biObjByteConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjByteConsumer.biObjByteConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjCharConsumer.biObjCharConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToCharFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjCharConsumer.biObjCharConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToCharFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjDblConsumer.biObjDblConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjDblConsumer.biObjDblConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjFltConsumer.biObjFltConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjFltConsumer.biObjFltConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3) Allows to manipulate the domain of the function.
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.
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.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjLongConsumer.biObjLongConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjLongConsumer.biObjLongConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjSrtConsumer.biObjSrtConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjSrtConsumer.biObjSrtConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1> LObjByteConsumer<V1>	LObjByteConsumer.compose(LFunction<? super V1,? extends T> before1, LByteUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LObjCharConsumer<V1>	LObjCharConsumer.compose(LFunction<? super V1,? extends T> before1, LCharUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LObjDblConsumer<V1>	LObjDblConsumer.compose(LFunction<? super V1,? extends T> before1, LDblUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LObjFltConsumer<V1>	LObjFltConsumer.compose(LFunction<? super V1,? extends T> before1, LFltUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LObjIntConsumer<V1>	LObjIntConsumer.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LTieByteConsumer<V1>	LTieByteConsumer.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LByteUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieCharConsumer<V1>	LTieCharConsumer.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LCharUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieDblConsumer<V1>	LTieDblConsumer.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LDblUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieFltConsumer<V1>	LTieFltConsumer.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LFltUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieIntConsumer<V1>	LTieIntConsumer.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LIntUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieBoolConsumer<V1>	LTieBoolConsumer.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLogicalOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieLongConsumer<V1>	LTieLongConsumer.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLongUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieSrtConsumer<V1>	LTieSrtConsumer.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LSrtUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjBoolConsumer<V1>	LObjBoolConsumer.compose(LFunction<? super V1,? extends T> before1, LLogicalOperator before2) Allows to manipulate the domain of the function.
default <V1> LObjLongConsumer<V1>	LObjLongConsumer.compose(LFunction<? super V1,? extends T> before1, LLongUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LObjSrtConsumer<V1>	LObjSrtConsumer.compose(LFunction<? super V1,? extends T> before1, LSrtUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjByteConsumer<V1,V2>	LBiObjByteConsumer.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LByteUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjByteConsumer<V1,V2>	LBiObjByteConsumer.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LByteUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjCharConsumer<V1,V2>	LBiObjCharConsumer.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LCharUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjCharConsumer<V1,V2>	LBiObjCharConsumer.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LCharUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjDblConsumer<V1,V2>	LBiObjDblConsumer.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LDblUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjDblConsumer<V1,V2>	LBiObjDblConsumer.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LDblUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjFltConsumer<V1,V2>	LBiObjFltConsumer.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFltUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjFltConsumer<V1,V2>	LBiObjFltConsumer.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFltUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjIntConsumer<V1,V2>	LBiObjIntConsumer.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LIntUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjIntConsumer<V1,V2>	LBiObjIntConsumer.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LIntUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjBoolConsumer<V1,V2>	LBiObjBoolConsumer.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLogicalOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjBoolConsumer<V1,V2>	LBiObjBoolConsumer.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLogicalOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjLongConsumer<V1,V2>	LBiObjLongConsumer.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLongUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjLongConsumer<V1,V2>	LBiObjLongConsumer.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLongUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjSrtConsumer<V1,V2>	LBiObjSrtConsumer.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LSrtUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjSrtConsumer<V1,V2>	LBiObjSrtConsumer.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LSrtUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V3> LTieConsumer<V1,V3>	LTieConsumer.compose(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3) Allows to manipulate the domain of the function.
default <V1,V3> LTieConsumer<V1,V3>	LTieConsumer.compose(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3) Allows to manipulate the domain of the function.
static <V1,T> LObjByteConsumer<V1>	LObjByteConsumer.composed(LFunction<? super V1,? extends T> before1, LByteUnaryOperator before2, LObjByteConsumer<T> after)
static <V1,T> LObjCharConsumer<V1>	LObjCharConsumer.composed(LFunction<? super V1,? extends T> before1, LCharUnaryOperator before2, LObjCharConsumer<T> after)
static <V1,T> LObjDblConsumer<V1>	LObjDblConsumer.composed(LFunction<? super V1,? extends T> before1, LDblUnaryOperator before2, LObjDblConsumer<T> after)
static <V1,T> LObjFltConsumer<V1>	LObjFltConsumer.composed(LFunction<? super V1,? extends T> before1, LFltUnaryOperator before2, LObjFltConsumer<T> after)
static <V1,T> LTieByteConsumer<V1>	LTieByteConsumer.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LByteUnaryOperator before3, LTieByteConsumer<T> after)
static <V1,T> LTieCharConsumer<V1>	LTieCharConsumer.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LCharUnaryOperator before3, LTieCharConsumer<T> after)
static <V1,T> LTieDblConsumer<V1>	LTieDblConsumer.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LDblUnaryOperator before3, LTieDblConsumer<T> after)
static <V1,T> LTieFltConsumer<V1>	LTieFltConsumer.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LFltUnaryOperator before3, LTieFltConsumer<T> after)
static <V1,T> LTieIntConsumer<V1>	LTieIntConsumer.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LIntUnaryOperator before3, LTieIntConsumer<T> after)
static <V1,T> LTieBoolConsumer<V1>	LTieBoolConsumer.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLogicalOperator before3, LTieBoolConsumer<T> after)
static <V1,T> LTieLongConsumer<V1>	LTieLongConsumer.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLongUnaryOperator before3, LTieLongConsumer<T> after)
static <V1,T> LObjIntConsumer<V1>	LObjIntConsumer.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LObjIntConsumer<T> after)
static <V1,T> LTieSrtConsumer<V1>	LTieSrtConsumer.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LSrtUnaryOperator before3, LTieSrtConsumer<T> after)
static <V1,T> LObjBoolConsumer<V1>	LObjBoolConsumer.composed(LFunction<? super V1,? extends T> before1, LLogicalOperator before2, LObjBoolConsumer<T> after)
static <V1,T> LObjLongConsumer<V1>	LObjLongConsumer.composed(LFunction<? super V1,? extends T> before1, LLongUnaryOperator before2, LObjLongConsumer<T> after)
static <V1,V2,T> LBiConsumer<V1,V2>	LObjBoolConsumer.composed(LFunction<? super V1,? extends T> before1, LPredicate<? super V2> before2, LObjBoolConsumer<T> after)
static <V1,T> LObjSrtConsumer<V1>	LObjSrtConsumer.composed(LFunction<? super V1,? extends T> before1, LSrtUnaryOperator before2, LObjSrtConsumer<T> after)
static <V1,V2,T> LBiConsumer<V1,V2>	LObjByteConsumer.composed(LFunction<? super V1,? extends T> before1, LToByteFunction<? super V2> before2, LObjByteConsumer<T> after)
static <V1,V2,T> LBiConsumer<V1,V2>	LObjCharConsumer.composed(LFunction<? super V1,? extends T> before1, LToCharFunction<? super V2> before2, LObjCharConsumer<T> after)
static <V1,V2,T> LBiConsumer<V1,V2>	LObjDblConsumer.composed(LFunction<? super V1,? extends T> before1, LToDblFunction<? super V2> before2, LObjDblConsumer<T> after)
static <V1,V2,T> LBiConsumer<V1,V2>	LObjFltConsumer.composed(LFunction<? super V1,? extends T> before1, LToFltFunction<? super V2> before2, LObjFltConsumer<T> after)
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>	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,T> LBiConsumer<V1,V2>	LObjLongConsumer.composed(LFunction<? super V1,? extends T> before1, LToLongFunction<? super V2> before2, LObjLongConsumer<T> after)
static <V1,V2,T> LBiConsumer<V1,V2>	LObjSrtConsumer.composed(LFunction<? super V1,? extends T> before1, LToSrtFunction<? super V2> before2, LObjSrtConsumer<T> after)
static <V1,V2,T1,T2> LBiObjByteConsumer<V1,V2>	LBiObjByteConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LByteUnaryOperator before3, LBiObjByteConsumer<T1,T2> after)
static <V1,V2,T1,T2> LBiObjByteConsumer<V1,V2>	LBiObjByteConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LByteUnaryOperator before3, LBiObjByteConsumer<T1,T2> after)
static <V1,V2,T1,T2> LBiObjCharConsumer<V1,V2>	LBiObjCharConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LCharUnaryOperator before3, LBiObjCharConsumer<T1,T2> after)
static <V1,V2,T1,T2> LBiObjCharConsumer<V1,V2>	LBiObjCharConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LCharUnaryOperator before3, LBiObjCharConsumer<T1,T2> after)
static <V1,V2,T1,T2> LBiObjDblConsumer<V1,V2>	LBiObjDblConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LDblUnaryOperator before3, LBiObjDblConsumer<T1,T2> after)
static <V1,V2,T1,T2> LBiObjDblConsumer<V1,V2>	LBiObjDblConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LDblUnaryOperator before3, LBiObjDblConsumer<T1,T2> after)
static <V1,V2,T1,T2> LBiObjFltConsumer<V1,V2>	LBiObjFltConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFltUnaryOperator before3, LBiObjFltConsumer<T1,T2> after)
static <V1,V2,T1,T2> LBiObjFltConsumer<V1,V2>	LBiObjFltConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFltUnaryOperator before3, LBiObjFltConsumer<T1,T2> after)
static <V1,V2,T1,T2> LBiObjIntConsumer<V1,V2>	LBiObjIntConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LIntUnaryOperator before3, LBiObjIntConsumer<T1,T2> after)
static <V1,V2,T1,T2> LBiObjIntConsumer<V1,V2>	LBiObjIntConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LIntUnaryOperator before3, LBiObjIntConsumer<T1,T2> after)
static <V1,V2,T1,T2> LBiObjBoolConsumer<V1,V2>	LBiObjBoolConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLogicalOperator before3, LBiObjBoolConsumer<T1,T2> after)
static <V1,V2,T1,T2> LBiObjBoolConsumer<V1,V2>	LBiObjBoolConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLogicalOperator before3, LBiObjBoolConsumer<T1,T2> after)
static <V1,V2,T1,T2> LBiObjLongConsumer<V1,V2>	LBiObjLongConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLongUnaryOperator before3, LBiObjLongConsumer<T1,T2> after)
static <V1,V2,T1,T2> LBiObjLongConsumer<V1,V2>	LBiObjLongConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLongUnaryOperator before3, LBiObjLongConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjBoolConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LPredicate<? super V3> before3, LBiObjBoolConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjBoolConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LPredicate<? super V3> before3, LBiObjBoolConsumer<T1,T2> after)
static <V1,V2,T1,T2> LBiObjSrtConsumer<V1,V2>	LBiObjSrtConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LSrtUnaryOperator before3, LBiObjSrtConsumer<T1,T2> after)
static <V1,V2,T1,T2> LBiObjSrtConsumer<V1,V2>	LBiObjSrtConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LSrtUnaryOperator before3, LBiObjSrtConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjByteConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3, LBiObjByteConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjByteConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3, LBiObjByteConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjCharConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToCharFunction<? super V3> before3, LBiObjCharConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjCharConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToCharFunction<? super V3> before3, LBiObjCharConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjDblConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblFunction<? super V3> before3, LBiObjDblConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjDblConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblFunction<? super V3> before3, LBiObjDblConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjFltConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3, LBiObjFltConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjFltConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3, LBiObjFltConsumer<T1,T2> 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>	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>	LBiObjLongConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3, LBiObjLongConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjLongConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3, LBiObjLongConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjSrtConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3, LBiObjSrtConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjSrtConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3, LBiObjSrtConsumer<T1,T2> after)
static <V1,V3,T1,T2> LTieConsumer<V1,V3>	LTieConsumer.composed(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3, LTieConsumer<T1,T2> after)
static <V1,V3,T1,T2> LTieConsumer<V1,V3>	LTieConsumer.composed(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3, LTieConsumer<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)
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>	LObjBoolConsumer.objBoolConsCompose(LFunction<? super V1,? extends T> before1, LPredicate<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LObjByteConsumer.objByteConsCompose(LFunction<? super V1,? extends T> before1, LToByteFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LObjCharConsumer.objCharConsCompose(LFunction<? super V1,? extends T> before1, LToCharFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LObjDblConsumer.objDblConsCompose(LFunction<? super V1,? extends T> before1, LToDblFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LObjFltConsumer.objFltConsCompose(LFunction<? super V1,? extends T> before1, LToFltFunction<? super V2> before2) Allows to manipulate the domain of the function.
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 <V1,V2> LBiConsumer<V1,V2>	LObjLongConsumer.objLongConsCompose(LFunction<? super V1,? extends T> before1, LToLongFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LObjSrtConsumer.objSrtConsCompose(LFunction<? super V1,? extends T> before1, LToSrtFunction<? super V2> before2) Allows to manipulate the domain of the function.
static <T1,T2> LBiObjBoolConsumer<T1,T2>	LBiObjBoolConsumer.recursive(LFunction<LBiObjBoolConsumer<T1,T2>,LBiObjBoolConsumer<T1,T2>> selfLambda)
static <T1,T2> LBiObjByteConsumer<T1,T2>	LBiObjByteConsumer.recursive(LFunction<LBiObjByteConsumer<T1,T2>,LBiObjByteConsumer<T1,T2>> selfLambda)
static <T1,T2> LBiObjCharConsumer<T1,T2>	LBiObjCharConsumer.recursive(LFunction<LBiObjCharConsumer<T1,T2>,LBiObjCharConsumer<T1,T2>> selfLambda)
static <T1,T2> LBiObjDblConsumer<T1,T2>	LBiObjDblConsumer.recursive(LFunction<LBiObjDblConsumer<T1,T2>,LBiObjDblConsumer<T1,T2>> selfLambda)
static <T1,T2> LBiObjFltConsumer<T1,T2>	LBiObjFltConsumer.recursive(LFunction<LBiObjFltConsumer<T1,T2>,LBiObjFltConsumer<T1,T2>> selfLambda)
static <T1,T2> LBiObjIntConsumer<T1,T2>	LBiObjIntConsumer.recursive(LFunction<LBiObjIntConsumer<T1,T2>,LBiObjIntConsumer<T1,T2>> selfLambda)
static <T1,T2> LBiObjLongConsumer<T1,T2>	LBiObjLongConsumer.recursive(LFunction<LBiObjLongConsumer<T1,T2>,LBiObjLongConsumer<T1,T2>> selfLambda)
static <T1,T2> LBiObjSrtConsumer<T1,T2>	LBiObjSrtConsumer.recursive(LFunction<LBiObjSrtConsumer<T1,T2>,LBiObjSrtConsumer<T1,T2>> selfLambda)
static <T> LObjBoolConsumer<T>	LObjBoolConsumer.recursive(LFunction<LObjBoolConsumer<T>,LObjBoolConsumer<T>> selfLambda)
static <T> LObjByteConsumer<T>	LObjByteConsumer.recursive(LFunction<LObjByteConsumer<T>,LObjByteConsumer<T>> selfLambda)
static <T> LObjCharConsumer<T>	LObjCharConsumer.recursive(LFunction<LObjCharConsumer<T>,LObjCharConsumer<T>> selfLambda)
static <T> LObjDblConsumer<T>	LObjDblConsumer.recursive(LFunction<LObjDblConsumer<T>,LObjDblConsumer<T>> selfLambda)
static <T> LObjFltConsumer<T>	LObjFltConsumer.recursive(LFunction<LObjFltConsumer<T>,LObjFltConsumer<T>> selfLambda)
static <T> LObjIntConsumer<T>	LObjIntConsumer.recursive(LFunction<LObjIntConsumer<T>,LObjIntConsumer<T>> selfLambda)
static <T> LObjLongConsumer<T>	LObjLongConsumer.recursive(LFunction<LObjLongConsumer<T>,LObjLongConsumer<T>> selfLambda)
static <T> LObjSrtConsumer<T>	LObjSrtConsumer.recursive(LFunction<LObjSrtConsumer<T>,LObjSrtConsumer<T>> selfLambda)
static <T> LTieBoolConsumer<T>	LTieBoolConsumer.recursive(LFunction<LTieBoolConsumer<T>,LTieBoolConsumer<T>> selfLambda)
static <T> LTieByteConsumer<T>	LTieByteConsumer.recursive(LFunction<LTieByteConsumer<T>,LTieByteConsumer<T>> selfLambda)
static <T> LTieCharConsumer<T>	LTieCharConsumer.recursive(LFunction<LTieCharConsumer<T>,LTieCharConsumer<T>> selfLambda)
static <T1,T2> LTieConsumer<T1,T2>	LTieConsumer.recursive(LFunction<LTieConsumer<T1,T2>,LTieConsumer<T1,T2>> selfLambda)
static <T> LTieDblConsumer<T>	LTieDblConsumer.recursive(LFunction<LTieDblConsumer<T>,LTieDblConsumer<T>> selfLambda)
static <T> LTieFltConsumer<T>	LTieFltConsumer.recursive(LFunction<LTieFltConsumer<T>,LTieFltConsumer<T>> selfLambda)
static <T> LTieIntConsumer<T>	LTieIntConsumer.recursive(LFunction<LTieIntConsumer<T>,LTieIntConsumer<T>> selfLambda)
static <T> LTieLongConsumer<T>	LTieLongConsumer.recursive(LFunction<LTieLongConsumer<T>,LTieLongConsumer<T>> selfLambda)
static <T> LTieSrtConsumer<T>	LTieSrtConsumer.recursive(LFunction<LTieSrtConsumer<T>,LTieSrtConsumer<T>> selfLambda)
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>	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 <T1,SRC,T2> int	LTieConsumer.tieForEach(int sStart, int tStart, T1 trg1, SRC src3, LPredicate<SRC> srcTest3, LFunction<SRC,T2> srcAcc3, LTieConsumer<? super T1,? super T2> 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>	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.
static <T1,T2> LBiObjBoolConsumer<T1,T2>	LBiObjBoolConsumer.uncurry(LFunction<T1,LFunction<T2,LBoolConsumer>> func)
static <T1,T2> LBiObjByteConsumer<T1,T2>	LBiObjByteConsumer.uncurry(LFunction<T1,LFunction<T2,LByteConsumer>> func)
static <T1,T2> LBiObjCharConsumer<T1,T2>	LBiObjCharConsumer.uncurry(LFunction<T1,LFunction<T2,LCharConsumer>> func)
static <T1,T2> LBiObjDblConsumer<T1,T2>	LBiObjDblConsumer.uncurry(LFunction<T1,LFunction<T2,LDblConsumer>> func)
static <T1,T2> LBiObjFltConsumer<T1,T2>	LBiObjFltConsumer.uncurry(LFunction<T1,LFunction<T2,LFltConsumer>> func)
static <T1,T2> LBiObjIntConsumer<T1,T2>	LBiObjIntConsumer.uncurry(LFunction<T1,LFunction<T2,LIntConsumer>> func)
static <T1,T2> LBiObjLongConsumer<T1,T2>	LBiObjLongConsumer.uncurry(LFunction<T1,LFunction<T2,LLongConsumer>> func)
static <T1,T2> LBiObjSrtConsumer<T1,T2>	LBiObjSrtConsumer.uncurry(LFunction<T1,LFunction<T2,LSrtConsumer>> func)
static <T1,T2> LTieConsumer<T1,T2>	LTieConsumer.uncurry(LFunction<T1,LIntFunction<LConsumer<T2>>> func)
static <T> LObjBoolConsumer<T>	LObjBoolConsumer.uncurry(LFunction<T,LBoolConsumer> func)
static <T> LObjByteConsumer<T>	LObjByteConsumer.uncurry(LFunction<T,LByteConsumer> func)
static <T> LObjCharConsumer<T>	LObjCharConsumer.uncurry(LFunction<T,LCharConsumer> func)
static <T> LObjDblConsumer<T>	LObjDblConsumer.uncurry(LFunction<T,LDblConsumer> func)
static <T> LObjFltConsumer<T>	LObjFltConsumer.uncurry(LFunction<T,LFltConsumer> func)
static <T> LObjIntConsumer<T>	LObjIntConsumer.uncurry(LFunction<T,LIntConsumer> 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)
static <T> LObjLongConsumer<T>	LObjLongConsumer.uncurry(LFunction<T,LLongConsumer> func)
static <T> LObjSrtConsumer<T>	LObjSrtConsumer.uncurry(LFunction<T,LSrtConsumer> func)

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

Modifier and Type	Method and Description
static <T1,T2> LBiObjBoolConsumer<T1,T2>	LBiObjBoolConsumer.uncurry(LFunction<T1,LFunction<T2,LBoolConsumer>> func)
static <T1,T2> LBiObjByteConsumer<T1,T2>	LBiObjByteConsumer.uncurry(LFunction<T1,LFunction<T2,LByteConsumer>> func)
static <T1,T2> LBiObjCharConsumer<T1,T2>	LBiObjCharConsumer.uncurry(LFunction<T1,LFunction<T2,LCharConsumer>> func)
static <T1,T2> LBiObjDblConsumer<T1,T2>	LBiObjDblConsumer.uncurry(LFunction<T1,LFunction<T2,LDblConsumer>> func)
static <T1,T2> LBiObjFltConsumer<T1,T2>	LBiObjFltConsumer.uncurry(LFunction<T1,LFunction<T2,LFltConsumer>> func)
static <T1,T2> LBiObjIntConsumer<T1,T2>	LBiObjIntConsumer.uncurry(LFunction<T1,LFunction<T2,LIntConsumer>> func)
static <T1,T2> LBiObjLongConsumer<T1,T2>	LBiObjLongConsumer.uncurry(LFunction<T1,LFunction<T2,LLongConsumer>> func)
static <T1,T2> LBiObjSrtConsumer<T1,T2>	LBiObjSrtConsumer.uncurry(LFunction<T1,LFunction<T2,LSrtConsumer>> func)

Uses of LFunction in eu.lunisolar.magma.func.consumer.primitives.tri

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

Modifier and Type	Method and Description
static LTriBoolConsumer	LTriBoolConsumer.recursive(LFunction<LTriBoolConsumer,LTriBoolConsumer> selfLambda)

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

Classes in eu.lunisolar.magma.func.function that implement LFunction

Modifier and Type	Class and Description
static class	LFunction.LFunctionSingle<T,R>

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

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

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

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

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

Modifier and Type	Method and Description
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiFunction.apply1st(LFunction<T1,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	LTriFunction.apply1st(LFunction<T1,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiFunction.apply2nd(LFunction<T2,R> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	LTriFunction.apply2nd(LFunction<T2,R> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	LTriFunction.apply3rd(LFunction<T3,R> func) Captures single parameter function into this interface where only 3rd parameter will be used.
default R	LBiFunction.applyThen(T1 a1, T2 a2, LFunction<Throwable,R> handler)
default R	LTriFunction.applyThen(T1 a1, T2 a2, T3 a3, LFunction<Throwable,R> handler)
default R	LFunction.applyThen(T a, LFunction<Throwable,R> handler)
static <T,R> R	LFunction.call(T a, LFunction<T,R> lambda)
static <V2,V3,T,R> LFunction<V2,V3>	LFunction.cast(LFunction<T,R> function) Cast that replace generics.
default <V> LFunction<V,R>	LFunction.compose(LFunction<? super V,? extends T> before) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LBiFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LBiFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LTriFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LTriFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LTriFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3) Allows to manipulate the domain of the function.
static <V,T,R> LFunction<V,R>	LFunction.composed(LFunction<? super V,? extends T> before, LFunction<T,R> after)
static <V,T,R> LFunction<V,R>	LFunction.composed(LFunction<? super V,? extends T> before, LFunction<T,R> after)
static <V1,V2,T1,T2,R> LBiFunction<V1,V2,R>	LBiFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LBiFunction<T1,T2,R> after)
static <V1,V2,T1,T2,R> LBiFunction<V1,V2,R>	LBiFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LBiFunction<T1,T2,R> after)
static <V1,V2,V3,T1,T2,T3,R> LTriFunction<V1,V2,V3,R>	LTriFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3, LTriFunction<T1,T2,T3,R> after)
static <V1,V2,V3,T1,T2,T3,R> LTriFunction<V1,V2,V3,R>	LTriFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3, LTriFunction<T1,T2,T3,R> after)
static <V1,V2,V3,T1,T2,T3,R> LTriFunction<V1,V2,V3,R>	LTriFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3, LTriFunction<T1,T2,T3,R> after)
static <T,R> LFunction<T,R>	LFunction.failSafe(LFunction<T,R> func, LFunction<T,R> failSafe)
static <T,R> LFunction<T,R>	LFunction.failSafe(LFunction<T,R> func, LFunction<T,R> failSafe)
default R	LFunction.failSafeApply(T a, LFunction<T,R> failSafe)
static <T,R> R	LFunction.failSafeApply(T a, LFunction<T,R> func, LFunction<T,R> failSafe)
static <T,R> R	LFunction.failSafeApply(T a, LFunction<T,R> func, LFunction<T,R> failSafe)
static <T,R> void	LFunction.fromTill(int min_i, int max_i, T a, LFunction<T,R> func) From-To.
static <T,R> void	LFunction.fromTo(int min_i, int max_i, T a, LFunction<T,R> func) From-To.
static <T,R> LFunction<T,R>	LFunction.func(LFunction<T,R> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T,R> R	LFunction.handlingApply(T a, LFunction<T,R> func, HandlingInstructions<Throwable,RuntimeException> handling)
default LFunction<T2,R>	LBiFunction.lShrink(LFunction<T2,T1> left)
static <T2,R,T1> LFunction<T2,R>	LBiFunction.lShrinked(LFunction<T2,T1> left, LBiFunction<T1,T2,R> func)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiFunction.recursive(LFunction<LBiFunction<T1,T2,R>,LBiFunction<T1,T2,R>> selfLambda)
static <T,R> LFunction<T,R>	LFunction.recursive(LFunction<LFunction<T,R>,LFunction<T,R>> selfLambda)
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	LTriFunction.recursive(LFunction<LTriFunction<T1,T2,T3,R>,LTriFunction<T1,T2,T3,R>> selfLambda)
default LFunction<T1,R>	LBiFunction.rShrink(LFunction<T1,T2> right)
static <T1,R,T2> LFunction<T1,R>	LBiFunction.rShrinked(LFunction<T1,T2> right, LBiFunction<T1,T2,R> func)
static <T,R> LFunction<T,R>	LFunction.safe(LFunction<T,R> other) Safe wrapping.
default <V> LTriFunction<T1,T2,T3,V>	LTriFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LFunction<T,V>	LFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LBiFunction<T1,T2,V>	LBiFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
static <T,R> void	LFunction.times(int max_i, T a, LFunction<T,R> func) From-To.
static <T,R> R	LFunction.tryApply(T a, LFunction<T,R> func)
static <T,R> R	LFunction.tryApply(T a, LFunction<T,R> func, ExWF<RuntimeException> exF)
static <T,R> R	LFunction.tryApply(T a, LFunction<T,R> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static <T1,T2,R> R	LBiFunction.tryApplyThen(T1 a1, T2 a2, LBiFunction<T1,T2,R> func, LFunction<Throwable,R> handler)
static <T1,T2,T3,R> R	LTriFunction.tryApplyThen(T1 a1, T2 a2, T3 a3, LTriFunction<T1,T2,T3,R> func, LFunction<Throwable,R> handler)
static <T,R> R	LFunction.tryApplyThen(T a, LFunction<T,R> func, LFunction<Throwable,R> handler)
static <T,R> R	LFunction.tryApplyThen(T a, LFunction<T,R> func, LFunction<Throwable,R> handler)
default LTriFunction<T1,T2,T3,R>	LTriFunction.tryingThen(LFunction<Throwable,R> handler)
default LFunction<T,R>	LFunction.tryingThen(LFunction<Throwable,R> handler)
default LBiFunction<T1,T2,R>	LBiFunction.tryingThen(LFunction<Throwable,R> handler)
static <T1,T2,T3,R> LTriFunction<T1,T2,T3,R>	LTriFunction.uncurry(LFunction<T1,LFunction<T2,LFunction<T3,R>>> func)
static <T1,T2,R> LBiFunction<T1,T2,R>	LBiFunction.uncurry(LFunction<T1,LFunction<T2,R>> func)

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

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

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

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

Modifier and Type	Method and Description
static LBoolToByteFunction	LBoolToByteFunction.recursive(LFunction<LBoolToByteFunction,LBoolToByteFunction> selfLambda)
static LBoolToCharFunction	LBoolToCharFunction.recursive(LFunction<LBoolToCharFunction,LBoolToCharFunction> selfLambda)
static LBoolToDblFunction	LBoolToDblFunction.recursive(LFunction<LBoolToDblFunction,LBoolToDblFunction> selfLambda)
static LBoolToFltFunction	LBoolToFltFunction.recursive(LFunction<LBoolToFltFunction,LBoolToFltFunction> selfLambda)
static LBoolToIntFunction	LBoolToIntFunction.recursive(LFunction<LBoolToIntFunction,LBoolToIntFunction> selfLambda)
static LBoolToLongFunction	LBoolToLongFunction.recursive(LFunction<LBoolToLongFunction,LBoolToLongFunction> selfLambda)
static LBoolToSrtFunction	LBoolToSrtFunction.recursive(LFunction<LBoolToSrtFunction,LBoolToSrtFunction> selfLambda)
static LByteToCharFunction	LByteToCharFunction.recursive(LFunction<LByteToCharFunction,LByteToCharFunction> selfLambda)
static LByteToDblFunction	LByteToDblFunction.recursive(LFunction<LByteToDblFunction,LByteToDblFunction> selfLambda)
static LByteToFltFunction	LByteToFltFunction.recursive(LFunction<LByteToFltFunction,LByteToFltFunction> selfLambda)
static LByteToIntFunction	LByteToIntFunction.recursive(LFunction<LByteToIntFunction,LByteToIntFunction> selfLambda)
static LByteToLongFunction	LByteToLongFunction.recursive(LFunction<LByteToLongFunction,LByteToLongFunction> selfLambda)
static LByteToSrtFunction	LByteToSrtFunction.recursive(LFunction<LByteToSrtFunction,LByteToSrtFunction> selfLambda)
static LCharToByteFunction	LCharToByteFunction.recursive(LFunction<LCharToByteFunction,LCharToByteFunction> selfLambda)
static LCharToDblFunction	LCharToDblFunction.recursive(LFunction<LCharToDblFunction,LCharToDblFunction> selfLambda)
static LCharToFltFunction	LCharToFltFunction.recursive(LFunction<LCharToFltFunction,LCharToFltFunction> selfLambda)
static LCharToIntFunction	LCharToIntFunction.recursive(LFunction<LCharToIntFunction,LCharToIntFunction> selfLambda)
static LCharToLongFunction	LCharToLongFunction.recursive(LFunction<LCharToLongFunction,LCharToLongFunction> selfLambda)
static LCharToSrtFunction	LCharToSrtFunction.recursive(LFunction<LCharToSrtFunction,LCharToSrtFunction> selfLambda)
static LDblToByteFunction	LDblToByteFunction.recursive(LFunction<LDblToByteFunction,LDblToByteFunction> selfLambda)
static LDblToCharFunction	LDblToCharFunction.recursive(LFunction<LDblToCharFunction,LDblToCharFunction> selfLambda)
static LDblToFltFunction	LDblToFltFunction.recursive(LFunction<LDblToFltFunction,LDblToFltFunction> selfLambda)
static LDblToIntFunction	LDblToIntFunction.recursive(LFunction<LDblToIntFunction,LDblToIntFunction> selfLambda)
static LDblToLongFunction	LDblToLongFunction.recursive(LFunction<LDblToLongFunction,LDblToLongFunction> selfLambda)
static LDblToSrtFunction	LDblToSrtFunction.recursive(LFunction<LDblToSrtFunction,LDblToSrtFunction> selfLambda)
static LFltToByteFunction	LFltToByteFunction.recursive(LFunction<LFltToByteFunction,LFltToByteFunction> selfLambda)
static LFltToCharFunction	LFltToCharFunction.recursive(LFunction<LFltToCharFunction,LFltToCharFunction> selfLambda)
static LFltToDblFunction	LFltToDblFunction.recursive(LFunction<LFltToDblFunction,LFltToDblFunction> selfLambda)
static LFltToIntFunction	LFltToIntFunction.recursive(LFunction<LFltToIntFunction,LFltToIntFunction> selfLambda)
static LFltToLongFunction	LFltToLongFunction.recursive(LFunction<LFltToLongFunction,LFltToLongFunction> selfLambda)
static LFltToSrtFunction	LFltToSrtFunction.recursive(LFunction<LFltToSrtFunction,LFltToSrtFunction> selfLambda)
static LIntToByteFunction	LIntToByteFunction.recursive(LFunction<LIntToByteFunction,LIntToByteFunction> selfLambda)
static LIntToCharFunction	LIntToCharFunction.recursive(LFunction<LIntToCharFunction,LIntToCharFunction> selfLambda)
static LIntToDblFunction	LIntToDblFunction.recursive(LFunction<LIntToDblFunction,LIntToDblFunction> selfLambda)
static LIntToFltFunction	LIntToFltFunction.recursive(LFunction<LIntToFltFunction,LIntToFltFunction> selfLambda)
static LIntToLongFunction	LIntToLongFunction.recursive(LFunction<LIntToLongFunction,LIntToLongFunction> selfLambda)
static LIntToSrtFunction	LIntToSrtFunction.recursive(LFunction<LIntToSrtFunction,LIntToSrtFunction> selfLambda)
static LLongToByteFunction	LLongToByteFunction.recursive(LFunction<LLongToByteFunction,LLongToByteFunction> selfLambda)
static LLongToCharFunction	LLongToCharFunction.recursive(LFunction<LLongToCharFunction,LLongToCharFunction> selfLambda)
static LLongToDblFunction	LLongToDblFunction.recursive(LFunction<LLongToDblFunction,LLongToDblFunction> selfLambda)
static LLongToFltFunction	LLongToFltFunction.recursive(LFunction<LLongToFltFunction,LLongToFltFunction> selfLambda)
static LLongToIntFunction	LLongToIntFunction.recursive(LFunction<LLongToIntFunction,LLongToIntFunction> selfLambda)
static LLongToSrtFunction	LLongToSrtFunction.recursive(LFunction<LLongToSrtFunction,LLongToSrtFunction> selfLambda)
static LSrtToByteFunction	LSrtToByteFunction.recursive(LFunction<LSrtToByteFunction,LSrtToByteFunction> selfLambda)
static LSrtToCharFunction	LSrtToCharFunction.recursive(LFunction<LSrtToCharFunction,LSrtToCharFunction> selfLambda)
static LSrtToDblFunction	LSrtToDblFunction.recursive(LFunction<LSrtToDblFunction,LSrtToDblFunction> selfLambda)
static LSrtToFltFunction	LSrtToFltFunction.recursive(LFunction<LSrtToFltFunction,LSrtToFltFunction> selfLambda)
static LSrtToIntFunction	LSrtToIntFunction.recursive(LFunction<LSrtToIntFunction,LSrtToIntFunction> selfLambda)
static LSrtToLongFunction	LSrtToLongFunction.recursive(LFunction<LSrtToLongFunction,LSrtToLongFunction> selfLambda)

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

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

Modifier and Type	Method and Description
default <V> LFunction<V,R>	LBoolFunction.boolFuncCompose(LPredicate<? super V> before) Allows to manipulate the domain of the function.
default <V> LFunction<V,R>	LByteFunction.byteFuncCompose(LToByteFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LFunction<V,R>	LCharFunction.charFuncCompose(LToCharFunction<? super V> before) Allows to manipulate the domain of the function.
static <V,R> LFunction<V,R>	LBoolFunction.composed(LPredicate<? super V> before, LBoolFunction<R> after)
static <V,R> LFunction<V,R>	LByteFunction.composed(LToByteFunction<? super V> before, LByteFunction<R> after)
static <V,R> LFunction<V,R>	LCharFunction.composed(LToCharFunction<? super V> before, LCharFunction<R> after)
static <V,R> LFunction<V,R>	LDblFunction.composed(LToDblFunction<? super V> before, LDblFunction<R> after)
static <V,R> LFunction<V,R>	LFltFunction.composed(LToFltFunction<? super V> before, LFltFunction<R> after)
static <V,R> LFunction<V,R>	LIntFunction.composed(LToIntFunction<? super V> before, LIntFunction<R> after)
static <V,R> LFunction<V,R>	LLongFunction.composed(LToLongFunction<? super V> before, LLongFunction<R> after)
static <V,R> LFunction<V,R>	LSrtFunction.composed(LToSrtFunction<? super V> before, LSrtFunction<R> after)
default <V> LFunction<V,R>	LDblFunction.dblFuncCompose(LToDblFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LFunction<V,R>	LFltFunction.fltFuncCompose(LToFltFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LFunction<V,R>	LIntFunction.intFuncCompose(LToIntFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LFunction<V,R>	LLongFunction.longFuncCompose(LToLongFunction<? super V> before) Allows to manipulate the domain of the function.
default LFunction<T,R>	LObjBoolFunction.rShrink(LPredicate<T> right)
default LFunction<T,R>	LObjByteFunction.rShrink(LToByteFunction<T> right)
default LFunction<T,R>	LObjCharFunction.rShrink(LToCharFunction<T> right)
default LFunction<T,R>	LObjDblFunction.rShrink(LToDblFunction<T> right)
default LFunction<T,R>	LObjFltFunction.rShrink(LToFltFunction<T> right)
default LFunction<T,R>	LOiFunction.rShrink(LToIntFunction<T> right)
default LFunction<T,R>	LObjLongFunction.rShrink(LToLongFunction<T> right)
default LFunction<T,R>	LObjSrtFunction.rShrink(LToSrtFunction<T> right)
default LFunction<T,R>	LObjBoolFunction.rShrinkc(boolean a2)
default LFunction<T,R>	LObjByteFunction.rShrinkc(byte a2)
default LFunction<T,R>	LObjCharFunction.rShrinkc(char a2)
default LFunction<T,R>	LObjDblFunction.rShrinkc(double a2)
default LFunction<T,R>	LObjFltFunction.rShrinkc(float a2)
default LFunction<T,R>	LOiFunction.rShrinkc(int a2)
default LFunction<T,R>	LObjLongFunction.rShrinkc(long a2)
default LFunction<T,R>	LObjSrtFunction.rShrinkc(short a2)
static <T,R> LFunction<T,R>	LObjBoolFunction.rShrinked(LPredicate<T> right, LObjBoolFunction<T,R> func)
static <T,R> LFunction<T,R>	LObjByteFunction.rShrinked(LToByteFunction<T> right, LObjByteFunction<T,R> func)
static <T,R> LFunction<T,R>	LObjCharFunction.rShrinked(LToCharFunction<T> right, LObjCharFunction<T,R> func)
static <T,R> LFunction<T,R>	LObjDblFunction.rShrinked(LToDblFunction<T> right, LObjDblFunction<T,R> func)
static <T,R> LFunction<T,R>	LObjFltFunction.rShrinked(LToFltFunction<T> right, LObjFltFunction<T,R> func)
static <T,R> LFunction<T,R>	LOiFunction.rShrinked(LToIntFunction<T> right, LOiFunction<T,R> func)
static <T,R> LFunction<T,R>	LObjLongFunction.rShrinked(LToLongFunction<T> right, LObjLongFunction<T,R> func)
static <T,R> LFunction<T,R>	LObjSrtFunction.rShrinked(LToSrtFunction<T> right, LObjSrtFunction<T,R> func)
static <T,R> LFunction<T,R>	LObjBoolFunction.rShrinkedc(boolean a2, LObjBoolFunction<T,R> func)
static <T,R> LFunction<T,R>	LObjByteFunction.rShrinkedc(byte a2, LObjByteFunction<T,R> func)
static <T,R> LFunction<T,R>	LObjCharFunction.rShrinkedc(char a2, LObjCharFunction<T,R> func)
static <T,R> LFunction<T,R>	LObjDblFunction.rShrinkedc(double a2, LObjDblFunction<T,R> func)
static <T,R> LFunction<T,R>	LObjFltFunction.rShrinkedc(float a2, LObjFltFunction<T,R> func)
static <T,R> LFunction<T,R>	LOiFunction.rShrinkedc(int a2, LOiFunction<T,R> func)
static <T,R> LFunction<T,R>	LObjLongFunction.rShrinkedc(long a2, LObjLongFunction<T,R> func)
static <T,R> LFunction<T,R>	LObjSrtFunction.rShrinkedc(short a2, LObjSrtFunction<T,R> func)
default <V> LFunction<V,R>	LSrtFunction.srtFuncCompose(LToSrtFunction<? super V> before) Allows to manipulate the domain of the function.

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

Modifier and Type	Method and Description
static <T1,T2,R> LObjIntObjFunction<T1,T2,R>	LObjIntObjFunction.apply1st(LFunction<T1,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2,R> LBiObjSrtFunction<T1,T2,R>	LBiObjSrtFunction.apply1st(LFunction<T1,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2,R> LBiObjLongFunction<T1,T2,R>	LBiObjLongFunction.apply1st(LFunction<T1,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2,R> LBiObjIntFunction<T1,T2,R>	LBiObjIntFunction.apply1st(LFunction<T1,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2,R> LBiObjFltFunction<T1,T2,R>	LBiObjFltFunction.apply1st(LFunction<T1,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2,R> LBiObjDblFunction<T1,T2,R>	LBiObjDblFunction.apply1st(LFunction<T1,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2,R> LBiObjCharFunction<T1,T2,R>	LBiObjCharFunction.apply1st(LFunction<T1,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2,R> LBiObjByteFunction<T1,T2,R>	LBiObjByteFunction.apply1st(LFunction<T1,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2,R> LBiObjBoolFunction<T1,T2,R>	LBiObjBoolFunction.apply1st(LFunction<T1,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T,R> LOiFunction<T,R>	LOiFunction.apply1st(LFunction<T,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T,R> LObjSrtFunction<T,R>	LObjSrtFunction.apply1st(LFunction<T,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T,R> LObjLongFunction<T,R>	LObjLongFunction.apply1st(LFunction<T,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T,R> LObjIntSrtFunction<T,R>	LObjIntSrtFunction.apply1st(LFunction<T,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T,R> LObjIntLongFunction<T,R>	LObjIntLongFunction.apply1st(LFunction<T,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T,R> LObjIntFltFunction<T,R>	LObjIntFltFunction.apply1st(LFunction<T,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T,R> LObjIntDblFunction<T,R>	LObjIntDblFunction.apply1st(LFunction<T,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T,R> LObjIntCharFunction<T,R>	LObjIntCharFunction.apply1st(LFunction<T,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T,R> LObjIntByteFunction<T,R>	LObjIntByteFunction.apply1st(LFunction<T,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T,R> LObjIntBoolFunction<T,R>	LObjIntBoolFunction.apply1st(LFunction<T,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T,R> LObjFltFunction<T,R>	LObjFltFunction.apply1st(LFunction<T,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T,R> LObjDblFunction<T,R>	LObjDblFunction.apply1st(LFunction<T,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T,R> LObjCharFunction<T,R>	LObjCharFunction.apply1st(LFunction<T,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T,R> LObjByteFunction<T,R>	LObjByteFunction.apply1st(LFunction<T,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T,R> LObjBoolFunction<T,R>	LObjBoolFunction.apply1st(LFunction<T,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T,R> LObjBiIntFunction<T,R>	LObjBiIntFunction.apply1st(LFunction<T,R> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2,R> LBiObjSrtFunction<T1,T2,R>	LBiObjSrtFunction.apply2nd(LFunction<T2,R> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2,R> LBiObjLongFunction<T1,T2,R>	LBiObjLongFunction.apply2nd(LFunction<T2,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.apply2nd(LFunction<T2,R> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2,R> LBiObjFltFunction<T1,T2,R>	LBiObjFltFunction.apply2nd(LFunction<T2,R> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2,R> LBiObjDblFunction<T1,T2,R>	LBiObjDblFunction.apply2nd(LFunction<T2,R> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2,R> LBiObjCharFunction<T1,T2,R>	LBiObjCharFunction.apply2nd(LFunction<T2,R> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2,R> LBiObjByteFunction<T1,T2,R>	LBiObjByteFunction.apply2nd(LFunction<T2,R> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2,R> LBiObjBoolFunction<T1,T2,R>	LBiObjBoolFunction.apply2nd(LFunction<T2,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.apply3rd(LFunction<T2,R> func) Captures single parameter function into this interface where only 3rd parameter will be used.
default R	LTriBoolFunction.applyThen(boolean a1, boolean a2, boolean a3, LFunction<Throwable,R> handler)
default R	LBiBoolFunction.applyThen(boolean a1, boolean a2, LFunction<Throwable,R> handler)
default R	LBoolFunction.applyThen(boolean a, LFunction<Throwable,R> handler)
default R	LBiByteFunction.applyThen(byte a1, byte a2, LFunction<Throwable,R> handler)
default R	LByteFunction.applyThen(byte a, LFunction<Throwable,R> handler)
default R	LBiCharFunction.applyThen(char a1, char a2, LFunction<Throwable,R> handler)
default R	LCharFunction.applyThen(char a, LFunction<Throwable,R> handler)
default R	LBiDblFunction.applyThen(double a1, double a2, LFunction<Throwable,R> handler)
default R	LDblFunction.applyThen(double a, LFunction<Throwable,R> handler)
default R	LBiFltFunction.applyThen(float a1, float a2, LFunction<Throwable,R> handler)
default R	LFltFunction.applyThen(float a, LFunction<Throwable,R> handler)
default R	LBiIntFunction.applyThen(int a1, int a2, LFunction<Throwable,R> handler)
default R	LIntFunction.applyThen(int a, LFunction<Throwable,R> handler)
default R	LLongFunction.applyThen(long a, LFunction<Throwable,R> handler)
default R	LBiLongFunction.applyThen(long a1, long a2, LFunction<Throwable,R> handler)
default R	LSrtFunction.applyThen(short a, LFunction<Throwable,R> handler)
default R	LBiSrtFunction.applyThen(short a1, short a2, LFunction<Throwable,R> handler)
default R	LObjIntObjFunction.applyThen(T1 a1, int a2, T2 a3, LFunction<Throwable,R> handler)
default R	LBiObjBoolFunction.applyThen(T1 a1, T2 a2, boolean a3, LFunction<Throwable,R> handler)
default R	LBiObjByteFunction.applyThen(T1 a1, T2 a2, byte a3, LFunction<Throwable,R> handler)
default R	LBiObjCharFunction.applyThen(T1 a1, T2 a2, char a3, LFunction<Throwable,R> handler)
default R	LBiObjDblFunction.applyThen(T1 a1, T2 a2, double a3, LFunction<Throwable,R> handler)
default R	LBiObjFltFunction.applyThen(T1 a1, T2 a2, float a3, LFunction<Throwable,R> handler)
default R	LBiObjIntFunction.applyThen(T1 a1, T2 a2, int a3, LFunction<Throwable,R> handler)
default R	LBiObjLongFunction.applyThen(T1 a1, T2 a2, long a3, LFunction<Throwable,R> handler)
default R	LBiObjSrtFunction.applyThen(T1 a1, T2 a2, short a3, LFunction<Throwable,R> handler)
default R	LObjBoolFunction.applyThen(T a1, boolean a2, LFunction<Throwable,R> handler)
default R	LObjByteFunction.applyThen(T a1, byte a2, LFunction<Throwable,R> handler)
default R	LObjCharFunction.applyThen(T a1, char a2, LFunction<Throwable,R> handler)
default R	LObjDblFunction.applyThen(T a1, double a2, LFunction<Throwable,R> handler)
default R	LObjFltFunction.applyThen(T a1, float a2, LFunction<Throwable,R> handler)
default R	LObjIntBoolFunction.applyThen(T a1, int a2, boolean a3, LFunction<Throwable,R> handler)
default R	LObjIntByteFunction.applyThen(T a1, int a2, byte a3, LFunction<Throwable,R> handler)
default R	LObjIntCharFunction.applyThen(T a1, int a2, char a3, LFunction<Throwable,R> handler)
default R	LObjIntDblFunction.applyThen(T a1, int a2, double a3, LFunction<Throwable,R> handler)
default R	LObjIntFltFunction.applyThen(T a1, int a2, float a3, LFunction<Throwable,R> handler)
default R	LObjBiIntFunction.applyThen(T a1, int a2, int a3, LFunction<Throwable,R> handler)
default R	LOiFunction.applyThen(T a1, int a2, LFunction<Throwable,R> handler)
default R	LObjIntLongFunction.applyThen(T a1, int a2, long a3, LFunction<Throwable,R> handler)
default R	LObjIntSrtFunction.applyThen(T a1, int a2, short a3, LFunction<Throwable,R> handler)
default R	LObjLongFunction.applyThen(T a1, long a2, LFunction<Throwable,R> handler)
default R	LObjSrtFunction.applyThen(T a1, short a2, LFunction<Throwable,R> handler)
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjBoolFunction.biObjBoolFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LPredicate<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjBoolFunction.biObjBoolFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LPredicate<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjByteFunction.biObjByteFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjByteFunction.biObjByteFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjCharFunction.biObjCharFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToCharFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjCharFunction.biObjCharFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToCharFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjDblFunction.biObjDblFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjDblFunction.biObjDblFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjFltFunction.biObjFltFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjFltFunction.biObjFltFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3) 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.
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.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjLongFunction.biObjLongFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjLongFunction.biObjLongFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjSrtFunction.biObjSrtFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjSrtFunction.biObjSrtFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1> LObjByteFunction<V1,R>	LObjByteFunction.compose(LFunction<? super V1,? extends T> before1, LByteUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LObjCharFunction<V1,R>	LObjCharFunction.compose(LFunction<? super V1,? extends T> before1, LCharUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LObjDblFunction<V1,R>	LObjDblFunction.compose(LFunction<? super V1,? extends T> before1, LDblUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LObjFltFunction<V1,R>	LObjFltFunction.compose(LFunction<? super V1,? extends T> before1, LFltUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LOiFunction<V1,R>	LOiFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LObjIntByteFunction<V1,R>	LObjIntByteFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LByteUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntCharFunction<V1,R>	LObjIntCharFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LCharUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntDblFunction<V1,R>	LObjIntDblFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LDblUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntFltFunction<V1,R>	LObjIntFltFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LFltUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjBiIntFunction<V1,R>	LObjBiIntFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LIntUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntBoolFunction<V1,R>	LObjIntBoolFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLogicalOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntLongFunction<V1,R>	LObjIntLongFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLongUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntSrtFunction<V1,R>	LObjIntSrtFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LSrtUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjBoolFunction<V1,R>	LObjBoolFunction.compose(LFunction<? super V1,? extends T> before1, LLogicalOperator before2) Allows to manipulate the domain of the function.
default <V1> LObjLongFunction<V1,R>	LObjLongFunction.compose(LFunction<? super V1,? extends T> before1, LLongUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LObjSrtFunction<V1,R>	LObjSrtFunction.compose(LFunction<? super V1,? extends T> before1, LSrtUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjByteFunction<V1,V2,R>	LBiObjByteFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LByteUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjByteFunction<V1,V2,R>	LBiObjByteFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LByteUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjCharFunction<V1,V2,R>	LBiObjCharFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LCharUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjCharFunction<V1,V2,R>	LBiObjCharFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LCharUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjDblFunction<V1,V2,R>	LBiObjDblFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LDblUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjDblFunction<V1,V2,R>	LBiObjDblFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LDblUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjFltFunction<V1,V2,R>	LBiObjFltFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFltUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjFltFunction<V1,V2,R>	LBiObjFltFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFltUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjIntFunction<V1,V2,R>	LBiObjIntFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LIntUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjIntFunction<V1,V2,R>	LBiObjIntFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LIntUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjBoolFunction<V1,V2,R>	LBiObjBoolFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLogicalOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjBoolFunction<V1,V2,R>	LBiObjBoolFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLogicalOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjLongFunction<V1,V2,R>	LBiObjLongFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLongUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjLongFunction<V1,V2,R>	LBiObjLongFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLongUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjSrtFunction<V1,V2,R>	LBiObjSrtFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LSrtUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjSrtFunction<V1,V2,R>	LBiObjSrtFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LSrtUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V3> LObjIntObjFunction<V1,V3,R>	LObjIntObjFunction.compose(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3) Allows to manipulate the domain of the function.
default <V1,V3> LObjIntObjFunction<V1,V3,R>	LObjIntObjFunction.compose(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3) Allows to manipulate the domain of the function.
static <V1,T,R> LObjByteFunction<V1,R>	LObjByteFunction.composed(LFunction<? super V1,? extends T> before1, LByteUnaryOperator before2, LObjByteFunction<T,R> after)
static <V1,T,R> LObjCharFunction<V1,R>	LObjCharFunction.composed(LFunction<? super V1,? extends T> before1, LCharUnaryOperator before2, LObjCharFunction<T,R> after)
static <V1,T,R> LObjDblFunction<V1,R>	LObjDblFunction.composed(LFunction<? super V1,? extends T> before1, LDblUnaryOperator before2, LObjDblFunction<T,R> after)
static <V1,T,R> LObjFltFunction<V1,R>	LObjFltFunction.composed(LFunction<? super V1,? extends T> before1, LFltUnaryOperator before2, LObjFltFunction<T,R> after)
static <V1,T,R> LObjIntByteFunction<V1,R>	LObjIntByteFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LByteUnaryOperator before3, LObjIntByteFunction<T,R> after)
static <V1,T,R> LObjIntCharFunction<V1,R>	LObjIntCharFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LCharUnaryOperator before3, LObjIntCharFunction<T,R> after)
static <V1,T,R> LObjIntDblFunction<V1,R>	LObjIntDblFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LDblUnaryOperator before3, LObjIntDblFunction<T,R> after)
static <V1,T,R> LObjIntFltFunction<V1,R>	LObjIntFltFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LFltUnaryOperator before3, LObjIntFltFunction<T,R> after)
static <V1,T,R> LObjBiIntFunction<V1,R>	LObjBiIntFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LIntUnaryOperator before3, LObjBiIntFunction<T,R> after)
static <V1,T,R> LObjIntBoolFunction<V1,R>	LObjIntBoolFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLogicalOperator before3, LObjIntBoolFunction<T,R> after)
static <V1,T,R> LObjIntLongFunction<V1,R>	LObjIntLongFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLongUnaryOperator before3, LObjIntLongFunction<T,R> after)
static <V1,T,R> LOiFunction<V1,R>	LOiFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LOiFunction<T,R> after)
static <V1,T,R> LObjIntSrtFunction<V1,R>	LObjIntSrtFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LSrtUnaryOperator before3, LObjIntSrtFunction<T,R> after)
static <V1,T,R> LObjBoolFunction<V1,R>	LObjBoolFunction.composed(LFunction<? super V1,? extends T> before1, LLogicalOperator before2, LObjBoolFunction<T,R> after)
static <V1,T,R> LObjLongFunction<V1,R>	LObjLongFunction.composed(LFunction<? super V1,? extends T> before1, LLongUnaryOperator before2, LObjLongFunction<T,R> after)
static <V1,V2,T,R> LBiFunction<V1,V2,R>	LObjBoolFunction.composed(LFunction<? super V1,? extends T> before1, LPredicate<? super V2> before2, LObjBoolFunction<T,R> after)
static <V1,T,R> LObjSrtFunction<V1,R>	LObjSrtFunction.composed(LFunction<? super V1,? extends T> before1, LSrtUnaryOperator before2, LObjSrtFunction<T,R> after)
static <V1,V2,T,R> LBiFunction<V1,V2,R>	LObjByteFunction.composed(LFunction<? super V1,? extends T> before1, LToByteFunction<? super V2> before2, LObjByteFunction<T,R> after)
static <V1,V2,T,R> LBiFunction<V1,V2,R>	LObjCharFunction.composed(LFunction<? super V1,? extends T> before1, LToCharFunction<? super V2> before2, LObjCharFunction<T,R> after)
static <V1,V2,T,R> LBiFunction<V1,V2,R>	LObjDblFunction.composed(LFunction<? super V1,? extends T> before1, LToDblFunction<? super V2> before2, LObjDblFunction<T,R> after)
static <V1,V2,T,R> LBiFunction<V1,V2,R>	LObjFltFunction.composed(LFunction<? super V1,? extends T> before1, LToFltFunction<? super V2> before2, LObjFltFunction<T,R> after)
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>	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,T,R> LBiFunction<V1,V2,R>	LObjLongFunction.composed(LFunction<? super V1,? extends T> before1, LToLongFunction<? super V2> before2, LObjLongFunction<T,R> after)
static <V1,V2,T,R> LBiFunction<V1,V2,R>	LObjSrtFunction.composed(LFunction<? super V1,? extends T> before1, LToSrtFunction<? super V2> before2, LObjSrtFunction<T,R> after)
static <V1,V2,T1,T2,R> LBiObjByteFunction<V1,V2,R>	LBiObjByteFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LByteUnaryOperator before3, LBiObjByteFunction<T1,T2,R> after)
static <V1,V2,T1,T2,R> LBiObjByteFunction<V1,V2,R>	LBiObjByteFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LByteUnaryOperator before3, LBiObjByteFunction<T1,T2,R> after)
static <V1,V2,T1,T2,R> LBiObjCharFunction<V1,V2,R>	LBiObjCharFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LCharUnaryOperator before3, LBiObjCharFunction<T1,T2,R> after)
static <V1,V2,T1,T2,R> LBiObjCharFunction<V1,V2,R>	LBiObjCharFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LCharUnaryOperator before3, LBiObjCharFunction<T1,T2,R> after)
static <V1,V2,T1,T2,R> LBiObjDblFunction<V1,V2,R>	LBiObjDblFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LDblUnaryOperator before3, LBiObjDblFunction<T1,T2,R> after)
static <V1,V2,T1,T2,R> LBiObjDblFunction<V1,V2,R>	LBiObjDblFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LDblUnaryOperator before3, LBiObjDblFunction<T1,T2,R> after)
static <V1,V2,T1,T2,R> LBiObjFltFunction<V1,V2,R>	LBiObjFltFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFltUnaryOperator before3, LBiObjFltFunction<T1,T2,R> after)
static <V1,V2,T1,T2,R> LBiObjFltFunction<V1,V2,R>	LBiObjFltFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFltUnaryOperator before3, LBiObjFltFunction<T1,T2,R> after)
static <V1,V2,T1,T2,R> LBiObjIntFunction<V1,V2,R>	LBiObjIntFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LIntUnaryOperator before3, LBiObjIntFunction<T1,T2,R> after)
static <V1,V2,T1,T2,R> LBiObjIntFunction<V1,V2,R>	LBiObjIntFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LIntUnaryOperator before3, LBiObjIntFunction<T1,T2,R> after)
static <V1,V2,T1,T2,R> LBiObjBoolFunction<V1,V2,R>	LBiObjBoolFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLogicalOperator before3, LBiObjBoolFunction<T1,T2,R> after)
static <V1,V2,T1,T2,R> LBiObjBoolFunction<V1,V2,R>	LBiObjBoolFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLogicalOperator before3, LBiObjBoolFunction<T1,T2,R> after)
static <V1,V2,T1,T2,R> LBiObjLongFunction<V1,V2,R>	LBiObjLongFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLongUnaryOperator before3, LBiObjLongFunction<T1,T2,R> after)
static <V1,V2,T1,T2,R> LBiObjLongFunction<V1,V2,R>	LBiObjLongFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLongUnaryOperator before3, LBiObjLongFunction<T1,T2,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjBoolFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LPredicate<? super V3> before3, LBiObjBoolFunction<T1,T2,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjBoolFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LPredicate<? super V3> before3, LBiObjBoolFunction<T1,T2,R> after)
static <V1,V2,T1,T2,R> LBiObjSrtFunction<V1,V2,R>	LBiObjSrtFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LSrtUnaryOperator before3, LBiObjSrtFunction<T1,T2,R> after)
static <V1,V2,T1,T2,R> LBiObjSrtFunction<V1,V2,R>	LBiObjSrtFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LSrtUnaryOperator before3, LBiObjSrtFunction<T1,T2,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjByteFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3, LBiObjByteFunction<T1,T2,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjByteFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3, LBiObjByteFunction<T1,T2,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjCharFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToCharFunction<? super V3> before3, LBiObjCharFunction<T1,T2,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjCharFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToCharFunction<? super V3> before3, LBiObjCharFunction<T1,T2,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjDblFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblFunction<? super V3> before3, LBiObjDblFunction<T1,T2,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjDblFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblFunction<? super V3> before3, LBiObjDblFunction<T1,T2,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjFltFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3, LBiObjFltFunction<T1,T2,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjFltFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3, LBiObjFltFunction<T1,T2,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>	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>	LBiObjLongFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3, LBiObjLongFunction<T1,T2,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjLongFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3, LBiObjLongFunction<T1,T2,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjSrtFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3, LBiObjSrtFunction<T1,T2,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjSrtFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3, LBiObjSrtFunction<T1,T2,R> after)
static <V1,V3,T1,T2,R> LObjIntObjFunction<V1,V3,R>	LObjIntObjFunction.composed(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3, LObjIntObjFunction<T1,T2,R> after)
static <V1,V3,T1,T2,R> LObjIntObjFunction<V1,V3,R>	LObjIntObjFunction.composed(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3, LObjIntObjFunction<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 <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)
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> LBiFunction<V1,V2,R>	LObjBoolFunction.objBoolFuncCompose(LFunction<? super V1,? extends T> before1, LPredicate<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LObjByteFunction.objByteFuncCompose(LFunction<? super V1,? extends T> before1, LToByteFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LObjCharFunction.objCharFuncCompose(LFunction<? super V1,? extends T> before1, LToCharFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LObjDblFunction.objDblFuncCompose(LFunction<? super V1,? extends T> before1, LToDblFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LObjFltFunction.objFltFuncCompose(LFunction<? super V1,? extends T> before1, LToFltFunction<? super V2> before2) 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>	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>	LObjLongFunction.objLongFuncCompose(LFunction<? super V1,? extends T> before1, LToLongFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LObjSrtFunction.objSrtFuncCompose(LFunction<? super V1,? extends T> before1, LToSrtFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <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.
static <R> LBiBoolFunction<R>	LBiBoolFunction.recursive(LFunction<LBiBoolFunction<R>,LBiBoolFunction<R>> selfLambda)
static <R> LBiByteFunction<R>	LBiByteFunction.recursive(LFunction<LBiByteFunction<R>,LBiByteFunction<R>> selfLambda)
static <R> LBiCharFunction<R>	LBiCharFunction.recursive(LFunction<LBiCharFunction<R>,LBiCharFunction<R>> selfLambda)
static <R> LBiDblFunction<R>	LBiDblFunction.recursive(LFunction<LBiDblFunction<R>,LBiDblFunction<R>> selfLambda)
static <R> LBiFltFunction<R>	LBiFltFunction.recursive(LFunction<LBiFltFunction<R>,LBiFltFunction<R>> selfLambda)
static <R> LBiIntFunction<R>	LBiIntFunction.recursive(LFunction<LBiIntFunction<R>,LBiIntFunction<R>> selfLambda)
static <R> LBiLongFunction<R>	LBiLongFunction.recursive(LFunction<LBiLongFunction<R>,LBiLongFunction<R>> selfLambda)
static <T1,T2,R> LBiObjBoolFunction<T1,T2,R>	LBiObjBoolFunction.recursive(LFunction<LBiObjBoolFunction<T1,T2,R>,LBiObjBoolFunction<T1,T2,R>> selfLambda)
static <T1,T2,R> LBiObjByteFunction<T1,T2,R>	LBiObjByteFunction.recursive(LFunction<LBiObjByteFunction<T1,T2,R>,LBiObjByteFunction<T1,T2,R>> selfLambda)
static <T1,T2,R> LBiObjCharFunction<T1,T2,R>	LBiObjCharFunction.recursive(LFunction<LBiObjCharFunction<T1,T2,R>,LBiObjCharFunction<T1,T2,R>> selfLambda)
static <T1,T2,R> LBiObjDblFunction<T1,T2,R>	LBiObjDblFunction.recursive(LFunction<LBiObjDblFunction<T1,T2,R>,LBiObjDblFunction<T1,T2,R>> selfLambda)
static <T1,T2,R> LBiObjFltFunction<T1,T2,R>	LBiObjFltFunction.recursive(LFunction<LBiObjFltFunction<T1,T2,R>,LBiObjFltFunction<T1,T2,R>> selfLambda)
static <T1,T2,R> LBiObjIntFunction<T1,T2,R>	LBiObjIntFunction.recursive(LFunction<LBiObjIntFunction<T1,T2,R>,LBiObjIntFunction<T1,T2,R>> selfLambda)
static <T1,T2,R> LBiObjLongFunction<T1,T2,R>	LBiObjLongFunction.recursive(LFunction<LBiObjLongFunction<T1,T2,R>,LBiObjLongFunction<T1,T2,R>> selfLambda)
static <T1,T2,R> LBiObjSrtFunction<T1,T2,R>	LBiObjSrtFunction.recursive(LFunction<LBiObjSrtFunction<T1,T2,R>,LBiObjSrtFunction<T1,T2,R>> selfLambda)
static <R> LBiSrtFunction<R>	LBiSrtFunction.recursive(LFunction<LBiSrtFunction<R>,LBiSrtFunction<R>> selfLambda)
static <R> LBoolFunction<R>	LBoolFunction.recursive(LFunction<LBoolFunction<R>,LBoolFunction<R>> selfLambda)
static <R> LByteFunction<R>	LByteFunction.recursive(LFunction<LByteFunction<R>,LByteFunction<R>> selfLambda)
static <R> LCharFunction<R>	LCharFunction.recursive(LFunction<LCharFunction<R>,LCharFunction<R>> selfLambda)
static <R> LDblFunction<R>	LDblFunction.recursive(LFunction<LDblFunction<R>,LDblFunction<R>> selfLambda)
static <R> LFltFunction<R>	LFltFunction.recursive(LFunction<LFltFunction<R>,LFltFunction<R>> selfLambda)
static <R> LIntFunction<R>	LIntFunction.recursive(LFunction<LIntFunction<R>,LIntFunction<R>> selfLambda)
static <R> LLongFunction<R>	LLongFunction.recursive(LFunction<LLongFunction<R>,LLongFunction<R>> selfLambda)
static <T,R> LObjBiIntFunction<T,R>	LObjBiIntFunction.recursive(LFunction<LObjBiIntFunction<T,R>,LObjBiIntFunction<T,R>> selfLambda)
static <T,R> LObjBoolFunction<T,R>	LObjBoolFunction.recursive(LFunction<LObjBoolFunction<T,R>,LObjBoolFunction<T,R>> selfLambda)
static <T,R> LObjByteFunction<T,R>	LObjByteFunction.recursive(LFunction<LObjByteFunction<T,R>,LObjByteFunction<T,R>> selfLambda)
static <T,R> LObjCharFunction<T,R>	LObjCharFunction.recursive(LFunction<LObjCharFunction<T,R>,LObjCharFunction<T,R>> selfLambda)
static <T,R> LObjDblFunction<T,R>	LObjDblFunction.recursive(LFunction<LObjDblFunction<T,R>,LObjDblFunction<T,R>> selfLambda)
static <T,R> LObjFltFunction<T,R>	LObjFltFunction.recursive(LFunction<LObjFltFunction<T,R>,LObjFltFunction<T,R>> selfLambda)
static <T,R> LObjIntBoolFunction<T,R>	LObjIntBoolFunction.recursive(LFunction<LObjIntBoolFunction<T,R>,LObjIntBoolFunction<T,R>> selfLambda)
static <T,R> LObjIntByteFunction<T,R>	LObjIntByteFunction.recursive(LFunction<LObjIntByteFunction<T,R>,LObjIntByteFunction<T,R>> selfLambda)
static <T,R> LObjIntCharFunction<T,R>	LObjIntCharFunction.recursive(LFunction<LObjIntCharFunction<T,R>,LObjIntCharFunction<T,R>> selfLambda)
static <T,R> LObjIntDblFunction<T,R>	LObjIntDblFunction.recursive(LFunction<LObjIntDblFunction<T,R>,LObjIntDblFunction<T,R>> selfLambda)
static <T,R> LObjIntFltFunction<T,R>	LObjIntFltFunction.recursive(LFunction<LObjIntFltFunction<T,R>,LObjIntFltFunction<T,R>> selfLambda)
static <T,R> LObjIntLongFunction<T,R>	LObjIntLongFunction.recursive(LFunction<LObjIntLongFunction<T,R>,LObjIntLongFunction<T,R>> selfLambda)
static <T1,T2,R> LObjIntObjFunction<T1,T2,R>	LObjIntObjFunction.recursive(LFunction<LObjIntObjFunction<T1,T2,R>,LObjIntObjFunction<T1,T2,R>> selfLambda)
static <T,R> LObjIntSrtFunction<T,R>	LObjIntSrtFunction.recursive(LFunction<LObjIntSrtFunction<T,R>,LObjIntSrtFunction<T,R>> selfLambda)
static <T,R> LObjLongFunction<T,R>	LObjLongFunction.recursive(LFunction<LObjLongFunction<T,R>,LObjLongFunction<T,R>> selfLambda)
static <T,R> LObjSrtFunction<T,R>	LObjSrtFunction.recursive(LFunction<LObjSrtFunction<T,R>,LObjSrtFunction<T,R>> selfLambda)
static <T,R> LOiFunction<T,R>	LOiFunction.recursive(LFunction<LOiFunction<T,R>,LOiFunction<T,R>> selfLambda)
static <R> LSrtFunction<R>	LSrtFunction.recursive(LFunction<LSrtFunction<R>,LSrtFunction<R>> selfLambda)
static <R> LTriBoolFunction<R>	LTriBoolFunction.recursive(LFunction<LTriBoolFunction<R>,LTriBoolFunction<R>> selfLambda)
default <V> LTriBoolFunction<V>	LTriBoolFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LSrtFunction<V>	LSrtFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LOiFunction<T,V>	LOiFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LObjSrtFunction<T,V>	LObjSrtFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LObjLongFunction<T,V>	LObjLongFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LObjIntSrtFunction<T,V>	LObjIntSrtFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LObjIntObjFunction<T1,T2,V>	LObjIntObjFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LObjIntLongFunction<T,V>	LObjIntLongFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LObjIntFltFunction<T,V>	LObjIntFltFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LObjIntDblFunction<T,V>	LObjIntDblFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LObjIntCharFunction<T,V>	LObjIntCharFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LObjIntByteFunction<T,V>	LObjIntByteFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LObjIntBoolFunction<T,V>	LObjIntBoolFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LObjFltFunction<T,V>	LObjFltFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LObjDblFunction<T,V>	LObjDblFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LObjCharFunction<T,V>	LObjCharFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LObjByteFunction<T,V>	LObjByteFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LObjBoolFunction<T,V>	LObjBoolFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LObjBiIntFunction<T,V>	LObjBiIntFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LLongFunction<V>	LLongFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LIntFunction<V>	LIntFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LFltFunction<V>	LFltFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LDblFunction<V>	LDblFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LCharFunction<V>	LCharFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LByteFunction<V>	LByteFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LBoolFunction<V>	LBoolFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LBiSrtFunction<V>	LBiSrtFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LBiObjSrtFunction<T1,T2,V>	LBiObjSrtFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LBiObjLongFunction<T1,T2,V>	LBiObjLongFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LBiObjIntFunction<T1,T2,V>	LBiObjIntFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LBiObjFltFunction<T1,T2,V>	LBiObjFltFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LBiObjDblFunction<T1,T2,V>	LBiObjDblFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LBiObjCharFunction<T1,T2,V>	LBiObjCharFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LBiObjByteFunction<T1,T2,V>	LBiObjByteFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LBiObjBoolFunction<T1,T2,V>	LBiObjBoolFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LBiLongFunction<V>	LBiLongFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LBiIntFunction<V>	LBiIntFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LBiFltFunction<V>	LBiFltFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LBiDblFunction<V>	LBiDblFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LBiCharFunction<V>	LBiCharFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LBiByteFunction<V>	LBiByteFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
default <V> LBiBoolFunction<V>	LBiBoolFunction.then(LFunction<? super R,? extends V> after) Combines two functions together in a order.
static <R> R	LTriBoolFunction.tryApplyThen(boolean a1, boolean a2, boolean a3, LTriBoolFunction<R> func, LFunction<Throwable,R> handler)
static <R> R	LBiBoolFunction.tryApplyThen(boolean a1, boolean a2, LBiBoolFunction<R> func, LFunction<Throwable,R> handler)
static <R> R	LBoolFunction.tryApplyThen(boolean a, LBoolFunction<R> func, LFunction<Throwable,R> handler)
static <R> R	LBiByteFunction.tryApplyThen(byte a1, byte a2, LBiByteFunction<R> func, LFunction<Throwable,R> handler)
static <R> R	LByteFunction.tryApplyThen(byte a, LByteFunction<R> func, LFunction<Throwable,R> handler)
static <R> R	LBiCharFunction.tryApplyThen(char a1, char a2, LBiCharFunction<R> func, LFunction<Throwable,R> handler)
static <R> R	LCharFunction.tryApplyThen(char a, LCharFunction<R> func, LFunction<Throwable,R> handler)
static <R> R	LBiDblFunction.tryApplyThen(double a1, double a2, LBiDblFunction<R> func, LFunction<Throwable,R> handler)
static <R> R	LDblFunction.tryApplyThen(double a, LDblFunction<R> func, LFunction<Throwable,R> handler)
static <R> R	LBiFltFunction.tryApplyThen(float a1, float a2, LBiFltFunction<R> func, LFunction<Throwable,R> handler)
static <R> R	LFltFunction.tryApplyThen(float a, LFltFunction<R> func, LFunction<Throwable,R> handler)
static <R> R	LBiIntFunction.tryApplyThen(int a1, int a2, LBiIntFunction<R> func, LFunction<Throwable,R> handler)
static <R> R	LIntFunction.tryApplyThen(int a, LIntFunction<R> func, LFunction<Throwable,R> handler)
static <R> R	LLongFunction.tryApplyThen(long a, LLongFunction<R> func, LFunction<Throwable,R> handler)
static <R> R	LBiLongFunction.tryApplyThen(long a1, long a2, LBiLongFunction<R> func, LFunction<Throwable,R> handler)
static <R> R	LSrtFunction.tryApplyThen(short a, LSrtFunction<R> func, LFunction<Throwable,R> handler)
static <R> R	LBiSrtFunction.tryApplyThen(short a1, short a2, LBiSrtFunction<R> func, LFunction<Throwable,R> handler)
static <T1,T2,R> R	LObjIntObjFunction.tryApplyThen(T1 a1, int a2, T2 a3, LObjIntObjFunction<T1,T2,R> func, LFunction<Throwable,R> handler)
static <T1,T2,R> R	LBiObjBoolFunction.tryApplyThen(T1 a1, T2 a2, boolean a3, LBiObjBoolFunction<T1,T2,R> func, LFunction<Throwable,R> handler)
static <T1,T2,R> R	LBiObjByteFunction.tryApplyThen(T1 a1, T2 a2, byte a3, LBiObjByteFunction<T1,T2,R> func, LFunction<Throwable,R> handler)
static <T1,T2,R> R	LBiObjCharFunction.tryApplyThen(T1 a1, T2 a2, char a3, LBiObjCharFunction<T1,T2,R> func, LFunction<Throwable,R> handler)
static <T1,T2,R> R	LBiObjDblFunction.tryApplyThen(T1 a1, T2 a2, double a3, LBiObjDblFunction<T1,T2,R> func, LFunction<Throwable,R> handler)
static <T1,T2,R> R	LBiObjFltFunction.tryApplyThen(T1 a1, T2 a2, float a3, LBiObjFltFunction<T1,T2,R> func, LFunction<Throwable,R> handler)
static <T1,T2,R> R	LBiObjIntFunction.tryApplyThen(T1 a1, T2 a2, int a3, LBiObjIntFunction<T1,T2,R> func, LFunction<Throwable,R> handler)
static <T1,T2,R> R	LBiObjLongFunction.tryApplyThen(T1 a1, T2 a2, long a3, LBiObjLongFunction<T1,T2,R> func, LFunction<Throwable,R> handler)
static <T1,T2,R> R	LBiObjSrtFunction.tryApplyThen(T1 a1, T2 a2, short a3, LBiObjSrtFunction<T1,T2,R> func, LFunction<Throwable,R> handler)
static <T,R> R	LObjBoolFunction.tryApplyThen(T a1, boolean a2, LObjBoolFunction<T,R> func, LFunction<Throwable,R> handler)
static <T,R> R	LObjByteFunction.tryApplyThen(T a1, byte a2, LObjByteFunction<T,R> func, LFunction<Throwable,R> handler)
static <T,R> R	LObjCharFunction.tryApplyThen(T a1, char a2, LObjCharFunction<T,R> func, LFunction<Throwable,R> handler)
static <T,R> R	LObjDblFunction.tryApplyThen(T a1, double a2, LObjDblFunction<T,R> func, LFunction<Throwable,R> handler)
static <T,R> R	LObjFltFunction.tryApplyThen(T a1, float a2, LObjFltFunction<T,R> func, LFunction<Throwable,R> handler)
static <T,R> R	LObjIntBoolFunction.tryApplyThen(T a1, int a2, boolean a3, LObjIntBoolFunction<T,R> func, LFunction<Throwable,R> handler)
static <T,R> R	LObjIntByteFunction.tryApplyThen(T a1, int a2, byte a3, LObjIntByteFunction<T,R> func, LFunction<Throwable,R> handler)
static <T,R> R	LObjIntCharFunction.tryApplyThen(T a1, int a2, char a3, LObjIntCharFunction<T,R> func, LFunction<Throwable,R> handler)
static <T,R> R	LObjIntDblFunction.tryApplyThen(T a1, int a2, double a3, LObjIntDblFunction<T,R> func, LFunction<Throwable,R> handler)
static <T,R> R	LObjIntFltFunction.tryApplyThen(T a1, int a2, float a3, LObjIntFltFunction<T,R> func, LFunction<Throwable,R> handler)
static <T,R> R	LObjBiIntFunction.tryApplyThen(T a1, int a2, int a3, LObjBiIntFunction<T,R> func, LFunction<Throwable,R> handler)
static <T,R> R	LOiFunction.tryApplyThen(T a1, int a2, LOiFunction<T,R> func, LFunction<Throwable,R> handler)
static <T,R> R	LObjIntLongFunction.tryApplyThen(T a1, int a2, long a3, LObjIntLongFunction<T,R> func, LFunction<Throwable,R> handler)
static <T,R> R	LObjIntSrtFunction.tryApplyThen(T a1, int a2, short a3, LObjIntSrtFunction<T,R> func, LFunction<Throwable,R> handler)
static <T,R> R	LObjLongFunction.tryApplyThen(T a1, long a2, LObjLongFunction<T,R> func, LFunction<Throwable,R> handler)
static <T,R> R	LObjSrtFunction.tryApplyThen(T a1, short a2, LObjSrtFunction<T,R> func, LFunction<Throwable,R> handler)
default LTriBoolFunction<R>	LTriBoolFunction.tryingThen(LFunction<Throwable,R> handler)
default LSrtFunction<R>	LSrtFunction.tryingThen(LFunction<Throwable,R> handler)
default LOiFunction<T,R>	LOiFunction.tryingThen(LFunction<Throwable,R> handler)
default LObjSrtFunction<T,R>	LObjSrtFunction.tryingThen(LFunction<Throwable,R> handler)
default LObjLongFunction<T,R>	LObjLongFunction.tryingThen(LFunction<Throwable,R> handler)
default LObjIntSrtFunction<T,R>	LObjIntSrtFunction.tryingThen(LFunction<Throwable,R> handler)
default LObjIntObjFunction<T1,T2,R>	LObjIntObjFunction.tryingThen(LFunction<Throwable,R> handler)
default LObjIntLongFunction<T,R>	LObjIntLongFunction.tryingThen(LFunction<Throwable,R> handler)
default LObjIntFltFunction<T,R>	LObjIntFltFunction.tryingThen(LFunction<Throwable,R> handler)
default LObjIntDblFunction<T,R>	LObjIntDblFunction.tryingThen(LFunction<Throwable,R> handler)
default LObjIntCharFunction<T,R>	LObjIntCharFunction.tryingThen(LFunction<Throwable,R> handler)
default LObjIntByteFunction<T,R>	LObjIntByteFunction.tryingThen(LFunction<Throwable,R> handler)
default LObjIntBoolFunction<T,R>	LObjIntBoolFunction.tryingThen(LFunction<Throwable,R> handler)
default LObjFltFunction<T,R>	LObjFltFunction.tryingThen(LFunction<Throwable,R> handler)
default LObjDblFunction<T,R>	LObjDblFunction.tryingThen(LFunction<Throwable,R> handler)
default LObjCharFunction<T,R>	LObjCharFunction.tryingThen(LFunction<Throwable,R> handler)
default LObjByteFunction<T,R>	LObjByteFunction.tryingThen(LFunction<Throwable,R> handler)
default LObjBoolFunction<T,R>	LObjBoolFunction.tryingThen(LFunction<Throwable,R> handler)
default LObjBiIntFunction<T,R>	LObjBiIntFunction.tryingThen(LFunction<Throwable,R> handler)
default LLongFunction<R>	LLongFunction.tryingThen(LFunction<Throwable,R> handler)
default LIntFunction<R>	LIntFunction.tryingThen(LFunction<Throwable,R> handler)
default LFltFunction<R>	LFltFunction.tryingThen(LFunction<Throwable,R> handler)
default LDblFunction<R>	LDblFunction.tryingThen(LFunction<Throwable,R> handler)
default LCharFunction<R>	LCharFunction.tryingThen(LFunction<Throwable,R> handler)
default LByteFunction<R>	LByteFunction.tryingThen(LFunction<Throwable,R> handler)
default LBoolFunction<R>	LBoolFunction.tryingThen(LFunction<Throwable,R> handler)
default LBiSrtFunction<R>	LBiSrtFunction.tryingThen(LFunction<Throwable,R> handler)
default LBiObjSrtFunction<T1,T2,R>	LBiObjSrtFunction.tryingThen(LFunction<Throwable,R> handler)
default LBiObjLongFunction<T1,T2,R>	LBiObjLongFunction.tryingThen(LFunction<Throwable,R> handler)
default LBiObjIntFunction<T1,T2,R>	LBiObjIntFunction.tryingThen(LFunction<Throwable,R> handler)
default LBiObjFltFunction<T1,T2,R>	LBiObjFltFunction.tryingThen(LFunction<Throwable,R> handler)
default LBiObjDblFunction<T1,T2,R>	LBiObjDblFunction.tryingThen(LFunction<Throwable,R> handler)
default LBiObjCharFunction<T1,T2,R>	LBiObjCharFunction.tryingThen(LFunction<Throwable,R> handler)
default LBiObjByteFunction<T1,T2,R>	LBiObjByteFunction.tryingThen(LFunction<Throwable,R> handler)
default LBiObjBoolFunction<T1,T2,R>	LBiObjBoolFunction.tryingThen(LFunction<Throwable,R> handler)
default LBiLongFunction<R>	LBiLongFunction.tryingThen(LFunction<Throwable,R> handler)
default LBiIntFunction<R>	LBiIntFunction.tryingThen(LFunction<Throwable,R> handler)
default LBiFltFunction<R>	LBiFltFunction.tryingThen(LFunction<Throwable,R> handler)
default LBiDblFunction<R>	LBiDblFunction.tryingThen(LFunction<Throwable,R> handler)
default LBiCharFunction<R>	LBiCharFunction.tryingThen(LFunction<Throwable,R> handler)
default LBiByteFunction<R>	LBiByteFunction.tryingThen(LFunction<Throwable,R> handler)
default LBiBoolFunction<R>	LBiBoolFunction.tryingThen(LFunction<Throwable,R> handler)
static <T1,T2,R> LBiObjBoolFunction<T1,T2,R>	LBiObjBoolFunction.uncurry(LFunction<T1,LFunction<T2,LBoolFunction<R>>> func)
static <T1,T2,R> LBiObjByteFunction<T1,T2,R>	LBiObjByteFunction.uncurry(LFunction<T1,LFunction<T2,LByteFunction<R>>> func)
static <T1,T2,R> LBiObjCharFunction<T1,T2,R>	LBiObjCharFunction.uncurry(LFunction<T1,LFunction<T2,LCharFunction<R>>> func)
static <T1,T2,R> LBiObjDblFunction<T1,T2,R>	LBiObjDblFunction.uncurry(LFunction<T1,LFunction<T2,LDblFunction<R>>> func)
static <T1,T2,R> LBiObjFltFunction<T1,T2,R>	LBiObjFltFunction.uncurry(LFunction<T1,LFunction<T2,LFltFunction<R>>> func)
static <T1,T2,R> LBiObjIntFunction<T1,T2,R>	LBiObjIntFunction.uncurry(LFunction<T1,LFunction<T2,LIntFunction<R>>> func)
static <T1,T2,R> LBiObjLongFunction<T1,T2,R>	LBiObjLongFunction.uncurry(LFunction<T1,LFunction<T2,LLongFunction<R>>> func)
static <T1,T2,R> LBiObjSrtFunction<T1,T2,R>	LBiObjSrtFunction.uncurry(LFunction<T1,LFunction<T2,LSrtFunction<R>>> func)
static <T1,T2,R> LObjIntObjFunction<T1,T2,R>	LObjIntObjFunction.uncurry(LFunction<T1,LIntFunction<LFunction<T2,R>>> func)
static <T,R> LObjBoolFunction<T,R>	LObjBoolFunction.uncurry(LFunction<T,LBoolFunction<R>> func)
static <T,R> LObjByteFunction<T,R>	LObjByteFunction.uncurry(LFunction<T,LByteFunction<R>> func)
static <T,R> LObjCharFunction<T,R>	LObjCharFunction.uncurry(LFunction<T,LCharFunction<R>> func)
static <T,R> LObjDblFunction<T,R>	LObjDblFunction.uncurry(LFunction<T,LDblFunction<R>> func)
static <T,R> LObjFltFunction<T,R>	LObjFltFunction.uncurry(LFunction<T,LFltFunction<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> 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 <T,R> LObjLongFunction<T,R>	LObjLongFunction.uncurry(LFunction<T,LLongFunction<R>> func)
static <T,R> LObjSrtFunction<T,R>	LObjSrtFunction.uncurry(LFunction<T,LSrtFunction<R>> func)

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

Modifier and Type	Method and Description
static <T1,T2,R> LBiObjBoolFunction<T1,T2,R>	LBiObjBoolFunction.uncurry(LFunction<T1,LFunction<T2,LBoolFunction<R>>> func)
static <T1,T2,R> LBiObjByteFunction<T1,T2,R>	LBiObjByteFunction.uncurry(LFunction<T1,LFunction<T2,LByteFunction<R>>> func)
static <T1,T2,R> LBiObjCharFunction<T1,T2,R>	LBiObjCharFunction.uncurry(LFunction<T1,LFunction<T2,LCharFunction<R>>> func)
static <T1,T2,R> LBiObjDblFunction<T1,T2,R>	LBiObjDblFunction.uncurry(LFunction<T1,LFunction<T2,LDblFunction<R>>> func)
static <T1,T2,R> LBiObjFltFunction<T1,T2,R>	LBiObjFltFunction.uncurry(LFunction<T1,LFunction<T2,LFltFunction<R>>> func)
static <T1,T2,R> LBiObjIntFunction<T1,T2,R>	LBiObjIntFunction.uncurry(LFunction<T1,LFunction<T2,LIntFunction<R>>> func)
static <T1,T2,R> LBiObjLongFunction<T1,T2,R>	LBiObjLongFunction.uncurry(LFunction<T1,LFunction<T2,LLongFunction<R>>> func)
static <T1,T2,R> LBiObjSrtFunction<T1,T2,R>	LBiObjSrtFunction.uncurry(LFunction<T1,LFunction<T2,LSrtFunction<R>>> func)
static <T1,T2,R> LObjIntObjFunction<T1,T2,R>	LObjIntObjFunction.uncurry(LFunction<T1,LIntFunction<LFunction<T2,R>>> func)

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

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

Modifier and Type	Method and Description
default <V> LFunction<T,V>	LToByteFunction.then(LByteFunction<? extends V> after) Combines two functions together in a order.
default <V> LFunction<T,V>	LToCharFunction.then(LCharFunction<? extends V> after) Combines two functions together in a order.
default <V> LFunction<T,V>	LToDblFunction.then(LDblFunction<? extends V> after) Combines two functions together in a order.
default <V> LFunction<T,V>	LToFltFunction.then(LFltFunction<? 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> LFunction<T,V>	LToLongFunction.then(LLongFunction<? extends V> after) Combines two functions together in a order.
default <V> LFunction<T,V>	LToSrtFunction.then(LSrtFunction<? extends V> after) Combines two functions together in a order.

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

Modifier and Type	Method and Description
default <V> LToSrtFunction<V>	LToSrtFunction.compose(LFunction<? super V,? extends T> before) Allows to manipulate the domain of the function.
default <V> LToLongFunction<V>	LToLongFunction.compose(LFunction<? super V,? extends T> before) Allows to manipulate the domain of the function.
default <V> LToIntFunction<V>	LToIntFunction.compose(LFunction<? super V,? extends T> before) Allows to manipulate the domain of the function.
default <V> LToFltFunction<V>	LToFltFunction.compose(LFunction<? super V,? extends T> before) Allows to manipulate the domain of the function.
default <V> LToDblFunction<V>	LToDblFunction.compose(LFunction<? super V,? extends T> before) Allows to manipulate the domain of the function.
default <V> LToCharFunction<V>	LToCharFunction.compose(LFunction<? super V,? extends T> before) Allows to manipulate the domain of the function.
default <V> LToByteFunction<V>	LToByteFunction.compose(LFunction<? super V,? extends T> before) Allows to manipulate the domain of the function.
default <V1> LOiToSrtFunction<V1>	LOiToSrtFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LOiToLongFunction<V1>	LOiToLongFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LOiToIntFunction<V1>	LOiToIntFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LOiToFltFunction<V1>	LOiToFltFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LOiToDblFunction<V1>	LOiToDblFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LOiToCharFunction<V1>	LOiToCharFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LOiToByteFunction<V1>	LOiToByteFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LTieByteFunction<V1>	LTieByteFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LByteUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieCharFunction<V1>	LTieCharFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LCharUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieDblFunction<V1>	LTieDblFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LDblUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieFltFunction<V1>	LTieFltFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LFltUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieIntFunction<V1>	LTieIntFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LIntUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieBoolFunction<V1>	LTieBoolFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLogicalOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieLongFunction<V1>	LTieLongFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLongUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieSrtFunction<V1>	LTieSrtFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LSrtUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LToSrtBiFunction<V1,V2>	LToSrtBiFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToSrtBiFunction<V1,V2>	LToSrtBiFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToLongBiFunction<V1,V2>	LToLongBiFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToLongBiFunction<V1,V2>	LToLongBiFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToIntBiFunction<V1,V2>	LToIntBiFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToIntBiFunction<V1,V2>	LToIntBiFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToFltBiFunction<V1,V2>	LToFltBiFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToFltBiFunction<V1,V2>	LToFltBiFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToDblBiFunction<V1,V2>	LToDblBiFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToDblBiFunction<V1,V2>	LToDblBiFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToCharBiFunction<V1,V2>	LToCharBiFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToCharBiFunction<V1,V2>	LToCharBiFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToByteBiFunction<V1,V2>	LToByteBiFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToByteBiFunction<V1,V2>	LToByteBiFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
default <V1,V2,V3> LToIntTriFunction<V1,V2,V3>	LToIntTriFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LToIntTriFunction<V1,V2,V3>	LToIntTriFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LToIntTriFunction<V1,V2,V3>	LToIntTriFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3) Allows to manipulate the domain of the function.
default <V1,V3> LTieFunction<V1,V3>	LTieFunction.compose(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3) Allows to manipulate the domain of the function.
default <V1,V3> LTieFunction<V1,V3>	LTieFunction.compose(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3) Allows to manipulate the domain of the function.
static <V,T> LToByteFunction<V>	LToByteFunction.composed(LFunction<? super V,? extends T> before, LToByteFunction<T> after)
static <V,T> LToCharFunction<V>	LToCharFunction.composed(LFunction<? super V,? extends T> before, LToCharFunction<T> after)
static <V,T> LToDblFunction<V>	LToDblFunction.composed(LFunction<? super V,? extends T> before, LToDblFunction<T> after)
static <V,T> LToFltFunction<V>	LToFltFunction.composed(LFunction<? super V,? extends T> before, LToFltFunction<T> after)
static <V,T> LToIntFunction<V>	LToIntFunction.composed(LFunction<? super V,? extends T> before, LToIntFunction<T> after)
static <V,T> LToLongFunction<V>	LToLongFunction.composed(LFunction<? super V,? extends T> before, LToLongFunction<T> after)
static <V,T> LToSrtFunction<V>	LToSrtFunction.composed(LFunction<? super V,? extends T> before, LToSrtFunction<T> after)
static <V1,T> LTieByteFunction<V1>	LTieByteFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LByteUnaryOperator before3, LTieByteFunction<T> after)
static <V1,T> LTieCharFunction<V1>	LTieCharFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LCharUnaryOperator before3, LTieCharFunction<T> after)
static <V1,T> LTieDblFunction<V1>	LTieDblFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LDblUnaryOperator before3, LTieDblFunction<T> after)
static <V1,T> LTieFltFunction<V1>	LTieFltFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LFltUnaryOperator before3, LTieFltFunction<T> after)
static <V1,T> LTieIntFunction<V1>	LTieIntFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LIntUnaryOperator before3, LTieIntFunction<T> after)
static <V1,T> LTieBoolFunction<V1>	LTieBoolFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLogicalOperator before3, LTieBoolFunction<T> after)
static <V1,T> LTieLongFunction<V1>	LTieLongFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLongUnaryOperator before3, LTieLongFunction<T> after)
static <V1,T> LOiToByteFunction<V1>	LOiToByteFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LOiToByteFunction<T> after)
static <V1,T> LOiToCharFunction<V1>	LOiToCharFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LOiToCharFunction<T> after)
static <V1,T> LOiToDblFunction<V1>	LOiToDblFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LOiToDblFunction<T> after)
static <V1,T> LOiToFltFunction<V1>	LOiToFltFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LOiToFltFunction<T> after)
static <V1,T> LOiToIntFunction<V1>	LOiToIntFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LOiToIntFunction<T> after)
static <V1,T> LOiToLongFunction<V1>	LOiToLongFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LOiToLongFunction<T> after)
static <V1,T> LOiToSrtFunction<V1>	LOiToSrtFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LOiToSrtFunction<T> after)
static <V1,T> LTieSrtFunction<V1>	LTieSrtFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LSrtUnaryOperator before3, LTieSrtFunction<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>	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,T3> LToIntTriFunction<V1,V2,V3>	LToIntTriFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3, LToIntTriFunction<T1,T2,T3> after)
static <V1,V2,V3,T1,T2,T3> LToIntTriFunction<V1,V2,V3>	LToIntTriFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3, LToIntTriFunction<T1,T2,T3> after)
static <V1,V2,V3,T1,T2,T3> LToIntTriFunction<V1,V2,V3>	LToIntTriFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3, LToIntTriFunction<T1,T2,T3> after)
static <V1,V2,T1,T2> LToByteBiFunction<V1,V2>	LToByteBiFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteBiFunction<T1,T2> after)
static <V1,V2,T1,T2> LToByteBiFunction<V1,V2>	LToByteBiFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteBiFunction<T1,T2> after)
static <V1,V2,T1,T2> LToCharBiFunction<V1,V2>	LToCharBiFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToCharBiFunction<T1,T2> after)
static <V1,V2,T1,T2> LToCharBiFunction<V1,V2>	LToCharBiFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToCharBiFunction<T1,T2> after)
static <V1,V2,T1,T2> LToDblBiFunction<V1,V2>	LToDblBiFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblBiFunction<T1,T2> after)
static <V1,V2,T1,T2> LToDblBiFunction<V1,V2>	LToDblBiFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblBiFunction<T1,T2> after)
static <V1,V2,T1,T2> LToFltBiFunction<V1,V2>	LToFltBiFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltBiFunction<T1,T2> after)
static <V1,V2,T1,T2> LToFltBiFunction<V1,V2>	LToFltBiFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltBiFunction<T1,T2> after)
static <V1,V2,T1,T2> LToIntBiFunction<V1,V2>	LToIntBiFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToIntBiFunction<T1,T2> after)
static <V1,V2,T1,T2> LToIntBiFunction<V1,V2>	LToIntBiFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToIntBiFunction<T1,T2> after)
static <V1,V2,T1,T2> LToLongBiFunction<V1,V2>	LToLongBiFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongBiFunction<T1,T2> after)
static <V1,V2,T1,T2> LToLongBiFunction<V1,V2>	LToLongBiFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongBiFunction<T1,T2> after)
static <V1,V2,T1,T2> LToSrtBiFunction<V1,V2>	LToSrtBiFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtBiFunction<T1,T2> after)
static <V1,V2,T1,T2> LToSrtBiFunction<V1,V2>	LToSrtBiFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtBiFunction<T1,T2> after)
static <V1,V3,T1,T2> LTieFunction<V1,V3>	LTieFunction.composed(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3, LTieFunction<T1,T2> after)
static <V1,V3,T1,T2> LTieFunction<V1,V3>	LTieFunction.composed(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3, LTieFunction<T1,T2> 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 <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)
default LToSrtFunction<T2>	LToSrtBiFunction.lShrink(LFunction<T2,T1> left)
default LToLongFunction<T2>	LToLongBiFunction.lShrink(LFunction<T2,T1> left)
default LToIntFunction<T2>	LToIntBiFunction.lShrink(LFunction<T2,T1> left)
default LToFltFunction<T2>	LToFltBiFunction.lShrink(LFunction<T2,T1> left)
default LToDblFunction<T2>	LToDblBiFunction.lShrink(LFunction<T2,T1> left)
default LToCharFunction<T2>	LToCharBiFunction.lShrink(LFunction<T2,T1> left)
default LToByteFunction<T2>	LToByteBiFunction.lShrink(LFunction<T2,T1> left)
static <T2,T1> LToByteFunction<T2>	LToByteBiFunction.lShrinked(LFunction<T2,T1> left, LToByteBiFunction<T1,T2> func)
static <T2,T1> LToCharFunction<T2>	LToCharBiFunction.lShrinked(LFunction<T2,T1> left, LToCharBiFunction<T1,T2> func)
static <T2,T1> LToDblFunction<T2>	LToDblBiFunction.lShrinked(LFunction<T2,T1> left, LToDblBiFunction<T1,T2> func)
static <T2,T1> LToFltFunction<T2>	LToFltBiFunction.lShrinked(LFunction<T2,T1> left, LToFltBiFunction<T1,T2> func)
static <T2,T1> LToIntFunction<T2>	LToIntBiFunction.lShrinked(LFunction<T2,T1> left, LToIntBiFunction<T1,T2> func)
static <T2,T1> LToLongFunction<T2>	LToLongBiFunction.lShrinked(LFunction<T2,T1> left, LToLongBiFunction<T1,T2> func)
static <T2,T1> LToSrtFunction<T2>	LToSrtBiFunction.lShrinked(LFunction<T2,T1> left, LToSrtBiFunction<T1,T2> func)
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.
static <T> LOiToByteFunction<T>	LOiToByteFunction.recursive(LFunction<LOiToByteFunction<T>,LOiToByteFunction<T>> selfLambda)
static <T> LOiToCharFunction<T>	LOiToCharFunction.recursive(LFunction<LOiToCharFunction<T>,LOiToCharFunction<T>> selfLambda)
static <T> LOiToDblFunction<T>	LOiToDblFunction.recursive(LFunction<LOiToDblFunction<T>,LOiToDblFunction<T>> selfLambda)
static <T> LOiToFltFunction<T>	LOiToFltFunction.recursive(LFunction<LOiToFltFunction<T>,LOiToFltFunction<T>> selfLambda)
static <T> LOiToIntFunction<T>	LOiToIntFunction.recursive(LFunction<LOiToIntFunction<T>,LOiToIntFunction<T>> selfLambda)
static <T> LOiToLongFunction<T>	LOiToLongFunction.recursive(LFunction<LOiToLongFunction<T>,LOiToLongFunction<T>> selfLambda)
static <T> LOiToSrtFunction<T>	LOiToSrtFunction.recursive(LFunction<LOiToSrtFunction<T>,LOiToSrtFunction<T>> selfLambda)
static <T> LTieBoolFunction<T>	LTieBoolFunction.recursive(LFunction<LTieBoolFunction<T>,LTieBoolFunction<T>> selfLambda)
static <T> LTieByteFunction<T>	LTieByteFunction.recursive(LFunction<LTieByteFunction<T>,LTieByteFunction<T>> selfLambda)
static <T> LTieCharFunction<T>	LTieCharFunction.recursive(LFunction<LTieCharFunction<T>,LTieCharFunction<T>> selfLambda)
static <T> LTieDblFunction<T>	LTieDblFunction.recursive(LFunction<LTieDblFunction<T>,LTieDblFunction<T>> selfLambda)
static <T> LTieFltFunction<T>	LTieFltFunction.recursive(LFunction<LTieFltFunction<T>,LTieFltFunction<T>> selfLambda)
static <T1,T2> LTieFunction<T1,T2>	LTieFunction.recursive(LFunction<LTieFunction<T1,T2>,LTieFunction<T1,T2>> selfLambda)
static <T> LTieIntFunction<T>	LTieIntFunction.recursive(LFunction<LTieIntFunction<T>,LTieIntFunction<T>> selfLambda)
static <T> LTieLongFunction<T>	LTieLongFunction.recursive(LFunction<LTieLongFunction<T>,LTieLongFunction<T>> selfLambda)
static <T> LTieSrtFunction<T>	LTieSrtFunction.recursive(LFunction<LTieSrtFunction<T>,LTieSrtFunction<T>> selfLambda)
static <T1,T2> LToByteBiFunction<T1,T2>	LToByteBiFunction.recursive(LFunction<LToByteBiFunction<T1,T2>,LToByteBiFunction<T1,T2>> selfLambda)
static <T> LToByteFunction<T>	LToByteFunction.recursive(LFunction<LToByteFunction<T>,LToByteFunction<T>> selfLambda)
static <T1,T2> LToCharBiFunction<T1,T2>	LToCharBiFunction.recursive(LFunction<LToCharBiFunction<T1,T2>,LToCharBiFunction<T1,T2>> selfLambda)
static <T> LToCharFunction<T>	LToCharFunction.recursive(LFunction<LToCharFunction<T>,LToCharFunction<T>> selfLambda)
static <T1,T2> LToDblBiFunction<T1,T2>	LToDblBiFunction.recursive(LFunction<LToDblBiFunction<T1,T2>,LToDblBiFunction<T1,T2>> selfLambda)
static <T> LToDblFunction<T>	LToDblFunction.recursive(LFunction<LToDblFunction<T>,LToDblFunction<T>> selfLambda)
static <T1,T2> LToFltBiFunction<T1,T2>	LToFltBiFunction.recursive(LFunction<LToFltBiFunction<T1,T2>,LToFltBiFunction<T1,T2>> selfLambda)
static <T> LToFltFunction<T>	LToFltFunction.recursive(LFunction<LToFltFunction<T>,LToFltFunction<T>> selfLambda)
static <T1,T2> LToIntBiFunction<T1,T2>	LToIntBiFunction.recursive(LFunction<LToIntBiFunction<T1,T2>,LToIntBiFunction<T1,T2>> selfLambda)
static <T> LToIntFunction<T>	LToIntFunction.recursive(LFunction<LToIntFunction<T>,LToIntFunction<T>> selfLambda)
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3>	LToIntTriFunction.recursive(LFunction<LToIntTriFunction<T1,T2,T3>,LToIntTriFunction<T1,T2,T3>> selfLambda)
static <T1,T2> LToLongBiFunction<T1,T2>	LToLongBiFunction.recursive(LFunction<LToLongBiFunction<T1,T2>,LToLongBiFunction<T1,T2>> selfLambda)
static <T> LToLongFunction<T>	LToLongFunction.recursive(LFunction<LToLongFunction<T>,LToLongFunction<T>> selfLambda)
static <T1,T2> LToSrtBiFunction<T1,T2>	LToSrtBiFunction.recursive(LFunction<LToSrtBiFunction<T1,T2>,LToSrtBiFunction<T1,T2>> selfLambda)
static <T> LToSrtFunction<T>	LToSrtFunction.recursive(LFunction<LToSrtFunction<T>,LToSrtFunction<T>> selfLambda)
default LToSrtFunction<T1>	LToSrtBiFunction.rShrink(LFunction<T1,T2> right)
default LToLongFunction<T1>	LToLongBiFunction.rShrink(LFunction<T1,T2> right)
default LToIntFunction<T1>	LToIntBiFunction.rShrink(LFunction<T1,T2> right)
default LToFltFunction<T1>	LToFltBiFunction.rShrink(LFunction<T1,T2> right)
default LToDblFunction<T1>	LToDblBiFunction.rShrink(LFunction<T1,T2> right)
default LToCharFunction<T1>	LToCharBiFunction.rShrink(LFunction<T1,T2> right)
default LToByteFunction<T1>	LToByteBiFunction.rShrink(LFunction<T1,T2> right)
static <T1,T2> LToByteFunction<T1>	LToByteBiFunction.rShrinked(LFunction<T1,T2> right, LToByteBiFunction<T1,T2> func)
static <T1,T2> LToCharFunction<T1>	LToCharBiFunction.rShrinked(LFunction<T1,T2> right, LToCharBiFunction<T1,T2> func)
static <T1,T2> LToDblFunction<T1>	LToDblBiFunction.rShrinked(LFunction<T1,T2> right, LToDblBiFunction<T1,T2> func)
static <T1,T2> LToFltFunction<T1>	LToFltBiFunction.rShrinked(LFunction<T1,T2> right, LToFltBiFunction<T1,T2> func)
static <T1,T2> LToIntFunction<T1>	LToIntBiFunction.rShrinked(LFunction<T1,T2> right, LToIntBiFunction<T1,T2> func)
static <T1,T2> LToLongFunction<T1>	LToLongBiFunction.rShrinked(LFunction<T1,T2> right, LToLongBiFunction<T1,T2> func)
static <T1,T2> LToSrtFunction<T1>	LToSrtBiFunction.rShrinked(LFunction<T1,T2> right, LToSrtBiFunction<T1,T2> func)
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 <T1,SRC,T2> int	LTieFunction.tieForEach(int sStart, int tStart, T1 trg1, SRC src3, LPredicate<SRC> srcTest3, LFunction<SRC,T2> srcAcc3, LTieFunction<? super T1,? super T2> 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>	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>	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 <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> LToByteBiFunction<T1,T2>	LToByteBiFunction.uncurry(LFunction<T1,LToByteFunction<T2>> func)
static <T1,T2> LToCharBiFunction<T1,T2>	LToCharBiFunction.uncurry(LFunction<T1,LToCharFunction<T2>> func)
static <T1,T2> LToDblBiFunction<T1,T2>	LToDblBiFunction.uncurry(LFunction<T1,LToDblFunction<T2>> func)
static <T1,T2> LToFltBiFunction<T1,T2>	LToFltBiFunction.uncurry(LFunction<T1,LToFltFunction<T2>> func)
static <T1,T2> LToIntBiFunction<T1,T2>	LToIntBiFunction.uncurry(LFunction<T1,LToIntFunction<T2>> func)
static <T1,T2> LToLongBiFunction<T1,T2>	LToLongBiFunction.uncurry(LFunction<T1,LToLongFunction<T2>> func)
static <T1,T2> LToSrtBiFunction<T1,T2>	LToSrtBiFunction.uncurry(LFunction<T1,LToSrtFunction<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)
static <T> LOiToByteFunction<T>	LOiToByteFunction.uncurry(LFunction<T,LIntToByteFunction> func)
static <T> LOiToCharFunction<T>	LOiToCharFunction.uncurry(LFunction<T,LIntToCharFunction> func)
static <T> LOiToDblFunction<T>	LOiToDblFunction.uncurry(LFunction<T,LIntToDblFunction> func)
static <T> LOiToFltFunction<T>	LOiToFltFunction.uncurry(LFunction<T,LIntToFltFunction> func)
static <T> LOiToLongFunction<T>	LOiToLongFunction.uncurry(LFunction<T,LIntToLongFunction> func)
static <T> LOiToSrtFunction<T>	LOiToSrtFunction.uncurry(LFunction<T,LIntToSrtFunction> func)
static <T> LOiToIntFunction<T>	LOiToIntFunction.uncurry(LFunction<T,LIntUnaryOperator> func)

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

Modifier and Type	Method and Description
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3>	LToIntTriFunction.uncurry(LFunction<T1,LFunction<T2,LToIntFunction<T3>>> func)

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

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

Modifier and Type	Method and Description
default T	LBinaryOperator.applyThen(T a1, T a2, LFunction<Throwable,T> handler)
static <T> LBinaryOperator<T>	LBinaryOperator.recursive(LFunction<LBinaryOperator<T>,LBinaryOperator<T>> selfLambda)
static LByteBinaryOperator	LByteBinaryOperator.recursive(LFunction<LByteBinaryOperator,LByteBinaryOperator> selfLambda)
static LCharBinaryOperator	LCharBinaryOperator.recursive(LFunction<LCharBinaryOperator,LCharBinaryOperator> selfLambda)
static LDblBinaryOperator	LDblBinaryOperator.recursive(LFunction<LDblBinaryOperator,LDblBinaryOperator> selfLambda)
static LFltBinaryOperator	LFltBinaryOperator.recursive(LFunction<LFltBinaryOperator,LFltBinaryOperator> selfLambda)
static LIntBinaryOperator	LIntBinaryOperator.recursive(LFunction<LIntBinaryOperator,LIntBinaryOperator> selfLambda)
static LLogicalBinaryOperator	LLogicalBinaryOperator.recursive(LFunction<LLogicalBinaryOperator,LLogicalBinaryOperator> selfLambda)
static LLongBinaryOperator	LLongBinaryOperator.recursive(LFunction<LLongBinaryOperator,LLongBinaryOperator> selfLambda)
static LSrtBinaryOperator	LSrtBinaryOperator.recursive(LFunction<LSrtBinaryOperator,LSrtBinaryOperator> selfLambda)
default <V> LBiFunction<T,T,V>	LBinaryOperator.then(LFunction<? super T,? extends V> after) Combines two functions together in a order.
static <T> T	LBinaryOperator.tryApplyThen(T a1, T a2, LBinaryOperator<T> func, LFunction<Throwable,T> handler)
default LBinaryOperator<T>	LBinaryOperator.tryingThen(LFunction<Throwable,T> handler)
static <T> LBinaryOperator<T>	LBinaryOperator.uncurry(LFunction<T,LUnaryOperator<T>> func)

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

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

Modifier and Type	Method and Description
default T	LTernaryOperator.applyThen(T a1, T a2, T a3, LFunction<Throwable,T> handler)
static LLogicalTernaryOperator	LLogicalTernaryOperator.recursive(LFunction<LLogicalTernaryOperator,LLogicalTernaryOperator> selfLambda)
static <T> LTernaryOperator<T>	LTernaryOperator.recursive(LFunction<LTernaryOperator<T>,LTernaryOperator<T>> selfLambda)
default <V> LTriFunction<T,T,T,V>	LTernaryOperator.then(LFunction<? super T,? extends V> after) Combines two functions together in a order.
static <T> T	LTernaryOperator.tryApplyThen(T a1, T a2, T a3, LTernaryOperator<T> func, LFunction<Throwable,T> handler)
default LTernaryOperator<T>	LTernaryOperator.tryingThen(LFunction<Throwable,T> handler)
static <T> LTernaryOperator<T>	LTernaryOperator.uncurry(LFunction<T,LFunction<T,LUnaryOperator<T>>> func)

Method parameters in eu.lunisolar.magma.func.operator.ternary with type arguments of type LFunction

Modifier and Type	Method and Description
static <T> LTernaryOperator<T>	LTernaryOperator.uncurry(LFunction<T,LFunction<T,LUnaryOperator<T>>> func)

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

Subinterfaces of LFunction in eu.lunisolar.magma.func.operator.unary

Modifier and Type	Interface and Description
interface	LUnaryOperator<T> Non-throwing functional interface (lambda) LUnaryOperator for Java 8.

Classes in eu.lunisolar.magma.func.operator.unary that implement LFunction

Modifier and Type	Class and Description
static class	LUnaryOperator.LUnaryOperatorSingle<T>

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

Modifier and Type	Method and Description
default <V> LFunction<T,V>	LUnaryOperator.then(LFunction<? super T,? extends V> after) Combines two functions together in a order.

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

Modifier and Type	Method and Description
default T	LUnaryOperator.applyThen(T a, LFunction<Throwable,T> handler)
static LByteUnaryOperator	LByteUnaryOperator.recursive(LFunction<LByteUnaryOperator,LByteUnaryOperator> selfLambda)
static LCharUnaryOperator	LCharUnaryOperator.recursive(LFunction<LCharUnaryOperator,LCharUnaryOperator> selfLambda)
static LDblUnaryOperator	LDblUnaryOperator.recursive(LFunction<LDblUnaryOperator,LDblUnaryOperator> selfLambda)
static LFltUnaryOperator	LFltUnaryOperator.recursive(LFunction<LFltUnaryOperator,LFltUnaryOperator> selfLambda)
static LIntUnaryOperator	LIntUnaryOperator.recursive(LFunction<LIntUnaryOperator,LIntUnaryOperator> selfLambda)
static LLogicalOperator	LLogicalOperator.recursive(LFunction<LLogicalOperator,LLogicalOperator> selfLambda)
static LLongUnaryOperator	LLongUnaryOperator.recursive(LFunction<LLongUnaryOperator,LLongUnaryOperator> selfLambda)
static LSrtUnaryOperator	LSrtUnaryOperator.recursive(LFunction<LSrtUnaryOperator,LSrtUnaryOperator> selfLambda)
static <T> LUnaryOperator<T>	LUnaryOperator.recursive(LFunction<LUnaryOperator<T>,LUnaryOperator<T>> selfLambda)
default <V> LFunction<T,V>	LUnaryOperator.then(LFunction<? super T,? extends V> after) Combines two functions together in a order.
static <T> T	LUnaryOperator.tryApplyThen(T a, LUnaryOperator<T> func, LFunction<Throwable,T> handler)
default LUnaryOperator<T>	LUnaryOperator.tryingThen(LFunction<Throwable,T> handler)

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

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

Modifier and Type	Method and Description
default <V> LFunction<T,V>	LPredicate.boolToFunc(LBoolFunction<? extends V> after) Combines two functions together in a order.

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

Modifier and Type	Method and Description
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjBoolPredicate.biObjBoolPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LPredicate<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjBoolPredicate.biObjBoolPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LPredicate<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjBytePredicate.biObjBytePredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjBytePredicate.biObjBytePredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjCharPredicate.biObjCharPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToCharFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjCharPredicate.biObjCharPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToCharFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjDblPredicate.biObjDblPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjDblPredicate.biObjDblPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjFltPredicate.biObjFltPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjFltPredicate.biObjFltPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3) 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,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,V3> LTriPredicate<V1,V2,V3>	LBiObjLongPredicate.biObjLongPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjLongPredicate.biObjLongPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjSrtPredicate.biObjSrtPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjSrtPredicate.biObjSrtPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V> LPredicate<V>	LPredicate.compose(LFunction<? super V,? extends T> before) Allows to manipulate the domain of the function.
default <V1> LObjBytePredicate<V1>	LObjBytePredicate.compose(LFunction<? super V1,? extends T> before1, LByteUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LObjCharPredicate<V1>	LObjCharPredicate.compose(LFunction<? super V1,? extends T> before1, LCharUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LObjDblPredicate<V1>	LObjDblPredicate.compose(LFunction<? super V1,? extends T> before1, LDblUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LObjFltPredicate<V1>	LObjFltPredicate.compose(LFunction<? super V1,? extends T> before1, LFltUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LObjIntPredicate<V1>	LObjIntPredicate.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LObjIntBytePredicate<V1>	LObjIntBytePredicate.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LByteUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntCharPredicate<V1>	LObjIntCharPredicate.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LCharUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntDblPredicate<V1>	LObjIntDblPredicate.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LDblUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntFltPredicate<V1>	LObjIntFltPredicate.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LFltUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjBiIntPredicate<V1>	LObjBiIntPredicate.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LIntUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntBoolPredicate<V1>	LObjIntBoolPredicate.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLogicalOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntLongPredicate<V1>	LObjIntLongPredicate.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLongUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntSrtPredicate<V1>	LObjIntSrtPredicate.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LSrtUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjBoolPredicate<V1>	LObjBoolPredicate.compose(LFunction<? super V1,? extends T> before1, LLogicalOperator before2) Allows to manipulate the domain of the function.
default <V1> LObjLongPredicate<V1>	LObjLongPredicate.compose(LFunction<? super V1,? extends T> before1, LLongUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LObjSrtPredicate<V1>	LObjSrtPredicate.compose(LFunction<? super V1,? extends T> before1, LSrtUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiPredicate<V1,V2>	LBiPredicate.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiPredicate<V1,V2>	LBiPredicate.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjBytePredicate<V1,V2>	LBiObjBytePredicate.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LByteUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjBytePredicate<V1,V2>	LBiObjBytePredicate.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LByteUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjCharPredicate<V1,V2>	LBiObjCharPredicate.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LCharUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjCharPredicate<V1,V2>	LBiObjCharPredicate.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LCharUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjDblPredicate<V1,V2>	LBiObjDblPredicate.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LDblUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjDblPredicate<V1,V2>	LBiObjDblPredicate.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LDblUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjFltPredicate<V1,V2>	LBiObjFltPredicate.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFltUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjFltPredicate<V1,V2>	LBiObjFltPredicate.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFltUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LTriPredicate.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LTriPredicate.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LTriPredicate.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjIntPredicate<V1,V2>	LBiObjIntPredicate.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LIntUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjIntPredicate<V1,V2>	LBiObjIntPredicate.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LIntUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjBoolPredicate<V1,V2>	LBiObjBoolPredicate.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLogicalOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjBoolPredicate<V1,V2>	LBiObjBoolPredicate.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLogicalOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjLongPredicate<V1,V2>	LBiObjLongPredicate.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLongUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjLongPredicate<V1,V2>	LBiObjLongPredicate.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLongUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjSrtPredicate<V1,V2>	LBiObjSrtPredicate.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LSrtUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjSrtPredicate<V1,V2>	LBiObjSrtPredicate.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LSrtUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V3> LObjIntObjPredicate<V1,V3>	LObjIntObjPredicate.compose(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3) Allows to manipulate the domain of the function.
default <V1,V3> LObjIntObjPredicate<V1,V3>	LObjIntObjPredicate.compose(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3) Allows to manipulate the domain of the function.
static <V,T> LPredicate<V>	LPredicate.composed(LFunction<? super V,? extends T> before, LPredicate<T> after)
static <V1,T> LObjBytePredicate<V1>	LObjBytePredicate.composed(LFunction<? super V1,? extends T> before1, LByteUnaryOperator before2, LObjBytePredicate<T> after)
static <V1,T> LObjCharPredicate<V1>	LObjCharPredicate.composed(LFunction<? super V1,? extends T> before1, LCharUnaryOperator before2, LObjCharPredicate<T> after)
static <V1,T> LObjDblPredicate<V1>	LObjDblPredicate.composed(LFunction<? super V1,? extends T> before1, LDblUnaryOperator before2, LObjDblPredicate<T> after)
static <V1,T> LObjFltPredicate<V1>	LObjFltPredicate.composed(LFunction<? super V1,? extends T> before1, LFltUnaryOperator before2, LObjFltPredicate<T> after)
static <V1,T> LObjIntBytePredicate<V1>	LObjIntBytePredicate.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LByteUnaryOperator before3, LObjIntBytePredicate<T> after)
static <V1,T> LObjIntCharPredicate<V1>	LObjIntCharPredicate.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LCharUnaryOperator before3, LObjIntCharPredicate<T> after)
static <V1,T> LObjIntDblPredicate<V1>	LObjIntDblPredicate.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LDblUnaryOperator before3, LObjIntDblPredicate<T> after)
static <V1,T> LObjIntFltPredicate<V1>	LObjIntFltPredicate.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LFltUnaryOperator before3, LObjIntFltPredicate<T> after)
static <V1,T> LObjBiIntPredicate<V1>	LObjBiIntPredicate.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LIntUnaryOperator before3, LObjBiIntPredicate<T> after)
static <V1,T> LObjIntBoolPredicate<V1>	LObjIntBoolPredicate.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLogicalOperator before3, LObjIntBoolPredicate<T> after)
static <V1,T> LObjIntLongPredicate<V1>	LObjIntLongPredicate.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLongUnaryOperator before3, LObjIntLongPredicate<T> after)
static <V1,T> LObjIntPredicate<V1>	LObjIntPredicate.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LObjIntPredicate<T> after)
static <V1,T> LObjIntSrtPredicate<V1>	LObjIntSrtPredicate.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LSrtUnaryOperator before3, LObjIntSrtPredicate<T> after)
static <V1,T> LObjBoolPredicate<V1>	LObjBoolPredicate.composed(LFunction<? super V1,? extends T> before1, LLogicalOperator before2, LObjBoolPredicate<T> after)
static <V1,T> LObjLongPredicate<V1>	LObjLongPredicate.composed(LFunction<? super V1,? extends T> before1, LLongUnaryOperator before2, LObjLongPredicate<T> after)
static <V1,V2,T> LBiPredicate<V1,V2>	LObjBoolPredicate.composed(LFunction<? super V1,? extends T> before1, LPredicate<? super V2> before2, LObjBoolPredicate<T> after)
static <V1,T> LObjSrtPredicate<V1>	LObjSrtPredicate.composed(LFunction<? super V1,? extends T> before1, LSrtUnaryOperator before2, LObjSrtPredicate<T> after)
static <V1,V2,T> LBiPredicate<V1,V2>	LObjBytePredicate.composed(LFunction<? super V1,? extends T> before1, LToByteFunction<? super V2> before2, LObjBytePredicate<T> after)
static <V1,V2,T> LBiPredicate<V1,V2>	LObjCharPredicate.composed(LFunction<? super V1,? extends T> before1, LToCharFunction<? super V2> before2, LObjCharPredicate<T> after)
static <V1,V2,T> LBiPredicate<V1,V2>	LObjDblPredicate.composed(LFunction<? super V1,? extends T> before1, LToDblFunction<? super V2> before2, LObjDblPredicate<T> after)
static <V1,V2,T> LBiPredicate<V1,V2>	LObjFltPredicate.composed(LFunction<? super V1,? extends T> before1, LToFltFunction<? super V2> before2, LObjFltPredicate<T> after)
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>	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,T> LBiPredicate<V1,V2>	LObjLongPredicate.composed(LFunction<? super V1,? extends T> before1, LToLongFunction<? super V2> before2, LObjLongPredicate<T> after)
static <V1,V2,T> LBiPredicate<V1,V2>	LObjSrtPredicate.composed(LFunction<? super V1,? extends T> before1, LToSrtFunction<? super V2> before2, LObjSrtPredicate<T> after)
static <V1,V2,T1,T2> LBiPredicate<V1,V2>	LBiPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LBiPredicate<T1,T2> after)
static <V1,V2,T1,T2> LBiPredicate<V1,V2>	LBiPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LBiPredicate<T1,T2> after)
static <V1,V2,T1,T2> LBiObjBytePredicate<V1,V2>	LBiObjBytePredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LByteUnaryOperator before3, LBiObjBytePredicate<T1,T2> after)
static <V1,V2,T1,T2> LBiObjBytePredicate<V1,V2>	LBiObjBytePredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LByteUnaryOperator before3, LBiObjBytePredicate<T1,T2> after)
static <V1,V2,T1,T2> LBiObjCharPredicate<V1,V2>	LBiObjCharPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LCharUnaryOperator before3, LBiObjCharPredicate<T1,T2> after)
static <V1,V2,T1,T2> LBiObjCharPredicate<V1,V2>	LBiObjCharPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LCharUnaryOperator before3, LBiObjCharPredicate<T1,T2> after)
static <V1,V2,T1,T2> LBiObjDblPredicate<V1,V2>	LBiObjDblPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LDblUnaryOperator before3, LBiObjDblPredicate<T1,T2> after)
static <V1,V2,T1,T2> LBiObjDblPredicate<V1,V2>	LBiObjDblPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LDblUnaryOperator before3, LBiObjDblPredicate<T1,T2> after)
static <V1,V2,T1,T2> LBiObjFltPredicate<V1,V2>	LBiObjFltPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFltUnaryOperator before3, LBiObjFltPredicate<T1,T2> after)
static <V1,V2,T1,T2> LBiObjFltPredicate<V1,V2>	LBiObjFltPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFltUnaryOperator before3, LBiObjFltPredicate<T1,T2> after)
static <V1,V2,V3,T1,T2,T3> LTriPredicate<V1,V2,V3>	LTriPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3, LTriPredicate<T1,T2,T3> after)
static <V1,V2,V3,T1,T2,T3> LTriPredicate<V1,V2,V3>	LTriPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3, LTriPredicate<T1,T2,T3> after)
static <V1,V2,V3,T1,T2,T3> LTriPredicate<V1,V2,V3>	LTriPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3, LTriPredicate<T1,T2,T3> after)
static <V1,V2,T1,T2> LBiObjIntPredicate<V1,V2>	LBiObjIntPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LIntUnaryOperator before3, LBiObjIntPredicate<T1,T2> after)
static <V1,V2,T1,T2> LBiObjIntPredicate<V1,V2>	LBiObjIntPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LIntUnaryOperator before3, LBiObjIntPredicate<T1,T2> after)
static <V1,V2,T1,T2> LBiObjBoolPredicate<V1,V2>	LBiObjBoolPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLogicalOperator before3, LBiObjBoolPredicate<T1,T2> after)
static <V1,V2,T1,T2> LBiObjBoolPredicate<V1,V2>	LBiObjBoolPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLogicalOperator before3, LBiObjBoolPredicate<T1,T2> after)
static <V1,V2,T1,T2> LBiObjLongPredicate<V1,V2>	LBiObjLongPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLongUnaryOperator before3, LBiObjLongPredicate<T1,T2> after)
static <V1,V2,T1,T2> LBiObjLongPredicate<V1,V2>	LBiObjLongPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LLongUnaryOperator before3, LBiObjLongPredicate<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjBoolPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LPredicate<? super V3> before3, LBiObjBoolPredicate<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjBoolPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LPredicate<? super V3> before3, LBiObjBoolPredicate<T1,T2> after)
static <V1,V2,T1,T2> LBiObjSrtPredicate<V1,V2>	LBiObjSrtPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LSrtUnaryOperator before3, LBiObjSrtPredicate<T1,T2> after)
static <V1,V2,T1,T2> LBiObjSrtPredicate<V1,V2>	LBiObjSrtPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LSrtUnaryOperator before3, LBiObjSrtPredicate<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjBytePredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3, LBiObjBytePredicate<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjBytePredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3, LBiObjBytePredicate<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjCharPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToCharFunction<? super V3> before3, LBiObjCharPredicate<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjCharPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToCharFunction<? super V3> before3, LBiObjCharPredicate<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjDblPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblFunction<? super V3> before3, LBiObjDblPredicate<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjDblPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblFunction<? super V3> before3, LBiObjDblPredicate<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjFltPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3, LBiObjFltPredicate<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjFltPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3, LBiObjFltPredicate<T1,T2> 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>	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>	LBiObjLongPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3, LBiObjLongPredicate<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjLongPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3, LBiObjLongPredicate<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjSrtPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3, LBiObjSrtPredicate<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjSrtPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3, LBiObjSrtPredicate<T1,T2> after)
static <V1,V3,T1,T2> LObjIntObjPredicate<V1,V3>	LObjIntObjPredicate.composed(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3, LObjIntObjPredicate<T1,T2> after)
static <V1,V3,T1,T2> LObjIntObjPredicate<V1,V3>	LObjIntObjPredicate.composed(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3, LObjIntObjPredicate<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,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)
default LPredicate<T2>	LBiPredicate.lShrink(LFunction<T2,T1> left)
static <T2,T1> LPredicate<T2>	LBiPredicate.lShrinked(LFunction<T2,T1> left, LBiPredicate<T1,T2> func)
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> LBiPredicate<V1,V2>	LObjBoolPredicate.objBoolPredCompose(LFunction<? super V1,? extends T> before1, LPredicate<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiPredicate<V1,V2>	LObjBytePredicate.objBytePredCompose(LFunction<? super V1,? extends T> before1, LToByteFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiPredicate<V1,V2>	LObjCharPredicate.objCharPredCompose(LFunction<? super V1,? extends T> before1, LToCharFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiPredicate<V1,V2>	LObjDblPredicate.objDblPredCompose(LFunction<? super V1,? extends T> before1, LToDblFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiPredicate<V1,V2>	LObjFltPredicate.objFltPredCompose(LFunction<? super V1,? extends T> before1, LToFltFunction<? super V2> before2) 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,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 <V1,V2> LBiPredicate<V1,V2>	LObjLongPredicate.objLongPredCompose(LFunction<? super V1,? extends T> before1, LToLongFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiPredicate<V1,V2>	LObjSrtPredicate.objSrtPredCompose(LFunction<? super V1,? extends T> before1, LToSrtFunction<? super V2> before2) Allows to manipulate the domain of the function.
static LBiBytePredicate	LBiBytePredicate.recursive(LFunction<LBiBytePredicate,LBiBytePredicate> selfLambda)
static LBiCharPredicate	LBiCharPredicate.recursive(LFunction<LBiCharPredicate,LBiCharPredicate> selfLambda)
static LBiDblPredicate	LBiDblPredicate.recursive(LFunction<LBiDblPredicate,LBiDblPredicate> selfLambda)
static LBiFltPredicate	LBiFltPredicate.recursive(LFunction<LBiFltPredicate,LBiFltPredicate> selfLambda)
static LBiIntPredicate	LBiIntPredicate.recursive(LFunction<LBiIntPredicate,LBiIntPredicate> selfLambda)
static LBiLongPredicate	LBiLongPredicate.recursive(LFunction<LBiLongPredicate,LBiLongPredicate> selfLambda)
static <T1,T2> LBiObjBoolPredicate<T1,T2>	LBiObjBoolPredicate.recursive(LFunction<LBiObjBoolPredicate<T1,T2>,LBiObjBoolPredicate<T1,T2>> selfLambda)
static <T1,T2> LBiObjBytePredicate<T1,T2>	LBiObjBytePredicate.recursive(LFunction<LBiObjBytePredicate<T1,T2>,LBiObjBytePredicate<T1,T2>> selfLambda)
static <T1,T2> LBiObjCharPredicate<T1,T2>	LBiObjCharPredicate.recursive(LFunction<LBiObjCharPredicate<T1,T2>,LBiObjCharPredicate<T1,T2>> selfLambda)
static <T1,T2> LBiObjDblPredicate<T1,T2>	LBiObjDblPredicate.recursive(LFunction<LBiObjDblPredicate<T1,T2>,LBiObjDblPredicate<T1,T2>> selfLambda)
static <T1,T2> LBiObjFltPredicate<T1,T2>	LBiObjFltPredicate.recursive(LFunction<LBiObjFltPredicate<T1,T2>,LBiObjFltPredicate<T1,T2>> selfLambda)
static <T1,T2> LBiObjIntPredicate<T1,T2>	LBiObjIntPredicate.recursive(LFunction<LBiObjIntPredicate<T1,T2>,LBiObjIntPredicate<T1,T2>> selfLambda)
static <T1,T2> LBiObjLongPredicate<T1,T2>	LBiObjLongPredicate.recursive(LFunction<LBiObjLongPredicate<T1,T2>,LBiObjLongPredicate<T1,T2>> selfLambda)
static <T1,T2> LBiObjSrtPredicate<T1,T2>	LBiObjSrtPredicate.recursive(LFunction<LBiObjSrtPredicate<T1,T2>,LBiObjSrtPredicate<T1,T2>> selfLambda)
static <T1,T2> LBiPredicate<T1,T2>	LBiPredicate.recursive(LFunction<LBiPredicate<T1,T2>,LBiPredicate<T1,T2>> selfLambda)
static LBiSrtPredicate	LBiSrtPredicate.recursive(LFunction<LBiSrtPredicate,LBiSrtPredicate> selfLambda)
static LBoolIntPredicate	LBoolIntPredicate.recursive(LFunction<LBoolIntPredicate,LBoolIntPredicate> selfLambda)
static LByteIntPredicate	LByteIntPredicate.recursive(LFunction<LByteIntPredicate,LByteIntPredicate> selfLambda)
static LBytePredicate	LBytePredicate.recursive(LFunction<LBytePredicate,LBytePredicate> selfLambda)
static LCharIntPredicate	LCharIntPredicate.recursive(LFunction<LCharIntPredicate,LCharIntPredicate> selfLambda)
static LCharPredicate	LCharPredicate.recursive(LFunction<LCharPredicate,LCharPredicate> selfLambda)
static LDblIntPredicate	LDblIntPredicate.recursive(LFunction<LDblIntPredicate,LDblIntPredicate> selfLambda)
static LDblPredicate	LDblPredicate.recursive(LFunction<LDblPredicate,LDblPredicate> selfLambda)
static LFltIntPredicate	LFltIntPredicate.recursive(LFunction<LFltIntPredicate,LFltIntPredicate> selfLambda)
static LFltPredicate	LFltPredicate.recursive(LFunction<LFltPredicate,LFltPredicate> selfLambda)
static LIntPredicate	LIntPredicate.recursive(LFunction<LIntPredicate,LIntPredicate> selfLambda)
static LLongIntPredicate	LLongIntPredicate.recursive(LFunction<LLongIntPredicate,LLongIntPredicate> selfLambda)
static LLongPredicate	LLongPredicate.recursive(LFunction<LLongPredicate,LLongPredicate> selfLambda)
static <T> LObjBiIntPredicate<T>	LObjBiIntPredicate.recursive(LFunction<LObjBiIntPredicate<T>,LObjBiIntPredicate<T>> selfLambda)
static <T> LObjBoolPredicate<T>	LObjBoolPredicate.recursive(LFunction<LObjBoolPredicate<T>,LObjBoolPredicate<T>> selfLambda)
static <T> LObjBytePredicate<T>	LObjBytePredicate.recursive(LFunction<LObjBytePredicate<T>,LObjBytePredicate<T>> selfLambda)
static <T> LObjCharPredicate<T>	LObjCharPredicate.recursive(LFunction<LObjCharPredicate<T>,LObjCharPredicate<T>> selfLambda)
static <T> LObjDblPredicate<T>	LObjDblPredicate.recursive(LFunction<LObjDblPredicate<T>,LObjDblPredicate<T>> selfLambda)
static <T> LObjFltPredicate<T>	LObjFltPredicate.recursive(LFunction<LObjFltPredicate<T>,LObjFltPredicate<T>> selfLambda)
static <T> LObjIntBoolPredicate<T>	LObjIntBoolPredicate.recursive(LFunction<LObjIntBoolPredicate<T>,LObjIntBoolPredicate<T>> selfLambda)
static <T> LObjIntBytePredicate<T>	LObjIntBytePredicate.recursive(LFunction<LObjIntBytePredicate<T>,LObjIntBytePredicate<T>> selfLambda)
static <T> LObjIntCharPredicate<T>	LObjIntCharPredicate.recursive(LFunction<LObjIntCharPredicate<T>,LObjIntCharPredicate<T>> selfLambda)
static <T> LObjIntDblPredicate<T>	LObjIntDblPredicate.recursive(LFunction<LObjIntDblPredicate<T>,LObjIntDblPredicate<T>> selfLambda)
static <T> LObjIntFltPredicate<T>	LObjIntFltPredicate.recursive(LFunction<LObjIntFltPredicate<T>,LObjIntFltPredicate<T>> selfLambda)
static <T> LObjIntLongPredicate<T>	LObjIntLongPredicate.recursive(LFunction<LObjIntLongPredicate<T>,LObjIntLongPredicate<T>> selfLambda)
static <T1,T2> LObjIntObjPredicate<T1,T2>	LObjIntObjPredicate.recursive(LFunction<LObjIntObjPredicate<T1,T2>,LObjIntObjPredicate<T1,T2>> selfLambda)
static <T> LObjIntPredicate<T>	LObjIntPredicate.recursive(LFunction<LObjIntPredicate<T>,LObjIntPredicate<T>> selfLambda)
static <T> LObjIntSrtPredicate<T>	LObjIntSrtPredicate.recursive(LFunction<LObjIntSrtPredicate<T>,LObjIntSrtPredicate<T>> selfLambda)
static <T> LObjLongPredicate<T>	LObjLongPredicate.recursive(LFunction<LObjLongPredicate<T>,LObjLongPredicate<T>> selfLambda)
static <T> LObjSrtPredicate<T>	LObjSrtPredicate.recursive(LFunction<LObjSrtPredicate<T>,LObjSrtPredicate<T>> selfLambda)
static <T> LPredicate<T>	LPredicate.recursive(LFunction<LPredicate<T>,LPredicate<T>> selfLambda)
static LSrtIntPredicate	LSrtIntPredicate.recursive(LFunction<LSrtIntPredicate,LSrtIntPredicate> selfLambda)
static LSrtPredicate	LSrtPredicate.recursive(LFunction<LSrtPredicate,LSrtPredicate> selfLambda)
static <T1,T2,T3> LTriPredicate<T1,T2,T3>	LTriPredicate.recursive(LFunction<LTriPredicate<T1,T2,T3>,LTriPredicate<T1,T2,T3>> selfLambda)
default LPredicate<T1>	LBiPredicate.rShrink(LFunction<T1,T2> right)
static <T1,T2> LPredicate<T1>	LBiPredicate.rShrinked(LFunction<T1,T2> right, LBiPredicate<T1,T2> func)
static <T1,T2> LBiObjBytePredicate<T1,T2>	LBiObjBytePredicate.uncurry(LFunction<T1,LFunction<T2,LBytePredicate>> func)
static <T1,T2> LBiObjCharPredicate<T1,T2>	LBiObjCharPredicate.uncurry(LFunction<T1,LFunction<T2,LCharPredicate>> func)
static <T1,T2> LBiObjDblPredicate<T1,T2>	LBiObjDblPredicate.uncurry(LFunction<T1,LFunction<T2,LDblPredicate>> func)
static <T1,T2> LBiObjFltPredicate<T1,T2>	LBiObjFltPredicate.uncurry(LFunction<T1,LFunction<T2,LFltPredicate>> func)
static <T1,T2> LBiObjIntPredicate<T1,T2>	LBiObjIntPredicate.uncurry(LFunction<T1,LFunction<T2,LIntPredicate>> func)
static <T1,T2> LBiObjBoolPredicate<T1,T2>	LBiObjBoolPredicate.uncurry(LFunction<T1,LFunction<T2,LLogicalOperator>> func)
static <T1,T2> LBiObjLongPredicate<T1,T2>	LBiObjLongPredicate.uncurry(LFunction<T1,LFunction<T2,LLongPredicate>> func)
static <T1,T2,T3> LTriPredicate<T1,T2,T3>	LTriPredicate.uncurry(LFunction<T1,LFunction<T2,LPredicate<T3>>> func)
static <T1,T2> LBiObjSrtPredicate<T1,T2>	LBiObjSrtPredicate.uncurry(LFunction<T1,LFunction<T2,LSrtPredicate>> func)
static <T1,T2> LObjIntObjPredicate<T1,T2>	LObjIntObjPredicate.uncurry(LFunction<T1,LIntFunction<LPredicate<T2>>> func)
static <T1,T2> LBiPredicate<T1,T2>	LBiPredicate.uncurry(LFunction<T1,LPredicate<T2>> func)
static <T> LObjBytePredicate<T>	LObjBytePredicate.uncurry(LFunction<T,LBytePredicate> func)
static <T> LObjCharPredicate<T>	LObjCharPredicate.uncurry(LFunction<T,LCharPredicate> func)
static <T> LObjDblPredicate<T>	LObjDblPredicate.uncurry(LFunction<T,LDblPredicate> func)
static <T> LObjFltPredicate<T>	LObjFltPredicate.uncurry(LFunction<T,LFltPredicate> 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)
static <T> LObjIntPredicate<T>	LObjIntPredicate.uncurry(LFunction<T,LIntPredicate> func)
static <T> LObjBoolPredicate<T>	LObjBoolPredicate.uncurry(LFunction<T,LLogicalOperator> func)
static <T> LObjLongPredicate<T>	LObjLongPredicate.uncurry(LFunction<T,LLongPredicate> func)
static <T> LObjSrtPredicate<T>	LObjSrtPredicate.uncurry(LFunction<T,LSrtPredicate> func)

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

Modifier and Type	Method and Description
static <T1,T2> LBiObjBytePredicate<T1,T2>	LBiObjBytePredicate.uncurry(LFunction<T1,LFunction<T2,LBytePredicate>> func)
static <T1,T2> LBiObjCharPredicate<T1,T2>	LBiObjCharPredicate.uncurry(LFunction<T1,LFunction<T2,LCharPredicate>> func)
static <T1,T2> LBiObjDblPredicate<T1,T2>	LBiObjDblPredicate.uncurry(LFunction<T1,LFunction<T2,LDblPredicate>> func)
static <T1,T2> LBiObjFltPredicate<T1,T2>	LBiObjFltPredicate.uncurry(LFunction<T1,LFunction<T2,LFltPredicate>> func)
static <T1,T2> LBiObjIntPredicate<T1,T2>	LBiObjIntPredicate.uncurry(LFunction<T1,LFunction<T2,LIntPredicate>> func)
static <T1,T2> LBiObjBoolPredicate<T1,T2>	LBiObjBoolPredicate.uncurry(LFunction<T1,LFunction<T2,LLogicalOperator>> func)
static <T1,T2> LBiObjLongPredicate<T1,T2>	LBiObjLongPredicate.uncurry(LFunction<T1,LFunction<T2,LLongPredicate>> func)
static <T1,T2,T3> LTriPredicate<T1,T2,T3>	LTriPredicate.uncurry(LFunction<T1,LFunction<T2,LPredicate<T3>>> func)
static <T1,T2> LBiObjSrtPredicate<T1,T2>	LBiObjSrtPredicate.uncurry(LFunction<T1,LFunction<T2,LSrtPredicate>> func)

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

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

Modifier and Type	Method and Description
default T	LSupplier.getThen(LFunction<Throwable,T> handler)
static LBoolSupplier	LBoolSupplier.recursive(LFunction<LBoolSupplier,LBoolSupplier> selfLambda)
static LByteSupplier	LByteSupplier.recursive(LFunction<LByteSupplier,LByteSupplier> selfLambda)
static LCharSupplier	LCharSupplier.recursive(LFunction<LCharSupplier,LCharSupplier> selfLambda)
static LDblSupplier	LDblSupplier.recursive(LFunction<LDblSupplier,LDblSupplier> selfLambda)
static LFltSupplier	LFltSupplier.recursive(LFunction<LFltSupplier,LFltSupplier> selfLambda)
static LIntSupplier	LIntSupplier.recursive(LFunction<LIntSupplier,LIntSupplier> selfLambda)
static LLongSupplier	LLongSupplier.recursive(LFunction<LLongSupplier,LLongSupplier> selfLambda)
static LSrtSupplier	LSrtSupplier.recursive(LFunction<LSrtSupplier,LSrtSupplier> selfLambda)
static <T> LSupplier<T>	LSupplier.recursive(LFunction<LSupplier<T>,LSupplier<T>> selfLambda)
default <V> LSupplier<V>	LSupplier.toSup(LFunction<? super T,? extends V> after) Combines two functions together in a order.
static <T> T	LSupplier.tryGetThen(LSupplier<T> func, LFunction<Throwable,T> handler)
default LSupplier<T>	LSupplier.tryingThen(LFunction<Throwable,T> handler)

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

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

Modifier and Type	Method and Description
<R> LObjSrtPair.MutObjSrtPair<T>	LObjSrtPair.MutObjSrtPair.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjSrtPair.MutCompObjSrtPair<T>	LObjSrtPair.MutCompObjSrtPair.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjLongPair.MutObjLongPair<T>	LObjLongPair.MutObjLongPair.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjLongPair.MutCompObjLongPair<T>	LObjLongPair.MutCompObjLongPair.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntSrtTriple.MutObjIntSrtTriple<T>	LObjIntSrtTriple.MutObjIntSrtTriple.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntSrtTriple.MutCompObjIntSrtTriple<T>	LObjIntSrtTriple.MutCompObjIntSrtTriple.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntPair.MutObjIntPair<T>	LObjIntPair.MutObjIntPair.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntPair.MutCompObjIntPair<T>	LObjIntPair.MutCompObjIntPair.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntLongTriple.MutObjIntLongTriple<T>	LObjIntLongTriple.MutObjIntLongTriple.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntLongTriple.MutCompObjIntLongTriple<T>	LObjIntLongTriple.MutCompObjIntLongTriple.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntFltTriple.MutObjIntFltTriple<T>	LObjIntFltTriple.MutObjIntFltTriple.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntFltTriple.MutCompObjIntFltTriple<T>	LObjIntFltTriple.MutCompObjIntFltTriple.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntDblTriple.MutObjIntDblTriple<T>	LObjIntDblTriple.MutObjIntDblTriple.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntDblTriple.MutCompObjIntDblTriple<T>	LObjIntDblTriple.MutCompObjIntDblTriple.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntCharTriple.MutObjIntCharTriple<T>	LObjIntCharTriple.MutObjIntCharTriple.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntCharTriple.MutCompObjIntCharTriple<T>	LObjIntCharTriple.MutCompObjIntCharTriple.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntByteTriple.MutObjIntByteTriple<T>	LObjIntByteTriple.MutObjIntByteTriple.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntByteTriple.MutCompObjIntByteTriple<T>	LObjIntByteTriple.MutCompObjIntByteTriple.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntBoolTriple.MutObjIntBoolTriple<T>	LObjIntBoolTriple.MutObjIntBoolTriple.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntBoolTriple.MutCompObjIntBoolTriple<T>	LObjIntBoolTriple.MutCompObjIntBoolTriple.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjFltPair.MutObjFltPair<T>	LObjFltPair.MutObjFltPair.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjFltPair.MutCompObjFltPair<T>	LObjFltPair.MutCompObjFltPair.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjDblPair.MutObjDblPair<T>	LObjDblPair.MutObjDblPair.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjDblPair.MutCompObjDblPair<T>	LObjDblPair.MutCompObjDblPair.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjCharPair.MutObjCharPair<T>	LObjCharPair.MutObjCharPair.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjCharPair.MutCompObjCharPair<T>	LObjCharPair.MutCompObjCharPair.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjBytePair.MutObjBytePair<T>	LObjBytePair.MutObjBytePair.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjBytePair.MutCompObjBytePair<T>	LObjBytePair.MutCompObjBytePair.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjBoolPair.MutObjBoolPair<T>	LObjBoolPair.MutObjBoolPair.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjBoolPair.MutCompObjBoolPair<T>	LObjBoolPair.MutCompObjBoolPair.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjBiIntTriple.MutObjBiIntTriple<T>	LObjBiIntTriple.MutObjBiIntTriple.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjBiIntTriple.MutCompObjBiIntTriple<T>	LObjBiIntTriple.MutCompObjBiIntTriple.setFirstIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LTriple.MutTriple<T1,T2,T3>	LTriple.MutTriple.setFirstIfArgNotNull(R arg, LFunction<R,T1> func) Sets value derived from non-null argument, only if argument is not null.
<R> LTriple.MutCompTriple<T1,T2,T3>	LTriple.MutCompTriple.setFirstIfArgNotNull(R arg, LFunction<R,T1> func) Sets value derived from non-null argument, only if argument is not null.
<R> LPair.MutPair<T1,T2>	LPair.MutPair.setFirstIfArgNotNull(R arg, LFunction<R,T1> func) Sets value derived from non-null argument, only if argument is not null.
<R> LPair.MutCompPair<T1,T2>	LPair.MutCompPair.setFirstIfArgNotNull(R arg, LFunction<R,T1> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntObjTriple.MutObjIntObjTriple<T1,T2>	LObjIntObjTriple.MutObjIntObjTriple.setFirstIfArgNotNull(R arg, LFunction<R,T1> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntObjTriple.MutCompObjIntObjTriple<T1,T2>	LObjIntObjTriple.MutCompObjIntObjTriple.setFirstIfArgNotNull(R arg, LFunction<R,T1> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjSrtTriple.MutBiObjSrtTriple<T1,T2>	LBiObjSrtTriple.MutBiObjSrtTriple.setFirstIfArgNotNull(R arg, LFunction<R,T1> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjSrtTriple.MutCompBiObjSrtTriple<T1,T2>	LBiObjSrtTriple.MutCompBiObjSrtTriple.setFirstIfArgNotNull(R arg, LFunction<R,T1> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjLongTriple.MutBiObjLongTriple<T1,T2>	LBiObjLongTriple.MutBiObjLongTriple.setFirstIfArgNotNull(R arg, LFunction<R,T1> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjLongTriple.MutCompBiObjLongTriple<T1,T2>	LBiObjLongTriple.MutCompBiObjLongTriple.setFirstIfArgNotNull(R arg, LFunction<R,T1> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjIntTriple.MutBiObjIntTriple<T1,T2>	LBiObjIntTriple.MutBiObjIntTriple.setFirstIfArgNotNull(R arg, LFunction<R,T1> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjIntTriple.MutCompBiObjIntTriple<T1,T2>	LBiObjIntTriple.MutCompBiObjIntTriple.setFirstIfArgNotNull(R arg, LFunction<R,T1> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjFltTriple.MutBiObjFltTriple<T1,T2>	LBiObjFltTriple.MutBiObjFltTriple.setFirstIfArgNotNull(R arg, LFunction<R,T1> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjFltTriple.MutCompBiObjFltTriple<T1,T2>	LBiObjFltTriple.MutCompBiObjFltTriple.setFirstIfArgNotNull(R arg, LFunction<R,T1> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjDblTriple.MutBiObjDblTriple<T1,T2>	LBiObjDblTriple.MutBiObjDblTriple.setFirstIfArgNotNull(R arg, LFunction<R,T1> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjDblTriple.MutCompBiObjDblTriple<T1,T2>	LBiObjDblTriple.MutCompBiObjDblTriple.setFirstIfArgNotNull(R arg, LFunction<R,T1> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjCharTriple.MutBiObjCharTriple<T1,T2>	LBiObjCharTriple.MutBiObjCharTriple.setFirstIfArgNotNull(R arg, LFunction<R,T1> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjCharTriple.MutCompBiObjCharTriple<T1,T2>	LBiObjCharTriple.MutCompBiObjCharTriple.setFirstIfArgNotNull(R arg, LFunction<R,T1> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjByteTriple.MutBiObjByteTriple<T1,T2>	LBiObjByteTriple.MutBiObjByteTriple.setFirstIfArgNotNull(R arg, LFunction<R,T1> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjByteTriple.MutCompBiObjByteTriple<T1,T2>	LBiObjByteTriple.MutCompBiObjByteTriple.setFirstIfArgNotNull(R arg, LFunction<R,T1> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjBoolTriple.MutBiObjBoolTriple<T1,T2>	LBiObjBoolTriple.MutBiObjBoolTriple.setFirstIfArgNotNull(R arg, LFunction<R,T1> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjBoolTriple.MutCompBiObjBoolTriple<T1,T2>	LBiObjBoolTriple.MutCompBiObjBoolTriple.setFirstIfArgNotNull(R arg, LFunction<R,T1> func) Sets value derived from non-null argument, only if argument is not null.
<R> LTriple.MutTriple<T1,T2,T3>	LTriple.MutTriple.setSecondIfArgNotNull(R arg, LFunction<R,T2> func) Sets value derived from non-null argument, only if argument is not null.
<R> LTriple.MutCompTriple<T1,T2,T3>	LTriple.MutCompTriple.setSecondIfArgNotNull(R arg, LFunction<R,T2> func) Sets value derived from non-null argument, only if argument is not null.
<R> LPair.MutPair<T1,T2>	LPair.MutPair.setSecondIfArgNotNull(R arg, LFunction<R,T2> func) Sets value derived from non-null argument, only if argument is not null.
<R> LPair.MutCompPair<T1,T2>	LPair.MutCompPair.setSecondIfArgNotNull(R arg, LFunction<R,T2> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjSrtTriple.MutBiObjSrtTriple<T1,T2>	LBiObjSrtTriple.MutBiObjSrtTriple.setSecondIfArgNotNull(R arg, LFunction<R,T2> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjSrtTriple.MutCompBiObjSrtTriple<T1,T2>	LBiObjSrtTriple.MutCompBiObjSrtTriple.setSecondIfArgNotNull(R arg, LFunction<R,T2> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjLongTriple.MutBiObjLongTriple<T1,T2>	LBiObjLongTriple.MutBiObjLongTriple.setSecondIfArgNotNull(R arg, LFunction<R,T2> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjLongTriple.MutCompBiObjLongTriple<T1,T2>	LBiObjLongTriple.MutCompBiObjLongTriple.setSecondIfArgNotNull(R arg, LFunction<R,T2> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjIntTriple.MutBiObjIntTriple<T1,T2>	LBiObjIntTriple.MutBiObjIntTriple.setSecondIfArgNotNull(R arg, LFunction<R,T2> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjIntTriple.MutCompBiObjIntTriple<T1,T2>	LBiObjIntTriple.MutCompBiObjIntTriple.setSecondIfArgNotNull(R arg, LFunction<R,T2> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjFltTriple.MutBiObjFltTriple<T1,T2>	LBiObjFltTriple.MutBiObjFltTriple.setSecondIfArgNotNull(R arg, LFunction<R,T2> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjFltTriple.MutCompBiObjFltTriple<T1,T2>	LBiObjFltTriple.MutCompBiObjFltTriple.setSecondIfArgNotNull(R arg, LFunction<R,T2> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjDblTriple.MutBiObjDblTriple<T1,T2>	LBiObjDblTriple.MutBiObjDblTriple.setSecondIfArgNotNull(R arg, LFunction<R,T2> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjDblTriple.MutCompBiObjDblTriple<T1,T2>	LBiObjDblTriple.MutCompBiObjDblTriple.setSecondIfArgNotNull(R arg, LFunction<R,T2> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjCharTriple.MutBiObjCharTriple<T1,T2>	LBiObjCharTriple.MutBiObjCharTriple.setSecondIfArgNotNull(R arg, LFunction<R,T2> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjCharTriple.MutCompBiObjCharTriple<T1,T2>	LBiObjCharTriple.MutCompBiObjCharTriple.setSecondIfArgNotNull(R arg, LFunction<R,T2> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjByteTriple.MutBiObjByteTriple<T1,T2>	LBiObjByteTriple.MutBiObjByteTriple.setSecondIfArgNotNull(R arg, LFunction<R,T2> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjByteTriple.MutCompBiObjByteTriple<T1,T2>	LBiObjByteTriple.MutCompBiObjByteTriple.setSecondIfArgNotNull(R arg, LFunction<R,T2> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjBoolTriple.MutBiObjBoolTriple<T1,T2>	LBiObjBoolTriple.MutBiObjBoolTriple.setSecondIfArgNotNull(R arg, LFunction<R,T2> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjBoolTriple.MutCompBiObjBoolTriple<T1,T2>	LBiObjBoolTriple.MutCompBiObjBoolTriple.setSecondIfArgNotNull(R arg, LFunction<R,T2> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntObjTriple.MutObjIntObjTriple<T1,T2>	LObjIntObjTriple.MutObjIntObjTriple.setThirdIfArgNotNull(R arg, LFunction<R,T2> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntObjTriple.MutCompObjIntObjTriple<T1,T2>	LObjIntObjTriple.MutCompObjIntObjTriple.setThirdIfArgNotNull(R arg, LFunction<R,T2> func) Sets value derived from non-null argument, only if argument is not null.
<R> LTriple.MutTriple<T1,T2,T3>	LTriple.MutTriple.setThirdIfArgNotNull(R arg, LFunction<R,T3> func) Sets value derived from non-null argument, only if argument is not null.
<R> LTriple.MutCompTriple<T1,T2,T3>	LTriple.MutCompTriple.setThirdIfArgNotNull(R arg, LFunction<R,T3> func) Sets value derived from non-null argument, only if argument is not null.
<R> LSingle.MutSingle<T>	LSingle.MutSingle.setValueIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.
<R> LSingle.MutCompSingle<T>	LSingle.MutCompSingle.setValueIfArgNotNull(R arg, LFunction<R,T> func) Sets value derived from non-null argument, only if argument is not null.