de.caff.generics.function

Interface Procedure6<P1,P2,P3,P4,P5,P6>

Type Parameters:

P1 - first parameter type

P2 - second parameter type

P3 - third parameter type

P4 - fourth parameter type

P5 - fifth parameter type

P6 - sixth parameter type

All Superinterfaces:

java.util.function.Consumer<ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>>, Procedure1<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 Procedure6<P1,P2,P3,P4,P5,P6>
extends Procedure1<ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>>

Function without return and with six parameters.

Author:

Rammi

See Also:

Procedure0, Procedure1, Procedure2, Procedure3, Procedure4, Procedure5, Procedure7, Procedure8, Procedure9

Field Summary

Fields

Modifier and Type	Field and Description
static Procedure6<?,?,?,?,?,?>	NULL Procedure with six arguments which does nothing.

Method Summary

Modifier and Type	Method and Description
default void	accept(ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6> tuple6) Expand a tuple into the arguments of this procedure.
default <FR extends ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,FP> Procedure1<FP>	after1(java.util.function.Function<FP,FR> before) Get a chained procedure which first applies the given function, then this procedure.
default <FR extends ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,FP1,FP2> Procedure2<FP1,FP2>	after2(java.util.function.BiFunction<FP1,FP2,FR> before) Get a chained procedure which first applies the given 2-parameter function, then this procedure.
default <FR extends ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,FP1,FP2,FP3> Procedure3<FP1,FP2,FP3>	after3(Function3<FR,FP1,FP2,FP3> before) Get a chained procedure which first applies the given 3-parameter function, then this procedure.
default <FR extends ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,FP1,FP2,FP3,FP4,FP5> Procedure5<FP1,FP2,FP3,FP4,FP5>	after5(Function5<FR,FP1,FP2,FP3,FP4,FP5> before) Get a chained procedure which first applies the given 5-parameter function, then this procedure.
default <FR extends ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,FP1,FP2,FP3,FP4,FP5,FP6> Procedure6<FP1,FP2,FP3,FP4,FP5,FP6>	after6(Function6<FR,FP1,FP2,FP3,FP4,FP5,FP6> before) Get a chained procedure which first applies the given 6-parameter function, then this procedure.
default <FR extends ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,FP1,FP2,FP3,FP4,FP5,FP6,FP7> Procedure7<FP1,FP2,FP3,FP4,FP5,FP6,FP7>	after7(Function7<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7> before) Get a chained procedure 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> Procedure8<FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8>	after8(Function8<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> before) Get a chained procedure 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> Procedure9<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 procedure which first applies the given 9-parameter function, then this one.
void	apply(P1 arg1, P2 arg2, P3 arg3, P4 arg4, P5 arg5, P6 arg6) Run the procedure.
static <T1,T2,T3,T4,T5,T6> Procedure6<T1,T2,T3,T4,T5,T6>	empty() Return a procedure which does nothing.
default Procedure5<P2,P3,P4,P5,P6>	partial1(P1 argument) Get a partially applied procedure.
default Procedure5<P1,P3,P4,P5,P6>	partial2(P2 argument) Get a partially applied procedure.
default Procedure5<P1,P2,P4,P5,P6>	partial3(P3 argument) Get a partially applied procedure.
default Procedure5<P1,P2,P3,P5,P6>	partial4(P4 argument) Get a partially applied procedure.
default Procedure5<P1,P2,P3,P4,P6>	partial5(P5 argument) Get a partially applied procedure.
default Procedure5<P1,P2,P3,P4,P5>	partial6(P6 argument) Get a partially applied procedure.

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

apply, applyNonNull, from, nonFragile, nonFragileX, partial

Methods inherited from interface java.util.function.Consumer

andThen

Field Detail

NULL

@NotNull
static final Procedure6<?,?,?,?,?,?> NULL

Procedure with six arguments which does nothing. Use empty() instead.

Method Detail

apply

void apply(P1 arg1,
           P2 arg2,
           P3 arg3,
           P4 arg4,
           P5 arg5,
           P6 arg6)

Run the procedure.

Parameters:

arg1 - first procedure argument

arg2 - second procedure argument

arg3 - third procedure argument

arg4 - fourth procedure argument

arg5 - fifth procedure argument

arg6 - sixth procedure argument

accept

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

Expand a tuple into the arguments of this procedure.

Specified by:

accept in interface java.util.function.Consumer<ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>>

Parameters:

tuple6 - tuple to expand

partial1

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

Get a partially applied procedure.

Parameters:

argument - value applied for first argument

Returns:

partially evaluated procedure

partial2

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

Get a partially applied procedure.

Parameters:

argument - value applied for second argument

Returns:

partially evaluated procedure

partial3

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

Get a partially applied procedure.

Parameters:

argument - value applied for third argument

Returns:

partially evaluated procedure

partial4

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

Get a partially applied procedure.

Parameters:

argument - value applied for fourth argument

Returns:

partially evaluated procedure

partial5

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

Get a partially applied procedure.

Parameters:

argument - value applied for fifth argument

Returns:

partially evaluated procedure

partial6

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

Get a partially applied procedure.

Parameters:

argument - value applied for sixth argument

Returns:

partially evaluated procedure

after1

@NotNull
default <FR extends ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,FP> Procedure1<FP> after1(@NotNull
                                                                                                                                              java.util.function.Function<FP,FR> before)

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

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 procedure

Parameters:

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

Returns:

chain of function and this procedure

after2

@NotNull
default <FR extends ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,FP1,FP2> Procedure2<FP1,FP2> after2(@NotNull
                                                                                                                                                        java.util.function.BiFunction<FP1,FP2,FR> before)

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

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 procedure

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

Parameters:

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

Returns:

chain of the given function and this procedure

after3

@NotNull
default <FR extends ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,FP1,FP2,FP3> Procedure3<FP1,FP2,FP3> after3(@NotNull
                                                                                                                                                                Function3<FR,FP1,FP2,FP3> before)

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

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 procedure

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

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

Parameters:

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

Returns:

chain of the given function and this procedure

after5

@NotNull
default <FR extends ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,FP1,FP2,FP3,FP4,FP5> Procedure5<FP1,FP2,FP3,FP4,FP5> after5(@NotNull
                                                                                                                                                                                Function5<FR,FP1,FP2,FP3,FP4,FP5> before)

Get a chained procedure which first applies the given 5-parameter function, then this procedure. 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 procedure

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

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

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

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

Parameters:

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

Returns:

chain of the given function and this procedure

after6

@NotNull
default <FR extends ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>,FP1,FP2,FP3,FP4,FP5,FP6> Procedure6<FP1,FP2,FP3,FP4,FP5,FP6> after6(@NotNull
                                                                                                                                                                                        Function6<FR,FP1,FP2,FP3,FP4,FP5,FP6> before)

Get a chained procedure which first applies the given 6-parameter function, then this procedure. 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 procedure

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

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

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

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

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

Parameters:

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

Returns:

chain of the given function and this procedure

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> Procedure7<FP1,FP2,FP3,FP4,FP5,FP6,FP7> after7(@NotNull
                                                                                                                                                                                                Function7<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7> before)

Get a chained procedure 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 procedure.

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 procedure

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

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

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

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

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

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

Parameters:

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

Returns:

chain of the given function and this procedure

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> Procedure8<FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> after8(@NotNull
                                                                                                                                                                                                        Function8<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> before)

Get a chained procedure 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 procedure.

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 procedure

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

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

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

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

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

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

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

Parameters:

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

Returns:

chain of the given function and this procedure

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> Procedure9<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 procedure 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 procedure.

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 procedure

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

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

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

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

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

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

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

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

Parameters:

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

Returns:

chain of the given function and this procedure

empty

@NotNull
static <T1,T2,T3,T4,T5,T6> Procedure6<T1,T2,T3,T4,T5,T6> empty()

Return a procedure which does nothing. This just returns NULL, but the compiler will accept it smoothly.

Specified by:

empty in interface Procedure1<ITuple6<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6>>

Type Parameters:

T1 - first argument type

T2 - second argument type

T3 - third argument type

T4 - fourth argument type

T5 - fifth argument type

T6 - sixth argument type

Returns:

do-nothing procedure