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

Packages that use LToCharFunction

Package	Description
eu.lunisolar.magma.func.consumer.primitives
eu.lunisolar.magma.func.consumer.primitives.bi
eu.lunisolar.magma.func.consumer.primitives.obj
eu.lunisolar.magma.func.function
eu.lunisolar.magma.func.function.conversion
eu.lunisolar.magma.func.function.from
eu.lunisolar.magma.func.function.to
eu.lunisolar.magma.func.operator.binary
eu.lunisolar.magma.func.operator.unary
eu.lunisolar.magma.func.predicate
eu.lunisolar.magma.func.supplier
eu.lunisolar.magma.func.tuple

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

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

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

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

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

Modifier and Type	Method and Description
default <V1,V2> LBiConsumer<V1,V2>	LBiCharConsumer.biCharConsCompose(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LBiCharConsumer.biCharConsCompose(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LCharIntConsumer.charIntConsCompose(LToCharFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
static <V1,V2> LBiConsumer<V1,V2>	LBiCharConsumer.composed(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2, LBiCharConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LBiCharConsumer.composed(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2, LBiCharConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LCharIntConsumer.composed(LToCharFunction<? super V1> before1, LToIntFunction<? super V2> before2, LCharIntConsumer after)

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

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

Modifier and Type	Method and Description
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.
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,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,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)
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 LConsumer<T>	LObjCharConsumer.rShrink(LToCharFunction<T> right)
static <T> LConsumer<T>	LObjCharConsumer.rShrinked(LToCharFunction<T> right, LObjCharConsumer<T> func)
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.
static <T,SRC> int	LTieCharConsumer.tieForEach(int sStart, int tStart, T trg1, SRC src3, LPredicate<SRC> srcTest3, LToCharFunction<SRC> srcAcc3, LTieCharConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).

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

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

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

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

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

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

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

Modifier and Type	Method and Description
default <V> LToCharFunction<V>	LBoolToCharFunction.boolToCharFuncCompose(LPredicate<? super V> before) Allows to manipulate the domain of the function.
default <V> LToCharFunction<V>	LByteToCharFunction.byteToCharFuncCompose(LToByteFunction<? super V> before) Allows to manipulate the domain of the function.
static <V> LToCharFunction<V>	LBoolToCharFunction.composed(LPredicate<? super V> before, LBoolToCharFunction after)
static <V> LToCharFunction<V>	LByteToCharFunction.composed(LToByteFunction<? super V> before, LByteToCharFunction after)
static <V> LToCharFunction<V>	LDblToCharFunction.composed(LToDblFunction<? super V> before, LDblToCharFunction after)
static <V> LToCharFunction<V>	LFltToCharFunction.composed(LToFltFunction<? super V> before, LFltToCharFunction after)
static <V> LToCharFunction<V>	LIntToCharFunction.composed(LToIntFunction<? super V> before, LIntToCharFunction after)
static <V> LToCharFunction<V>	LLongToCharFunction.composed(LToLongFunction<? super V> before, LLongToCharFunction after)
static <V> LToCharFunction<V>	LSrtToCharFunction.composed(LToSrtFunction<? super V> before, LSrtToCharFunction after)
default <V> LToCharFunction<V>	LDblToCharFunction.dblToCharFuncCompose(LToDblFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToCharFunction<V>	LFltToCharFunction.fltToCharFuncCompose(LToFltFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToCharFunction<V>	LIntToCharFunction.intToCharFuncCompose(LToIntFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToCharFunction<V>	LLongToCharFunction.longToCharFuncCompose(LToLongFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToCharFunction<V>	LSrtToCharFunction.srtToCharFuncCompose(LToSrtFunction<? super V> before) Allows to manipulate the domain of the function.

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

Modifier and Type	Method and Description
default char	LBoolToCharFunction.applyAsCharThen(boolean a, LToCharFunction<Throwable> handler)
default char	LByteToCharFunction.applyAsCharThen(byte a, LToCharFunction<Throwable> handler)
default char	LDblToCharFunction.applyAsCharThen(double a, LToCharFunction<Throwable> handler)
default char	LFltToCharFunction.applyAsCharThen(float a, LToCharFunction<Throwable> handler)
default char	LIntToCharFunction.applyAsCharThen(int a, LToCharFunction<Throwable> handler)
default char	LLongToCharFunction.applyAsCharThen(long a, LToCharFunction<Throwable> handler)
default char	LSrtToCharFunction.applyAsCharThen(short a, LToCharFunction<Throwable> handler)
default <V> LToByteFunction<V>	LCharToByteFunction.charToByteFuncCompose(LToCharFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToDblFunction<V>	LCharToDblFunction.charToDblFuncCompose(LToCharFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToFltFunction<V>	LCharToFltFunction.charToFltFuncCompose(LToCharFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToIntFunction<V>	LCharToIntFunction.charToIntFuncCompose(LToCharFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToLongFunction<V>	LCharToLongFunction.charToLongFuncCompose(LToCharFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToSrtFunction<V>	LCharToSrtFunction.charToSrtFuncCompose(LToCharFunction<? super V> before) Allows to manipulate the domain of the function.
static <V> LToByteFunction<V>	LCharToByteFunction.composed(LToCharFunction<? super V> before, LCharToByteFunction after)
static <V> LToDblFunction<V>	LCharToDblFunction.composed(LToCharFunction<? super V> before, LCharToDblFunction after)
static <V> LToFltFunction<V>	LCharToFltFunction.composed(LToCharFunction<? super V> before, LCharToFltFunction after)
static <V> LToIntFunction<V>	LCharToIntFunction.composed(LToCharFunction<? super V> before, LCharToIntFunction after)
static <V> LToLongFunction<V>	LCharToLongFunction.composed(LToCharFunction<? super V> before, LCharToLongFunction after)
static <V> LToSrtFunction<V>	LCharToSrtFunction.composed(LToCharFunction<? super V> before, LCharToSrtFunction after)
static char	LBoolToCharFunction.tryApplyAsCharThen(boolean a, LBoolToCharFunction func, LToCharFunction<Throwable> handler)
static char	LByteToCharFunction.tryApplyAsCharThen(byte a, LByteToCharFunction func, LToCharFunction<Throwable> handler)
static char	LDblToCharFunction.tryApplyAsCharThen(double a, LDblToCharFunction func, LToCharFunction<Throwable> handler)
static char	LFltToCharFunction.tryApplyAsCharThen(float a, LFltToCharFunction func, LToCharFunction<Throwable> handler)
static char	LIntToCharFunction.tryApplyAsCharThen(int a, LIntToCharFunction func, LToCharFunction<Throwable> handler)
static char	LLongToCharFunction.tryApplyAsCharThen(long a, LLongToCharFunction func, LToCharFunction<Throwable> handler)
static char	LSrtToCharFunction.tryApplyAsCharThen(short a, LSrtToCharFunction func, LToCharFunction<Throwable> handler)
default LSrtToCharFunction	LSrtToCharFunction.tryingThen(LToCharFunction<Throwable> handler)
default LLongToCharFunction	LLongToCharFunction.tryingThen(LToCharFunction<Throwable> handler)
default LIntToCharFunction	LIntToCharFunction.tryingThen(LToCharFunction<Throwable> handler)
default LFltToCharFunction	LFltToCharFunction.tryingThen(LToCharFunction<Throwable> handler)
default LDblToCharFunction	LDblToCharFunction.tryingThen(LToCharFunction<Throwable> handler)
default LByteToCharFunction	LByteToCharFunction.tryingThen(LToCharFunction<Throwable> handler)
default LBoolToCharFunction	LBoolToCharFunction.tryingThen(LToCharFunction<Throwable> handler)

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

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

Modifier and Type	Method and Description
default <V1,V2> LBiFunction<V1,V2,R>	LBiCharFunction.biCharFuncCompose(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LBiCharFunction.biCharFuncCompose(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2) 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 <V> LFunction<V,R>	LCharFunction.charFuncCompose(LToCharFunction<? super V> before) Allows to manipulate the domain of the function.
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,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,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 <V,R> LFunction<V,R>	LCharFunction.composed(LToCharFunction<? super V> before, LCharFunction<R> after)
static <V1,V2,R> LBiFunction<V1,V2,R>	LBiCharFunction.composed(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2, LBiCharFunction<R> after)
static <V1,V2,R> LBiFunction<V1,V2,R>	LBiCharFunction.composed(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2, LBiCharFunction<R> after)
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,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 LFunction<T,R>	LObjCharFunction.rShrink(LToCharFunction<T> right)
static <T,R> LFunction<T,R>	LObjCharFunction.rShrinked(LToCharFunction<T> right, LObjCharFunction<T,R> func)
default LSrtToCharFunction	LSrtFunction.thenToChar(LToCharFunction<? super R> after) Combines two functions together in a order.
default LOiToCharFunction<T>	LOiFunction.thenToChar(LToCharFunction<? super R> after) Combines two functions together in a order.
default LLongToCharFunction	LLongFunction.thenToChar(LToCharFunction<? super R> after) Combines two functions together in a order.
default LIntToCharFunction	LIntFunction.thenToChar(LToCharFunction<? super R> after) Combines two functions together in a order.
default LFltToCharFunction	LFltFunction.thenToChar(LToCharFunction<? super R> after) Combines two functions together in a order.
default LDblToCharFunction	LDblFunction.thenToChar(LToCharFunction<? super R> after) Combines two functions together in a order.
default LCharUnaryOperator	LCharFunction.thenToChar(LToCharFunction<? super R> after) Combines two functions together in a order.
default LByteToCharFunction	LByteFunction.thenToChar(LToCharFunction<? super R> after) Combines two functions together in a order.
default LBoolToCharFunction	LBoolFunction.thenToChar(LToCharFunction<? super R> after) Combines two functions together in a order.
default LCharBinaryOperator	LBiCharFunction.thenToChar(LToCharFunction<? super R> after) Combines two functions together in a order.

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

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

Modifier and Type	Class and Description
static class	LToCharFunction.LToCharFunctionSingle<T>

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

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

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

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

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

Modifier and Type	Method and Description
static <T> LOiToCharFunction<T>	LOiToCharFunction.apply1stAsChar(LToCharFunction<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LToCharBiFunction<T1,T2>	LToCharBiFunction.apply1stAsChar(LToCharFunction<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LToCharBiFunction<T1,T2>	LToCharBiFunction.apply2ndAsChar(LToCharFunction<T2> func) Captures single parameter function into this interface where only 2nd parameter will be used.
default char	LToCharBiFunction.applyAsCharThen(T1 a1, T2 a2, LToCharFunction<Throwable> handler)
default char	LOiToCharFunction.applyAsCharThen(T a1, int a2, LToCharFunction<Throwable> handler)
default char	LToCharFunction.applyAsCharThen(T a, LToCharFunction<Throwable> handler)
static <T> char	LToCharFunction.call(T a, LToCharFunction<T> lambda)
static <V2,T> LToCharFunction<V2>	LToCharFunction.cast(LToCharFunction<T> function) Cast that replace generics.
static <V,T> LToCharFunction<V>	LToCharFunction.composed(LFunction<? super V,? extends T> before, LToCharFunction<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 <T> LToCharFunction<T>	LToCharFunction.failSafe(LToCharFunction<T> func, LToCharFunction<T> failSafe)
static <T> LToCharFunction<T>	LToCharFunction.failSafe(LToCharFunction<T> func, LToCharFunction<T> failSafe)
default char	LToCharFunction.failSafeApplyAsChar(T a, LToCharFunction<T> failSafe)
static <T> char	LToCharFunction.failSafeApplyAsChar(T a, LToCharFunction<T> func, LToCharFunction<T> failSafe)
static <T> char	LToCharFunction.failSafeApplyAsChar(T a, LToCharFunction<T> func, LToCharFunction<T> failSafe)
static <T> void	LToCharFunction.fromTill(int min_i, int max_i, T a, LToCharFunction<T> func) From-To.
static <T> void	LToCharFunction.fromTo(int min_i, int max_i, T a, LToCharFunction<T> func) From-To.
static <T> char	LToCharFunction.handlingApplyAsChar(T a, LToCharFunction<T> func, HandlingInstructions<Throwable,RuntimeException> handling)
static <T> LToCharFunction<T>	LToCharFunction.safe(LToCharFunction<T> other) Safe wrapping.
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.
static <T,SRC> int	LTieCharFunction.tieForEach(int sStart, int tStart, T trg1, SRC src3, LPredicate<SRC> srcTest3, LToCharFunction<SRC> srcAcc3, LTieCharFunction<? super T> consumer) For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
static <T> void	LToCharFunction.times(int max_i, T a, LToCharFunction<T> func) From-To.
static <T> LToCharFunction<T>	LToCharFunction.toCharFunc(LToCharFunction<T> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T> char	LToCharFunction.tryApplyAsChar(T a, LToCharFunction<T> func)
static <T> char	LToCharFunction.tryApplyAsChar(T a, LToCharFunction<T> func, ExWF<RuntimeException> exF)
static <T> char	LToCharFunction.tryApplyAsChar(T a, LToCharFunction<T> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static <T1,T2> char	LToCharBiFunction.tryApplyAsCharThen(T1 a1, T2 a2, LToCharBiFunction<T1,T2> func, LToCharFunction<Throwable> handler)
static <T> char	LOiToCharFunction.tryApplyAsCharThen(T a1, int a2, LOiToCharFunction<T> func, LToCharFunction<Throwable> handler)
static <T> char	LToCharFunction.tryApplyAsCharThen(T a, LToCharFunction<T> func, LToCharFunction<Throwable> handler)
static <T> char	LToCharFunction.tryApplyAsCharThen(T a, LToCharFunction<T> func, LToCharFunction<Throwable> handler)
default LToCharFunction<T>	LToCharFunction.tryingThen(LToCharFunction<Throwable> handler)
default LToCharBiFunction<T1,T2>	LToCharBiFunction.tryingThen(LToCharFunction<Throwable> handler)
default LOiToCharFunction<T>	LOiToCharFunction.tryingThen(LToCharFunction<Throwable> handler)

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

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

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

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

Modifier and Type	Method and Description
default char	LCharBinaryOperator.applyAsCharThen(char a1, char a2, LToCharFunction<Throwable> handler)
default <V1,V2> LToCharBiFunction<V1,V2>	LCharBinaryOperator.charBinaryOpCompose(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToCharBiFunction<V1,V2>	LCharBinaryOperator.charBinaryOpCompose(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2) Allows to manipulate the domain of the function.
static <V1,V2> LToCharBiFunction<V1,V2>	LCharBinaryOperator.composed(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2, LCharBinaryOperator after)
static <V1,V2> LToCharBiFunction<V1,V2>	LCharBinaryOperator.composed(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2, LCharBinaryOperator after)
default LToCharBiFunction<T,T>	LBinaryOperator.thenToChar(LToCharFunction<? super T> after) Combines two functions together in a order.
static char	LCharBinaryOperator.tryApplyAsCharThen(char a1, char a2, LCharBinaryOperator func, LToCharFunction<Throwable> handler)
default LCharBinaryOperator	LCharBinaryOperator.tryingThen(LToCharFunction<Throwable> handler)

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

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

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

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

Modifier and Type	Method and Description
default char	LCharUnaryOperator.applyAsCharThen(char a, LToCharFunction<Throwable> handler)
default <V> LToCharFunction<V>	LCharUnaryOperator.charUnaryOpCompose(LToCharFunction<? super V> before) Allows to manipulate the domain of the function.
static <V> LToCharFunction<V>	LCharUnaryOperator.composed(LToCharFunction<? super V> before, LCharUnaryOperator after)
default LToCharFunction<T>	LUnaryOperator.thenToChar(LToCharFunction<? super T> after) Combines two functions together in a order.
static char	LCharUnaryOperator.tryApplyAsCharThen(char a, LCharUnaryOperator func, LToCharFunction<Throwable> handler)
default LCharUnaryOperator	LCharUnaryOperator.tryingThen(LToCharFunction<Throwable> handler)

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

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

Modifier and Type	Method and Description
default LToCharFunction<T>	LPredicate.boolToToCharFunc(LBoolToCharFunction after) Combines two functions together in a order.

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

Modifier and Type	Method and Description
default <V1,V2> LBiPredicate<V1,V2>	LBiCharPredicate.biCharPredCompose(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiPredicate<V1,V2>	LBiCharPredicate.biCharPredCompose(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2) 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> LBiPredicate<V1,V2>	LCharIntPredicate.charIntPredCompose(LToCharFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V> LPredicate<V>	LCharPredicate.charPredCompose(LToCharFunction<? super V> before) Allows to manipulate the domain of the function.
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,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,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 <V> LPredicate<V>	LCharPredicate.composed(LToCharFunction<? super V> before, LCharPredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LBiCharPredicate.composed(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2, LBiCharPredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LBiCharPredicate.composed(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2, LBiCharPredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LCharIntPredicate.composed(LToCharFunction<? super V1> before1, LToIntFunction<? super V2> before2, LCharIntPredicate after)
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,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 LPredicate<T>	LObjCharPredicate.rShrink(LToCharFunction<T> right)
static <T> LPredicate<T>	LObjCharPredicate.rShrinked(LToCharFunction<T> right, LObjCharPredicate<T> func)

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

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

Modifier and Type	Method and Description
default char	LCharSupplier.getAsCharThen(LToCharFunction<Throwable> handler)
default LCharSupplier	LSupplier.toCharSup(LToCharFunction<? super T> after) Combines two functions together in a order.
static char	LCharSupplier.tryGetAsCharThen(LCharSupplier func, LToCharFunction<Throwable> handler)
default LCharSupplier	LCharSupplier.tryingThen(LToCharFunction<Throwable> handler)

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

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

Modifier and Type	Method and Description
<R> LCharPair.MutCharPair	LCharPair.MutCharPair.setFirstIfArgNotNull(R arg, LToCharFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LCharPair.MutCompCharPair	LCharPair.MutCompCharPair.setFirstIfArgNotNull(R arg, LToCharFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LCharIntPair.MutCharIntPair	LCharIntPair.MutCharIntPair.setFirstIfArgNotNull(R arg, LToCharFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LCharIntPair.MutCompCharIntPair	LCharIntPair.MutCompCharIntPair.setFirstIfArgNotNull(R arg, LToCharFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjCharPair.MutObjCharPair<T>	LObjCharPair.MutObjCharPair.setSecondIfArgNotNull(R arg, LToCharFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjCharPair.MutCompObjCharPair<T>	LObjCharPair.MutCompObjCharPair.setSecondIfArgNotNull(R arg, LToCharFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LCharPair.MutCharPair	LCharPair.MutCharPair.setSecondIfArgNotNull(R arg, LToCharFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LCharPair.MutCompCharPair	LCharPair.MutCompCharPair.setSecondIfArgNotNull(R arg, LToCharFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntCharTriple.MutObjIntCharTriple<T>	LObjIntCharTriple.MutObjIntCharTriple.setThirdIfArgNotNull(R arg, LToCharFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntCharTriple.MutCompObjIntCharTriple<T>	LObjIntCharTriple.MutCompObjIntCharTriple.setThirdIfArgNotNull(R arg, LToCharFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjCharTriple.MutBiObjCharTriple<T1,T2>	LBiObjCharTriple.MutBiObjCharTriple.setThirdIfArgNotNull(R arg, LToCharFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjCharTriple.MutCompBiObjCharTriple<T1,T2>	LBiObjCharTriple.MutCompBiObjCharTriple.setThirdIfArgNotNull(R arg, LToCharFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LCharSingle.MutCharSingle	LCharSingle.MutCharSingle.setValueIfArgNotNull(R arg, LToCharFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LCharSingle.MutCompCharSingle	LCharSingle.MutCompCharSingle.setValueIfArgNotNull(R arg, LToCharFunction<R> func) Sets value derived from non-null argument, only if argument is not null.