de.caff.generics.function

Interface Function6<R,P1,P2,P3,P4,P5,P6>

Type Parameters:

R - return type

P1 - parameter type 1

P2 - parameter type 2

P3 - parameter type 3

P4 - parameter type 4

P5 - parameter type 5

P6 - parameter type 6

All Superinterfaces:

java.util.function.Function<ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,R>, Function1<R,ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>>

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 Function6<R,P1,P2,P3,P4,P5,P6>
extends Function1<R,ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>>

Function with six parameters.

Author:

Rammi

See Also:

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

Method Summary

Modifier and Type	Method and Description
default <FR extends ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,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 ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,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 ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,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 ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,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 ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,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 ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,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 ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,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 ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,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> Function6<T,P1,P2,P3,P4,P5,P6>	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(ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6> tuple6) Expand a tuple into the arguments of this function.
R	apply(P1 arg1, P2 arg2, P3 arg3, P4 arg4, P5 arg5, P6 arg6) Run the function.
default R	applyOrDefault(P1 arg1, P2 arg2, P3 arg3, P4 arg4, P5 arg5, P6 arg6, R fallback) Apply this function, but take care to create a fallback.
default Function5<R,P2,P3,P4,P5,P6>	partial1(P1 argument) Get a partially applied function.
default Function5<R,P1,P3,P4,P5,P6>	partial2(P2 argument) Get a partially applied function.
default Function5<R,P1,P2,P4,P5,P6>	partial3(P3 argument) Get a partially applied function.
default Function5<R,P1,P2,P3,P5,P6>	partial4(P4 argument) Get a partially applied function.
default Function5<R,P1,P2,P3,P4,P6>	partial5(P5 argument) Get a partially applied function.
default Function5<R,P1,P2,P3,P4,P5>	partial6(P6 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,
        P4 arg4,
        P5 arg5,
        P6 arg6)

Run the function.

Parameters:

arg1 - function argument 1

arg2 - function argument 2

arg3 - function argument 3

arg4 - function argument 4

arg5 - function argument 5

arg6 - function argument 6

Returns:

return value

apply

default R apply(@NotNull
                ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6> tuple6)

Expand a tuple into the arguments of this function.

Specified by:

apply in interface java.util.function.Function<ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,R>

Parameters:

tuple6 - 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,
                                  P4 arg4,
                                  P5 arg5,
                                  P6 arg6,
                                  @NotNull
                                  R fallback)

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

Parameters:

arg1 - first argument of this function

arg2 - second argument of this function

arg3 - third argument of this function

arg4 - fourth argument of this function

arg5 - fifth argument of this function

arg6 - sixth argument of this function

fallback - fallback value returned if function returns null

Returns:

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

partial1

@NotNull
default Function5<R,P2,P3,P4,P5,P6> partial1(P1 argument)

Get a partially applied function.

Parameters:

argument - value applied for first argument

Returns:

partially evaluated function

partial2

@NotNull
default Function5<R,P1,P3,P4,P5,P6> partial2(P2 argument)

Get a partially applied function.

Parameters:

argument - value applied for second argument

Returns:

partially evaluated function

partial3

@NotNull
default Function5<R,P1,P2,P4,P5,P6> partial3(P3 argument)

Get a partially applied function.

Parameters:

argument - value applied for third argument

Returns:

partially evaluated function

partial4

@NotNull
default Function5<R,P1,P2,P3,P5,P6> partial4(P4 argument)

Get a partially applied function.

Parameters:

argument - value applied for fourth argument

Returns:

partially evaluated function

partial5

@NotNull
default Function5<R,P1,P2,P3,P4,P6> partial5(P5 argument)

Get a partially applied function.

Parameters:

argument - value applied for fifth argument

Returns:

partially evaluated function

partial6

@NotNull
default Function5<R,P1,P2,P3,P4,P5> partial6(P6 argument)

Get a partially applied function.

Parameters:

argument - value applied for sixth argument

Returns:

partially evaluated function

andThen

@NotNull
default <T> Function6<T,P1,P2,P3,P4,P5,P6> 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<ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,R>

Specified by:

andThen in interface Function1<R,ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>>

Type Parameters:

T - result type of returned function

Parameters:

after - function to apply after this one

Returns:

function chain

after1

@NotNull
default <FR extends ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,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 ITuple6 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 6-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 ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,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 ITuple6 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 6-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 ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,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 ITuple6 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 6-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

after5

@NotNull
default <FR extends ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,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 ITuple6 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 6-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 ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,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 ITuple6 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 6-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 ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,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 ITuple6 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 6-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 ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,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 ITuple6 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 6-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 ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,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 ITuple6 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 6-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