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

T10 - The type of the tenth value

All Superinterfaces:

ViewableAsDecuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
```
public interface Decuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
extends ViewableAsDecuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
```
A decuple is a simple composition of ten arbitrary values (objects). A decuple captures no semantics of the ten 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
`Decuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>`	`asDecuple()`
`T8`	`eighth()`
`T5`	`fifth()`
`T1`	`first()`
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Decuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>`	`flatten(Tuple<Tuple<Tuple<Tuple<Tuple<Tuple<Tuple<Tuple<Tuple<T1,T2>,T3>,T4>,T5>,T6>,T7>,T8>,T9>,T10> nestedTuple)`
`T4`	`fourth()`
`<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10> Decuple<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10>`	`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, Function<? super T10,? extends S10> tenthMapper)`	Create a new decuple by applying a function to each element, and putting the results into a new decuple.
`<S8> Decuple<T1,T2,T3,T4,T5,T6,T7,S8,T9,T10>`	`mapEighth(Function<? super T8,? extends S8> mapper)`	Create a new decuple by applying a function to the eighth element, and putting the result as the eighth element of the new decuple.
`<S5> Decuple<T1,T2,T3,T4,S5,T6,T7,T8,T9,T10>`	`mapFifth(Function<? super T5,? extends S5> mapper)`	Create a new decuple by applying a function to the fifth element, and putting the result as the fifth element of the new decuple.
`<S1> Decuple<S1,T2,T3,T4,T5,T6,T7,T8,T9,T10>`	`mapFirst(Function<? super T1,? extends S1> mapper)`	Create a new decuple by applying a function to the first element, and putting the result as the first element of the new decuple.
`<S4> Decuple<T1,T2,T3,S4,T5,T6,T7,T8,T9,T10>`	`mapFourth(Function<? super T4,? extends S4> mapper)`	Create a new decuple by applying a function to the fourth element, and putting the result as the fourth element of the new decuple.
`<S9> Decuple<T1,T2,T3,T4,T5,T6,T7,T8,S9,T10>`	`mapNinth(Function<? super T9,? extends S9> mapper)`	Create a new decuple by applying a function to the ninth element, and putting the result as the ninth element of the new decuple.
`<S2> Decuple<T1,S2,T3,T4,T5,T6,T7,T8,T9,T10>`	`mapSecond(Function<? super T2,? extends S2> mapper)`	Create a new decuple by applying a function to the second element, and putting the result as the second element of the new decuple.
`<S7> Decuple<T1,T2,T3,T4,T5,T6,S7,T8,T9,T10>`	`mapSeventh(Function<? super T7,? extends S7> mapper)`	Create a new decuple by applying a function to the seventh element, and putting the result as the seventh element of the new decuple.
`<S6> Decuple<T1,T2,T3,T4,T5,S6,T7,T8,T9,T10>`	`mapSixth(Function<? super T6,? extends S6> mapper)`	Create a new decuple by applying a function to the sixth element, and putting the result as the sixth element of the new decuple.
`<S10> Decuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,S10>`	`mapTenth(Function<? super T10,? extends S10> mapper)`	Create a new decuple by applying a function to the tenth element, and putting the result as the tenth element of the new decuple.
`<S3> Decuple<T1,T2,S3,T4,T5,T6,T7,T8,T9,T10>`	`mapThird(Function<? super T3,? extends S3> mapper)`	Create a new decuple by applying a function to the third element, and putting the result as the third element of the new decuple.
`T9`	`ninth()`
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Decuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>`	`of(T1 first, T2 second, T3 third, T4 fourth, T5 fifth, T6 sixth, T7 seventh, T8 eighth, T9 ninth, T10 tenth)`
`T2`	`second()`
`T7`	`seventh()`
`T6`	`sixth()`
`T10`	`tenth()`
`T3`	`third()`
`<R> R`	`to(DecaFunction<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,R> convertor)`	Convert this decuple to an instance of an arbitrary type.

Method Detail

of

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

flatten

static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Decuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> flatten(Tuple<Tuple<Tuple<Tuple<Tuple<Tuple<Tuple<Tuple<Tuple<T1,T2>,T3>,T4>,T5>,T6>,T7>,T8>,T9>,T10> 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

tenth
```
T10 tenth()
```
Returns:

the tenth value

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

Parameters:

mapper - the function to apply to the first element

Returns:

the new decuple

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

Parameters:

mapper - the function to apply to the second element

Returns:

the new decuple

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

Parameters:

mapper - the function to apply to the third element

Returns:

the new decuple

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

Parameters:

mapper - the function to apply to the fourth element

Returns:

the new decuple

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

Parameters:

mapper - the function to apply to the fifth element

Returns:

the new decuple

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

Parameters:

mapper - the function to apply to the sixth element

Returns:

the new decuple

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

Parameters:

mapper - the function to apply to the seventh element

Returns:

the new decuple

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

Parameters:

mapper - the function to apply to the eighth element

Returns:

the new decuple

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

Parameters:

mapper - the function to apply to the ninth element

Returns:

the new decuple

mapTenth
```
<S10> Decuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,S10> mapTenth(Function<? super T10,? extends S10> mapper)
```
Create a new decuple by applying a function to the tenth element, and putting the result as the tenth element of the new decuple.

Parameters:

mapper - the function to apply to the tenth element

Returns:

the new decuple

map

<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10> Decuple<S1,S2,S3,S4,S5,S6,S7,S8,S9,S10> 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,
                                                                                                                                                                                         Function<? super T10,? extends S10> tenthMapper)

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

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; tenthMapper - the function to apply to the tenth element
Returns:: the new decuple

asDecuple
```
Decuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> asDecuple()
```
Specified by:

asDecuple in interface ViewableAsDecuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>

Returns:

this decuple instance

to
```
<R> R to(DecaFunction<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,R> convertor)
```
Convert this decuple 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 Decuple<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10>

Method Summary

Method Detail

of

flatten

first

second

third

fourth

fifth

sixth

seventh

eighth

ninth

tenth

mapFirst

mapSecond

mapThird

mapFourth

mapFifth

mapSixth

mapSeventh

mapEighth

mapNinth

mapTenth

map

asDecuple

to

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