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

Packages that use LTieFunction

Package	Description
eu.lunisolar.magma.func.consumer.primitives.obj
eu.lunisolar.magma.func.function.from
eu.lunisolar.magma.func.function.to
eu.lunisolar.magma.func.predicate

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

Methods in eu.lunisolar.magma.func.consumer.primitives.obj that return LTieFunction

Modifier and Type	Method and Description
default LTieFunction<T1,T2>	LTieConsumer.toTieFunction()

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

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

Modifier and Type	Method and Description
default LTieFunction<T1,T2>	LObjIntObjFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.

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

Subinterfaces of LTieFunction in eu.lunisolar.magma.func.function.to

Modifier and Type	Interface and Description
static interface	LTieFunction.LInt1BiObj2ToIntFunc<T1,T2> Permutation of LTieFunction for method references.
static interface	LTieFunction.LInt1Obj2Obj0ToIntFunc<T2,T1> Permutation of LTieFunction for method references.
static interface	LTieFunction.LObj0Obj2Int1ToIntFunc<T1,T2> Permutation of LTieFunction for method references.
static interface	LTieFunction.LObj2Int1Obj0ToIntFunc<T2,T1> Permutation of LTieFunction for method references.
static interface	LTieFunction.LObj2Obj0Int1ToIntFunc<T2,T1> Permutation of LTieFunction for method references.

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

Modifier and Type	Class and Description
static class	LTieFunction.LTieFunctionSingle<T1,T2>

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

Modifier and Type	Method and Description
static <T1,T2> LTieFunction<T1,T2>	LTieFunction.apply1stAsInt(LToIntFunction<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LTieFunction<T1,T2>	LTieFunction.apply2ndAsInt(LIntUnaryOperator func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2> LTieFunction<T1,T2>	LTieFunction.apply3rdAsInt(LToIntFunction<T2> func) Captures single parameter function into this interface where only 3rd parameter will be used.
default <V2,V3> LTieFunction<V2,V3>	LTieFunction.cast() Cast that replace generics.
static <V2,V3,T1,T2> LTieFunction<V2,V3>	LTieFunction.cast(LTieFunction<T1,T2> function) Cast that replace generics.
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 <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 <T1,T2> LTieFunction<T1,T2>	LTieFunction.constant(int r) Creates function that always returns the same value.
static <T1,T2> LTieFunction<T1,T2>	LTieFunction.failSafe(LTieFunction<T1,T2> func, LTieFunction<T1,T2> failSafe)
default LTieFunction<T1,T2>	LTieFunction.handling(HandlingInstructions<Throwable,RuntimeException> handling)
static <T1,T2> LTieFunction<T1,T2>	LTieFunction.recursive(LFunction<LTieFunction<T1,T2>,LTieFunction<T1,T2>> selfLambda)
static <T1,T2> LTieFunction<T1,T2>	LTieFunction.safe() Safe instance.
static <T1,T2> LTieFunction<T1,T2>	LTieFunction.safe(LTieFunction<T1,T2> other) Safe wrapping.
default LTieFunction<T1,T2>	LTieFunction.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
static <T1,T2> LTieFunction<T1,T2>	LTieFunction.tieFunc(LTieFunction<T1,T2> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T1,T2> LTieFunction<T1,T2>	LTieFunction.tieFuncThrowing(ExF<Throwable> exF)
static <T1,T2> LTieFunction<T1,T2>	LTieFunction.tieFuncThrowing(String message, ExMF<Throwable> exF)
default LTieFunction<T1,T2>	LTieFunction.trying(ExWF<RuntimeException> exF)
default LTieFunction<T1,T2>	LTieFunction.trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LTieFunction<T1,T2>	LTieFunction.tryingThen(LToIntFunction<Throwable> handler)
static <T1,T2> LTieFunction<T1,T2>	LTieFunction.uncurry(LFunction<T1,LIntFunction<LToIntFunction<T2>>> func)
default LTieFunction	LTieFunction.untyped() Cast that removes generics.
LTieFunction<T1,T2>	LTieFunction.LTieFunctionSingle.value()

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

Modifier and Type	Method and Description
static <T1,T2> LSupplier<LTieFunction<T1,T2>>	LTieFunction.safeSupplier() Safe instance supplier.
static <T1,T2> LSupplier<LTieFunction<T1,T2>>	LTieFunction.safeSupplier(LSupplier<LTieFunction<T1,T2>> supplier) Safe supplier.

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

Modifier and Type	Method and Description
static <T1,T2> int	LTieFunction.call(T1 a1, int a2, T2 a3, LTieFunction<T1,T2> lambda)
static <V2,V3,T1,T2> LTieFunction<V2,V3>	LTieFunction.cast(LTieFunction<T1,T2> function) Cast that replace generics.
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 <T1,T2> LTieFunction<T1,T2>	LTieFunction.failSafe(LTieFunction<T1,T2> func, LTieFunction<T1,T2> failSafe)
static <T1,T2> LTieFunction<T1,T2>	LTieFunction.failSafe(LTieFunction<T1,T2> func, LTieFunction<T1,T2> failSafe)
default int	LTieFunction.failSafeApplyAsInt(T1 a1, int a2, T2 a3, LTieFunction<T1,T2> failSafe)
static <T1,T2> int	LTieFunction.failSafeApplyAsInt(T1 a1, int a2, T2 a3, LTieFunction<T1,T2> func, LTieFunction<T1,T2> failSafe)
static <T1,T2> int	LTieFunction.failSafeApplyAsInt(T1 a1, int a2, T2 a3, LTieFunction<T1,T2> func, LTieFunction<T1,T2> failSafe)
static <T1,T2> void	LTieFunction.fromTill(int min_a2, int max_a2, T1 a1, T2 a3, LTieFunction<T1,T2> func) From-To.
static <T1,T2> void	LTieFunction.fromTo(int min_a2, int max_a2, T1 a1, T2 a3, LTieFunction<T1,T2> func) From-To.
static <T1,T2> int	LTieFunction.handlingApplyAsInt(T1 a1, int a2, T2 a3, LTieFunction<T1,T2> func, HandlingInstructions<Throwable,RuntimeException> handling)
static <T1,C3,T2> T1	LTieFunction.ntiForEach(LIntFunction<T1> trgFactory1, IndexedRead<C3,aType.a<T2>> ia3, C3 source3, LTieFunction<? super T1,? super T2> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH_NEW: FOR, [SourcePurpose{arg=T1 trg1, type=SIZE_FACTORY}, SourcePurpose{arg=T2 a3, type=IA}, SourcePurpose{arg=LTieFunction<? super T1,? super T2> consumer, type=CONST}]
static <T1,C3,I3,T2> T1	LTieFunction.ntiIterate(LSupplier<T1> source1, SequentialRead<C3,I3,aType.a<T2>> sa3, C3 source3, LTieFunction<? super T1,? super T2> consumer) ITERATION: TARGETED_INDEXED_ITERATE_NEW: WHILE, [SourcePurpose{arg=T1 trg1, type=SUPPLIER}, SourcePurpose{arg=T2 a3, type=SA}, SourcePurpose{arg=LTieFunction<? super T1,? super T2> consumer, type=CONST}]
static <T1,T2> LTieFunction<T1,T2>	LTieFunction.safe(LTieFunction<T1,T2> other) Safe wrapping.
static <T1,SRC,T2> int	LTieFunction.tieForEach(int sStart, int sEnd, int tStart, T1 trg1, SRC src3, LOiFunction<SRC,T2> srcAcc3, LTieFunction<? super T1,? super T2> consumer) ITERATION: TIE_CONSUMER: FOR, [SourcePurpose{arg=int sStart, type=CONST}, SourcePurpose{arg=int sEnd, type=CONST}, SourcePurpose{arg=int tStart, type=CONST}, SourcePurpose{arg=T1 trg1, type=CONST}, SourcePurpose{arg=T2 a3, type=TIE_SOURCE}, SourcePurpose{arg=T2 a3, type=TIE_SUPPLIER}, SourcePurpose{arg=LTieFunction<? super T1,? super T2> consumer, type=CONST}]
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).
static <T1,C3,T2> int	LTieFunction.tieForEach(T1 trg1, IndexedRead<C3,aType.a<T2>> ia3, C3 source3, LTieFunction<? super T1,? super T2> consumer) ITERATION: TIE_CONSUMER_SHORT: FOR, [SourcePurpose{arg=T1 trg1, type=CONST}, SourcePurpose{arg=T2 a3, type=IA}, SourcePurpose{arg=LTieFunction<? super T1,? super T2> consumer, type=CONST}]
static <T1,T2> LTieFunction<T1,T2>	LTieFunction.tieFunc(LTieFunction<T1,T2> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T1,C3,I3,T2> int	LTieFunction.tieIterate(T1 trg1, SequentialRead<C3,I3,aType.a<T2>> sa3, C3 source3, LTieFunction<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
static <T1,C3,T2> T1	LTieFunction.tiForEach(T1 trg1, IndexedRead<C3,aType.a<T2>> ia3, C3 source3, LTieFunction<? super T1,? super T2> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH: FOR, [SourcePurpose{arg=T1 trg1, type=CONST}, SourcePurpose{arg=T2 a3, type=IA}, SourcePurpose{arg=LTieFunction<? super T1,? super T2> consumer, type=CONST}]
static <T1,C3,I3,T2> T1	LTieFunction.tiIterate(T1 trg1, SequentialRead<C3,I3,aType.a<T2>> sa3, C3 source3, LTieFunction<? super T1,? super T2> consumer) For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
static <T1,T2> void	LTieFunction.times(int max_a2, T1 a1, T2 a3, LTieFunction<T1,T2> func) From-To.
static <T1,T2> int	LTieFunction.tryApplyAsInt(T1 a1, int a2, T2 a3, LTieFunction<T1,T2> func)
static <T1,T2> int	LTieFunction.tryApplyAsInt(T1 a1, int a2, T2 a3, LTieFunction<T1,T2> func, ExWF<RuntimeException> exF)
static <T1,T2> int	LTieFunction.tryApplyAsInt(T1 a1, int a2, T2 a3, LTieFunction<T1,T2> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static <T1,T2> int	LTieFunction.tryApplyAsIntThen(T1 a1, int a2, T2 a3, LTieFunction<T1,T2> func, LToIntFunction<Throwable> handler)

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

Modifier and Type	Method and Description
static <T1,T2> LTieFunction<T1,T2>	LTieFunction.recursive(LFunction<LTieFunction<T1,T2>,LTieFunction<T1,T2>> selfLambda)
static <T1,T2> LTieFunction<T1,T2>	LTieFunction.recursive(LFunction<LTieFunction<T1,T2>,LTieFunction<T1,T2>> selfLambda)
static <T1,T2> LSupplier<LTieFunction<T1,T2>>	LTieFunction.safeSupplier(LSupplier<LTieFunction<T1,T2>> supplier) Safe supplier.

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

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

Modifier and Type	Method and Description
default LTieFunction<T1,T2>	LObjIntObjPredicate.boolToTieFunc(LBoolToIntFunction after) Combines two functions together in a order.

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

Modifier and Type	Method and Description
default <V> int	LPredicate.doIf(V a1, int a2, T a3, LTieFunction<? super V,? super T> consumer)
default <V> int	LObjIntPredicate.doIf(V a1, int a2, T a3, LTieFunction<? super V,? super T> consumer)