LBiPredicate (magma-func 2.0.0 API)

All Superinterfaces:

java.util.function.BiPredicate<T1,T2>, Codomain<aType.aBool>, Domain, Domain2<aType.a<T1>,aType.a<T2>>, Formattable, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>, MetaPredicate

All Known Subinterfaces:

LBiPredicate.LObj1Obj0Pred<T2,T1>

All Known Implementing Classes:

LBiPredicate.LBiPredicateSingle
```
@FunctionalInterface
public interface LBiPredicate<T1,T2>
extends java.util.function.BiPredicate<T1,T2>, MetaPredicate, MetaInterface.NonThrowing, Codomain<aType.aBool>, Domain2<aType.a<T1>,aType.a<T2>>
```
Non-throwing functional interface (lambda) LBiPredicate for Java 8.
Type: predicate
Domain (lvl: 2): T1 a1,T2 a2
Co-domain: boolean

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static class`	`LBiPredicate.LBiPredicateSingle<T1,T2>`
`static interface`	`LBiPredicate.LObj1Obj0Pred<T2,T1>` Permutation of LBiPredicate for method references.

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> boolean`	`alwaysFalse(T1 a1, T2 a2)` Returns FALSE.
`static <T1,T2> boolean`	`alwaysTrue(T1 a1, T2 a2)` Returns TRUE.
`default LBiPredicate<T1,T2>`	`and(LBiPredicate<? super T1,? super T2> other)` Returns a predicate that represents the logical AND of evaluation of this predicate and the argument one.
`static <T1,T2> LBiPredicate<T1,T2>`	`biPred(LBiPredicate<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> LBiPredicate<T1,T2>`	`biPredThrowing(ExF<Throwable> exF)`
`static <T1,T2> LBiPredicate<T1,T2>`	`biPredThrowing(String message, ExMF<Throwable> exF)`
`default <V> LBiFunction<T1,T2,V>`	`boolToBiFunc(LBoolFunction<? extends V> after)` Combines two functions together in a order.
`default LBiPredicate<T1,T2>`	`boolToBiPred(LLogicalOperator after)` Combines two functions together in a order.
`default LToByteBiFunction<T1,T2>`	`boolToToByteBiFunc(LBoolToByteFunction after)` Combines two functions together in a order.
`default LToCharBiFunction<T1,T2>`	`boolToToCharBiFunc(LBoolToCharFunction after)` Combines two functions together in a order.
`default LToDblBiFunction<T1,T2>`	`boolToToDblBiFunc(LBoolToDblFunction after)` Combines two functions together in a order.
`default LToFltBiFunction<T1,T2>`	`boolToToFltBiFunc(LBoolToFltFunction after)` Combines two functions together in a order.
`default LToIntBiFunction<T1,T2>`	`boolToToIntBiFunc(LBoolToIntFunction after)` Combines two functions together in a order.
`default LToLongBiFunction<T1,T2>`	`boolToToLongBiFunc(LBoolToLongFunction after)` Combines two functions together in a order.
`default LToSrtBiFunction<T1,T2>`	`boolToToSrtBiFunc(LBoolToSrtFunction after)` Combines two functions together in a order.
`static <T1,T2> boolean`	`call(T1 a1, T2 a2, LBiPredicate<T1,T2> lambda)`
`default LBoolSupplier`	`capture(T1 a1, T2 a2)` Captures arguments but delays the evaluation.
`default <V2,V3> LBiPredicate<V2,V3>`	`cast()` Cast that replace generics.
`static <V2,V3,T1,T2> LBiPredicate<V2,V3>`	`cast(LBiPredicate<T1,T2> function)` Cast that replace generics.
`default <V1,V2> LBiPredicate<V1,V2>`	`compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2)` Allows to manipulate the domain of the function.
`static <V1,V2,T1,T2> LBiPredicate<V1,V2>`	`composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LBiPredicate<T1,T2> after)`
`static <T1,T2> LBiPredicate<T1,T2>`	`constant(boolean r)` Creates function that always returns the same value.
`default boolean`	`doApplyAsBoolean(T1 a1, T2 a2)` For convenience, where “test()” makes things more confusing than “applyAsBoolean()”.
`default boolean`	`doIf(T1 a1, T2 a2, LAction action)`
`default boolean`	`doIf(T1 a1, T2 a2, LBiConsumer<? super T1,? super T2> consumer)`
`static <T1,T2> boolean`	`doIf(T1 a1, T2 a2, LBiPredicate<T1,T2> predicate, LAction action)`
`static <T1,T2> boolean`	`doIf(T1 a1, T2 a2, LBiPredicate<T1,T2> predicate, LBiConsumer<? super T1,? super T2> consumer)`
`default <V> int`	`doIf(V a1, T1 a2, T2 a3, LToIntTriFunction<V,? super T1,? super T2> consumer)` 2
`default <V> boolean`	`doIf(V a1, T1 a2, T2 a3, LTriConsumer<V,? super T1,? super T2> consumer)`
`static <T1,T2> LBiPredicate<T1,T2>`	`failSafe(LBiPredicate<T1,T2> func, LBiPredicate<T1,T2> failSafe)`
`default boolean`	`failSafeTest(T1 a1, T2 a2, LBiPredicate<T1,T2> failSafe)`
`static <T1,T2> boolean`	`failSafeTest(T1 a1, T2 a2, LBiPredicate<T1,T2> func, LBiPredicate<T1,T2> failSafe)`
`default <C1,C2> void`	`filterForEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, LBiConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer if predicate test passes.
`default <C1,C2,I2> void`	`filterIterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, LBiConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer if predicate test passes.
`default <C1,I1,C2> void`	`filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, LBiConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer if predicate test passes.
`default <C1,I1,C2,I2> void`	`filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, LBiConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer if predicate test passes.
`static <T1,T2> void`	`fromTill(int min_i, int max_i, T1 a1, T2 a2, LBiPredicate<T1,T2> func)` From-To.
`static <T1,T2> void`	`fromTo(int min_i, int max_i, T1 a1, T2 a2, LBiPredicate<T1,T2> func)` From-To.
`default String`	`functionalInterfaceDescription()` Returns description of the functional interface.
`default LBiPredicate<T1,T2>`	`handling(HandlingInstructions<Throwable,RuntimeException> handling)`
`default boolean`	`handlingTest(T1 a1, T2 a2, HandlingInstructions<Throwable,RuntimeException> handling)` Function call that handles exceptions according to the instructions.
`static <T1,T2> boolean`	`handlingTest(T1 a1, T2 a2, LBiPredicate<T1,T2> func, HandlingInstructions<Throwable,RuntimeException> handling)`
`static <T1,T2> LBiPredicate<T1,T2>`	`isEqual(T1 v1, T2 v2)` Creates predicate that evaluates if an object is equal with the argument one.
`default LPredicate<T2>`	`lShrink(LFunction<T2,T1> left)`
`default LPredicate<T2>`	`lShrinkc(T1 a1)`
`static <T2,T1> LPredicate<T2>`	`lShrinked(LFunction<T2,T1> left, LBiPredicate<T1,T2> func)`
`static <T2,T1> LPredicate<T2>`	`lShrinkedc(T1 a1, LBiPredicate<T1,T2> func)`
`default LBiPredicate<T1,T2>`	`negate()` Returns a predicate that represents the logical negation of this predicate.
`default boolean`	`nestingTest(T1 a1, T2 a2)` Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
`default boolean`	`nonNullTest(T1 a1, T2 a2)` Just to mirror the method: Ensures the result is not null
`static <T2,T1> LBiPredicate.LObj1Obj0Pred<T2,T1>`	`obj1Obj0Pred(LBiPredicate.LObj1Obj0Pred<T2,T1> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`default LBiPredicate<T1,T2>`	`or(LBiPredicate<? super T1,? super T2> other)` Returns a predicate that represents the logical OR of evaluation of this predicate and the argument one.
`static <T1,T2> LBiPredicate<T1,T2>`	`recursive(LFunction<LBiPredicate<T1,T2>,LBiPredicate<T1,T2>> selfLambda)`
`default LPredicate<T1>`	`rShrink(LFunction<T1,T2> right)`
`default LPredicate<T1>`	`rShrinkc(T2 a2)`
`static <T1,T2> LPredicate<T1>`	`rShrinked(LFunction<T1,T2> right, LBiPredicate<T1,T2> func)`
`static <T1,T2> LPredicate<T1>`	`rShrinkedc(T2 a2, LBiPredicate<T1,T2> func)`
`static <T1,T2> LBiPredicate<T1,T2>`	`safe()` Safe instance.
`static <T1,T2> LBiPredicate<T1,T2>`	`safe(LBiPredicate<T1,T2> other)` Safe wrapping.
`static <T1,T2> LSupplier<LBiPredicate<T1,T2>>`	`safeSupplier()` Safe instance supplier.
`static <T1,T2> LSupplier<LBiPredicate<T1,T2>>`	`safeSupplier(LSupplier<LBiPredicate<T1,T2>> supplier)` Safe supplier.
`default boolean`	`shovingTest(T1 a1, T2 a2)` 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)`
`default boolean`	`test(T1 a1, T2 a2, ExWF<RuntimeException> exF)`
`default boolean`	`test(T1 a1, T2 a2, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static <T1,T2> LBiPredicate<T1,T2>`	`test1st(LPredicate<T1> func)` Captures single parameter function into this interface where only 1st parameter will be used.
`static <T1,T2> LBiPredicate<T1,T2>`	`test2nd(LPredicate<T2> func)` Captures single parameter function into this interface where only 2nd parameter will be used.
`default boolean`	`testThen(T1 a1, T2 a2, LPredicate<Throwable> handler)`
`boolean`	`testX(T1 a1, T2 a2)` Implement this, but call test(T1 a1,T2 a2)
`static <T1,T2> void`	`throwIf(T1 a1, T2 a2, LBiPredicate<T1,T2> pred, ExMF<RuntimeException> factory, String newMessage, Object... messageParams)`
`static <T1,T2> void`	`throwIfNot(T1 a1, T2 a2, LBiPredicate<T1,T2> pred, ExMF<RuntimeException> factory, String newMessage, Object... messageParams)`
`static <T1,T2> void`	`times(int max_i, T1 a1, T2 a2, LBiPredicate<T1,T2> func)` From-To.
`default LBiPredicate<T1,T2>`	`trying(ExWF<RuntimeException> exF)`
`default LBiPredicate<T1,T2>`	`trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default LBiPredicate<T1,T2>`	`tryingThen(LPredicate<Throwable> handler)`
`static <T1,T2> boolean`	`tryTest(T1 a1, T2 a2, LBiPredicate<T1,T2> func)`
`static <T1,T2> boolean`	`tryTest(T1 a1, T2 a2, LBiPredicate<T1,T2> func, ExWF<RuntimeException> exF)`
`static <T1,T2> boolean`	`tryTest(T1 a1, T2 a2, LBiPredicate<T1,T2> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static <T1,T2> boolean`	`tryTestThen(T1 a1, T2 a2, LBiPredicate<T1,T2> func, LPredicate<Throwable> handler)`
`default boolean`	`tupleTest(LPair<T1,T2> args)`
`static <T1,T2> LBiPredicate<T1,T2>`	`uncurry(LFunction<T1,LPredicate<T2>> func)`
`default LBiPredicate`	`untyped()` Cast that removes generics.
`static <T1,T2> LBiPredicate<T1,T2>`	`wrap(java.util.function.BiPredicate<T1,T2> other)` Wraps JRE instance.
`default LBiPredicate<T1,T2>`	`xor(LBiPredicate<? super T1,? super T2> other)` Returns a predicate that represents the logical XOR of evaluation of this predicate and the argument one.

Methods inherited from interface java.util.function.BiPredicate
and, or

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)

Specified by:: test in interface java.util.function.BiPredicate<T1,T2>

testX

boolean testX(T1 a1,
              T2 a2)
       throws Throwable

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

Throws:: Throwable

tupleTest

default boolean tupleTest(LPair<T1,T2> args)

handlingTest

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

Function call that handles exceptions according to the instructions.

handling

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

test

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

trying

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

test

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

trying

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

testThen

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

tryingThen

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

nestingTest
```
default boolean nestingTest(T1 a1,
                            T2 a2)
```
Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.

shovingTest
```
default boolean shovingTest(T1 a1,
                            T2 a2)
```
Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.

handlingTest

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

tryTest

static <T1,T2> boolean tryTest(T1 a1,
                               T2 a2,
                               LBiPredicate<T1,T2> func)

tryTest

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

tryTest

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

tryTestThen

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

failSafeTest

default boolean failSafeTest(T1 a1,
                             T2 a2,
                             @Nonnull
                             LBiPredicate<T1,T2> failSafe)

failSafeTest

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

failSafe

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

doIf

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

doIf

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

doIf

static <T1,T2> boolean doIf(T1 a1,
                            T2 a2,
                            @Nonnull
                            LBiPredicate<T1,T2> predicate,
                            @Nonnull
                            LBiConsumer<? super T1,? super T2> consumer)

doIf

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

throwIf

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

throwIfNot

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

nonNullTest

default boolean nonNullTest(T1 a1,
                            T2 a2)

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

doApplyAsBoolean

default boolean doApplyAsBoolean(T1 a1,
                                 T2 a2)

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

doIf

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

doIf

default <V> int doIf(V a1,
                     T1 a2,
                     T2 a3,
                     LToIntTriFunction<V,? super T1,? super T2> consumer)

fromTo

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

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

fromTill

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

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

times

static <T1,T2> void times(int max_i,
                          T1 a1,
                          T2 a2,
                          LBiPredicate<T1,T2> func)

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

lShrink

default LPredicate<T2> lShrink(LFunction<T2,T1> left)

lShrinkc

default LPredicate<T2> lShrinkc(T1 a1)

lShrinked

static <T2,T1> LPredicate<T2> lShrinked(LFunction<T2,T1> left,
                                        LBiPredicate<T1,T2> func)

lShrinkedc

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

rShrink

default LPredicate<T1> rShrink(LFunction<T1,T2> right)

rShrinkc

default LPredicate<T1> rShrinkc(T2 a2)

rShrinked

static <T1,T2> LPredicate<T1> rShrinked(LFunction<T1,T2> right,
                                        LBiPredicate<T1,T2> func)

rShrinkedc

static <T1,T2> LPredicate<T1> rShrinkedc(T2 a2,
                                         LBiPredicate<T1,T2> func)

uncurry

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

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

cast

default <V2,V3> LBiPredicate<V2,V3> cast()

Cast that replace generics.

cast

static <V2,V3,T1,T2> LBiPredicate<V2,V3> cast(LBiPredicate<T1,T2> function)

Cast that replace generics.

capture

default LBoolSupplier capture(T1 a1,
                              T2 a2)

Captures arguments but delays the evaluation.

constant

static <T1,T2> LBiPredicate<T1,T2> constant(boolean r)

Creates function that always returns the same value.

test1st

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

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

test2nd

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

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

biPred

@Nonnull
static <T1,T2> LBiPredicate<T1,T2> biPred(@Nonnull
                                                    LBiPredicate<T1,T2> 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> LBiPredicate<T1,T2> recursive(@Nonnull
                                                       LFunction<LBiPredicate<T1,T2>,LBiPredicate<T1,T2>> selfLambda)

biPredThrowing

@Nonnull
static <T1,T2> LBiPredicate<T1,T2> biPredThrowing(@Nonnull
                                                            ExF<Throwable> exF)

biPredThrowing

@Nonnull
static <T1,T2> LBiPredicate<T1,T2> biPredThrowing(String message,
                                                            @Nonnull
                                                            ExMF<Throwable> exF)

obj1Obj0Pred

@Nonnull
static <T2,T1> LBiPredicate.LObj1Obj0Pred<T2,T1> obj1Obj0Pred(@Nonnull
                                                                        LBiPredicate.LObj1Obj0Pred<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> boolean call(T1 a1,
                            T2 a2,
                            @Nonnull
                            LBiPredicate<T1,T2> lambda)

wrap

@Nonnull
static <T1,T2> LBiPredicate<T1,T2> wrap(java.util.function.BiPredicate<T1,T2> other)

Wraps JRE instance.

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

safeSupplier

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

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

safe

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

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

safeSupplier

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

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

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

Specified by:

negate in interface java.util.function.BiPredicate<T1,T2>

See Also:

java.util.function.Predicate#negate}

and

@Nonnull
default LBiPredicate<T1,T2> and(@Nonnull
                                          LBiPredicate<? super T1,? super T2> 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 LBiPredicate<T1,T2> or(@Nonnull
                                         LBiPredicate<? super T1,? super T2> 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 LBiPredicate<T1,T2> xor(@Nonnull
                                          LBiPredicate<? super T1,? super T2> 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> LBiPredicate<T1,T2> isEqual(T1 v1,
                                                     T2 v2)
```
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> LBiPredicate<V1,V2> compose(@Nonnull
                                                      LFunction<? super V1,? extends T1> before1,
                                                      @Nonnull
                                                      LFunction<? super V2,? extends T2> before2)

Allows to manipulate the domain of the function.