no.digipost.tuple

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

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

All Superinterfaces:

ViewableAsOctuple<T1,T2,T3,T4,T5,T6,T7,T8>

public interface Octuple<T1,T2,T3,T4,T5,T6,T7,T8>
extends ViewableAsOctuple<T1,T2,T3,T4,T5,T6,T7,T8>

A octuple is a simple composition of eight arbitrary values (objects). A octuple captures no semantics of the eight values, and they are only referred to as "the first", "the second", "the third", "the fourth", "the fifth", "the sixth", "the seventh", and "the eighth" value.

Method Summary

Modifier and Type	Method and Description
Octuple<T1,T2,T3,T4,T5,T6,T7,T8>	asOctuple()
T8	eighth()
T5	fifth()
T1	first()
static <T1,T2,T3,T4,T5,T6,T7,T8> Octuple<T1,T2,T3,T4,T5,T6,T7,T8>	flatten(Tuple<Tuple<Tuple<Tuple<Tuple<Tuple<Tuple<T1,T2>,T3>,T4>,T5>,T6>,T7>,T8> nestedTuple)
T4	fourth()
<S1,S2,S3,S4,S5,S6,S7,S8> Octuple<S1,S2,S3,S4,S5,S6,S7,S8>	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) Create a new octuple by applying a function to each element, and putting the results into a new octuple.
<S8> Octuple<T1,T2,T3,T4,T5,T6,T7,S8>	mapEighth(Function<? super T8,? extends S8> mapper) Create a new octuple by applying a function to the eighth element, and putting the result as the eighth element of the new octuple.
<S5> Octuple<T1,T2,T3,T4,S5,T6,T7,T8>	mapFifth(Function<? super T5,? extends S5> mapper) Create a new octuple by applying a function to the fifth element, and putting the result as the fifth element of the new octuple.
<S1> Octuple<S1,T2,T3,T4,T5,T6,T7,T8>	mapFirst(Function<? super T1,? extends S1> mapper) Create a new octuple by applying a function to the first element, and putting the result as the first element of the new octuple.
<S4> Octuple<T1,T2,T3,S4,T5,T6,T7,T8>	mapFourth(Function<? super T4,? extends S4> mapper) Create a new octuple by applying a function to the fourth element, and putting the result as the fourth element of the new octuple.
<S2> Octuple<T1,S2,T3,T4,T5,T6,T7,T8>	mapSecond(Function<? super T2,? extends S2> mapper) Create a new octuple by applying a function to the second element, and putting the result as the second element of the new octuple.
<S7> Octuple<T1,T2,T3,T4,T5,T6,S7,T8>	mapSeventh(Function<? super T7,? extends S7> mapper) Create a new octuple by applying a function to the seventh element, and putting the result as the seventh element of the new octuple.
<S6> Octuple<T1,T2,T3,T4,T5,S6,T7,T8>	mapSixth(Function<? super T6,? extends S6> mapper) Create a new octuple by applying a function to the sixth element, and putting the result as the sixth element of the new octuple.
<S3> Octuple<T1,T2,S3,T4,T5,T6,T7,T8>	mapThird(Function<? super T3,? extends S3> mapper) Create a new octuple by applying a function to the third element, and putting the result as the third element of the new octuple.
static <T1,T2,T3,T4,T5,T6,T7,T8> Octuple<T1,T2,T3,T4,T5,T6,T7,T8>	of(T1 first, T2 second, T3 third, T4 fourth, T5 fifth, T6 sixth, T7 seventh, T8 eighth)
T2	second()
T7	seventh()
T6	sixth()
T3	third()

Method Detail

of

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

flatten

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

mapFirst

<S1> Octuple<S1,T2,T3,T4,T5,T6,T7,T8> mapFirst(Function<? super T1,? extends S1> mapper)

Create a new octuple by applying a function to the first element, and putting the result as the first element of the new octuple.

Parameters:

mapper - the function to apply to the first element

Returns:

the new octuple

mapSecond

<S2> Octuple<T1,S2,T3,T4,T5,T6,T7,T8> mapSecond(Function<? super T2,? extends S2> mapper)

Create a new octuple by applying a function to the second element, and putting the result as the second element of the new octuple.

Parameters:

mapper - the function to apply to the second element

Returns:

the new octuple

mapThird

<S3> Octuple<T1,T2,S3,T4,T5,T6,T7,T8> mapThird(Function<? super T3,? extends S3> mapper)

Create a new octuple by applying a function to the third element, and putting the result as the third element of the new octuple.

Parameters:

mapper - the function to apply to the third element

Returns:

the new octuple

mapFourth

<S4> Octuple<T1,T2,T3,S4,T5,T6,T7,T8> mapFourth(Function<? super T4,? extends S4> mapper)

Create a new octuple by applying a function to the fourth element, and putting the result as the fourth element of the new octuple.

Parameters:

mapper - the function to apply to the fourth element

Returns:

the new octuple

mapFifth

<S5> Octuple<T1,T2,T3,T4,S5,T6,T7,T8> mapFifth(Function<? super T5,? extends S5> mapper)

Create a new octuple by applying a function to the fifth element, and putting the result as the fifth element of the new octuple.

Parameters:

mapper - the function to apply to the fifth element

Returns:

the new octuple

mapSixth

<S6> Octuple<T1,T2,T3,T4,T5,S6,T7,T8> mapSixth(Function<? super T6,? extends S6> mapper)

Create a new octuple by applying a function to the sixth element, and putting the result as the sixth element of the new octuple.

Parameters:

mapper - the function to apply to the sixth element

Returns:

the new octuple

mapSeventh

<S7> Octuple<T1,T2,T3,T4,T5,T6,S7,T8> mapSeventh(Function<? super T7,? extends S7> mapper)

Create a new octuple by applying a function to the seventh element, and putting the result as the seventh element of the new octuple.

Parameters:

mapper - the function to apply to the seventh element

Returns:

the new octuple

mapEighth

<S8> Octuple<T1,T2,T3,T4,T5,T6,T7,S8> mapEighth(Function<? super T8,? extends S8> mapper)

Create a new octuple by applying a function to the eighth element, and putting the result as the eighth element of the new octuple.

Parameters:

mapper - the function to apply to the eighth element

Returns:

the new octuple

map

<S1,S2,S3,S4,S5,S6,S7,S8> Octuple<S1,S2,S3,S4,S5,S6,S7,S8> 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)

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

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

Returns:

the new octuple

asOctuple

Octuple<T1,T2,T3,T4,T5,T6,T7,T8> asOctuple()

Specified by:

asOctuple in interface ViewableAsOctuple<T1,T2,T3,T4,T5,T6,T7,T8>

Returns:

this octuple instance