de.caff.generics.function

Interface Procedure9<P1,P2,P3,P4,P5,P6,P7,P8,P9>

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

P8 - eighth parameter type

P9 - nineth parameter type

All Superinterfaces:

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

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 Procedure9<P1,P2,P3,P4,P5,P6,P7,P8,P9>
extends Procedure1<ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>>

Function without return and with nine parameters.

Author:

Rammi

See Also:

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

Field Summary

Fields

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

Method Summary

Modifier and Type	Method and Description
default void	accept(ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9> tuple9) Expand a tuple into the arguments of this procedure.
default <FR extends ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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, P8 arg8, P9 arg9) Run the procedure.
static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Procedure9<T1,T2,T3,T4,T5,T6,T7,T8,T9>	empty() Return a procedure which does nothing.
default Procedure8<P2,P3,P4,P5,P6,P7,P8,P9>	partial1(P1 argument) Get a partially applied procedure.
default Procedure8<P1,P3,P4,P5,P6,P7,P8,P9>	partial2(P2 argument) Get a partially applied procedure.
default Procedure8<P1,P2,P4,P5,P6,P7,P8,P9>	partial3(P3 argument) Get a partially applied procedure.
default Procedure8<P1,P2,P3,P5,P6,P7,P8,P9>	partial4(P4 argument) Get a partially applied procedure.
default Procedure8<P1,P2,P3,P4,P6,P7,P8,P9>	partial5(P5 argument) Get a partially applied procedure.
default Procedure8<P1,P2,P3,P4,P5,P7,P8,P9>	partial6(P6 argument) Get a partially applied procedure.
default Procedure8<P1,P2,P3,P4,P5,P6,P8,P9>	partial7(P7 argument) Get a partially applied procedure.
default Procedure8<P1,P2,P3,P4,P5,P6,P7,P9>	partial8(P8 argument) Get a partially applied procedure.
default Procedure8<P1,P2,P3,P4,P5,P6,P7,P8>	partial9(P9 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 Procedure9<?,?,?,?,?,?,?,?,?> NULL

Procedure with nine 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,
           P8 arg8,
           P9 arg9)

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

arg8 - eighth procedure argument

arg9 - nineth procedure argument

accept

default void accept(@NotNull
                    ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9> tuple9)

Expand a tuple into the arguments of this procedure.

Specified by:

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

Parameters:

tuple9 - tuple to expand

partial1

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

Get a partially applied procedure.

Parameters:

argument - value applied for first argument

Returns:

partially evaluated procedure

partial2

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

Get a partially applied procedure.

Parameters:

argument - value applied for second argument

Returns:

partially evaluated procedure

partial3

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

Get a partially applied procedure.

Parameters:

argument - value applied for third argument

Returns:

partially evaluated procedure

partial4

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

Get a partially applied procedure.

Parameters:

argument - value applied for fourth argument

Returns:

partially evaluated procedure

partial5

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

Get a partially applied procedure.

Parameters:

argument - value applied for fifth argument

Returns:

partially evaluated procedure

partial6

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

Get a partially applied procedure.

Parameters:

argument - value applied for sixth argument

Returns:

partially evaluated procedure

partial7

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

Get a partially applied procedure.

Parameters:

argument - value applied for seventh argument

Returns:

partially evaluated procedure

partial8

@NotNull
default Procedure8<P1,P2,P3,P4,P5,P6,P7,P9> partial8(P8 argument)

Get a partially applied procedure.

Parameters:

argument - value applied for eighth argument

Returns:

partially evaluated procedure

partial9

@NotNull
default Procedure8<P1,P2,P3,P4,P5,P6,P7,P8> partial9(P9 argument)

Get a partially applied procedure.

Parameters:

argument - value applied for nineth argument

Returns:

partially evaluated procedure

after1

@NotNull
default <FR extends ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9 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 9-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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9 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 9-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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9 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 9-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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9 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 9-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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9 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 9-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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9 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 9-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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9 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 9-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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9 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 9-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,T8,T9> Procedure9<T1,T2,T3,T4,T5,T6,T7,T8,T9> empty()

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

Specified by:

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

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

T8 - eoghth argument type

T9 - ninth argument type

Returns:

do-nothing procedure