Type Parameters:

T1 - The type of the first value

T2 - The type of the second value

T3 - The type of the third value

T4 - The type of the fourth value

T5 - The type of the fifth value

T6 - The type of the sixth value

T7 - The type of the seventh value

T8 - The type of the eighth value

T9 - The type of the ninth value

All Superinterfaces:

ViewableAsNonuple<T1,T2,T3,T4,T5,T6,T7,T8,T9>
```
public interface Nonuple<T1,T2,T3,T4,T5,T6,T7,T8,T9>
extends ViewableAsNonuple<T1,T2,T3,T4,T5,T6,T7,T8,T9>
```
A nonuple is a simple composition of nine arbitrary values (objects). A nonuple captures no semantics of the nine values, and they are only referred to as "the first", "the second", "the third", "the fourth", "the fifth", "the sixth", "the seventh", "the eighth", and "the ninth" value.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods
Modifier and Type	Method	Description
`Nonuple<T1,T2,T3,T4,T5,T6,T7,T8,T9>`	`asNonuple()`
`T8`	`eighth()`
`T5`	`fifth()`
`T1`	`first()`
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Nonuple<T1,T2,T3,T4,T5,T6,T7,T8,T9>`	`flatten(Tuple<Tuple<Tuple<Tuple<Tuple<Tuple<Tuple<Tuple<T1,T2>,T3>,T4>,T5>,T6>,T7>,T8>,T9> nestedTuple)`
`T4`	`fourth()`
`<S1,S2,S3,S4,S5,S6,S7,S8,S9> Nonuple<S1,S2,S3,S4,S5,S6,S7,S8,S9>`	`map(Function<? super T1,? extends S1> firstMapper, Function<? super T2,? extends S2> secondMapper, Function<? super T3,? extends S3> thirdMapper, Function<? super T4,? extends S4> fourthMapper, Function<? super T5,? extends S5> fifthMapper, Function<? super T6,? extends S6> sixthMapper, Function<? super T7,? extends S7> seventhMapper, Function<? super T8,? extends S8> eighthMapper, Function<? super T9,? extends S9> ninthMapper)`	Create a new nonuple by applying a function to each element, and putting the results into a new nonuple.
`<S8> Nonuple<T1,T2,T3,T4,T5,T6,T7,S8,T9>`	`mapEighth(Function<? super T8,? extends S8> mapper)`	Create a new nonuple by applying a function to the eighth element, and putting the result as the eighth element of the new nonuple.
`<S5> Nonuple<T1,T2,T3,T4,S5,T6,T7,T8,T9>`	`mapFifth(Function<? super T5,? extends S5> mapper)`	Create a new nonuple by applying a function to the fifth element, and putting the result as the fifth element of the new nonuple.
`<S1> Nonuple<S1,T2,T3,T4,T5,T6,T7,T8,T9>`	`mapFirst(Function<? super T1,? extends S1> mapper)`	Create a new nonuple by applying a function to the first element, and putting the result as the first element of the new nonuple.
`<S4> Nonuple<T1,T2,T3,S4,T5,T6,T7,T8,T9>`	`mapFourth(Function<? super T4,? extends S4> mapper)`	Create a new nonuple by applying a function to the fourth element, and putting the result as the fourth element of the new nonuple.
`<S9> Nonuple<T1,T2,T3,T4,T5,T6,T7,T8,S9>`	`mapNinth(Function<? super T9,? extends S9> mapper)`	Create a new nonuple by applying a function to the ninth element, and putting the result as the ninth element of the new nonuple.
`<S2> Nonuple<T1,S2,T3,T4,T5,T6,T7,T8,T9>`	`mapSecond(Function<? super T2,? extends S2> mapper)`	Create a new nonuple by applying a function to the second element, and putting the result as the second element of the new nonuple.
`<S7> Nonuple<T1,T2,T3,T4,T5,T6,S7,T8,T9>`	`mapSeventh(Function<? super T7,? extends S7> mapper)`	Create a new nonuple by applying a function to the seventh element, and putting the result as the seventh element of the new nonuple.
`<S6> Nonuple<T1,T2,T3,T4,T5,S6,T7,T8,T9>`	`mapSixth(Function<? super T6,? extends S6> mapper)`	Create a new nonuple by applying a function to the sixth element, and putting the result as the sixth element of the new nonuple.
`<S3> Nonuple<T1,T2,S3,T4,T5,T6,T7,T8,T9>`	`mapThird(Function<? super T3,? extends S3> mapper)`	Create a new nonuple by applying a function to the third element, and putting the result as the third element of the new nonuple.
`T9`	`ninth()`
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Nonuple<T1,T2,T3,T4,T5,T6,T7,T8,T9>`	`of(T1 first, T2 second, T3 third, T4 fourth, T5 fifth, T6 sixth, T7 seventh, T8 eighth, T9 ninth)`
`T2`	`second()`
`T7`	`seventh()`
`T6`	`sixth()`
`T3`	`third()`
`<R> R`	`to(NonaFunction<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,R> convertor)`	Convert this nonuple to an instance of an arbitrary type.

Method Detail

of

static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Nonuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> of(T1 first,
                                                                                                                                                                           T2 second,
                                                                                                                                                                           T3 third,
                                                                                                                                                                           T4 fourth,
                                                                                                                                                                           T5 fifth,
                                                                                                                                                                           T6 sixth,
                                                                                                                                                                           T7 seventh,
                                                                                                                                                                           T8 eighth,
                                                                                                                                                                           T9 ninth)

flatten

static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Nonuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> flatten(Tuple<Tuple<Tuple<Tuple<Tuple<Tuple<Tuple<Tuple<T1,T2>,T3>,T4>,T5>,T6>,T7>,T8>,T9> nestedTuple)

first
```
T1 first()
```
Returns:

the first value

second
```
T2 second()
```
Returns:

the second value

third
```
T3 third()
```
Returns:

the third value

fourth
```
T4 fourth()
```
Returns:

the fourth value

fifth
```
T5 fifth()
```
Returns:

the fifth value

sixth
```
T6 sixth()
```
Returns:

the sixth value

seventh
```
T7 seventh()
```
Returns:

the seventh value

eighth
```
T8 eighth()
```
Returns:

the eighth value

ninth
```
T9 ninth()
```
Returns:

the ninth value

mapFirst
```
<S1> Nonuple<S1,T2,T3,T4,T5,T6,T7,T8,T9> mapFirst(Function<? super T1,? extends S1> mapper)
```
Create a new nonuple by applying a function to the first element, and putting the result as the first element of the new nonuple.

Parameters:

mapper - the function to apply to the first element

Returns:

the new nonuple

mapSecond
```
<S2> Nonuple<T1,S2,T3,T4,T5,T6,T7,T8,T9> mapSecond(Function<? super T2,? extends S2> mapper)
```
Create a new nonuple by applying a function to the second element, and putting the result as the second element of the new nonuple.

Parameters:

mapper - the function to apply to the second element

Returns:

the new nonuple

mapThird
```
<S3> Nonuple<T1,T2,S3,T4,T5,T6,T7,T8,T9> mapThird(Function<? super T3,? extends S3> mapper)
```
Create a new nonuple by applying a function to the third element, and putting the result as the third element of the new nonuple.

Parameters:

mapper - the function to apply to the third element

Returns:

the new nonuple

mapFourth
```
<S4> Nonuple<T1,T2,T3,S4,T5,T6,T7,T8,T9> mapFourth(Function<? super T4,? extends S4> mapper)
```
Create a new nonuple by applying a function to the fourth element, and putting the result as the fourth element of the new nonuple.

Parameters:

mapper - the function to apply to the fourth element

Returns:

the new nonuple

mapFifth
```
<S5> Nonuple<T1,T2,T3,T4,S5,T6,T7,T8,T9> mapFifth(Function<? super T5,? extends S5> mapper)
```
Create a new nonuple by applying a function to the fifth element, and putting the result as the fifth element of the new nonuple.

Parameters:

mapper - the function to apply to the fifth element

Returns:

the new nonuple

mapSixth
```
<S6> Nonuple<T1,T2,T3,T4,T5,S6,T7,T8,T9> mapSixth(Function<? super T6,? extends S6> mapper)
```
Create a new nonuple by applying a function to the sixth element, and putting the result as the sixth element of the new nonuple.

Parameters:

mapper - the function to apply to the sixth element

Returns:

the new nonuple

mapSeventh
```
<S7> Nonuple<T1,T2,T3,T4,T5,T6,S7,T8,T9> mapSeventh(Function<? super T7,? extends S7> mapper)
```
Create a new nonuple by applying a function to the seventh element, and putting the result as the seventh element of the new nonuple.

Parameters:

mapper - the function to apply to the seventh element

Returns:

the new nonuple

mapEighth
```
<S8> Nonuple<T1,T2,T3,T4,T5,T6,T7,S8,T9> mapEighth(Function<? super T8,? extends S8> mapper)
```
Create a new nonuple by applying a function to the eighth element, and putting the result as the eighth element of the new nonuple.

Parameters:

mapper - the function to apply to the eighth element

Returns:

the new nonuple

mapNinth
```
<S9> Nonuple<T1,T2,T3,T4,T5,T6,T7,T8,S9> mapNinth(Function<? super T9,? extends S9> mapper)
```
Create a new nonuple by applying a function to the ninth element, and putting the result as the ninth element of the new nonuple.

Parameters:

mapper - the function to apply to the ninth element

Returns:

the new nonuple

map

<S1,S2,S3,S4,S5,S6,S7,S8,S9> Nonuple<S1,S2,S3,S4,S5,S6,S7,S8,S9> map(Function<? super T1,? extends S1> firstMapper,
                                                                                                                                                                     Function<? super T2,? extends S2> secondMapper,
                                                                                                                                                                     Function<? super T3,? extends S3> thirdMapper,
                                                                                                                                                                     Function<? super T4,? extends S4> fourthMapper,
                                                                                                                                                                     Function<? super T5,? extends S5> fifthMapper,
                                                                                                                                                                     Function<? super T6,? extends S6> sixthMapper,
                                                                                                                                                                     Function<? super T7,? extends S7> seventhMapper,
                                                                                                                                                                     Function<? super T8,? extends S8> eighthMapper,
                                                                                                                                                                     Function<? super T9,? extends S9> ninthMapper)

Create a new nonuple by applying a function to each element, and putting the results into a new nonuple.

Parameters:: firstMapper - the function to apply to the first element; secondMapper - the function to apply to the second element; thirdMapper - the function to apply to the third element; fourthMapper - the function to apply to the fourth element; fifthMapper - the function to apply to the fifth element; sixthMapper - the function to apply to the sixth element; seventhMapper - the function to apply to the seventh element; eighthMapper - the function to apply to the eighth element; ninthMapper - the function to apply to the ninth element
Returns:: the new nonuple

asNonuple
```
Nonuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> asNonuple()
```
Specified by:

asNonuple in interface ViewableAsNonuple<T1,T2,T3,T4,T5,T6,T7,T8,T9>

Returns:

this nonuple instance

to
```
<R> R to(NonaFunction<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,R> convertor)
```
Convert this nonuple to an instance of an arbitrary type.

Type Parameters:

R - The type of the resulting instance

Parameters:

convertor - the function used to convert the contained values to a resulting compound instance.

Returns:

the result from the given function

Interface Nonuple<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9>

Method Summary

Method Detail

of

flatten

first

second

third

fourth

fifth

sixth

seventh

eighth

ninth

mapFirst

mapSecond

mapThird

mapFourth

mapFifth

mapSixth

mapSeventh

mapEighth

mapNinth

map

asNonuple

to

Interface Nonuple<T1,T2,T3,T4,T5,T6,T7,T8,T9>