LObjIntPredicate (magma-func 2.0.0 API)

All Superinterfaces:

Codomain<aType.aBool>, Domain, Domain2<aType.a<T>,aType.aInt>, Formattable, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>, MetaPredicate, OiFunction<T,aType.aBool>

All Known Subinterfaces:

LObjIntPredicate.LIntObjPred<T>

All Known Implementing Classes:

LObjIntPredicate.LObjIntPredicateSingle
```
@FunctionalInterface
public interface LObjIntPredicate<T>
extends MetaPredicate, MetaInterface.NonThrowing, OiFunction<T,aType.aBool>, Codomain<aType.aBool>, Domain2<aType.a<T>,aType.aInt>
```
Non-throwing functional interface (lambda) LObjIntPredicate for Java 8.
Type: predicate
Domain (lvl: 2): T a1,int a2
Co-domain: boolean
Special case of function that corresponds to expressions like (list, index) -> List::get

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static interface`	`LObjIntPredicate.LIntObjPred<T>` Permutation of LObjIntPredicate for method references.
`static class`	`LObjIntPredicate.LObjIntPredicateSingle<T>`

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 <T> boolean`	`alwaysFalse(int a2, T a1)` Returns FALSE.
`static <T> boolean`	`alwaysFalse(T a1, int a2)` Returns FALSE.
`static <T> boolean`	`alwaysTrue(int a2, T a1)` Returns TRUE.
`static <T> boolean`	`alwaysTrue(T a1, int a2)` Returns TRUE.
`default LObjIntPredicate<T>`	`and(LObjIntPredicate<? super T> other)` Returns a predicate that represents the logical AND of evaluation of this predicate and the argument one.
`default LObjIntPredicate<T>`	`boolToObjIntPred(LLogicalOperator after)` Combines two functions together in a order.
`default <V> LOiFunction<T,V>`	`boolToOiFunc(LBoolFunction<? extends V> after)` Combines two functions together in a order.
`default LOiToByteFunction<T>`	`boolToOiToByteFunc(LBoolToByteFunction after)` Combines two functions together in a order.
`default LOiToCharFunction<T>`	`boolToOiToCharFunc(LBoolToCharFunction after)` Combines two functions together in a order.
`default LOiToDblFunction<T>`	`boolToOiToDblFunc(LBoolToDblFunction after)` Combines two functions together in a order.
`default LOiToFltFunction<T>`	`boolToOiToFltFunc(LBoolToFltFunction after)` Combines two functions together in a order.
`default LOiToIntFunction<T>`	`boolToOiToIntFunc(LBoolToIntFunction after)` Combines two functions together in a order.
`default LOiToLongFunction<T>`	`boolToOiToLongFunc(LBoolToLongFunction after)` Combines two functions together in a order.
`default LOiToSrtFunction<T>`	`boolToOiToSrtFunc(LBoolToSrtFunction after)` Combines two functions together in a order.
`static <T> boolean`	`call(T a1, int a2, LObjIntPredicate<T> lambda)`
`default LBoolSupplier`	`capture(T a1, int a2)` Captures arguments but delays the evaluation.
`default <V2> LObjIntPredicate<V2>`	`cast()` Cast that replace generics.
`static <V2,T> LObjIntPredicate<V2>`	`cast(LObjIntPredicate<T> function)` Cast that replace generics.
`default <V1> LObjIntPredicate<V1>`	`compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2)` Allows to manipulate the domain of the function.
`static <V1,T> LObjIntPredicate<V1>`	`composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LObjIntPredicate<T> after)`
`static <V1,V2,T> LBiPredicate<V1,V2>`	`composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LObjIntPredicate<T> after)`
`static <T> LObjIntPredicate<T>`	`constant(boolean r)` Creates function that always returns the same value.
`default boolean`	`doApplyAsBoolean(T a1, int a2)` For convenience, where “test()” makes things more confusing than “applyAsBoolean()”.
`default boolean`	`doIf(T a1, int a2, LAction action)`
`default boolean`	`doIf(T a1, int a2, LObjIntConsumer<? super T> consumer)`
`static <T> boolean`	`doIf(T a1, int a2, LObjIntPredicate<T> predicate, LAction action)`
`static <T> boolean`	`doIf(T a1, int a2, LObjIntPredicate<T> predicate, LObjIntConsumer<? super T> consumer)`
`default <V> boolean`	`doIf(V a1, int a2, T a3, LTieConsumer<? super V,? super T> consumer)`
`default <V> int`	`doIf(V a1, int a2, T a3, LTieFunction<? super V,? super T> consumer)`
`default <V> boolean`	`doIf(V a1, T a2, int a3, LBiObjIntConsumer<V,? super T> consumer)`
`static <T> LObjIntPredicate<T>`	`failSafe(LObjIntPredicate<T> func, LObjIntPredicate<T> failSafe)`
`default boolean`	`failSafeTest(T a1, int a2, LObjIntPredicate<T> failSafe)`
`static <T> boolean`	`failSafeTest(T a1, int a2, LObjIntPredicate<T> func, LObjIntPredicate<T> failSafe)`
`default <C1,C2> void`	`filterForEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, LObjIntConsumer<? super T> 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<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, LObjIntConsumer<? super T> 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<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, LObjIntConsumer<? super T> 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<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, LObjIntConsumer<? super T> consumer)` For each element (or tuple) from arguments, calls the consumer if predicate test passes.
`static <T> void`	`fromTill(int min_a2, int max_a2, T a1, LObjIntPredicate<T> func)` From-To.
`static <T> void`	`fromTo(int min_a2, int max_a2, T a1, LObjIntPredicate<T> func)` From-To.
`default String`	`functionalInterfaceDescription()` Returns description of the functional interface.
`default LObjIntPredicate<T>`	`handling(HandlingInstructions<Throwable,RuntimeException> handling)`
`default boolean`	`handlingTest(T a1, int a2, HandlingInstructions<Throwable,RuntimeException> handling)` Function call that handles exceptions according to the instructions.
`static <T> boolean`	`handlingTest(T a1, int a2, LObjIntPredicate<T> func, HandlingInstructions<Throwable,RuntimeException> handling)`
`static <T> LObjIntPredicate.LIntObjPred<T>`	`intObjPred(LObjIntPredicate.LIntObjPred<T> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`static <T> LObjIntPredicate<T>`	`isEqual(T v1, int v2)` Creates predicate that evaluates if an object is equal with the argument one.
`default LIntPredicate`	`lShrink(LIntFunction<T> left)`
`default LIntPredicate`	`lShrinkc(T a1)`
`static <T> LIntPredicate`	`lShrinked(LIntFunction<T> left, LObjIntPredicate<T> func)`
`static <T> LIntPredicate`	`lShrinkedc(T a1, LObjIntPredicate<T> func)`
`default LObjIntPredicate<T>`	`negate()` Returns a predicate that represents the logical negation of this predicate.
`default boolean`	`nestingTest(T a1, int a2)` Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
`default boolean`	`nonNullTest(T a1, int a2)` Just to mirror the method: Ensures the result is not null
`static <T> LObjIntPredicate<T>`	`objIntPred(LObjIntPredicate<T> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`default <V1,V2> LBiPredicate<V1,V2>`	`objIntPredCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2)` Allows to manipulate the domain of the function.
`static <T> LObjIntPredicate<T>`	`objIntPredThrowing(ExF<Throwable> exF)`
`static <T> LObjIntPredicate<T>`	`objIntPredThrowing(String message, ExMF<Throwable> exF)`
`default LObjIntPredicate<T>`	`or(LObjIntPredicate<? super T> other)` Returns a predicate that represents the logical OR of evaluation of this predicate and the argument one.
`static <T> LObjIntPredicate<T>`	`recursive(LFunction<LObjIntPredicate<T>,LObjIntPredicate<T>> selfLambda)`
`default LPredicate<T>`	`rShrink(LToIntFunction<T> right)`
`default LPredicate<T>`	`rShrinkc(int a2)`
`static <T> LPredicate<T>`	`rShrinked(LToIntFunction<T> right, LObjIntPredicate<T> func)`
`static <T> LPredicate<T>`	`rShrinkedc(int a2, LObjIntPredicate<T> func)`
`static <T> LObjIntPredicate<T>`	`safe()` Safe instance.
`static <T> LObjIntPredicate<T>`	`safe(LObjIntPredicate<T> other)` Safe wrapping.
`static <T> LSupplier<LObjIntPredicate<T>>`	`safeSupplier()` Safe instance supplier.
`static <T> LSupplier<LObjIntPredicate<T>>`	`safeSupplier(LSupplier<LObjIntPredicate<T>> supplier)` Safe supplier.
`default boolean`	`shovingTest(T a1, int a2)` Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
`default boolean`	`test(T a1, int a2)`
`default boolean`	`test(T a1, int a2, ExWF<RuntimeException> exF)`
`default boolean`	`test(T a1, int a2, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static <T> LObjIntPredicate<T>`	`test1st(LPredicate<T> func)` Captures single parameter function into this interface where only 1st parameter will be used.
`static <T> LObjIntPredicate<T>`	`test2nd(LIntPredicate func)` Captures single parameter function into this interface where only 2nd parameter will be used.
`default boolean`	`testThen(T a1, int a2, LPredicate<Throwable> handler)`
`boolean`	`testX(T a1, int a2)` Implement this, but call test(T a1,int a2)
`static <T> void`	`throwIf(T a1, int a2, LObjIntPredicate<T> pred, ExMF<RuntimeException> factory, String newMessage, Object... messageParams)`
`static <T> void`	`throwIfNot(T a1, int a2, LObjIntPredicate<T> pred, ExMF<RuntimeException> factory, String newMessage, Object... messageParams)`
`static <T> void`	`times(int max_a2, T a1, LObjIntPredicate<T> func)` From-To.
`default LObjIntPredicate<T>`	`trying(ExWF<RuntimeException> exF)`
`default LObjIntPredicate<T>`	`trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default LObjIntPredicate<T>`	`tryingThen(LPredicate<Throwable> handler)`
`static <T> boolean`	`tryTest(T a1, int a2, LObjIntPredicate<T> func)`
`static <T> boolean`	`tryTest(T a1, int a2, LObjIntPredicate<T> func, ExWF<RuntimeException> exF)`
`static <T> boolean`	`tryTest(T a1, int a2, LObjIntPredicate<T> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static <T> boolean`	`tryTestThen(T a1, int a2, LObjIntPredicate<T> func, LPredicate<Throwable> handler)`
`default boolean`	`tupleTest(LObjIntPair<T> args)`
`static <T> LObjIntPredicate<T>`	`uncurry(LFunction<T,LIntPredicate> func)`
`default LObjIntPredicate`	`untyped()` Cast that removes generics.
`default LObjIntPredicate<T>`	`xor(LObjIntPredicate<? super T> 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.MetaInterface.NonThrowing
isThrowing

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

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

Method Detail

test

default boolean test(T a1,
                     int a2)

testX

boolean testX(T a1,
              int a2)
       throws Throwable

Implement this, but call test(T a1,int a2)

Throws:: Throwable

tupleTest

default boolean tupleTest(LObjIntPair<T> args)

handlingTest

default boolean handlingTest(T a1,
                             int a2,
                             HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

default LObjIntPredicate<T> handling(HandlingInstructions<Throwable,RuntimeException> handling)

test

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

trying

default LObjIntPredicate<T> trying(@Nonnull
                                   ExWMF<RuntimeException> exF,
                                   @Nonnull
                                   String newMessage,
                                   @Nullable
                                   Object... messageParams)

test

default boolean test(T a1,
                     int a2,
                     @Nonnull
                     ExWF<RuntimeException> exF)

trying

default LObjIntPredicate<T> trying(@Nonnull
                                   ExWF<RuntimeException> exF)

testThen

default boolean testThen(T a1,
                         int a2,
                         @Nonnull
                         LPredicate<Throwable> handler)

tryingThen

default LObjIntPredicate<T> tryingThen(@Nonnull
                                       LPredicate<Throwable> handler)

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

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

handlingTest

static <T> boolean handlingTest(T a1,
                                int a2,
                                LObjIntPredicate<T> func,
                                HandlingInstructions<Throwable,RuntimeException> handling)

tryTest

static <T> boolean tryTest(T a1,
                           int a2,
                           LObjIntPredicate<T> func)

tryTest

static <T> boolean tryTest(T a1,
                           int a2,
                           LObjIntPredicate<T> func,
                           @Nonnull
                           ExWMF<RuntimeException> exF,
                           @Nonnull
                           String newMessage,
                           @Nullable
                           Object... messageParams)

tryTest

static <T> boolean tryTest(T a1,
                           int a2,
                           LObjIntPredicate<T> func,
                           @Nonnull
                           ExWF<RuntimeException> exF)

tryTestThen

static <T> boolean tryTestThen(T a1,
                               int a2,
                               LObjIntPredicate<T> func,
                               @Nonnull
                               LPredicate<Throwable> handler)

failSafeTest

default boolean failSafeTest(T a1,
                             int a2,
                             @Nonnull
                             LObjIntPredicate<T> failSafe)

failSafeTest

static <T> boolean failSafeTest(T a1,
                                int a2,
                                LObjIntPredicate<T> func,
                                @Nonnull
                                LObjIntPredicate<T> failSafe)

failSafe

static <T> LObjIntPredicate<T> failSafe(LObjIntPredicate<T> func,
                                        @Nonnull
                                        LObjIntPredicate<T> failSafe)

doIf

default boolean doIf(T a1,
                     int a2,
                     LAction action)

doIf

static <T> boolean doIf(T a1,
                        int a2,
                        @Nonnull
                        LObjIntPredicate<T> predicate,
                        @Nonnull
                        LAction action)

doIf

static <T> boolean doIf(T a1,
                        int a2,
                        @Nonnull
                        LObjIntPredicate<T> predicate,
                        @Nonnull
                        LObjIntConsumer<? super T> consumer)

doIf

default boolean doIf(T a1,
                     int a2,
                     @Nonnull
                     LObjIntConsumer<? super T> consumer)

throwIf

static <T> void throwIf(T a1,
                        int a2,
                        LObjIntPredicate<T> pred,
                        ExMF<RuntimeException> factory,
                        @Nonnull
                        String newMessage,
                        @Nullable
                        Object... messageParams)

throwIfNot

static <T> void throwIfNot(T a1,
                           int a2,
                           LObjIntPredicate<T> pred,
                           ExMF<RuntimeException> factory,
                           @Nonnull
                           String newMessage,
                           @Nullable
                           Object... messageParams)

nonNullTest

default boolean nonNullTest(T a1,
                            int a2)

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

doApplyAsBoolean
```
default boolean doApplyAsBoolean(T a1,
                                 int 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,
                         T a2,
                         int a3,
                         LBiObjIntConsumer<V,? super T> consumer)

doIf

default <V> boolean doIf(V a1,
                         int a2,
                         T a3,
                         LTieConsumer<? super V,? super T> consumer)

doIf

default <V> int doIf(V a1,
                     int a2,
                     T a3,
                     LTieFunction<? super V,? super T> consumer)

fromTo

static <T> void fromTo(int min_a2,
                       int max_a2,
                       T a1,
                       LObjIntPredicate<T> func)

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

fromTill

static <T> void fromTill(int min_a2,
                         int max_a2,
                         T a1,
                         LObjIntPredicate<T> func)

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

times

static <T> void times(int max_a2,
                      T a1,
                      LObjIntPredicate<T> func)

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

lShrink

default LIntPredicate lShrink(LIntFunction<T> left)

lShrinkc
```
default LIntPredicate lShrinkc(T a1)
```

lShrinked

static <T> LIntPredicate lShrinked(LIntFunction<T> left,
                                   LObjIntPredicate<T> func)

lShrinkedc

static <T> LIntPredicate lShrinkedc(T a1,
                                    LObjIntPredicate<T> func)

rShrink

default LPredicate<T> rShrink(LToIntFunction<T> right)

rShrinkc

default LPredicate<T> rShrinkc(int a2)

rShrinked

static <T> LPredicate<T> rShrinked(LToIntFunction<T> right,
                                   LObjIntPredicate<T> func)

rShrinkedc

static <T> LPredicate<T> rShrinkedc(int a2,
                                    LObjIntPredicate<T> func)

uncurry

static <T> LObjIntPredicate<T> uncurry(LFunction<T,LIntPredicate> func)

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

cast

default <V2> LObjIntPredicate<V2> cast()

Cast that replace generics.

cast

static <V2,T> LObjIntPredicate<V2> cast(LObjIntPredicate<T> function)

Cast that replace generics.

capture

default LBoolSupplier capture(T a1,
                              int a2)

Captures arguments but delays the evaluation.

constant
```
static <T> LObjIntPredicate<T> constant(boolean r)
```
Creates function that always returns the same value.

test1st

@Nonnull
static <T> LObjIntPredicate<T> test1st(@Nonnull
                                                 LPredicate<T> func)

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

test2nd

@Nonnull
static <T> LObjIntPredicate<T> test2nd(@Nonnull
                                                 LIntPredicate func)

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

objIntPred

@Nonnull
static <T> LObjIntPredicate<T> objIntPred(@Nonnull
                                                    LObjIntPredicate<T> lambda)

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

recursive

@Nonnull
static <T> LObjIntPredicate<T> recursive(@Nonnull
                                                   LFunction<LObjIntPredicate<T>,LObjIntPredicate<T>> selfLambda)

objIntPredThrowing

@Nonnull
static <T> LObjIntPredicate<T> objIntPredThrowing(@Nonnull
                                                            ExF<Throwable> exF)

objIntPredThrowing

@Nonnull
static <T> LObjIntPredicate<T> objIntPredThrowing(String message,
                                                            @Nonnull
                                                            ExMF<Throwable> exF)

intObjPred

@Nonnull
static <T> LObjIntPredicate.LIntObjPred<T> intObjPred(@Nonnull
                                                                LObjIntPredicate.LIntObjPred<T> lambda)

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

call

static <T> boolean call(T a1,
                        int a2,
                        @Nonnull
                        LObjIntPredicate<T> lambda)

safe
```
@Nonnull
static <T> LObjIntPredicate<T> safe()
```
Safe instance. That always returns the same value (as alwaysFalse).

safeSupplier
```
@Nonnull
static <T> LSupplier<LObjIntPredicate<T>> safeSupplier()
```
Safe instance supplier. Returns supplier of safe() instance.

safe

@Nonnull
static <T> LObjIntPredicate<T> safe(@Nullable
                                              LObjIntPredicate<T> other)

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

safeSupplier

@Nonnull
static <T> LSupplier<LObjIntPredicate<T>> safeSupplier(@Nullable
                                                                 LSupplier<LObjIntPredicate<T>> supplier)

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

negate
```
@Nonnull
default LObjIntPredicate<T> negate()
```
Returns a predicate that represents the logical negation of this predicate.

See Also:

java.util.function.Predicate#negate}

and

@Nonnull
default LObjIntPredicate<T> and(@Nonnull
                                          LObjIntPredicate<? super T> 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 LObjIntPredicate<T> or(@Nonnull
                                         LObjIntPredicate<? super T> 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 LObjIntPredicate<T> xor(@Nonnull
                                          LObjIntPredicate<? super T> 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 <T> LObjIntPredicate<T> isEqual(T v1,
                                                 int 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> LObjIntPredicate<V1> compose(@Nonnull
                                                    LFunction<? super V1,? extends T> before1,
                                                    @Nonnull
                                                    LIntUnaryOperator before2)

Allows to manipulate the domain of the function.

composed

static <V1,T> LObjIntPredicate<V1> composed(@Nonnull
                                            LFunction<? super V1,? extends T> before1,
                                            @Nonnull
                                            LIntUnaryOperator before2,
                                            LObjIntPredicate<T> after)

objIntPredCompose

@Nonnull
default <V1,V2> LBiPredicate<V1,V2> objIntPredCompose(@Nonnull
                                                                LFunction<? super V1,? extends T> before1,
                                                                @Nonnull
                                                                LToIntFunction<? super V2> before2)

Allows to manipulate the domain of the function.