de.caff.generics.function

Interface Procedure7<P1,P2,P3,P4,P5,P6,P7>

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

P7 - seventh parameter type

All Superinterfaces:

java.util.function.Consumer<ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7>>, Procedure1<ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7>>

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 Procedure7<P1,P2,P3,P4,P5,P6,P7>
extends Procedure1<ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7>>

Function without return and with seven parameters.

Author:

Rammi

See Also:

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

Field Summary

Fields

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

Method Summary

Modifier and Type	Method and Description
default void	accept(ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7> tuple7) Expand a tuple into the arguments of this procedure.
default <FR extends ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7>,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 ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7>,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 ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7>,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 ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7>,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 ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7>,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 ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7>,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 ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7>,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 ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7>,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, P7 arg7) Run the procedure.
static <T1,T2,T3,T4,T5,T6,T7> Procedure7<T1,T2,T3,T4,T5,T6,T7>	empty() Return a procedure which does nothing.
default Procedure6<P2,P3,P4,P5,P6,P7>	partial1(P1 argument) Get a partially applied procedure.
default Procedure6<P1,P3,P4,P5,P6,P7>	partial2(P2 argument) Get a partially applied procedure.
default Procedure6<P1,P2,P4,P5,P6,P7>	partial3(P3 argument) Get a partially applied procedure.
default Procedure6<P1,P2,P3,P5,P6,P7>	partial4(P4 argument) Get a partially applied procedure.
default Procedure6<P1,P2,P3,P4,P6,P7>	partial5(P5 argument) Get a partially applied procedure.
default Procedure6<P1,P2,P3,P4,P5,P7>	partial6(P6 argument) Get a partially applied procedure.
default Procedure6<P1,P2,P3,P4,P5,P6>	partial7(P7 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 Procedure7<?,?,?,?,?,?,?> NULL

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

Method Detail

apply

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

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

arg7 - seventh procedure argument

accept

default void accept(@NotNull
                    ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7> tuple7)

Expand a tuple into the arguments of this procedure.

Specified by:

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

Parameters:

tuple7 - tuple to expand

partial1

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

Get a partially applied procedure.

Parameters:

argument - value applied for first argument

Returns:

partially evaluated procedure

partial2

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

Get a partially applied procedure.

Parameters:

argument - value applied for second argument

Returns:

partially evaluated procedure

partial3

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

Get a partially applied procedure.

Parameters:

argument - value applied for third argument

Returns:

partially evaluated procedure

partial4

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

Get a partially applied procedure.

Parameters:

argument - value applied for fourth argument

Returns:

partially evaluated procedure

partial5

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

Get a partially applied procedure.

Parameters:

argument - value applied for fifth argument

Returns:

partially evaluated procedure

partial6

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

Get a partially applied procedure.

Parameters:

argument - value applied for sixth argument

Returns:

partially evaluated procedure

partial7

@NotNull
default Procedure6<P1,P2,P3,P4,P5,P6> partial7(P7 argument)

Get a partially applied procedure.

Parameters:

argument - value applied for seventh argument

Returns:

partially evaluated procedure

after1

@NotNull
default <FR extends ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7>,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 ITuple7 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 7-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 ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7>,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 ITuple7 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 7-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 ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7>,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 ITuple7 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 7-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 ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7>,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 ITuple7 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 7-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 ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7>,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 ITuple7 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 7-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 ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7>,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 ITuple7 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 7-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 ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7>,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 ITuple7 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 7-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 ITuple7<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7>,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 ITuple7 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 7-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,T7> Procedure7<T1,T2,T3,T4,T5,T6,T7> empty()

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

Specified by:

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

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

T7 - seventh argument type

Returns:

do-nothing procedure