@FunctionalInterface public interface LBiIntFunction<R> extends MetaFunction, MetaInterface.NonThrowing, Codomain<aType.a<R>>, Domain2<aType.aInt,aType.aInt>
Non-throwing functional interface (lambda) LBiIntFunction for Java 8.
Type: function
Domain (lvl: 2): int a1,int a2
Co-domain: R
| Modifier and Type | Interface and Description |
|---|---|
static class |
LBiIntFunction.LBiIntFunctionSingle<R> |
static interface |
LBiIntFunction.LInt1Int0Func<R>
Permutation of LBiIntFunction for method references.
|
MetaInterface.NonThrowing, MetaInterface.Throwing<X>| Modifier and Type | Field and Description |
|---|---|
static String |
DESCRIPTION |
static LSupplier<String> |
NULL_VALUE_MESSAGE_SUPPLIER |
| Modifier and Type | Method and Description |
|---|---|
default LBiIntFunction<R> |
after(LConsumer<? super R> after) |
default R |
apply(int a1,
int a2) |
default R |
apply(int a1,
int a2,
ExWF<RuntimeException> exF) |
default R |
apply(int a1,
int a2,
ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
static <R> LBiIntFunction<R> |
apply1st(LIntFunction<R> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <R> LBiIntFunction<R> |
apply2nd(LIntFunction<R> func)
Captures single parameter function into this interface where only 2nd parameter will be used.
|
default R |
applyThen(int a1,
int a2,
LFunction<Throwable,R> handler) |
R |
applyX(int a1,
int a2)
Implement this, but call apply(int a1,int a2)
|
default LBiIntFunction<R> |
before(LBiIntConsumer before) |
static <R> LBiIntFunction<R> |
biIntFunc(LBiIntFunction<R> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
default <V1,V2> LBiFunction<V1,V2,R> |
biIntFuncCompose(LToIntFunction<? super V1> before1,
LToIntFunction<? super V2> before2)
Allows to manipulate the domain of the function.
|
static <R> LBiIntFunction<R> |
biIntFuncThrowing(ExF<Throwable> exF) |
static <R> LBiIntFunction<R> |
biIntFuncThrowing(String message,
ExMF<Throwable> exF) |
static <R> R |
call(int a1,
int a2,
LBiIntFunction<R> lambda) |
default LSupplier<R> |
capture(int a1,
int a2)
Captures arguments but delays the evaluation.
|
default <V2> LBiIntFunction<V2> |
cast()
Cast that replace generics.
|
static <V2,R> LBiIntFunction<V2> |
cast(LBiIntFunction<R> function)
Cast that replace generics.
|
default LBiIntFunction<R> |
compose(LIntUnaryOperator before1,
LIntUnaryOperator before2)
Allows to manipulate the domain of the function.
|
static <R> LBiIntFunction<R> |
composed(LIntUnaryOperator before1,
LIntUnaryOperator before2,
LBiIntFunction<R> after) |
static <V1,V2,R> LBiFunction<V1,V2,R> |
composed(LToIntFunction<? super V1> before1,
LToIntFunction<? super V2> before2,
LBiIntFunction<R> after) |
static <R> LBiIntFunction<R> |
constant(R r)
Creates function that always returns the same value.
|
static <R> LBiIntFunction<R> |
failSafe(LBiIntFunction<R> func,
LBiIntFunction<R> failSafe) |
default R |
failSafeApply(int a1,
int a2,
LBiIntFunction<R> failSafe) |
static <R> R |
failSafeApply(int a1,
int a2,
LBiIntFunction<R> func,
LBiIntFunction<R> failSafe) |
default <C1,C2> void |
forEach(IndexedRead<C1,aType.aInt> ia1,
C1 source1,
IndexedRead<C2,aType.aInt> ia2,
C2 source2,
LConsumer<? super R> consumer)
For each element (or tuple) from arguments, calls the function and passes the result to consumer.
|
static <R> void |
fromTill(int min_i,
int max_i,
int a1,
int a2,
LBiIntFunction<R> func)
From-To.
|
static <R> void |
fromTo(int min_i,
int max_i,
int a1,
int a2,
LBiIntFunction<R> func)
From-To.
|
default String |
functionalInterfaceDescription()
Returns description of the functional interface.
|
default LBiIntFunction<R> |
handling(HandlingInstructions<Throwable,RuntimeException> handling) |
default R |
handlingApply(int a1,
int a2,
HandlingInstructions<Throwable,RuntimeException> handling)
Function call that handles exceptions according to the instructions.
|
static <R> R |
handlingApply(int a1,
int a2,
LBiIntFunction<R> func,
HandlingInstructions<Throwable,RuntimeException> handling) |
static <R> LBiIntFunction.LInt1Int0Func<R> |
int1Int0Func(LBiIntFunction.LInt1Int0Func<R> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
default <C1,C2,I2> void |
iterate(IndexedRead<C1,aType.aInt> ia1,
C1 source1,
SequentialRead<C2,I2,aType.aInt> sa2,
C2 source2,
LConsumer<? super R> consumer)
For each element (or tuple) from arguments, calls the function and passes the result to consumer.
|
default <C1,I1,C2> void |
iterate(SequentialRead<C1,I1,aType.aInt> sa1,
C1 source1,
IndexedRead<C2,aType.aInt> ia2,
C2 source2,
LConsumer<? super R> consumer)
For each element (or tuple) from arguments, calls the function and passes the result to consumer.
|
default <C1,I1,C2,I2> |
iterate(SequentialRead<C1,I1,aType.aInt> sa1,
C1 source1,
SequentialRead<C2,I2,aType.aInt> sa2,
C2 source2,
LConsumer<? super R> consumer)
For each element (or tuple) from arguments, calls the function and passes the result to consumer.
|
default LIntFunction<R> |
lShrink(LIntUnaryOperator left) |
default LIntFunction<R> |
lShrinkc(int a1) |
static <R> LIntFunction<R> |
lShrinked(LIntUnaryOperator left,
LBiIntFunction<R> func) |
static <R> LIntFunction<R> |
lShrinkedc(int a1,
LBiIntFunction<R> func) |
default R |
nestingApply(int a1,
int a2)
Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
|
default LBiIntFunction<R> |
nonNullable()
Converts to function that makes sure that the result is not null.
|
default R |
nonNullApply(int a1,
int a2)
Function call that ensures the result is not null
|
static <R> R |
produce(int a1,
int a2)
Does nothing (LBiIntFunction) Function
|
static <R> LBiIntFunction<R> |
recursive(LFunction<LBiIntFunction<R>,LBiIntFunction<R>> selfLambda) |
default LIntFunction<R> |
rShrink(LIntUnaryOperator right) |
default LIntFunction<R> |
rShrinkc(int a2) |
static <R> LIntFunction<R> |
rShrinked(LIntUnaryOperator right,
LBiIntFunction<R> func) |
static <R> LIntFunction<R> |
rShrinkedc(int a2,
LBiIntFunction<R> func) |
static <R> LBiIntFunction<R> |
safe()
Safe instance.
|
static <R> LBiIntFunction<R> |
safe(LBiIntFunction<R> other)
Safe wrapping.
|
static <R> LSupplier<LBiIntFunction<R>> |
safeSupplier()
Safe instance supplier.
|
static <R> LSupplier<LBiIntFunction<R>> |
safeSupplier(LSupplier<LBiIntFunction<R>> supplier)
Safe supplier.
|
default R |
shovingApply(int a1,
int a2)
Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
|
default <V> LBiIntFunction<V> |
then(LFunction<? super R,? extends V> after)
Combines two functions together in a order.
|
default LBiIntConsumer |
thenConsume(LConsumer<? super R> after)
Combines two functions together in a order.
|
default LBiIntPredicate |
thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LIntBinaryOperator |
thenToInt(LToIntFunction<? super R> after)
Combines two functions together in a order.
|
static <R> void |
times(int max_i,
int a1,
int a2,
LBiIntFunction<R> func)
From-To.
|
static <R> R |
tryApply(int a1,
int a2,
LBiIntFunction<R> func) |
static <R> R |
tryApply(int a1,
int a2,
LBiIntFunction<R> func,
ExWF<RuntimeException> exF) |
static <R> R |
tryApply(int a1,
int a2,
LBiIntFunction<R> func,
ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
static <R> R |
tryApplyThen(int a1,
int a2,
LBiIntFunction<R> func,
LFunction<Throwable,R> handler) |
default LBiIntFunction<R> |
trying(ExWF<RuntimeException> exF) |
default LBiIntFunction<R> |
trying(ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
default LBiIntFunction<R> |
tryingThen(LFunction<Throwable,R> handler) |
default R |
tupleApply(LIntPair args) |
static <R> LBiIntFunction<R> |
uncurry(LIntFunction<LIntFunction<R>> func) |
default LBiIntFunction |
untyped()
Cast that removes generics.
|
isFunctionformatTo, isAction, isConsumer, isOperator, isPredicate, isSupplierisThrowingstatic final String DESCRIPTION
R applyX(int a1, int a2) throws Throwable
Implement this, but call apply(int a1,int a2)
Throwabledefault R handlingApply(int a1, int a2, HandlingInstructions<Throwable,RuntimeException> handling)
Function call that handles exceptions according to the instructions.
default LBiIntFunction<R> handling(HandlingInstructions<Throwable,RuntimeException> handling)
default R apply(int a1, int a2, @Nonnull ExWMF<RuntimeException> exF, @Nonnull String newMessage, @Nullable Object... messageParams)
default LBiIntFunction<R> trying(@Nonnull ExWMF<RuntimeException> exF, @Nonnull String newMessage, @Nullable Object... messageParams)
default R apply(int a1, int a2, @Nonnull ExWF<RuntimeException> exF)
default LBiIntFunction<R> trying(@Nonnull ExWF<RuntimeException> exF)
default R nestingApply(int a1, int a2)
Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default R shovingApply(int a1, int a2)
Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
static <R> R handlingApply(int a1,
int a2,
LBiIntFunction<R> func,
HandlingInstructions<Throwable,RuntimeException> handling)
static <R> R tryApply(int a1,
int a2,
LBiIntFunction<R> func)
static <R> R tryApply(int a1,
int a2,
LBiIntFunction<R> func,
@Nonnull
ExWMF<RuntimeException> exF,
@Nonnull
String newMessage,
@Nullable
Object... messageParams)
static <R> R tryApply(int a1,
int a2,
LBiIntFunction<R> func,
@Nonnull
ExWF<RuntimeException> exF)
static <R> R tryApplyThen(int a1,
int a2,
LBiIntFunction<R> func,
@Nonnull
LFunction<Throwable,R> handler)
default R failSafeApply(int a1, int a2, @Nonnull LBiIntFunction<R> failSafe)
static <R> R failSafeApply(int a1,
int a2,
LBiIntFunction<R> func,
@Nonnull
LBiIntFunction<R> failSafe)
static <R> LBiIntFunction<R> failSafe(LBiIntFunction<R> func, @Nonnull LBiIntFunction<R> failSafe)
@Nonnull default R nonNullApply(int a1, int a2)
Function call that ensures the result is not null
@Nonnull default String functionalInterfaceDescription()
Returns description of the functional interface.
functionalInterfaceDescription in interface MetaFunctionalInterfacestatic <R> void fromTo(int min_i,
int max_i,
int a1,
int a2,
LBiIntFunction<R> func)
From-To. Intended to be used with non-capturing lambda.
static <R> void fromTill(int min_i,
int max_i,
int a1,
int a2,
LBiIntFunction<R> func)
From-To. Intended to be used with non-capturing lambda.
static <R> void times(int max_i,
int a1,
int a2,
LBiIntFunction<R> func)
From-To. Intended to be used with non-capturing lambda.
default LIntFunction<R> lShrink(LIntUnaryOperator left)
default LIntFunction<R> lShrinkc(int a1)
static <R> LIntFunction<R> lShrinked(LIntUnaryOperator left, LBiIntFunction<R> func)
static <R> LIntFunction<R> lShrinkedc(int a1, LBiIntFunction<R> func)
default LIntFunction<R> rShrink(LIntUnaryOperator right)
default LIntFunction<R> rShrinkc(int a2)
static <R> LIntFunction<R> rShrinked(LIntUnaryOperator right, LBiIntFunction<R> func)
static <R> LIntFunction<R> rShrinkedc(int a2, LBiIntFunction<R> func)
static <R> LBiIntFunction<R> uncurry(LIntFunction<LIntFunction<R>> func)
default LBiIntFunction untyped()
Cast that removes generics.
default <V2> LBiIntFunction<V2> cast()
Cast that replace generics.
static <V2,R> LBiIntFunction<V2> cast(LBiIntFunction<R> function)
Cast that replace generics.
static <R> LBiIntFunction<R> constant(R r)
Creates function that always returns the same value.
@Nonnull static <R> LBiIntFunction<R> apply1st(@Nonnull LIntFunction<R> func)
Captures single parameter function into this interface where only 1st parameter will be used.
@Nonnull static <R> LBiIntFunction<R> apply2nd(@Nonnull LIntFunction<R> func)
Captures single parameter function into this interface where only 2nd parameter will be used.
@Nonnull static <R> LBiIntFunction<R> biIntFunc(@Nonnull LBiIntFunction<R> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
@Nonnull static <R> LBiIntFunction<R> recursive(@Nonnull LFunction<LBiIntFunction<R>,LBiIntFunction<R>> selfLambda)
@Nonnull static <R> LBiIntFunction<R> biIntFuncThrowing(@Nonnull ExF<Throwable> exF)
@Nonnull static <R> LBiIntFunction<R> biIntFuncThrowing(String message, @Nonnull ExMF<Throwable> exF)
@Nonnull static <R> LBiIntFunction.LInt1Int0Func<R> int1Int0Func(@Nonnull LBiIntFunction.LInt1Int0Func<R> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <R> R call(int a1,
int a2,
@Nonnull
LBiIntFunction<R> lambda)
@Nonnull static <R> LBiIntFunction<R> safe()
Safe instance. That always returns the same value (as produce).
@Nonnull static <R> LSupplier<LBiIntFunction<R>> safeSupplier()
Safe instance supplier. Returns supplier of safe() instance.
@Nonnull static <R> LBiIntFunction<R> safe(@Nullable LBiIntFunction<R> other)
Safe wrapping. Either argument function is returned (if it is not null) or safe() instance.
@Nonnull static <R> LSupplier<LBiIntFunction<R>> safeSupplier(@Nullable LSupplier<LBiIntFunction<R>> supplier)
Safe supplier. Either argument supplier is returned (if it is not null) or supplier of safe() instance.
@Nonnull default LBiIntFunction<R> compose(@Nonnull LIntUnaryOperator before1, @Nonnull LIntUnaryOperator before2)
Allows to manipulate the domain of the function.
static <R> LBiIntFunction<R> composed(@Nonnull LIntUnaryOperator before1, @Nonnull LIntUnaryOperator before2, LBiIntFunction<R> after)
@Nonnull default <V1,V2> LBiFunction<V1,V2,R> biIntFuncCompose(@Nonnull LToIntFunction<? super V1> before1, @Nonnull LToIntFunction<? super V2> before2)
Allows to manipulate the domain of the function.
static <V1,V2,R> LBiFunction<V1,V2,R> composed(@Nonnull LToIntFunction<? super V1> before1, @Nonnull LToIntFunction<? super V2> before2, LBiIntFunction<R> after)
@Nonnull default <V> LBiIntFunction<V> then(@Nonnull LFunction<? super R,? extends V> after)
Combines two functions together in a order.
@Nonnull default LBiIntConsumer thenConsume(@Nonnull LConsumer<? super R> after)
Combines two functions together in a order.
@Nonnull default LBiIntFunction<R> before(@Nonnull LBiIntConsumer before)
@Nonnull default LIntBinaryOperator thenToInt(@Nonnull LToIntFunction<? super R> after)
Combines two functions together in a order.
@Nonnull default LBiIntPredicate thenToBool(@Nonnull LPredicate<? super R> after)
Combines two functions together in a order.
@Nonnull default LBiIntFunction<R> nonNullable()
Converts to function that makes sure that the result is not null.
static <R> R produce(int a1,
int a2)
Does nothing (LBiIntFunction) Function
default <C1,C2> void forEach(IndexedRead<C1,aType.aInt> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, LConsumer<? super R> consumer)
For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method is not expected.
default <C1,I1,C2> void iterate(SequentialRead<C1,I1,aType.aInt> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, LConsumer<? super R> consumer)
For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method is not expected.
default <C1,C2,I2> void iterate(IndexedRead<C1,aType.aInt> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, LConsumer<? super R> consumer)
For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method is not expected.
default <C1,I1,C2,I2> void iterate(SequentialRead<C1,I1,aType.aInt> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, LConsumer<? super R> consumer)
For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method depends highly on the arguments.
Copyright © 2019. All rights reserved.