Interface Tuple

    • Method Summary

      All Methods Static Methods Instance Methods Abstract Methods Deprecated Methods 
      Modifier and Type Method Description
      java.lang.Object[] array()
      Deprecated.
      - Use toArray() instead.
      static <T,​A1,​D1>
      java.util.stream.Collector<T,​Tuple1<A1>,​Tuple1<D1>>
      collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1)
      Construct a tuple collector of degree 1.
      static <T,​A1,​A2,​D1,​D2>
      java.util.stream.Collector<T,​Tuple2<A1,​A2>,​Tuple2<D1,​D2>>
      collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1, java.util.stream.Collector<? super T,​A2,​D2> collector2)
      Construct a tuple collector of degree 2.
      static <T,​A1,​A2,​A3,​D1,​D2,​D3>
      java.util.stream.Collector<T,​Tuple3<A1,​A2,​A3>,​Tuple3<D1,​D2,​D3>>
      collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1, java.util.stream.Collector<? super T,​A2,​D2> collector2, java.util.stream.Collector<? super T,​A3,​D3> collector3)
      Construct a tuple collector of degree 3.
      static <T,​A1,​A2,​A3,​A4,​D1,​D2,​D3,​D4>
      java.util.stream.Collector<T,​Tuple4<A1,​A2,​A3,​A4>,​Tuple4<D1,​D2,​D3,​D4>>
      collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1, java.util.stream.Collector<? super T,​A2,​D2> collector2, java.util.stream.Collector<? super T,​A3,​D3> collector3, java.util.stream.Collector<? super T,​A4,​D4> collector4)
      Construct a tuple collector of degree 4.
      static <T,​A1,​A2,​A3,​A4,​A5,​D1,​D2,​D3,​D4,​D5>
      java.util.stream.Collector<T,​Tuple5<A1,​A2,​A3,​A4,​A5>,​Tuple5<D1,​D2,​D3,​D4,​D5>>
      collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1, java.util.stream.Collector<? super T,​A2,​D2> collector2, java.util.stream.Collector<? super T,​A3,​D3> collector3, java.util.stream.Collector<? super T,​A4,​D4> collector4, java.util.stream.Collector<? super T,​A5,​D5> collector5)
      Construct a tuple collector of degree 5.
      static <T,​A1,​A2,​A3,​A4,​A5,​A6,​D1,​D2,​D3,​D4,​D5,​D6>
      java.util.stream.Collector<T,​Tuple6<A1,​A2,​A3,​A4,​A5,​A6>,​Tuple6<D1,​D2,​D3,​D4,​D5,​D6>>
      collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1, java.util.stream.Collector<? super T,​A2,​D2> collector2, java.util.stream.Collector<? super T,​A3,​D3> collector3, java.util.stream.Collector<? super T,​A4,​D4> collector4, java.util.stream.Collector<? super T,​A5,​D5> collector5, java.util.stream.Collector<? super T,​A6,​D6> collector6)
      Construct a tuple collector of degree 6.
      static <T,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​D1,​D2,​D3,​D4,​D5,​D6,​D7>
      java.util.stream.Collector<T,​Tuple7<A1,​A2,​A3,​A4,​A5,​A6,​A7>,​Tuple7<D1,​D2,​D3,​D4,​D5,​D6,​D7>>
      collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1, java.util.stream.Collector<? super T,​A2,​D2> collector2, java.util.stream.Collector<? super T,​A3,​D3> collector3, java.util.stream.Collector<? super T,​A4,​D4> collector4, java.util.stream.Collector<? super T,​A5,​D5> collector5, java.util.stream.Collector<? super T,​A6,​D6> collector6, java.util.stream.Collector<? super T,​A7,​D7> collector7)
      Construct a tuple collector of degree 7.
      static <T,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8>
      java.util.stream.Collector<T,​Tuple8<A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8>,​Tuple8<D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8>>
      collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1, java.util.stream.Collector<? super T,​A2,​D2> collector2, java.util.stream.Collector<? super T,​A3,​D3> collector3, java.util.stream.Collector<? super T,​A4,​D4> collector4, java.util.stream.Collector<? super T,​A5,​D5> collector5, java.util.stream.Collector<? super T,​A6,​D6> collector6, java.util.stream.Collector<? super T,​A7,​D7> collector7, java.util.stream.Collector<? super T,​A8,​D8> collector8)
      Construct a tuple collector of degree 8.
      static <T,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9>
      java.util.stream.Collector<T,​Tuple9<A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9>,​Tuple9<D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9>>
      collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1, java.util.stream.Collector<? super T,​A2,​D2> collector2, java.util.stream.Collector<? super T,​A3,​D3> collector3, java.util.stream.Collector<? super T,​A4,​D4> collector4, java.util.stream.Collector<? super T,​A5,​D5> collector5, java.util.stream.Collector<? super T,​A6,​D6> collector6, java.util.stream.Collector<? super T,​A7,​D7> collector7, java.util.stream.Collector<? super T,​A8,​D8> collector8, java.util.stream.Collector<? super T,​A9,​D9> collector9)
      Construct a tuple collector of degree 9.
      static <T,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10>
      java.util.stream.Collector<T,​Tuple10<A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10>,​Tuple10<D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10>>
      collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1, java.util.stream.Collector<? super T,​A2,​D2> collector2, java.util.stream.Collector<? super T,​A3,​D3> collector3, java.util.stream.Collector<? super T,​A4,​D4> collector4, java.util.stream.Collector<? super T,​A5,​D5> collector5, java.util.stream.Collector<? super T,​A6,​D6> collector6, java.util.stream.Collector<? super T,​A7,​D7> collector7, java.util.stream.Collector<? super T,​A8,​D8> collector8, java.util.stream.Collector<? super T,​A9,​D9> collector9, java.util.stream.Collector<? super T,​A10,​D10> collector10)
      Construct a tuple collector of degree 10.
      static <T,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11>
      java.util.stream.Collector<T,​Tuple11<A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11>,​Tuple11<D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11>>
      collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1, java.util.stream.Collector<? super T,​A2,​D2> collector2, java.util.stream.Collector<? super T,​A3,​D3> collector3, java.util.stream.Collector<? super T,​A4,​D4> collector4, java.util.stream.Collector<? super T,​A5,​D5> collector5, java.util.stream.Collector<? super T,​A6,​D6> collector6, java.util.stream.Collector<? super T,​A7,​D7> collector7, java.util.stream.Collector<? super T,​A8,​D8> collector8, java.util.stream.Collector<? super T,​A9,​D9> collector9, java.util.stream.Collector<? super T,​A10,​D10> collector10, java.util.stream.Collector<? super T,​A11,​D11> collector11)
      Construct a tuple collector of degree 11.
      static <T,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11,​D12>
      java.util.stream.Collector<T,​Tuple12<A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12>,​Tuple12<D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11,​D12>>
      collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1, java.util.stream.Collector<? super T,​A2,​D2> collector2, java.util.stream.Collector<? super T,​A3,​D3> collector3, java.util.stream.Collector<? super T,​A4,​D4> collector4, java.util.stream.Collector<? super T,​A5,​D5> collector5, java.util.stream.Collector<? super T,​A6,​D6> collector6, java.util.stream.Collector<? super T,​A7,​D7> collector7, java.util.stream.Collector<? super T,​A8,​D8> collector8, java.util.stream.Collector<? super T,​A9,​D9> collector9, java.util.stream.Collector<? super T,​A10,​D10> collector10, java.util.stream.Collector<? super T,​A11,​D11> collector11, java.util.stream.Collector<? super T,​A12,​D12> collector12)
      Construct a tuple collector of degree 12.
      static <T,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13,​D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11,​D12,​D13>
      java.util.stream.Collector<T,​Tuple13<A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13>,​Tuple13<D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11,​D12,​D13>>
      collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1, java.util.stream.Collector<? super T,​A2,​D2> collector2, java.util.stream.Collector<? super T,​A3,​D3> collector3, java.util.stream.Collector<? super T,​A4,​D4> collector4, java.util.stream.Collector<? super T,​A5,​D5> collector5, java.util.stream.Collector<? super T,​A6,​D6> collector6, java.util.stream.Collector<? super T,​A7,​D7> collector7, java.util.stream.Collector<? super T,​A8,​D8> collector8, java.util.stream.Collector<? super T,​A9,​D9> collector9, java.util.stream.Collector<? super T,​A10,​D10> collector10, java.util.stream.Collector<? super T,​A11,​D11> collector11, java.util.stream.Collector<? super T,​A12,​D12> collector12, java.util.stream.Collector<? super T,​A13,​D13> collector13)
      Construct a tuple collector of degree 13.
      static <T,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13,​A14,​D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11,​D12,​D13,​D14>
      java.util.stream.Collector<T,​Tuple14<A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13,​A14>,​Tuple14<D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11,​D12,​D13,​D14>>
      collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1, java.util.stream.Collector<? super T,​A2,​D2> collector2, java.util.stream.Collector<? super T,​A3,​D3> collector3, java.util.stream.Collector<? super T,​A4,​D4> collector4, java.util.stream.Collector<? super T,​A5,​D5> collector5, java.util.stream.Collector<? super T,​A6,​D6> collector6, java.util.stream.Collector<? super T,​A7,​D7> collector7, java.util.stream.Collector<? super T,​A8,​D8> collector8, java.util.stream.Collector<? super T,​A9,​D9> collector9, java.util.stream.Collector<? super T,​A10,​D10> collector10, java.util.stream.Collector<? super T,​A11,​D11> collector11, java.util.stream.Collector<? super T,​A12,​D12> collector12, java.util.stream.Collector<? super T,​A13,​D13> collector13, java.util.stream.Collector<? super T,​A14,​D14> collector14)
      Construct a tuple collector of degree 14.
      static <T,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13,​A14,​A15,​D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11,​D12,​D13,​D14,​D15>
      java.util.stream.Collector<T,​Tuple15<A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13,​A14,​A15>,​Tuple15<D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11,​D12,​D13,​D14,​D15>>
      collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1, java.util.stream.Collector<? super T,​A2,​D2> collector2, java.util.stream.Collector<? super T,​A3,​D3> collector3, java.util.stream.Collector<? super T,​A4,​D4> collector4, java.util.stream.Collector<? super T,​A5,​D5> collector5, java.util.stream.Collector<? super T,​A6,​D6> collector6, java.util.stream.Collector<? super T,​A7,​D7> collector7, java.util.stream.Collector<? super T,​A8,​D8> collector8, java.util.stream.Collector<? super T,​A9,​D9> collector9, java.util.stream.Collector<? super T,​A10,​D10> collector10, java.util.stream.Collector<? super T,​A11,​D11> collector11, java.util.stream.Collector<? super T,​A12,​D12> collector12, java.util.stream.Collector<? super T,​A13,​D13> collector13, java.util.stream.Collector<? super T,​A14,​D14> collector14, java.util.stream.Collector<? super T,​A15,​D15> collector15)
      Construct a tuple collector of degree 15.
      static <T,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13,​A14,​A15,​A16,​D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11,​D12,​D13,​D14,​D15,​D16>
      java.util.stream.Collector<T,​Tuple16<A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13,​A14,​A15,​A16>,​Tuple16<D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11,​D12,​D13,​D14,​D15,​D16>>
      collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1, java.util.stream.Collector<? super T,​A2,​D2> collector2, java.util.stream.Collector<? super T,​A3,​D3> collector3, java.util.stream.Collector<? super T,​A4,​D4> collector4, java.util.stream.Collector<? super T,​A5,​D5> collector5, java.util.stream.Collector<? super T,​A6,​D6> collector6, java.util.stream.Collector<? super T,​A7,​D7> collector7, java.util.stream.Collector<? super T,​A8,​D8> collector8, java.util.stream.Collector<? super T,​A9,​D9> collector9, java.util.stream.Collector<? super T,​A10,​D10> collector10, java.util.stream.Collector<? super T,​A11,​D11> collector11, java.util.stream.Collector<? super T,​A12,​D12> collector12, java.util.stream.Collector<? super T,​A13,​D13> collector13, java.util.stream.Collector<? super T,​A14,​D14> collector14, java.util.stream.Collector<? super T,​A15,​D15> collector15, java.util.stream.Collector<? super T,​A16,​D16> collector16)
      Construct a tuple collector of degree 16.
      static Consumer1<Tuple0> consumer​(java.lang.Runnable consumer)
      Construct a tuple consumer of degree 0.
      static <T1,​T2>
      Consumer1<Tuple2<T1,​T2>>
      consumer​(java.util.function.BiConsumer<T1,​T2> consumer)
      Construct a tuple consumer of degree 2.
      static <T1> Consumer1<Tuple1<T1>> consumer​(java.util.function.Consumer<T1> consumer)
      Construct a tuple consumer of degree 1.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10>
      Consumer1<Tuple10<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10>>
      consumer​(Consumer10<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10> consumer)
      Construct a tuple consumer of degree 10.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11>
      Consumer1<Tuple11<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11>>
      consumer​(Consumer11<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11> consumer)
      Construct a tuple consumer of degree 11.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12>
      Consumer1<Tuple12<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12>>
      consumer​(Consumer12<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12> consumer)
      Construct a tuple consumer of degree 12.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13>
      Consumer1<Tuple13<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13>>
      consumer​(Consumer13<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13> consumer)
      Construct a tuple consumer of degree 13.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14>
      Consumer1<Tuple14<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14>>
      consumer​(Consumer14<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14> consumer)
      Construct a tuple consumer of degree 14.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15>
      Consumer1<Tuple15<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15>>
      consumer​(Consumer15<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15> consumer)
      Construct a tuple consumer of degree 15.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16>
      Consumer1<Tuple16<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16>>
      consumer​(Consumer16<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16> consumer)
      Construct a tuple consumer of degree 16.
      static <T1,​T2,​T3>
      Consumer1<Tuple3<T1,​T2,​T3>>
      consumer​(Consumer3<T1,​T2,​T3> consumer)
      Construct a tuple consumer of degree 3.
      static <T1,​T2,​T3,​T4>
      Consumer1<Tuple4<T1,​T2,​T3,​T4>>
      consumer​(Consumer4<T1,​T2,​T3,​T4> consumer)
      Construct a tuple consumer of degree 4.
      static <T1,​T2,​T3,​T4,​T5>
      Consumer1<Tuple5<T1,​T2,​T3,​T4,​T5>>
      consumer​(Consumer5<T1,​T2,​T3,​T4,​T5> consumer)
      Construct a tuple consumer of degree 5.
      static <T1,​T2,​T3,​T4,​T5,​T6>
      Consumer1<Tuple6<T1,​T2,​T3,​T4,​T5,​T6>>
      consumer​(Consumer6<T1,​T2,​T3,​T4,​T5,​T6> consumer)
      Construct a tuple consumer of degree 6.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7>
      Consumer1<Tuple7<T1,​T2,​T3,​T4,​T5,​T6,​T7>>
      consumer​(Consumer7<T1,​T2,​T3,​T4,​T5,​T6,​T7> consumer)
      Construct a tuple consumer of degree 7.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8>
      Consumer1<Tuple8<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8>>
      consumer​(Consumer8<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8> consumer)
      Construct a tuple consumer of degree 8.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9>
      Consumer1<Tuple9<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9>>
      consumer​(Consumer9<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9> consumer)
      Construct a tuple consumer of degree 9.
      int degree()
      The degree of this tuple.
      static <T1,​T2,​R>
      Function1<Tuple2<T1,​T2>,​R>
      function​(java.util.function.BiFunction<T1,​T2,​R> function)
      Construct a tuple function of degree 2.
      static <T1,​R>
      Function1<Tuple1<T1>,​R>
      function​(java.util.function.Function<T1,​R> function)
      Construct a tuple function of degree 1.
      static <R> Function1<Tuple0,​R> function​(java.util.function.Supplier<R> function)
      Construct a tuple function of degree 0.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​R>
      Function1<Tuple10<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10>,​R>
      function​(Function10<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​R> function)
      Construct a tuple function of degree 10.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​R>
      Function1<Tuple11<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11>,​R>
      function​(Function11<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​R> function)
      Construct a tuple function of degree 11.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​R>
      Function1<Tuple12<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12>,​R>
      function​(Function12<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​R> function)
      Construct a tuple function of degree 12.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​R>
      Function1<Tuple13<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13>,​R>
      function​(Function13<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​R> function)
      Construct a tuple function of degree 13.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​R>
      Function1<Tuple14<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14>,​R>
      function​(Function14<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​R> function)
      Construct a tuple function of degree 14.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​R>
      Function1<Tuple15<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15>,​R>
      function​(Function15<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​R> function)
      Construct a tuple function of degree 15.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​R>
      Function1<Tuple16<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16>,​R>
      function​(Function16<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​R> function)
      Construct a tuple function of degree 16.
      static <T1,​T2,​T3,​R>
      Function1<Tuple3<T1,​T2,​T3>,​R>
      function​(Function3<T1,​T2,​T3,​R> function)
      Construct a tuple function of degree 3.
      static <T1,​T2,​T3,​T4,​R>
      Function1<Tuple4<T1,​T2,​T3,​T4>,​R>
      function​(Function4<T1,​T2,​T3,​T4,​R> function)
      Construct a tuple function of degree 4.
      static <T1,​T2,​T3,​T4,​T5,​R>
      Function1<Tuple5<T1,​T2,​T3,​T4,​T5>,​R>
      function​(Function5<T1,​T2,​T3,​T4,​T5,​R> function)
      Construct a tuple function of degree 5.
      static <T1,​T2,​T3,​T4,​T5,​T6,​R>
      Function1<Tuple6<T1,​T2,​T3,​T4,​T5,​T6>,​R>
      function​(Function6<T1,​T2,​T3,​T4,​T5,​T6,​R> function)
      Construct a tuple function of degree 6.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​R>
      Function1<Tuple7<T1,​T2,​T3,​T4,​T5,​T6,​T7>,​R>
      function​(Function7<T1,​T2,​T3,​T4,​T5,​T6,​T7,​R> function)
      Construct a tuple function of degree 7.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​R>
      Function1<Tuple8<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8>,​R>
      function​(Function8<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​R> function)
      Construct a tuple function of degree 8.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​R>
      Function1<Tuple9<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9>,​R>
      function​(Function9<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​R> function)
      Construct a tuple function of degree 9.
      java.util.List<?> list()
      Deprecated.
      - Use toList() instead.
      static <T extends java.lang.Comparable<T>>
      Range<T>
      range​(T lowerInclusive, T upperInclusive)
      Create a new range with inclusive bounds.
      java.lang.Object[] toArray()
      Get an array representation of this tuple.
      java.util.List<?> toList()
      Get a list representation of this tuple.
      java.util.Map<java.lang.String,​?> toMap()
      Get a map representation of this tuple.
      <K> java.util.Map<K,​?> toMap​(java.util.function.Function<? super java.lang.Integer,​? extends K> keyMapper)
      Get a map representation of this tuple.
      Seq<?> toSeq()
      Get a Seq representation of this tuple.
      static Tuple0 tuple()
      Construct a tuple of degree 0.
      static <T1> Tuple1<T1> tuple​(T1 v1)
      Construct a tuple of degree 1.
      static <T1,​T2>
      Tuple2<T1,​T2>
      tuple​(T1 v1, T2 v2)
      Construct a tuple of degree 2.
      static <T1,​T2,​T3>
      Tuple3<T1,​T2,​T3>
      tuple​(T1 v1, T2 v2, T3 v3)
      Construct a tuple of degree 3.
      static <T1,​T2,​T3,​T4>
      Tuple4<T1,​T2,​T3,​T4>
      tuple​(T1 v1, T2 v2, T3 v3, T4 v4)
      Construct a tuple of degree 4.
      static <T1,​T2,​T3,​T4,​T5>
      Tuple5<T1,​T2,​T3,​T4,​T5>
      tuple​(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5)
      Construct a tuple of degree 5.
      static <T1,​T2,​T3,​T4,​T5,​T6>
      Tuple6<T1,​T2,​T3,​T4,​T5,​T6>
      tuple​(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6)
      Construct a tuple of degree 6.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7>
      Tuple7<T1,​T2,​T3,​T4,​T5,​T6,​T7>
      tuple​(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7)
      Construct a tuple of degree 7.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8>
      Tuple8<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8>
      tuple​(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8)
      Construct a tuple of degree 8.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9>
      Tuple9<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9>
      tuple​(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9)
      Construct a tuple of degree 9.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10>
      Tuple10<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10>
      tuple​(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10)
      Construct a tuple of degree 10.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11>
      Tuple11<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11>
      tuple​(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11)
      Construct a tuple of degree 11.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12>
      Tuple12<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12>
      tuple​(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12)
      Construct a tuple of degree 12.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13>
      Tuple13<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13>
      tuple​(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13)
      Construct a tuple of degree 13.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14>
      Tuple14<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14>
      tuple​(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14)
      Construct a tuple of degree 14.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15>
      Tuple15<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15>
      tuple​(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15)
      Construct a tuple of degree 15.
      static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16>
      Tuple16<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16>
      tuple​(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16)
      Construct a tuple of degree 16.
      • Methods inherited from interface java.lang.Iterable

        forEach, iterator, spliterator
    • Method Detail

      • tuple

        static Tuple0 tuple()
        Construct a tuple of degree 0.
      • tuple

        static <T1> Tuple1<T1> tuple​(T1 v1)
        Construct a tuple of degree 1.
      • tuple

        static <T1,​T2> Tuple2<T1,​T2> tuple​(T1 v1,
                                                       T2 v2)
        Construct a tuple of degree 2.
      • tuple

        static <T1,​T2,​T3> Tuple3<T1,​T2,​T3> tuple​(T1 v1,
                                                                         T2 v2,
                                                                         T3 v3)
        Construct a tuple of degree 3.
      • tuple

        static <T1,​T2,​T3,​T4> Tuple4<T1,​T2,​T3,​T4> tuple​(T1 v1,
                                                                                           T2 v2,
                                                                                           T3 v3,
                                                                                           T4 v4)
        Construct a tuple of degree 4.
      • tuple

        static <T1,​T2,​T3,​T4,​T5> Tuple5<T1,​T2,​T3,​T4,​T5> tuple​(T1 v1,
                                                                                                             T2 v2,
                                                                                                             T3 v3,
                                                                                                             T4 v4,
                                                                                                             T5 v5)
        Construct a tuple of degree 5.
      • tuple

        static <T1,​T2,​T3,​T4,​T5,​T6> Tuple6<T1,​T2,​T3,​T4,​T5,​T6> tuple​(T1 v1,
                                                                                                                               T2 v2,
                                                                                                                               T3 v3,
                                                                                                                               T4 v4,
                                                                                                                               T5 v5,
                                                                                                                               T6 v6)
        Construct a tuple of degree 6.
      • tuple

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7> Tuple7<T1,​T2,​T3,​T4,​T5,​T6,​T7> tuple​(T1 v1,
                                                                                                                                                 T2 v2,
                                                                                                                                                 T3 v3,
                                                                                                                                                 T4 v4,
                                                                                                                                                 T5 v5,
                                                                                                                                                 T6 v6,
                                                                                                                                                 T7 v7)
        Construct a tuple of degree 7.
      • tuple

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8> Tuple8<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8> tuple​(T1 v1,
                                                                                                                                                                   T2 v2,
                                                                                                                                                                   T3 v3,
                                                                                                                                                                   T4 v4,
                                                                                                                                                                   T5 v5,
                                                                                                                                                                   T6 v6,
                                                                                                                                                                   T7 v7,
                                                                                                                                                                   T8 v8)
        Construct a tuple of degree 8.
      • tuple

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9> Tuple9<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9> tuple​(T1 v1,
                                                                                                                                                                                     T2 v2,
                                                                                                                                                                                     T3 v3,
                                                                                                                                                                                     T4 v4,
                                                                                                                                                                                     T5 v5,
                                                                                                                                                                                     T6 v6,
                                                                                                                                                                                     T7 v7,
                                                                                                                                                                                     T8 v8,
                                                                                                                                                                                     T9 v9)
        Construct a tuple of degree 9.
      • tuple

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10> Tuple10<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10> tuple​(T1 v1,
                                                                                                                                                                                                          T2 v2,
                                                                                                                                                                                                          T3 v3,
                                                                                                                                                                                                          T4 v4,
                                                                                                                                                                                                          T5 v5,
                                                                                                                                                                                                          T6 v6,
                                                                                                                                                                                                          T7 v7,
                                                                                                                                                                                                          T8 v8,
                                                                                                                                                                                                          T9 v9,
                                                                                                                                                                                                          T10 v10)
        Construct a tuple of degree 10.
      • tuple

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11> Tuple11<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11> tuple​(T1 v1,
                                                                                                                                                                                                                              T2 v2,
                                                                                                                                                                                                                              T3 v3,
                                                                                                                                                                                                                              T4 v4,
                                                                                                                                                                                                                              T5 v5,
                                                                                                                                                                                                                              T6 v6,
                                                                                                                                                                                                                              T7 v7,
                                                                                                                                                                                                                              T8 v8,
                                                                                                                                                                                                                              T9 v9,
                                                                                                                                                                                                                              T10 v10,
                                                                                                                                                                                                                              T11 v11)
        Construct a tuple of degree 11.
      • tuple

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12> Tuple12<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12> tuple​(T1 v1,
                                                                                                                                                                                                                                                  T2 v2,
                                                                                                                                                                                                                                                  T3 v3,
                                                                                                                                                                                                                                                  T4 v4,
                                                                                                                                                                                                                                                  T5 v5,
                                                                                                                                                                                                                                                  T6 v6,
                                                                                                                                                                                                                                                  T7 v7,
                                                                                                                                                                                                                                                  T8 v8,
                                                                                                                                                                                                                                                  T9 v9,
                                                                                                                                                                                                                                                  T10 v10,
                                                                                                                                                                                                                                                  T11 v11,
                                                                                                                                                                                                                                                  T12 v12)
        Construct a tuple of degree 12.
      • tuple

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13> Tuple13<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13> tuple​(T1 v1,
                                                                                                                                                                                                                                                                      T2 v2,
                                                                                                                                                                                                                                                                      T3 v3,
                                                                                                                                                                                                                                                                      T4 v4,
                                                                                                                                                                                                                                                                      T5 v5,
                                                                                                                                                                                                                                                                      T6 v6,
                                                                                                                                                                                                                                                                      T7 v7,
                                                                                                                                                                                                                                                                      T8 v8,
                                                                                                                                                                                                                                                                      T9 v9,
                                                                                                                                                                                                                                                                      T10 v10,
                                                                                                                                                                                                                                                                      T11 v11,
                                                                                                                                                                                                                                                                      T12 v12,
                                                                                                                                                                                                                                                                      T13 v13)
        Construct a tuple of degree 13.
      • tuple

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14> Tuple14<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14> tuple​(T1 v1,
                                                                                                                                                                                                                                                                                          T2 v2,
                                                                                                                                                                                                                                                                                          T3 v3,
                                                                                                                                                                                                                                                                                          T4 v4,
                                                                                                                                                                                                                                                                                          T5 v5,
                                                                                                                                                                                                                                                                                          T6 v6,
                                                                                                                                                                                                                                                                                          T7 v7,
                                                                                                                                                                                                                                                                                          T8 v8,
                                                                                                                                                                                                                                                                                          T9 v9,
                                                                                                                                                                                                                                                                                          T10 v10,
                                                                                                                                                                                                                                                                                          T11 v11,
                                                                                                                                                                                                                                                                                          T12 v12,
                                                                                                                                                                                                                                                                                          T13 v13,
                                                                                                                                                                                                                                                                                          T14 v14)
        Construct a tuple of degree 14.
      • tuple

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15> Tuple15<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15> tuple​(T1 v1,
                                                                                                                                                                                                                                                                                                              T2 v2,
                                                                                                                                                                                                                                                                                                              T3 v3,
                                                                                                                                                                                                                                                                                                              T4 v4,
                                                                                                                                                                                                                                                                                                              T5 v5,
                                                                                                                                                                                                                                                                                                              T6 v6,
                                                                                                                                                                                                                                                                                                              T7 v7,
                                                                                                                                                                                                                                                                                                              T8 v8,
                                                                                                                                                                                                                                                                                                              T9 v9,
                                                                                                                                                                                                                                                                                                              T10 v10,
                                                                                                                                                                                                                                                                                                              T11 v11,
                                                                                                                                                                                                                                                                                                              T12 v12,
                                                                                                                                                                                                                                                                                                              T13 v13,
                                                                                                                                                                                                                                                                                                              T14 v14,
                                                                                                                                                                                                                                                                                                              T15 v15)
        Construct a tuple of degree 15.
      • tuple

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16> Tuple16<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16> tuple​(T1 v1,
                                                                                                                                                                                                                                                                                                                                  T2 v2,
                                                                                                                                                                                                                                                                                                                                  T3 v3,
                                                                                                                                                                                                                                                                                                                                  T4 v4,
                                                                                                                                                                                                                                                                                                                                  T5 v5,
                                                                                                                                                                                                                                                                                                                                  T6 v6,
                                                                                                                                                                                                                                                                                                                                  T7 v7,
                                                                                                                                                                                                                                                                                                                                  T8 v8,
                                                                                                                                                                                                                                                                                                                                  T9 v9,
                                                                                                                                                                                                                                                                                                                                  T10 v10,
                                                                                                                                                                                                                                                                                                                                  T11 v11,
                                                                                                                                                                                                                                                                                                                                  T12 v12,
                                                                                                                                                                                                                                                                                                                                  T13 v13,
                                                                                                                                                                                                                                                                                                                                  T14 v14,
                                                                                                                                                                                                                                                                                                                                  T15 v15,
                                                                                                                                                                                                                                                                                                                                  T16 v16)
        Construct a tuple of degree 16.
      • function

        static <R> Function1<Tuple0,​R> function​(java.util.function.Supplier<R> function)
        Construct a tuple function of degree 0.
      • function

        static <T1,​R> Function1<Tuple1<T1>,​R> function​(java.util.function.Function<T1,​R> function)
        Construct a tuple function of degree 1.
      • function

        static <T1,​T2,​R> Function1<Tuple2<T1,​T2>,​R> function​(java.util.function.BiFunction<T1,​T2,​R> function)
        Construct a tuple function of degree 2.
      • function

        static <T1,​T2,​T3,​R> Function1<Tuple3<T1,​T2,​T3>,​R> function​(Function3<T1,​T2,​T3,​R> function)
        Construct a tuple function of degree 3.
      • function

        static <T1,​T2,​T3,​T4,​R> Function1<Tuple4<T1,​T2,​T3,​T4>,​R> function​(Function4<T1,​T2,​T3,​T4,​R> function)
        Construct a tuple function of degree 4.
      • function

        static <T1,​T2,​T3,​T4,​T5,​R> Function1<Tuple5<T1,​T2,​T3,​T4,​T5>,​R> function​(Function5<T1,​T2,​T3,​T4,​T5,​R> function)
        Construct a tuple function of degree 5.
      • function

        static <T1,​T2,​T3,​T4,​T5,​T6,​R> Function1<Tuple6<T1,​T2,​T3,​T4,​T5,​T6>,​R> function​(Function6<T1,​T2,​T3,​T4,​T5,​T6,​R> function)
        Construct a tuple function of degree 6.
      • function

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​R> Function1<Tuple7<T1,​T2,​T3,​T4,​T5,​T6,​T7>,​R> function​(Function7<T1,​T2,​T3,​T4,​T5,​T6,​T7,​R> function)
        Construct a tuple function of degree 7.
      • function

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​R> Function1<Tuple8<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8>,​R> function​(Function8<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​R> function)
        Construct a tuple function of degree 8.
      • function

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​R> Function1<Tuple9<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9>,​R> function​(Function9<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​R> function)
        Construct a tuple function of degree 9.
      • function

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​R> Function1<Tuple10<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10>,​R> function​(Function10<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​R> function)
        Construct a tuple function of degree 10.
      • function

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​R> Function1<Tuple11<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11>,​R> function​(Function11<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​R> function)
        Construct a tuple function of degree 11.
      • function

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​R> Function1<Tuple12<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12>,​R> function​(Function12<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​R> function)
        Construct a tuple function of degree 12.
      • function

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​R> Function1<Tuple13<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13>,​R> function​(Function13<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​R> function)
        Construct a tuple function of degree 13.
      • function

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​R> Function1<Tuple14<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14>,​R> function​(Function14<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​R> function)
        Construct a tuple function of degree 14.
      • function

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​R> Function1<Tuple15<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15>,​R> function​(Function15<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​R> function)
        Construct a tuple function of degree 15.
      • function

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​R> Function1<Tuple16<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16>,​R> function​(Function16<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​R> function)
        Construct a tuple function of degree 16.
      • consumer

        static Consumer1<Tuple0> consumer​(java.lang.Runnable consumer)
        Construct a tuple consumer of degree 0.
      • consumer

        static <T1> Consumer1<Tuple1<T1>> consumer​(java.util.function.Consumer<T1> consumer)
        Construct a tuple consumer of degree 1.
      • consumer

        static <T1,​T2> Consumer1<Tuple2<T1,​T2>> consumer​(java.util.function.BiConsumer<T1,​T2> consumer)
        Construct a tuple consumer of degree 2.
      • consumer

        static <T1,​T2,​T3> Consumer1<Tuple3<T1,​T2,​T3>> consumer​(Consumer3<T1,​T2,​T3> consumer)
        Construct a tuple consumer of degree 3.
      • consumer

        static <T1,​T2,​T3,​T4> Consumer1<Tuple4<T1,​T2,​T3,​T4>> consumer​(Consumer4<T1,​T2,​T3,​T4> consumer)
        Construct a tuple consumer of degree 4.
      • consumer

        static <T1,​T2,​T3,​T4,​T5> Consumer1<Tuple5<T1,​T2,​T3,​T4,​T5>> consumer​(Consumer5<T1,​T2,​T3,​T4,​T5> consumer)
        Construct a tuple consumer of degree 5.
      • consumer

        static <T1,​T2,​T3,​T4,​T5,​T6> Consumer1<Tuple6<T1,​T2,​T3,​T4,​T5,​T6>> consumer​(Consumer6<T1,​T2,​T3,​T4,​T5,​T6> consumer)
        Construct a tuple consumer of degree 6.
      • consumer

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7> Consumer1<Tuple7<T1,​T2,​T3,​T4,​T5,​T6,​T7>> consumer​(Consumer7<T1,​T2,​T3,​T4,​T5,​T6,​T7> consumer)
        Construct a tuple consumer of degree 7.
      • consumer

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8> Consumer1<Tuple8<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8>> consumer​(Consumer8<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8> consumer)
        Construct a tuple consumer of degree 8.
      • consumer

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9> Consumer1<Tuple9<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9>> consumer​(Consumer9<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9> consumer)
        Construct a tuple consumer of degree 9.
      • consumer

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10> Consumer1<Tuple10<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10>> consumer​(Consumer10<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10> consumer)
        Construct a tuple consumer of degree 10.
      • consumer

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11> Consumer1<Tuple11<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11>> consumer​(Consumer11<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11> consumer)
        Construct a tuple consumer of degree 11.
      • consumer

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12> Consumer1<Tuple12<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12>> consumer​(Consumer12<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12> consumer)
        Construct a tuple consumer of degree 12.
      • consumer

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13> Consumer1<Tuple13<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13>> consumer​(Consumer13<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13> consumer)
        Construct a tuple consumer of degree 13.
      • consumer

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14> Consumer1<Tuple14<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14>> consumer​(Consumer14<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14> consumer)
        Construct a tuple consumer of degree 14.
      • consumer

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15> Consumer1<Tuple15<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15>> consumer​(Consumer15<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15> consumer)
        Construct a tuple consumer of degree 15.
      • consumer

        static <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16> Consumer1<Tuple16<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16>> consumer​(Consumer16<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16> consumer)
        Construct a tuple consumer of degree 16.
      • collectors

        static <T,​A1,​D1> java.util.stream.Collector<T,​Tuple1<A1>,​Tuple1<D1>> collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1)
        Construct a tuple collector of degree 1.
      • collectors

        static <T,​A1,​A2,​D1,​D2> java.util.stream.Collector<T,​Tuple2<A1,​A2>,​Tuple2<D1,​D2>> collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1,
                                                                                                                                                    java.util.stream.Collector<? super T,​A2,​D2> collector2)
        Construct a tuple collector of degree 2.
      • collectors

        static <T,​A1,​A2,​A3,​D1,​D2,​D3> java.util.stream.Collector<T,​Tuple3<A1,​A2,​A3>,​Tuple3<D1,​D2,​D3>> collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1,
                                                                                                                                                                                        java.util.stream.Collector<? super T,​A2,​D2> collector2,
                                                                                                                                                                                        java.util.stream.Collector<? super T,​A3,​D3> collector3)
        Construct a tuple collector of degree 3.
      • collectors

        static <T,​A1,​A2,​A3,​A4,​D1,​D2,​D3,​D4> java.util.stream.Collector<T,​Tuple4<A1,​A2,​A3,​A4>,​Tuple4<D1,​D2,​D3,​D4>> collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1,
                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A2,​D2> collector2,
                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A3,​D3> collector3,
                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A4,​D4> collector4)
        Construct a tuple collector of degree 4.
      • collectors

        static <T,​A1,​A2,​A3,​A4,​A5,​D1,​D2,​D3,​D4,​D5> java.util.stream.Collector<T,​Tuple5<A1,​A2,​A3,​A4,​A5>,​Tuple5<D1,​D2,​D3,​D4,​D5>> collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1,
                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A2,​D2> collector2,
                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A3,​D3> collector3,
                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A4,​D4> collector4,
                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A5,​D5> collector5)
        Construct a tuple collector of degree 5.
      • collectors

        static <T,​A1,​A2,​A3,​A4,​A5,​A6,​D1,​D2,​D3,​D4,​D5,​D6> java.util.stream.Collector<T,​Tuple6<A1,​A2,​A3,​A4,​A5,​A6>,​Tuple6<D1,​D2,​D3,​D4,​D5,​D6>> collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1,
                                                                                                                                                                                                                                                                                                    java.util.stream.Collector<? super T,​A2,​D2> collector2,
                                                                                                                                                                                                                                                                                                    java.util.stream.Collector<? super T,​A3,​D3> collector3,
                                                                                                                                                                                                                                                                                                    java.util.stream.Collector<? super T,​A4,​D4> collector4,
                                                                                                                                                                                                                                                                                                    java.util.stream.Collector<? super T,​A5,​D5> collector5,
                                                                                                                                                                                                                                                                                                    java.util.stream.Collector<? super T,​A6,​D6> collector6)
        Construct a tuple collector of degree 6.
      • collectors

        static <T,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​D1,​D2,​D3,​D4,​D5,​D6,​D7> java.util.stream.Collector<T,​Tuple7<A1,​A2,​A3,​A4,​A5,​A6,​A7>,​Tuple7<D1,​D2,​D3,​D4,​D5,​D6,​D7>> collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1,
                                                                                                                                                                                                                                                                                                                                        java.util.stream.Collector<? super T,​A2,​D2> collector2,
                                                                                                                                                                                                                                                                                                                                        java.util.stream.Collector<? super T,​A3,​D3> collector3,
                                                                                                                                                                                                                                                                                                                                        java.util.stream.Collector<? super T,​A4,​D4> collector4,
                                                                                                                                                                                                                                                                                                                                        java.util.stream.Collector<? super T,​A5,​D5> collector5,
                                                                                                                                                                                                                                                                                                                                        java.util.stream.Collector<? super T,​A6,​D6> collector6,
                                                                                                                                                                                                                                                                                                                                        java.util.stream.Collector<? super T,​A7,​D7> collector7)
        Construct a tuple collector of degree 7.
      • collectors

        static <T,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8> java.util.stream.Collector<T,​Tuple8<A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8>,​Tuple8<D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8>> collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1,
                                                                                                                                                                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A2,​D2> collector2,
                                                                                                                                                                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A3,​D3> collector3,
                                                                                                                                                                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A4,​D4> collector4,
                                                                                                                                                                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A5,​D5> collector5,
                                                                                                                                                                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A6,​D6> collector6,
                                                                                                                                                                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A7,​D7> collector7,
                                                                                                                                                                                                                                                                                                                                                                            java.util.stream.Collector<? super T,​A8,​D8> collector8)
        Construct a tuple collector of degree 8.
      • collectors

        static <T,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9> java.util.stream.Collector<T,​Tuple9<A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9>,​Tuple9<D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9>> collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1,
                                                                                                                                                                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A2,​D2> collector2,
                                                                                                                                                                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A3,​D3> collector3,
                                                                                                                                                                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A4,​D4> collector4,
                                                                                                                                                                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A5,​D5> collector5,
                                                                                                                                                                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A6,​D6> collector6,
                                                                                                                                                                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A7,​D7> collector7,
                                                                                                                                                                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A8,​D8> collector8,
                                                                                                                                                                                                                                                                                                                                                                                                                java.util.stream.Collector<? super T,​A9,​D9> collector9)
        Construct a tuple collector of degree 9.
      • collectors

        static <T,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10> java.util.stream.Collector<T,​Tuple10<A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10>,​Tuple10<D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10>> collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A2,​D2> collector2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A3,​D3> collector3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A4,​D4> collector4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A5,​D5> collector5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A6,​D6> collector6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A7,​D7> collector7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A8,​D8> collector8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A9,​D9> collector9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A10,​D10> collector10)
        Construct a tuple collector of degree 10.
      • collectors

        static <T,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11> java.util.stream.Collector<T,​Tuple11<A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11>,​Tuple11<D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11>> collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A2,​D2> collector2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A3,​D3> collector3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A4,​D4> collector4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A5,​D5> collector5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A6,​D6> collector6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A7,​D7> collector7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A8,​D8> collector8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A9,​D9> collector9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A10,​D10> collector10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A11,​D11> collector11)
        Construct a tuple collector of degree 11.
      • collectors

        static <T,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11,​D12> java.util.stream.Collector<T,​Tuple12<A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12>,​Tuple12<D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11,​D12>> collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A2,​D2> collector2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A3,​D3> collector3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A4,​D4> collector4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A5,​D5> collector5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A6,​D6> collector6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A7,​D7> collector7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A8,​D8> collector8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A9,​D9> collector9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A10,​D10> collector10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A11,​D11> collector11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A12,​D12> collector12)
        Construct a tuple collector of degree 12.
      • collectors

        static <T,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13,​D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11,​D12,​D13> java.util.stream.Collector<T,​Tuple13<A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13>,​Tuple13<D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11,​D12,​D13>> collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A2,​D2> collector2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A3,​D3> collector3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A4,​D4> collector4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A5,​D5> collector5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A6,​D6> collector6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A7,​D7> collector7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A8,​D8> collector8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A9,​D9> collector9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A10,​D10> collector10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A11,​D11> collector11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A12,​D12> collector12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A13,​D13> collector13)
        Construct a tuple collector of degree 13.
      • collectors

        static <T,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13,​A14,​D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11,​D12,​D13,​D14> java.util.stream.Collector<T,​Tuple14<A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13,​A14>,​Tuple14<D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11,​D12,​D13,​D14>> collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A2,​D2> collector2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A3,​D3> collector3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A4,​D4> collector4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A5,​D5> collector5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A6,​D6> collector6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A7,​D7> collector7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A8,​D8> collector8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A9,​D9> collector9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A10,​D10> collector10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A11,​D11> collector11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A12,​D12> collector12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A13,​D13> collector13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A14,​D14> collector14)
        Construct a tuple collector of degree 14.
      • collectors

        static <T,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13,​A14,​A15,​D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11,​D12,​D13,​D14,​D15> java.util.stream.Collector<T,​Tuple15<A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13,​A14,​A15>,​Tuple15<D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11,​D12,​D13,​D14,​D15>> collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A2,​D2> collector2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A3,​D3> collector3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A4,​D4> collector4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A5,​D5> collector5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A6,​D6> collector6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A7,​D7> collector7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A8,​D8> collector8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A9,​D9> collector9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A10,​D10> collector10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A11,​D11> collector11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A12,​D12> collector12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A13,​D13> collector13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A14,​D14> collector14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  java.util.stream.Collector<? super T,​A15,​D15> collector15)
        Construct a tuple collector of degree 15.
      • collectors

        static <T,​A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13,​A14,​A15,​A16,​D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11,​D12,​D13,​D14,​D15,​D16> java.util.stream.Collector<T,​Tuple16<A1,​A2,​A3,​A4,​A5,​A6,​A7,​A8,​A9,​A10,​A11,​A12,​A13,​A14,​A15,​A16>,​Tuple16<D1,​D2,​D3,​D4,​D5,​D6,​D7,​D8,​D9,​D10,​D11,​D12,​D13,​D14,​D15,​D16>> collectors​(java.util.stream.Collector<? super T,​A1,​D1> collector1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A2,​D2> collector2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A3,​D3> collector3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A4,​D4> collector4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A5,​D5> collector5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A6,​D6> collector6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A7,​D7> collector7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A8,​D8> collector8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A9,​D9> collector9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A10,​D10> collector10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A11,​D11> collector11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A12,​D12> collector12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A13,​D13> collector13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A14,​D14> collector14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A15,​D15> collector15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.util.stream.Collector<? super T,​A16,​D16> collector16)
        Construct a tuple collector of degree 16.
      • range

        static <T extends java.lang.Comparable<T>> Range<T> range​(T lowerInclusive,
                                                                  T upperInclusive)
        Create a new range with inclusive bounds.
      • array

        @Deprecated
        java.lang.Object[] array()
        Deprecated.
        - Use toArray() instead.
        Get an array representation of this tuple.
      • toArray

        java.lang.Object[] toArray()
        Get an array representation of this tuple.
      • list

        @Deprecated
        java.util.List<?> list()
        Deprecated.
        - Use toList() instead.
        Get a list representation of this tuple.
      • toList

        java.util.List<?> toList()
        Get a list representation of this tuple.
      • toSeq

        Seq<?> toSeq()
        Get a Seq representation of this tuple.
      • toMap

        java.util.Map<java.lang.String,​?> toMap()
        Get a map representation of this tuple.
      • toMap

        <K> java.util.Map<K,​?> toMap​(java.util.function.Function<? super java.lang.Integer,​? extends K> keyMapper)
        Get a map representation of this tuple.
      • degree

        int degree()
        The degree of this tuple.