T1
- argument 1 of the functionT2
- argument 2 of the functionR
- return type of the function@FunctionalInterface public interface Function2<T1,T2,R> extends λ<R>, BiFunction<T1,T2,R>
λ.Memoized
Modifier and Type | Field and Description |
---|---|
static long |
serialVersionUID
The serial version uid.
|
Modifier and Type | Method and Description |
---|---|
default <V> Function2<T1,T2,V> |
andThen(Function<? super R,? extends V> after)
Returns a composed function that first applies this Function2 to the given argument and then applies
Function
after to the result. |
default Function1<T2,R> |
apply(T1 t1)
Applies this function partially to one argument.
|
R |
apply(T1 t1,
T2 t2)
Applies this function to two arguments and returns the result.
|
default int |
arity() |
static <T1,T2,R> Function2<T1,T2,R> |
constant(R value)
Returns a function that always returns the constant
value that you give in parameter.
|
default Function1<T1,Function1<T2,R>> |
curried()
Returns a curried version of this function.
|
static <T1,T2,R> Function2<T1,T2,Option<R>> |
lift(BiFunction<? super T1,? super T2,? extends R> partialFunction)
Lifts the given
partialFunction into a total function that returns an Option result. |
static <T1,T2,R> Function2<T1,T2,Try<R>> |
liftTry(BiFunction<? super T1,? super T2,? extends R> partialFunction)
Lifts the given
partialFunction into a total function that returns an Try result. |
default Function2<T1,T2,R> |
memoized()
Returns a memoizing version of this function, which computes the return value for given arguments only one time.
|
static <T1,T2,R> Function2<T1,T2,R> |
of(Function2<T1,T2,R> methodReference)
|
default Function2<T2,T1,R> |
reversed()
Returns a reversed version of this function.
|
default Function1<Tuple2<T1,T2>,R> |
tupled()
Returns a tupled version of this function.
|
isMemoized
static final long serialVersionUID
static <T1,T2,R> Function2<T1,T2,R> of(Function2<T1,T2,R> methodReference)
Function2
based on
Examples (w.l.o.g. referring to Function1):
// using a lambda expression
Function1<Integer, Integer> add1 = Function1.of(i -> i + 1);
// using a method reference (, e.g. Integer method(Integer i) { return i + 1; })
Function1<Integer, Integer> add2 = Function1.of(this::method);
// using a lambda reference
Function1<Integer, Integer> add3 = Function1.of(add1::apply);
Caution: Reflection loses type information of lambda references.
// type of a lambda expression
Type<?, ?> type1 = add1.getType(); // (Integer) -> Integer
// type of a method reference
Type<?, ?> type2 = add2.getType(); // (Integer) -> Integer
// type of a lambda reference
Type<?, ?> type3 = add3.getType(); // (Object) -> Object
R
- return typeT1
- 1st argumentT2
- 2nd argumentmethodReference
- (typically) a method reference, e.g. Type::method
Function2
static <T1,T2,R> Function2<T1,T2,Option<R>> lift(BiFunction<? super T1,? super T2,? extends R> partialFunction)
partialFunction
into a total function that returns an Option
result.R
- return typeT1
- 1st argumentT2
- 2nd argumentpartialFunction
- a function that is not defined for all values of the domain (e.g. by throwing)partialFunction
and returns Some(result)
if the function is defined for the given arguments, and None
otherwise.static <T1,T2,R> Function2<T1,T2,Try<R>> liftTry(BiFunction<? super T1,? super T2,? extends R> partialFunction)
partialFunction
into a total function that returns an Try
result.R
- return typeT1
- 1st argumentT2
- 2nd argumentpartialFunction
- a function that is not defined for all values of the domain (e.g. by throwing)partialFunction
and returns Success(result)
if the function is defined for the given arguments, and Failure(throwable)
otherwise.R apply(T1 t1, T2 t2)
apply
in interface BiFunction<T1,T2,R>
t1
- argument 1t2
- argument 2default Function1<T2,R> apply(T1 t1)
t1
- argument 1default int arity()
static <T1,T2,R> Function2<T1,T2,R> constant(R value)
T1
- generic parameter type 1 of the resulting functionT2
- generic parameter type 2 of the resulting functionR
- the result typevalue
- the value to be returneddefault Function1<T1,Function1<T2,R>> curried()
λ
default Function1<Tuple2<T1,T2>,R> tupled()
λ
default Function2<T2,T1,R> reversed()
λ
default Function2<T1,T2,R> memoized()
λ
Please note that memoizing functions do not permit null
as single argument or return value.
default <V> Function2<T1,T2,V> andThen(Function<? super R,? extends V> after)
after
to the result.andThen
in interface BiFunction<T1,T2,R>
V
- return type of afterafter
- the function applied after thisNullPointerException
- if after is nullCopyright © 2016. All Rights Reserved.