LTriPredicate (magma-func 2.0.0 API)

All Superinterfaces:

Codomain<aType.aBool>, Domain, Domain3<aType.a<T1>,aType.a<T2>,aType.a<T3>>, Formattable, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>, MetaPredicate

All Known Subinterfaces:

LTriPredicate.LBiObj1Obj0Pred<T3,T2,T1>, LTriPredicate.LObj0Obj2Obj1Pred<T1,T3,T2>, LTriPredicate.LObj1BiObj2Pred<T2,T1,T3>, LTriPredicate.LObj1Obj2Obj0Pred<T2,T3,T1>, LTriPredicate.LObj2Obj0Obj1Pred<T3,T1,T2>

All Known Implementing Classes:

LTriPredicate.LTriPredicateSingle
```
@FunctionalInterface
public interface LTriPredicate<T1,T2,T3>
extends MetaPredicate, MetaInterface.NonThrowing, Codomain<aType.aBool>, Domain3<aType.a<T1>,aType.a<T2>,aType.a<T3>>
```
Non-throwing functional interface (lambda) LTriPredicate for Java 8.
Type: predicate
Domain (lvl: 3): T1 a1,T2 a2,T3 a3
Co-domain: boolean

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static interface`	`LTriPredicate.LBiObj1Obj0Pred<T3,T2,T1>` Permutation of LTriPredicate for method references.
`static interface`	`LTriPredicate.LObj0Obj2Obj1Pred<T1,T3,T2>` Permutation of LTriPredicate for method references.
`static interface`	`LTriPredicate.LObj1BiObj2Pred<T2,T1,T3>` Permutation of LTriPredicate for method references.
`static interface`	`LTriPredicate.LObj1Obj2Obj0Pred<T2,T3,T1>` Permutation of LTriPredicate for method references.
`static interface`	`LTriPredicate.LObj2Obj0Obj1Pred<T3,T1,T2>` Permutation of LTriPredicate for method references.
`static class`	`LTriPredicate.LTriPredicateSingle<T1,T2,T3>`

Nested classes/interfaces inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface
MetaInterface.NonThrowing, MetaInterface.Throwing<X>

Field Summary

Fields
Modifier and Type Field and Description

static String DESCRIPTION

Fields
Modifier and Type	Field and Description
`static String`	`DESCRIPTION`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`static <T1,T2,T3> boolean`	`alwaysFalse(T1 a1, T2 a2, T3 a3)` Returns FALSE.
`static <T1,T2,T3> boolean`	`alwaysTrue(T1 a1, T2 a2, T3 a3)` Returns TRUE.
`default LTriPredicate<T1,T2,T3>`	`and(LTriPredicate<? super T1,? super T2,? super T3> other)` Returns a predicate that represents the logical AND of evaluation of this predicate and the argument one.
`static <T3,T2,T1> LTriPredicate.LBiObj1Obj0Pred<T3,T2,T1>`	`biObj1Obj0Pred(LTriPredicate.LBiObj1Obj0Pred<T3,T2,T1> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`default LToIntTriFunction<T1,T2,T3>`	`boolToToIntTriFunc(LBoolToIntFunction after)` Combines two functions together in a order.
`default <V> LTriFunction<T1,T2,T3,V>`	`boolToTriFunc(LBoolFunction<? extends V> after)` Combines two functions together in a order.
`default LTriPredicate<T1,T2,T3>`	`boolToTriPred(LLogicalOperator after)` Combines two functions together in a order.
`static <T1,T2,T3> boolean`	`call(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> lambda)`
`default LBoolSupplier`	`capture(T1 a1, T2 a2, T3 a3)` Captures arguments but delays the evaluation.
`default <V2,V3,V4> LTriPredicate<V2,V3,V4>`	`cast()` Cast that replace generics.
`static <V2,V3,V4,T1,T2,T3> LTriPredicate<V2,V3,V4>`	`cast(LTriPredicate<T1,T2,T3> function)` Cast that replace generics.
`default <V1,V2,V3> LTriPredicate<V1,V2,V3>`	`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 <V1,V2,V3,T1,T2,T3> LTriPredicate<V1,V2,V3>`	`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 <T1,T2,T3> LTriPredicate<T1,T2,T3>`	`constant(boolean r)` Creates function that always returns the same value.
`default boolean`	`doApplyAsBoolean(T1 a1, T2 a2, T3 a3)` For convenience, where “test()” makes things more confusing than “applyAsBoolean()”.
`default boolean`	`doIf(T1 a1, T2 a2, T3 a3, LAction action)`
`default boolean`	`doIf(T1 a1, T2 a2, T3 a3, LTriConsumer<? super T1,? super T2,? super T3> consumer)`
`static <T1,T2,T3> boolean`	`doIf(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> predicate, LAction action)`
`static <T1,T2,T3> boolean`	`doIf(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> predicate, LTriConsumer<? super T1,? super T2,? super T3> consumer)`
`static <T1,T2,T3> LTriPredicate<T1,T2,T3>`	`failSafe(LTriPredicate<T1,T2,T3> func, LTriPredicate<T1,T2,T3> failSafe)`
`default boolean`	`failSafeTest(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> failSafe)`
`static <T1,T2,T3> boolean`	`failSafeTest(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> func, LTriPredicate<T1,T2,T3> failSafe)`
`default <C1,C2,C3> void`	`filterForEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)` For each element (or tuple) from arguments, calls the consumer if predicate test passes.
`default <C1,C2,C3,I3> void`	`filterIterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)` For each element (or tuple) from arguments, calls the consumer if predicate test passes.
`default <C1,C2,I2,C3> void`	`filterIterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)` For each element (or tuple) from arguments, calls the consumer if predicate test passes.
`default <C1,C2,I2,C3,I3> void`	`filterIterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)` For each element (or tuple) from arguments, calls the consumer if predicate test passes.
`default <C1,I1,C2,C3> void`	`filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)` For each element (or tuple) from arguments, calls the consumer if predicate test passes.
`default <C1,I1,C2,C3,I3> void`	`filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)` For each element (or tuple) from arguments, calls the consumer if predicate test passes.
`default <C1,I1,C2,I2,C3> void`	`filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)` For each element (or tuple) from arguments, calls the consumer if predicate test passes.
`default <C1,I1,C2,I2,C3,I3> void`	`filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)` For each element (or tuple) from arguments, calls the consumer if predicate test passes.
`static <T1,T2,T3> void`	`fromTill(int min_i, int max_i, T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> func)` From-To.
`static <T1,T2,T3> void`	`fromTo(int min_i, int max_i, T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> func)` From-To.
`default String`	`functionalInterfaceDescription()` Returns description of the functional interface.
`default LTriPredicate<T1,T2,T3>`	`handling(HandlingInstructions<Throwable,RuntimeException> handling)`
`default boolean`	`handlingTest(T1 a1, T2 a2, T3 a3, HandlingInstructions<Throwable,RuntimeException> handling)` Function call that handles exceptions according to the instructions.
`static <T1,T2,T3> boolean`	`handlingTest(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> func, HandlingInstructions<Throwable,RuntimeException> handling)`
`static <T1,T2,T3> LTriPredicate<T1,T2,T3>`	`isEqual(T1 v1, T2 v2, T3 v3)` Creates predicate that evaluates if an object is equal with the argument one.
`default LBiPredicate<T2,T3>`	`lShrink(LBiFunction<T2,T3,T1> left)`
`default LBiPredicate<T2,T3>`	`lShrinkc(T1 a1)`
`static <T2,T3,T1> LBiPredicate<T2,T3>`	`lShrinked(LBiFunction<T2,T3,T1> left, LTriPredicate<T1,T2,T3> func)`
`static <T2,T3,T1> LBiPredicate<T2,T3>`	`lShrinkedc(T1 a1, LTriPredicate<T1,T2,T3> func)`
`default LTriPredicate<T1,T2,T3>`	`negate()` Returns a predicate that represents the logical negation of this predicate.
`default boolean`	`nestingTest(T1 a1, T2 a2, T3 a3)` Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
`default boolean`	`nonNullTest(T1 a1, T2 a2, T3 a3)` Just to mirror the method: Ensures the result is not null
`static <T1,T3,T2> LTriPredicate.LObj0Obj2Obj1Pred<T1,T3,T2>`	`obj0Obj2Obj1Pred(LTriPredicate.LObj0Obj2Obj1Pred<T1,T3,T2> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`static <T2,T1,T3> LTriPredicate.LObj1BiObj2Pred<T2,T1,T3>`	`obj1BiObj2Pred(LTriPredicate.LObj1BiObj2Pred<T2,T1,T3> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`static <T2,T3,T1> LTriPredicate.LObj1Obj2Obj0Pred<T2,T3,T1>`	`obj1Obj2Obj0Pred(LTriPredicate.LObj1Obj2Obj0Pred<T2,T3,T1> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`static <T3,T1,T2> LTriPredicate.LObj2Obj0Obj1Pred<T3,T1,T2>`	`obj2Obj0Obj1Pred(LTriPredicate.LObj2Obj0Obj1Pred<T3,T1,T2> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`default LTriPredicate<T1,T2,T3>`	`or(LTriPredicate<? super T1,? super T2,? super T3> other)` Returns a predicate that represents the logical OR of evaluation of this predicate and the argument one.
`static <T1,T2,T3> LTriPredicate<T1,T2,T3>`	`recursive(LFunction<LTriPredicate<T1,T2,T3>,LTriPredicate<T1,T2,T3>> selfLambda)`
`default LBiPredicate<T1,T2>`	`rShrink(LBiFunction<T1,T2,T3> right)`
`default LBiPredicate<T1,T2>`	`rShrinkc(T3 a3)`
`static <T1,T2,T3> LBiPredicate<T1,T2>`	`rShrinked(LBiFunction<T1,T2,T3> right, LTriPredicate<T1,T2,T3> func)`
`static <T1,T2,T3> LBiPredicate<T1,T2>`	`rShrinkedc(T3 a3, LTriPredicate<T1,T2,T3> func)`
`static <T1,T2,T3> LTriPredicate<T1,T2,T3>`	`safe()` Safe instance.
`static <T1,T2,T3> LTriPredicate<T1,T2,T3>`	`safe(LTriPredicate<T1,T2,T3> other)` Safe wrapping.
`static <T1,T2,T3> LSupplier<LTriPredicate<T1,T2,T3>>`	`safeSupplier()` Safe instance supplier.
`static <T1,T2,T3> LSupplier<LTriPredicate<T1,T2,T3>>`	`safeSupplier(LSupplier<LTriPredicate<T1,T2,T3>> supplier)` Safe supplier.
`default boolean`	`shovingTest(T1 a1, T2 a2, T3 a3)` Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
`default boolean`	`test(T1 a1, T2 a2, T3 a3)`
`default boolean`	`test(T1 a1, T2 a2, T3 a3, ExWF<RuntimeException> exF)`
`default boolean`	`test(T1 a1, T2 a2, T3 a3, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static <T1,T2,T3> LTriPredicate<T1,T2,T3>`	`test1st(LPredicate<T1> func)` Captures single parameter function into this interface where only 1st parameter will be used.
`static <T1,T2,T3> LTriPredicate<T1,T2,T3>`	`test2nd(LPredicate<T2> func)` Captures single parameter function into this interface where only 2nd parameter will be used.
`static <T1,T2,T3> LTriPredicate<T1,T2,T3>`	`test3rd(LPredicate<T3> func)` Captures single parameter function into this interface where only 3rd parameter will be used.
`default boolean`	`testThen(T1 a1, T2 a2, T3 a3, LPredicate<Throwable> handler)`
`boolean`	`testX(T1 a1, T2 a2, T3 a3)` Implement this, but call test(T1 a1,T2 a2,T3 a3)
`static <T1,T2,T3> void`	`throwIf(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> pred, ExMF<RuntimeException> factory, String newMessage, Object... messageParams)`
`static <T1,T2,T3> void`	`throwIfNot(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> pred, ExMF<RuntimeException> factory, String newMessage, Object... messageParams)`
`static <T1,T2,T3> void`	`times(int max_i, T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> func)` From-To.
`static <T1,T2,T3> LTriPredicate<T1,T2,T3>`	`triPred(LTriPredicate<T1,T2,T3> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`static <T1,T2,T3> LTriPredicate<T1,T2,T3>`	`triPredThrowing(ExF<Throwable> exF)`
`static <T1,T2,T3> LTriPredicate<T1,T2,T3>`	`triPredThrowing(String message, ExMF<Throwable> exF)`
`default LTriPredicate<T1,T2,T3>`	`trying(ExWF<RuntimeException> exF)`
`default LTriPredicate<T1,T2,T3>`	`trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default LTriPredicate<T1,T2,T3>`	`tryingThen(LPredicate<Throwable> handler)`
`static <T1,T2,T3> boolean`	`tryTest(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> func)`
`static <T1,T2,T3> boolean`	`tryTest(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> func, ExWF<RuntimeException> exF)`
`static <T1,T2,T3> boolean`	`tryTest(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static <T1,T2,T3> boolean`	`tryTestThen(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> func, LPredicate<Throwable> handler)`
`default boolean`	`tupleTest(LTriple<T1,T2,T3> args)`
`static <T1,T2,T3> LTriPredicate<T1,T2,T3>`	`uncurry(LFunction<T1,LFunction<T2,LPredicate<T3>>> func)`
`default LTriPredicate`	`untyped()` Cast that removes generics.
`default LTriPredicate<T1,T2,T3>`	`xor(LTriPredicate<? super T1,? super T2,? super T3> other)` Returns a predicate that represents the logical XOR of evaluation of this predicate and the argument one.

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.type.MetaPredicate
isPredicate

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.type.MetaFunction
isFunction

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.MetaFunctionalInterface
formatTo, isAction, isConsumer, isOperator, isSupplier

Methods inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface
isThrowing

Methods inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface.NonThrowing
isThrowing

Field Detail
- DESCRIPTION
```
static final String DESCRIPTION
```
  See Also:
  
  Constant Field Values

Method Detail

test

default boolean test(T1 a1,
                     T2 a2,
                     T3 a3)

testX

boolean testX(T1 a1,
              T2 a2,
              T3 a3)
       throws Throwable

Implement this, but call test(T1 a1,T2 a2,T3 a3)

Throws:: Throwable

tupleTest

default boolean tupleTest(LTriple<T1,T2,T3> args)

handlingTest

default boolean handlingTest(T1 a1,
                             T2 a2,
                             T3 a3,
                             HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

default LTriPredicate<T1,T2,T3> handling(HandlingInstructions<Throwable,RuntimeException> handling)

test

default boolean test(T1 a1,
                     T2 a2,
                     T3 a3,
                     @Nonnull
                     ExWMF<RuntimeException> exF,
                     @Nonnull
                     String newMessage,
                     @Nullable
                     Object... messageParams)

trying

default LTriPredicate<T1,T2,T3> trying(@Nonnull
                                       ExWMF<RuntimeException> exF,
                                       @Nonnull
                                       String newMessage,
                                       @Nullable
                                       Object... messageParams)

test

default boolean test(T1 a1,
                     T2 a2,
                     T3 a3,
                     @Nonnull
                     ExWF<RuntimeException> exF)

trying

default LTriPredicate<T1,T2,T3> trying(@Nonnull
                                       ExWF<RuntimeException> exF)

testThen

default boolean testThen(T1 a1,
                         T2 a2,
                         T3 a3,
                         @Nonnull
                         LPredicate<Throwable> handler)

tryingThen

default LTriPredicate<T1,T2,T3> tryingThen(@Nonnull
                                           LPredicate<Throwable> handler)

nestingTest

default boolean nestingTest(T1 a1,
                            T2 a2,
                            T3 a3)

Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.

shovingTest

default boolean shovingTest(T1 a1,
                            T2 a2,
                            T3 a3)

Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.

handlingTest

static <T1,T2,T3> boolean handlingTest(T1 a1,
                                       T2 a2,
                                       T3 a3,
                                       LTriPredicate<T1,T2,T3> func,
                                       HandlingInstructions<Throwable,RuntimeException> handling)

tryTest

static <T1,T2,T3> boolean tryTest(T1 a1,
                                  T2 a2,
                                  T3 a3,
                                  LTriPredicate<T1,T2,T3> func)

tryTest

static <T1,T2,T3> boolean tryTest(T1 a1,
                                  T2 a2,
                                  T3 a3,
                                  LTriPredicate<T1,T2,T3> func,
                                  @Nonnull
                                  ExWMF<RuntimeException> exF,
                                  @Nonnull
                                  String newMessage,
                                  @Nullable
                                  Object... messageParams)

tryTest

static <T1,T2,T3> boolean tryTest(T1 a1,
                                  T2 a2,
                                  T3 a3,
                                  LTriPredicate<T1,T2,T3> func,
                                  @Nonnull
                                  ExWF<RuntimeException> exF)

tryTestThen

static <T1,T2,T3> boolean tryTestThen(T1 a1,
                                      T2 a2,
                                      T3 a3,
                                      LTriPredicate<T1,T2,T3> func,
                                      @Nonnull
                                      LPredicate<Throwable> handler)

failSafeTest

default boolean failSafeTest(T1 a1,
                             T2 a2,
                             T3 a3,
                             @Nonnull
                             LTriPredicate<T1,T2,T3> failSafe)

failSafeTest

static <T1,T2,T3> boolean failSafeTest(T1 a1,
                                       T2 a2,
                                       T3 a3,
                                       LTriPredicate<T1,T2,T3> func,
                                       @Nonnull
                                       LTriPredicate<T1,T2,T3> failSafe)

failSafe

static <T1,T2,T3> LTriPredicate<T1,T2,T3> failSafe(LTriPredicate<T1,T2,T3> func,
                                                   @Nonnull
                                                   LTriPredicate<T1,T2,T3> failSafe)

doIf

default boolean doIf(T1 a1,
                     T2 a2,
                     T3 a3,
                     LAction action)

doIf

static <T1,T2,T3> boolean doIf(T1 a1,
                               T2 a2,
                               T3 a3,
                               @Nonnull
                               LTriPredicate<T1,T2,T3> predicate,
                               @Nonnull
                               LAction action)

doIf

static <T1,T2,T3> boolean doIf(T1 a1,
                               T2 a2,
                               T3 a3,
                               @Nonnull
                               LTriPredicate<T1,T2,T3> predicate,
                               @Nonnull
                               LTriConsumer<? super T1,? super T2,? super T3> consumer)

doIf

default boolean doIf(T1 a1,
                     T2 a2,
                     T3 a3,
                     @Nonnull
                     LTriConsumer<? super T1,? super T2,? super T3> consumer)

throwIf

static <T1,T2,T3> void throwIf(T1 a1,
                               T2 a2,
                               T3 a3,
                               LTriPredicate<T1,T2,T3> pred,
                               ExMF<RuntimeException> factory,
                               @Nonnull
                               String newMessage,
                               @Nullable
                               Object... messageParams)

throwIfNot

static <T1,T2,T3> void throwIfNot(T1 a1,
                                  T2 a2,
                                  T3 a3,
                                  LTriPredicate<T1,T2,T3> pred,
                                  ExMF<RuntimeException> factory,
                                  @Nonnull
                                  String newMessage,
                                  @Nullable
                                  Object... messageParams)

nonNullTest

default boolean nonNullTest(T1 a1,
                            T2 a2,
                            T3 a3)

Just to mirror the method: Ensures the result is not null

doApplyAsBoolean

default boolean doApplyAsBoolean(T1 a1,
                                 T2 a2,
                                 T3 a3)

For convenience, where “test()” makes things more confusing than “applyAsBoolean()”.

functionalInterfaceDescription
```
@Nonnull
default String functionalInterfaceDescription()
```
Returns description of the functional interface.

Specified by:

functionalInterfaceDescription in interface MetaFunctionalInterface

fromTo

static <T1,T2,T3> void fromTo(int min_i,
                              int max_i,
                              T1 a1,
                              T2 a2,
                              T3 a3,
                              LTriPredicate<T1,T2,T3> func)

From-To. Intended to be used with non-capturing lambda.

fromTill

static <T1,T2,T3> void fromTill(int min_i,
                                int max_i,
                                T1 a1,
                                T2 a2,
                                T3 a3,
                                LTriPredicate<T1,T2,T3> func)

From-To. Intended to be used with non-capturing lambda.

times

static <T1,T2,T3> void times(int max_i,
                             T1 a1,
                             T2 a2,
                             T3 a3,
                             LTriPredicate<T1,T2,T3> func)

From-To. Intended to be used with non-capturing lambda.

lShrink

default LBiPredicate<T2,T3> lShrink(LBiFunction<T2,T3,T1> left)

lShrinkc

default LBiPredicate<T2,T3> lShrinkc(T1 a1)

lShrinked

static <T2,T3,T1> LBiPredicate<T2,T3> lShrinked(LBiFunction<T2,T3,T1> left,
                                                LTriPredicate<T1,T2,T3> func)

lShrinkedc

static <T2,T3,T1> LBiPredicate<T2,T3> lShrinkedc(T1 a1,
                                                 LTriPredicate<T1,T2,T3> func)

rShrink

default LBiPredicate<T1,T2> rShrink(LBiFunction<T1,T2,T3> right)

rShrinkc

default LBiPredicate<T1,T2> rShrinkc(T3 a3)

rShrinked

static <T1,T2,T3> LBiPredicate<T1,T2> rShrinked(LBiFunction<T1,T2,T3> right,
                                                LTriPredicate<T1,T2,T3> func)

rShrinkedc

static <T1,T2,T3> LBiPredicate<T1,T2> rShrinkedc(T3 a3,
                                                 LTriPredicate<T1,T2,T3> func)

uncurry

static <T1,T2,T3> LTriPredicate<T1,T2,T3> uncurry(LFunction<T1,LFunction<T2,LPredicate<T3>>> func)

untyped
```
default LTriPredicate untyped()
```
Cast that removes generics.

cast

default <V2,V3,V4> LTriPredicate<V2,V3,V4> cast()

Cast that replace generics.

cast

static <V2,V3,V4,T1,T2,T3> LTriPredicate<V2,V3,V4> cast(LTriPredicate<T1,T2,T3> function)

Cast that replace generics.

capture

default LBoolSupplier capture(T1 a1,
                              T2 a2,
                              T3 a3)

Captures arguments but delays the evaluation.

constant

static <T1,T2,T3> LTriPredicate<T1,T2,T3> constant(boolean r)

Creates function that always returns the same value.

test1st

@Nonnull
static <T1,T2,T3> LTriPredicate<T1,T2,T3> test1st(@Nonnull
                                                            LPredicate<T1> func)

Captures single parameter function into this interface where only 1st parameter will be used.

test2nd

@Nonnull
static <T1,T2,T3> LTriPredicate<T1,T2,T3> test2nd(@Nonnull
                                                            LPredicate<T2> func)

Captures single parameter function into this interface where only 2nd parameter will be used.

test3rd

@Nonnull
static <T1,T2,T3> LTriPredicate<T1,T2,T3> test3rd(@Nonnull
                                                            LPredicate<T3> func)

Captures single parameter function into this interface where only 3rd parameter will be used.

triPred

@Nonnull
static <T1,T2,T3> LTriPredicate<T1,T2,T3> triPred(@Nonnull
                                                            LTriPredicate<T1,T2,T3> lambda)

Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).

recursive

@Nonnull
static <T1,T2,T3> LTriPredicate<T1,T2,T3> recursive(@Nonnull
                                                              LFunction<LTriPredicate<T1,T2,T3>,LTriPredicate<T1,T2,T3>> selfLambda)

triPredThrowing

@Nonnull
static <T1,T2,T3> LTriPredicate<T1,T2,T3> triPredThrowing(@Nonnull
                                                                    ExF<Throwable> exF)

triPredThrowing

@Nonnull
static <T1,T2,T3> LTriPredicate<T1,T2,T3> triPredThrowing(String message,
                                                                    @Nonnull
                                                                    ExMF<Throwable> exF)

obj0Obj2Obj1Pred

@Nonnull
static <T1,T3,T2> LTriPredicate.LObj0Obj2Obj1Pred<T1,T3,T2> obj0Obj2Obj1Pred(@Nonnull
                                                                                       LTriPredicate.LObj0Obj2Obj1Pred<T1,T3,T2> lambda)

Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).

obj1BiObj2Pred

@Nonnull
static <T2,T1,T3> LTriPredicate.LObj1BiObj2Pred<T2,T1,T3> obj1BiObj2Pred(@Nonnull
                                                                                   LTriPredicate.LObj1BiObj2Pred<T2,T1,T3> lambda)

Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).

obj1Obj2Obj0Pred

@Nonnull
static <T2,T3,T1> LTriPredicate.LObj1Obj2Obj0Pred<T2,T3,T1> obj1Obj2Obj0Pred(@Nonnull
                                                                                       LTriPredicate.LObj1Obj2Obj0Pred<T2,T3,T1> lambda)

Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).

obj2Obj0Obj1Pred

@Nonnull
static <T3,T1,T2> LTriPredicate.LObj2Obj0Obj1Pred<T3,T1,T2> obj2Obj0Obj1Pred(@Nonnull
                                                                                       LTriPredicate.LObj2Obj0Obj1Pred<T3,T1,T2> lambda)

Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).

biObj1Obj0Pred

@Nonnull
static <T3,T2,T1> LTriPredicate.LBiObj1Obj0Pred<T3,T2,T1> biObj1Obj0Pred(@Nonnull
                                                                                   LTriPredicate.LBiObj1Obj0Pred<T3,T2,T1> lambda)

Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).

call

static <T1,T2,T3> boolean call(T1 a1,
                               T2 a2,
                               T3 a3,
                               @Nonnull
                               LTriPredicate<T1,T2,T3> lambda)

safe
```
@Nonnull
static <T1,T2,T3> LTriPredicate<T1,T2,T3> safe()
```
Safe instance. That always returns the same value (as alwaysFalse).

safeSupplier

@Nonnull
static <T1,T2,T3> LSupplier<LTriPredicate<T1,T2,T3>> safeSupplier()

Safe instance supplier. Returns supplier of safe() instance.

safe

@Nonnull
static <T1,T2,T3> LTriPredicate<T1,T2,T3> safe(@Nullable
                                                         LTriPredicate<T1,T2,T3> other)

Safe wrapping. Either argument function is returned (if it is not null) or safe() instance.

safeSupplier

@Nonnull
static <T1,T2,T3> LSupplier<LTriPredicate<T1,T2,T3>> safeSupplier(@Nullable
                                                                            LSupplier<LTriPredicate<T1,T2,T3>> supplier)

Safe supplier. Either argument supplier is returned (if it is not null) or supplier of safe() instance.

negate
```
@Nonnull
default LTriPredicate<T1,T2,T3> negate()
```
Returns a predicate that represents the logical negation of this predicate.

See Also:

java.util.function.Predicate#negate}

and

@Nonnull
default LTriPredicate<T1,T2,T3> and(@Nonnull
                                              LTriPredicate<? super T1,? super T2,? super T3> other)

Returns a predicate that represents the logical AND of evaluation of this predicate and the argument one.

See Also:: java.util.function.Predicate#and()}

or

@Nonnull
default LTriPredicate<T1,T2,T3> or(@Nonnull
                                             LTriPredicate<? super T1,? super T2,? super T3> other)

Returns a predicate that represents the logical OR of evaluation of this predicate and the argument one.

See Also:: java.util.function.Predicate#or}

xor

@Nonnull
default LTriPredicate<T1,T2,T3> xor(@Nonnull
                                              LTriPredicate<? super T1,? super T2,? super T3> other)

Returns a predicate that represents the logical XOR of evaluation of this predicate and the argument one.

See Also:: java.util.function.Predicate#or}

isEqual

@Nonnull
static <T1,T2,T3> LTriPredicate<T1,T2,T3> isEqual(T1 v1,
                                                            T2 v2,
                                                            T3 v3)

Creates predicate that evaluates if an object is equal with the argument one.

See Also:: java.util.function.Predicate#isEqual()

compose

@Nonnull
default <V1,V2,V3> LTriPredicate<V1,V2,V3> compose(@Nonnull
                                                             LFunction<? super V1,? extends T1> before1,
                                                             @Nonnull
                                                             LFunction<? super V2,? extends T2> before2,
                                                             @Nonnull
                                                             LFunction<? super V3,? extends T3> before3)

Allows to manipulate the domain of the function.

composed

static <V1,V2,V3,T1,T2,T3> LTriPredicate<V1,V2,V3> composed(@Nonnull
                                                            LFunction<? super V1,? extends T1> before1,
                                                            @Nonnull
                                                            LFunction<? super V2,? extends T2> before2,
                                                            @Nonnull
                                                            LFunction<? super V3,? extends T3> before3,
                                                            LTriPredicate<T1,T2,T3> after)

boolToTriFunc

@Nonnull
default <V> LTriFunction<T1,T2,T3,V> boolToTriFunc(@Nonnull
                                                             LBoolFunction<? extends V> after)

Combines two functions together in a order.

boolToToIntTriFunc

@Nonnull
default LToIntTriFunction<T1,T2,T3> boolToToIntTriFunc(@Nonnull
                                                                 LBoolToIntFunction after)

Combines two functions together in a order.

boolToTriPred

@Nonnull
default LTriPredicate<T1,T2,T3> boolToTriPred(@Nonnull
                                                        LLogicalOperator after)

Combines two functions together in a order.

alwaysTrue

static <T1,T2,T3> boolean alwaysTrue(T1 a1,
                                     T2 a2,
                                     T3 a3)

Returns TRUE.

alwaysFalse

static <T1,T2,T3> boolean alwaysFalse(T1 a1,
                                      T2 a2,
                                      T3 a3)

Returns FALSE.