de.caff.generics.function

Interface Function3<R,P1,P2,P3>

Type Parameters:

R - return type

P1 - parameter type 1

P2 - parameter type 2

P3 - parameter type 3

All Superinterfaces:

java.util.function.Function<ITuple3<? extends P1,? extends P2,? extends P3>,R>, Function1<R,ITuple3<? extends P1,? extends P2,? extends P3>>

Functional Interface:

This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

@FunctionalInterface
public interface Function3<R,P1,P2,P3>
extends Function1<R,ITuple3<? extends P1,? extends P2,? extends P3>>

Function with three parameters.

Author:

Rammi

See Also:

Function0, Function1, Function2, Function4, Function5, Function6, Function7, Function8, Function9

Method Summary

Modifier and Type	Method and Description
default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP> Function1<R,FP>	after1(java.util.function.Function<FP,FR> before) Get a chained function which first applies the given function, then this one.
default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2> Function2<R,FP1,FP2>	after2(java.util.function.BiFunction<FP1,FP2,FR> before) Get a chained function which first applies the given 2-parameter function, then this one.
default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3> Function3<R,FP1,FP2,FP3>	after3(Function3<FR,FP1,FP2,FP3> before) Get a chained function which first applies the given 3-parameter function, then this one.
default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3,FP4> Function4<R,FP1,FP2,FP3,FP4>	after4(Function4<FR,FP1,FP2,FP3,FP4> before) Get a chained function which first applies the given 4-parameter function, then this one.
default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3,FP4,FP5> Function5<R,FP1,FP2,FP3,FP4,FP5>	after5(Function5<FR,FP1,FP2,FP3,FP4,FP5> before) Get a chained function which first applies the given 5-parameter function, then this one.
default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3,FP4,FP5,FP6> Function6<R,FP1,FP2,FP3,FP4,FP5,FP6>	after6(Function6<FR,FP1,FP2,FP3,FP4,FP5,FP6> before) Get a chained function which first applies the given 6-parameter function, then this one.
default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3,FP4,FP5,FP6,FP7> Function7<R,FP1,FP2,FP3,FP4,FP5,FP6,FP7>	after7(Function7<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7> before) Get a chained function which first applies the given 7-parameter function, then this one.
default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> Function8<R,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8>	after8(Function8<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> before) Get a chained function which first applies the given 8-parameter function, then this one.
default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> Function9<R,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9>	after9(Function9<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> before) Get a chained function which first applies the given 9-parameter function, then this one.
default <T> Function3<T,P1,P2,P3>	andThen(java.util.function.Function<? super R,? extends T> after) Get a chained function which first applies this function and then the given function to the returned value.
default R	apply(ITuple3<? extends P1,? extends P2,? extends P3> tuple3) Expand a tuple into the arguments of this function.
R	apply(P1 arg1, P2 arg2, P3 arg3) Run the function.
default R	applyOrDefault(P1 arg1, P2 arg2, P3 arg3, R fallback) Apply this function, but take care to create a fallback.
static <E extends java.lang.Exception,RR,PP1,PP2,PP3> Function3<RR,PP1,PP2,PP3>	nonFragile(FragileFunction3<? extends RR,E,? super PP1,? super PP2,? super PP3> fragileFunction) Convert a 3-argument function which might throw a checked exception into one which does throw an unchecked exception.
static <E extends java.lang.Exception,RR,PP1,PP2,PP3> Function3<RR,PP1,PP2,PP3>	nonFragile(FragileFunction3<? extends RR,E,? super PP1,? super PP2,? super PP3> fragileFunction, RR fallback) Convert a 3-argument function which might throw a checked exception into one which will return a default value instead of throwing an exception.
static <E extends java.lang.Exception,RR,PP1,PP2,PP3> Function3<RR,PP1,PP2,PP3>	nonFragileX(FragileFunction3<? extends RR,E,? super PP1,? super PP2,? super PP3> fragileFunction, Function4<? extends RR,? super E,? super PP1,? super PP2,? super PP3> exceptionHandler) Convert a 3-argument function which might throw a checked exception into one for which you can decide what happens with the exception.
default Function2<R,P2,P3>	partial1(P1 argument) Get a partially applied function.
default Function2<R,P1,P3>	partial2(P2 argument) Get a partially applied function.
default Function2<R,P1,P2>	partial3(P3 argument) Get a partially applied function.
default Function2<R,P2,P3>	partialLeft(P1 argument) Get a partially applied function.
default Function2<R,P1,P3>	partialMid(P2 argument) Get a partially applied function.
default Function2<R,P1,P2>	partialRight(P3 argument) Get a partially applied function.

Methods inherited from interface de.caff.generics.function.Function1

after, applyNonNull, applyOrDefault, fallback, fallback, from, from, nonFragile, nonFragile, nonFragileX, partial, withFallback

Methods inherited from interface java.util.function.Function

compose, identity

Method Detail

apply

R apply(P1 arg1,
        P2 arg2,
        P3 arg3)

Run the function.

Parameters:

arg1 - function argument 1

arg2 - function argument 2

arg3 - function argument 3

Returns:

return value

apply

default R apply(@NotNull
                ITuple3<? extends P1,? extends P2,? extends P3> tuple3)

Expand a tuple into the arguments of this function.

Specified by:

apply in interface java.util.function.Function<ITuple3<? extends P1,? extends P2,? extends P3>,R>

Parameters:

tuple3 - tuple to expand

Returns:

the result of calling this function with the arguments set from the tuple

applyOrDefault

@NotNull
default R applyOrDefault(P1 arg1,
                                  P2 arg2,
                                  P3 arg3,
                                  @NotNull
                                  R fallback)

Apply this function, but take care to create a fallback. This will return the fallback when apply(Object, Object, Object) returns null.

Parameters:

arg1 - first argument of this function

arg2 - second argument of this function

arg3 - third argument of this function

fallback - fallback value returned if function returns null

Returns:

the non-null result of calling apply(Object, Object, Object), or fallback if the result was null

partialLeft

@NotNull
default Function2<R,P2,P3> partialLeft(P1 argument)

Get a partially applied function.

Parameters:

argument - value applied for first argument

Returns:

partially evaluated function

partial1

@NotNull
default Function2<R,P2,P3> partial1(P1 argument)

Get a partially applied function. This is the same as partialLeft(Object), but with a name which is more consistent with functions having more arguments.

Parameters:

argument - value applied for first argument

Returns:

partially evaluated function

partialMid

@NotNull
default Function2<R,P1,P3> partialMid(P2 argument)

Get a partially applied function.

Parameters:

argument - value applied for second argument

Returns:

partially evaluated function

partial2

@NotNull
default Function2<R,P1,P3> partial2(P2 argument)

Get a partially applied function. This is the same as partialMid(Object), but with a name which is more consistent with functions having more arguments.

Parameters:

argument - value applied for second argument

Returns:

partially evaluated function

partialRight

@NotNull
default Function2<R,P1,P2> partialRight(P3 argument)

Get a partially applied function.

Parameters:

argument - value applied for third argument

Returns:

partially evaluated function

partial3

@NotNull
default Function2<R,P1,P2> partial3(P3 argument)

Get a partially applied function. This is the same as partialRight(Object), but with a name which is more consistent with functions having more arguments.

Parameters:

argument - value applied for third argument

Returns:

partially evaluated function

andThen

@NotNull
default <T> Function3<T,P1,P2,P3> andThen(@NotNull
                                                   java.util.function.Function<? super R,? extends T> after)

Get a chained function which first applies this function and then the given function to the returned value.

Specified by:

andThen in interface java.util.function.Function<ITuple3<? extends P1,? extends P2,? extends P3>,R>

Specified by:

andThen in interface Function1<R,ITuple3<? extends P1,? extends P2,? extends P3>>

Type Parameters:

T - result type of returned function

Parameters:

after - function to apply after this one

Returns:

function chain

after1

@NotNull
default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP> Function1<R,FP> after1(@NotNull
                                                                                                        java.util.function.Function<FP,FR> before)

Get a chained function which first applies the given function, then this one. The given function has to return a ITuple3 with matching parametric types which are applied in their order to this function.

Type Parameters:

FR - function before's return type, has to be a 3-tuple with matching types

FP - function before's parameter type, same for returned function

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

function chain

after2

@NotNull
default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2> Function2<R,FP1,FP2> after2(@NotNull
                                                                                                                  java.util.function.BiFunction<FP1,FP2,FR> before)

Get a chained function which first applies the given 2-parameter function, then this one. The given function has to return a ITuple3 with matching parametric types which are applied in their order to this function.

Type Parameters:

FR - function before's return type, has to be a 3-tuple with matching types

FP1 - function before's first parameter type, sane for returned function

FP2 - function before's second parameter type, same for returned function

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

function chain

after3

@NotNull
default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3> Function3<R,FP1,FP2,FP3> after3(@NotNull
                                                                                                                          Function3<FR,FP1,FP2,FP3> before)

Get a chained function which first applies the given 3-parameter function, then this one. The given function has to return a ITuple3 with matching parametric types which are applied in their order to this function.

Type Parameters:

FR - function before's return type, has to be a 3-tuple with matching types

FP1 - function before's first parameter type, sane for returned function

FP2 - function before's second parameter type, sane for returned function

FP3 - function before's third parameter type, sane for returned function

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

function chain

after4

@NotNull
default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3,FP4> Function4<R,FP1,FP2,FP3,FP4> after4(@NotNull
                                                                                                                                  Function4<FR,FP1,FP2,FP3,FP4> before)

Get a chained function which first applies the given 4-parameter function, then this one. The given function has to return a ITuple3 with matching parametric types which are applied in their order to this function.

Type Parameters:

FR - function before's return type, has to be a 3-tuple with matching types

FP1 - function before's first parameter type, sane for returned function

FP2 - function before's second parameter type, sane for returned function

FP3 - function before's third parameter type, sane for returned function

FP4 - function before's fourth parameter type, sane for returned function

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

function chain

after5

@NotNull
default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3,FP4,FP5> Function5<R,FP1,FP2,FP3,FP4,FP5> after5(@NotNull
                                                                                                                                          Function5<FR,FP1,FP2,FP3,FP4,FP5> before)

Get a chained function which first applies the given 5-parameter function, then this one. The given function has to return a ITuple3 with matching parametric types which are applied in their order to this function.

Type Parameters:

FR - function before's return type, has to be a 3-tuple with matching types

FP1 - function before's first parameter type, sane for returned function

FP2 - function before's second parameter type, sane for returned function

FP3 - function before's third parameter type, sane for returned function

FP4 - function before's fourth parameter type, sane for returned function

FP5 - function before's fifth parameter type, sane for returned function

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

function chain

after6

@NotNull
default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3,FP4,FP5,FP6> Function6<R,FP1,FP2,FP3,FP4,FP5,FP6> after6(@NotNull
                                                                                                                                                  Function6<FR,FP1,FP2,FP3,FP4,FP5,FP6> before)

Get a chained function which first applies the given 6-parameter function, then this one. The given function has to return a ITuple3 with matching parametric types which are applied in their order to this function.

Type Parameters:

FR - function before's return type, has to be a 3-tuple with matching types

FP1 - function before's first parameter type, sane for returned function

FP2 - function before's second parameter type, sane for returned function

FP3 - function before's third parameter type, sane for returned function

FP4 - function before's fourth parameter type, sane for returned function

FP5 - function before's fifth parameter type, sane for returned function

FP6 - function before's sixth parameter type, sane for returned function

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

function chain

after7

@NotNull
default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3,FP4,FP5,FP6,FP7> Function7<R,FP1,FP2,FP3,FP4,FP5,FP6,FP7> after7(@NotNull
                                                                                                                                                          Function7<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7> before)

Get a chained function which first applies the given 7-parameter function, then this one. The given function has to return a ITuple3 with matching parametric types which are applied in their order to this function.

Type Parameters:

FR - function before's return type, has to be a 3-tuple with matching types

FP1 - function before's first parameter type, sane for returned function

FP2 - function before's second parameter type, sane for returned function

FP3 - function before's third parameter type, sane for returned function

FP4 - function before's fourth parameter type, sane for returned function

FP5 - function before's fifth parameter type, sane for returned function

FP6 - function before's sixth parameter type, sane for returned function

FP7 - function before's seventh parameter type, sane for returned function

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

function chain

after8

@NotNull
default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> Function8<R,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> after8(@NotNull
                                                                                                                                                                  Function8<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> before)

Get a chained function which first applies the given 8-parameter function, then this one. The given function has to return a ITuple3 with matching parametric types which are applied in their order to this function.

Type Parameters:

FR - function before's return type, has to be a 3-tuple with matching types

FP1 - function before's first parameter type, sane for returned function

FP2 - function before's second parameter type, sane for returned function

FP3 - function before's third parameter type, sane for returned function

FP4 - function before's fourth parameter type, sane for returned function

FP5 - function before's fifth parameter type, sane for returned function

FP6 - function before's sixth parameter type, sane for returned function

FP7 - function before's seventh parameter type, sane for returned function

FP8 - function before's seventh parameter type, sane for returned function

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

function chain

after9

@NotNull
default <FR extends ITuple3<? extends P1,? extends P2,? extends P3>,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> Function9<R,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> after9(@NotNull
                                                                                                                                                                          Function9<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> before)

Get a chained function which first applies the given 9-parameter function, then this one. The given function has to return a ITuple3 with matching parametric types which are applied in their order to this function.

Type Parameters:

FR - function before's return type, has to be a 3-tuple with matching types

FP1 - function before's first parameter type, sane for returned function

FP2 - function before's second parameter type, sane for returned function

FP3 - function before's third parameter type, sane for returned function

FP4 - function before's fourth parameter type, sane for returned function

FP5 - function before's fifth parameter type, sane for returned function

FP6 - function before's sixth parameter type, sane for returned function

FP7 - function before's seventh parameter type, sane for returned function

FP8 - function before's seventh parameter type, sane for returned function

FP9 - function before's ninth parameter type, sane for returned function

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

function chain

nonFragile

@NotNull
static <E extends java.lang.Exception,RR,PP1,PP2,PP3> Function3<RR,PP1,PP2,PP3> nonFragile(@NotNull
                                                                                                    FragileFunction3<? extends RR,E,? super PP1,? super PP2,? super PP3> fragileFunction)

Convert a 3-argument function which might throw a checked exception into one which does throw an unchecked exception. The returned function will instead throw an unchecked WrappedFragileException for any checked exception thrown during apply(Object, Object, Object).

Type Parameters:

E - exception type

RR - result type of incoming and outgoing function.

PP1 - type of first parameter of returned functions

PP2 - type of second parameter of returned functions

PP3 - type of third parameter of returned functions

Parameters:

fragileFunction - function throwing a checked exception

Returns:

non-fragile function

nonFragile

@NotNull
static <E extends java.lang.Exception,RR,PP1,PP2,PP3> Function3<RR,PP1,PP2,PP3> nonFragile(@NotNull
                                                                                                    FragileFunction3<? extends RR,E,? super PP1,? super PP2,? super PP3> fragileFunction,
                                                                                                    RR fallback)

Convert a 3-argument function which might throw a checked exception into one which will return a default value instead of throwing an exception. Please note that the exception is lost in this case.

Type Parameters:

E - exception type

RR - result type of incoming and outgoing function.

PP1 - type of first parameter of returned functions

PP2 - type of second parameter of returned functions

PP3 - type of third parameter of returned functions

Parameters:

fragileFunction - function throwing a checked exception

fallback - fallback returned when fragileFunction has thrown an exception

Returns:

non-fragile function

nonFragileX

@NotNull
static <E extends java.lang.Exception,RR,PP1,PP2,PP3> Function3<RR,PP1,PP2,PP3> nonFragileX(@NotNull
                                                                                                     FragileFunction3<? extends RR,E,? super PP1,? super PP2,? super PP3> fragileFunction,
                                                                                                     @NotNull
                                                                                                     Function4<? extends RR,? super E,? super PP1,? super PP2,? super PP3> exceptionHandler)

Convert a 3-argument function which might throw a checked exception into one for which you can decide what happens with the exception. The exception handler allows

• throw an unchecked exception instead (compare Function1.nonFragile(FragileFunction1))
• provide a fallback value (compare Function1.nonFragile(FragileFunction1, Object))
• include logging in one of the above
• and more...

Type Parameters:

E - exception type

RR - result type of incoming and outgoing function.

PP1 - type of first parameter of returned functions

PP2 - type of second parameter of returned functions

PP3 - type of third parameter of returned functions

Parameters:

fragileFunction - function throwing a checked exception

exceptionHandler - exception handler. Its return value will be used as return value of the returned function.

Returns:

non-fragile function