Seq (jOOL 0.9.9 API)

All Superinterfaces:

AutoCloseable, java.util.stream.BaseStream<T,java.util.stream.Stream<T>>, Collectable<T>, Iterable<T>, java.util.stream.Stream<T>
```
public interface Seq<T>
extends java.util.stream.Stream<T>, Iterable<T>, Collectable<T>
```
A sequential, ordered Stream that adds all sorts of useful methods that work only because it is sequential and ordered.

Author:

Lukas Eder, Roman Tkalenko

Nested Class Summary
- Nested classes/interfaces inherited from interface java.util.stream.Stream
  java.util.stream.Stream.Builder<T>

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`default Seq<T>`	`append(Iterable<T> other)` Concatenate two streams.
`default Seq<T>`	`append(Seq<T> other)` Concatenate two streams.
`default Seq<T>`	`append(java.util.stream.Stream<T> other)` Concatenate two streams.
`default Seq<T>`	`append(T... other)` Concatenate two streams.
`default Seq<T>`	`append(T other)` Concatenate two streams.
`default <U> Seq<U>`	`cast(Class<U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`static <T,U> Seq<U>`	`cast(java.util.stream.Stream<T> stream, Class<U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`void`	`close()`
`static <T> Seq<T>`	`concat(Iterable<T>... iterables)` Concatenate a number of streams.
`default Seq<T>`	`concat(Iterable<T> other)` Concatenate two streams.
`static <T> Seq<T>`	`concat(Seq<T>... streams)` Concatenate a number of streams.
`default Seq<T>`	`concat(Seq<T> other)` Concatenate two streams.
`static <T> Seq<T>`	`concat(java.util.stream.Stream<T>... streams)` Concatenate a number of streams.
`default Seq<T>`	`concat(java.util.stream.Stream<T> other)` Concatenate two streams.
`default Seq<T>`	`concat(T... other)` Concatenate two streams.
`default Seq<T>`	`concat(T other)` Concatenate two streams.
`default boolean`	`contains(T other)` Check whether this stream contains a given value.
`default boolean`	`containsAll(Iterable<T> other)` Check whether this stream contains all given values.
`default boolean`	`containsAll(Seq<T> other)` Check whether this stream contains all given values.
`default boolean`	`containsAll(java.util.stream.Stream<T> other)` Check whether this stream contains all given values.
`default boolean`	`containsAll(T... other)` Check whether this stream contains all given values.
`default boolean`	`containsAny(Iterable<T> other)` Check whether this stream contains any of the given values.
`default boolean`	`containsAny(Seq<T> other)` Check whether this stream contains any of the given values.
`default boolean`	`containsAny(java.util.stream.Stream<T> other)` Check whether this stream contains any of the given values.
`default boolean`	`containsAny(T... other)` Check whether this stream contains any of the given values.
`long`	`count()` Count the values in this collectable.
`static <T1,T2> Seq<Tuple2<T1,T2>>`	`crossJoin(Iterable<T1> i1, Iterable<T2> i2)` Cross join 2 streams into one.
`static <T1,T2,T3> Seq<Tuple3<T1,T2,T3>>`	`crossJoin(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3)` Cross join 3 streams into one.
`static <T1,T2,T3,T4> Seq<Tuple4<T1,T2,T3,T4>>`	`crossJoin(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4)` Cross join 4 streams into one.
`static <T1,T2,T3,T4,T5> Seq<Tuple5<T1,T2,T3,T4,T5>>`	`crossJoin(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5)` Cross join 5 streams into one.
`static <T1,T2,T3,T4,T5,T6> Seq<Tuple6<T1,T2,T3,T4,T5,T6>>`	`crossJoin(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6)` Cross join 6 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7> Seq<Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	`crossJoin(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7)` Cross join 7 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Seq<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	`crossJoin(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8)` Cross join 8 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Seq<Tuple9<T1,T2,T3,T4,T5,T6,T7,T8,T9>>`	`crossJoin(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9)` Cross join 9 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Seq<Tuple10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>>`	`crossJoin(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9, Iterable<T10> i10)` Cross join 10 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Seq<Tuple11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>>`	`crossJoin(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9, Iterable<T10> i10, Iterable<T11> i11)` Cross join 11 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Seq<Tuple12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>>`	`crossJoin(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9, Iterable<T10> i10, Iterable<T11> i11, Iterable<T12> i12)` Cross join 12 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Seq<Tuple13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>>`	`crossJoin(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9, Iterable<T10> i10, Iterable<T11> i11, Iterable<T12> i12, Iterable<T13> i13)` Cross join 13 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Seq<Tuple14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>>`	`crossJoin(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9, Iterable<T10> i10, Iterable<T11> i11, Iterable<T12> i12, Iterable<T13> i13, Iterable<T14> i14)` Cross join 14 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Seq<Tuple15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>>`	`crossJoin(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9, Iterable<T10> i10, Iterable<T11> i11, Iterable<T12> i12, Iterable<T13> i13, Iterable<T14> i14, Iterable<T15> i15)` Cross join 15 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Seq<Tuple16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>>`	`crossJoin(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9, Iterable<T10> i10, Iterable<T11> i11, Iterable<T12> i12, Iterable<T13> i13, Iterable<T14> i14, Iterable<T15> i15, Iterable<T16> i16)` Cross join 16 streams into one.
`default <U> Seq<Tuple2<T,U>>`	`crossJoin(Iterable<U> other)` Cross join 2 streams into one.
`static <T1,T2> Seq<Tuple2<T1,T2>>`	`crossJoin(Seq<T1> s1, Seq<T2> s2)` Cross join 2 streams into one.
`static <T1,T2,T3> Seq<Tuple3<T1,T2,T3>>`	`crossJoin(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3)` Cross join 3 streams into one.
`static <T1,T2,T3,T4> Seq<Tuple4<T1,T2,T3,T4>>`	`crossJoin(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4)` Cross join 4 streams into one.
`static <T1,T2,T3,T4,T5> Seq<Tuple5<T1,T2,T3,T4,T5>>`	`crossJoin(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5)` Cross join 5 streams into one.
`static <T1,T2,T3,T4,T5,T6> Seq<Tuple6<T1,T2,T3,T4,T5,T6>>`	`crossJoin(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6)` Cross join 6 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7> Seq<Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	`crossJoin(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7)` Cross join 7 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Seq<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	`crossJoin(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8)` Cross join 8 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Seq<Tuple9<T1,T2,T3,T4,T5,T6,T7,T8,T9>>`	`crossJoin(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9)` Cross join 9 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Seq<Tuple10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>>`	`crossJoin(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9, Seq<T10> s10)` Cross join 10 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Seq<Tuple11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>>`	`crossJoin(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9, Seq<T10> s10, Seq<T11> s11)` Cross join 11 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Seq<Tuple12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>>`	`crossJoin(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9, Seq<T10> s10, Seq<T11> s11, Seq<T12> s12)` Cross join 12 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Seq<Tuple13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>>`	`crossJoin(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9, Seq<T10> s10, Seq<T11> s11, Seq<T12> s12, Seq<T13> s13)` Cross join 13 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Seq<Tuple14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>>`	`crossJoin(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9, Seq<T10> s10, Seq<T11> s11, Seq<T12> s12, Seq<T13> s13, Seq<T14> s14)` Cross join 14 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Seq<Tuple15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>>`	`crossJoin(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9, Seq<T10> s10, Seq<T11> s11, Seq<T12> s12, Seq<T13> s13, Seq<T14> s14, Seq<T15> s15)` Cross join 15 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Seq<Tuple16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>>`	`crossJoin(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9, Seq<T10> s10, Seq<T11> s11, Seq<T12> s12, Seq<T13> s13, Seq<T14> s14, Seq<T15> s15, Seq<T16> s16)` Cross join 16 streams into one.
`default <U> Seq<Tuple2<T,U>>`	`crossJoin(Seq<U> other)` Cross join 2 streams into one.
`static <T1,T2> Seq<Tuple2<T1,T2>>`	`crossJoin(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2)` Cross join 2 streams into one.
`static <T1,T2,T3> Seq<Tuple3<T1,T2,T3>>`	`crossJoin(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3)` Cross join 3 streams into one.
`static <T1,T2,T3,T4> Seq<Tuple4<T1,T2,T3,T4>>`	`crossJoin(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4)` Cross join 4 streams into one.
`static <T1,T2,T3,T4,T5> Seq<Tuple5<T1,T2,T3,T4,T5>>`	`crossJoin(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5)` Cross join 5 streams into one.
`static <T1,T2,T3,T4,T5,T6> Seq<Tuple6<T1,T2,T3,T4,T5,T6>>`	`crossJoin(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6)` Cross join 6 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7> Seq<Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	`crossJoin(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7)` Cross join 7 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Seq<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	`crossJoin(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8)` Cross join 8 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Seq<Tuple9<T1,T2,T3,T4,T5,T6,T7,T8,T9>>`	`crossJoin(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9)` Cross join 9 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Seq<Tuple10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>>`	`crossJoin(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9, java.util.stream.Stream<T10> s10)` Cross join 10 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Seq<Tuple11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>>`	`crossJoin(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9, java.util.stream.Stream<T10> s10, java.util.stream.Stream<T11> s11)` Cross join 11 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Seq<Tuple12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>>`	`crossJoin(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9, java.util.stream.Stream<T10> s10, java.util.stream.Stream<T11> s11, java.util.stream.Stream<T12> s12)` Cross join 12 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Seq<Tuple13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>>`	`crossJoin(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9, java.util.stream.Stream<T10> s10, java.util.stream.Stream<T11> s11, java.util.stream.Stream<T12> s12, java.util.stream.Stream<T13> s13)` Cross join 13 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Seq<Tuple14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>>`	`crossJoin(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9, java.util.stream.Stream<T10> s10, java.util.stream.Stream<T11> s11, java.util.stream.Stream<T12> s12, java.util.stream.Stream<T13> s13, java.util.stream.Stream<T14> s14)` Cross join 14 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Seq<Tuple15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>>`	crossJoin(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9, java.util.stream.Stream<T10> s10, java.util.stream.Stream<T11> s11, java.util.stream.Stream<T12> s12, java.util.stream.Stream<T13> s13, java.util.stream.Stream<T14> s14, java.util.stream.Stream<T15> s15) Cross join 15 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Seq<Tuple16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>>`	crossJoin(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9, java.util.stream.Stream<T10> s10, java.util.stream.Stream<T11> s11, java.util.stream.Stream<T12> s12, java.util.stream.Stream<T13> s13, java.util.stream.Stream<T14> s14, java.util.stream.Stream<T15> s15, java.util.stream.Stream<T16> s16) Cross join 16 streams into one.
`default <U> Seq<Tuple2<T,U>>`	`crossJoin(java.util.stream.Stream<U> other)` Cross join 2 streams into one.
`default Seq<T>`	`cycle()` Repeat a stream infinitely.
`static <T> Seq<T>`	`cycle(Iterable<T> iterable)` Repeat a stream infinitely.
`static <T> Seq<T>`	`cycle(Seq<T> stream)` Repeat a stream infinitely.
`static <T> Seq<T>`	`cycle(java.util.stream.Stream<T> stream)` Repeat a stream infinitely.
`Seq<T>`	`distinct()`
`default <U> Seq<T>`	`distinct(java.util.function.Function<? super T,? extends U> keyExtractor)` Get a stream of distinct keys.
`default Tuple2<Seq<T>,Seq<T>>`	`duplicate()` Duplicate a Streams into two equivalent Streams.
`static <T> Tuple2<Seq<T>,Seq<T>>`	`duplicate(java.util.stream.Stream<T> stream)` Duplicate a Streams into two equivalent Streams.
`static <T> Seq<T>`	`empty()`
`Seq<T>`	`filter(java.util.function.Predicate<? super T> predicate)`
`<R> Seq<R>`	`flatMap(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> mapper)`
`java.util.stream.DoubleStream`	`flatMapToDouble(java.util.function.Function<? super T,? extends java.util.stream.DoubleStream> mapper)`
`java.util.stream.IntStream`	`flatMapToInt(java.util.function.Function<? super T,? extends java.util.stream.IntStream> mapper)`
`java.util.stream.LongStream`	`flatMapToLong(java.util.function.Function<? super T,? extends java.util.stream.LongStream> mapper)`
`static <T,U> U`	`foldLeft(Iterable<T> iterable, U seed, java.util.function.BiFunction<U,? super T,U> function)` Fold a stream to the left.
`static <T,U> U`	`foldLeft(Seq<T> stream, U seed, java.util.function.BiFunction<U,? super T,U> function)` Fold a stream to the left.
`static <T,U> U`	`foldLeft(java.util.stream.Stream<T> stream, U seed, java.util.function.BiFunction<U,? super T,U> function)` Fold a stream to the left.
`default <U> U`	`foldLeft(U seed, java.util.function.BiFunction<U,? super T,U> function)` Fold a Stream to the left.
`static <T,U> U`	`foldRight(Iterable<T> iterable, U seed, java.util.function.BiFunction<? super T,U,U> function)` Fold a stream to the right.
`static <T,U> U`	`foldRight(Seq<T> stream, U seed, java.util.function.BiFunction<? super T,U,U> function)` Fold a stream to the right.
`static <T,U> U`	`foldRight(java.util.stream.Stream<T> stream, U seed, java.util.function.BiFunction<? super T,U,U> function)` Fold a stream to the right.
`default <U> U`	`foldRight(U seed, java.util.function.BiFunction<? super T,U,U> function)` Fold a Stream to the right.
`default void`	`forEach(java.util.function.Consumer<? super T> action)`
`String`	`format()` Generate a nicely formatted representation of this stream.
`static Seq<Void>`	`generate()`
`static <T> Seq<T>`	`generate(java.util.function.Supplier<T> s)`
`static <T> Seq<T>`	`generate(T value)`
`default Optional<T>`	`get(long index)` Get a single element from the stream at a given index
`default <K> Map<K,List<T>>`	`groupBy(java.util.function.Function<? super T,? extends K> classifier)` Shortcut for calling `Stream.collect(Collector)` with a `Collectors.groupingBy(Function)` collector.
`default <K,A,D> Map<K,D>`	`groupBy(java.util.function.Function<? super T,? extends K> classifier, java.util.stream.Collector<? super T,A,D> downstream)` Shortcut for calling `Stream.collect(Collector)` with a `Collectors.groupingBy(Function, Collector)` collector.
`default <K,D,A,M extends Map<K,D>> M`	`groupBy(java.util.function.Function<? super T,? extends K> classifier, java.util.function.Supplier<M> mapFactory, java.util.stream.Collector<? super T,A,D> downstream)` Shortcut for calling `Stream.collect(Collector)` with a `Collectors.groupingBy(Function, Supplier, Collector)` collector.
`static <T,K> Map<K,List<T>>`	`groupBy(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,? extends K> classifier)` Shortcut for calling `Stream.collect(Collector)` with a `Collectors.groupingBy(Function)` collector.
`static <T,K,A,D> Map<K,D>`	`groupBy(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,? extends K> classifier, java.util.stream.Collector<? super T,A,D> downstream)` Shortcut for calling `Stream.collect(Collector)` with a `Collectors.groupingBy(Function, Collector)` collector.
`static <T,K,D,A,M extends Map<K,D>> M`	`groupBy(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,? extends K> classifier, java.util.function.Supplier<M> mapFactory, java.util.stream.Collector<? super T,A,D> downstream)` Shortcut for calling `Stream.collect(Collector)` with a `Collectors.groupingBy(Function, Supplier, Collector)` collector.
`default <K> Seq<Tuple2<K,Seq<T>>>`	`grouped(java.util.function.Function<? super T,? extends K> classifier)` Classify this stream's elements according to a given classifier function.
`default <K,A,D> Seq<Tuple2<K,D>>`	`grouped(java.util.function.Function<? super T,? extends K> classifier, java.util.stream.Collector<? super T,A,D> downstream)` Classify this stream's elements according to a given classifier function and collect each class's elements using a collector.
`static <K,T> Seq<Tuple2<K,Seq<T>>>`	`grouped(Iterable<T> iterable, java.util.function.Function<? super T,? extends K> classifier)` Classify this stream's elements according to a given classifier function `// Seq(tuple(1, Seq(1, 3, 5)), tuple(0, Seq(2, 4, 6))) Seq.of(1, 2, 3, 4, 5, 6).grouped(i -> i % 2 ) // Seq(tuple(true, Seq(1, 3, 5)), tuple(false, Seq(2, 4, 6))) Seq.of(1, 2, 3, 4, 5, 6).grouped(i -> i % 2 !`
`static <K,T,A,D> Seq<Tuple2<K,D>>`	`grouped(Iterable<T> iterable, java.util.function.Function<? super T,? extends K> classifier, java.util.stream.Collector<? super T,A,D> downstream)` Classify this stream's elements according to a given classifier function and collect each class's elements using a collector.
`static <K,T> Seq<Tuple2<K,Seq<T>>>`	`grouped(Seq<T> seq, java.util.function.Function<? super T,? extends K> classifier)` Classify this stream's elements according to a given classifier function `// Seq(tuple(1, Seq(1, 3, 5)), tuple(0, Seq(2, 4, 6))) Seq.of(1, 2, 3, 4, 5, 6).grouped(i -> i % 2 ) // Seq(tuple(true, Seq(1, 3, 5)), tuple(false, Seq(2, 4, 6))) Seq.of(1, 2, 3, 4, 5, 6).grouped(i -> i % 2 !`
`static <K,T,A,D> Seq<Tuple2<K,D>>`	`grouped(Seq<T> seq, java.util.function.Function<? super T,? extends K> classifier, java.util.stream.Collector<? super T,A,D> downstream)` Classify this stream's elements according to a given classifier function and collect each class's elements using a collector.
`static <K,T> Seq<Tuple2<K,Seq<T>>>`	`grouped(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,? extends K> classifier)` Classify this stream's elements according to a given classifier function `// Seq(tuple(1, Seq(1, 3, 5)), tuple(0, Seq(2, 4, 6))) Seq.of(1, 2, 3, 4, 5, 6).grouped(i -> i % 2 ) // Seq(tuple(true, Seq(1, 3, 5)), tuple(false, Seq(2, 4, 6))) Seq.of(1, 2, 3, 4, 5, 6).grouped(i -> i % 2 !`
`static <K,T,A,D> Seq<Tuple2<K,D>>`	`grouped(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,? extends K> classifier, java.util.stream.Collector<? super T,A,D> downstream)` Classify this stream's elements according to a given classifier function and collect each class's elements using a collector.
`default <U> Seq<Tuple2<T,U>>`	`innerJoin(Iterable<U> other, java.util.function.BiPredicate<? super T,? super U> predicate)` Inner join 2 streams into one.
`default <U> Seq<Tuple2<T,U>>`	`innerJoin(Seq<U> other, java.util.function.BiPredicate<? super T,? super U> predicate)` Inner join 2 streams into one.
`default <U> Seq<Tuple2<T,U>>`	`innerJoin(java.util.stream.Stream<U> other, java.util.function.BiPredicate<? super T,? super U> predicate)` Inner join 2 streams into one.
`static <T> Seq<T>`	`intersperse(java.util.stream.Stream<T> stream, T value)` Returns a stream with a given value interspersed between any two values of this stream.
`default Seq<T>`	`intersperse(T value)` Returns a stream with a given value interspersed between any two values of this stream.
`default boolean`	`isEmpty()` Check if the sequence has any elements
`default boolean`	`isNotEmpty()` Check if the sequence has no elements
`static <T> Seq<T>`	`iterate(T seed, java.util.function.UnaryOperator<T> f)`
`default String`	`join()` Deprecated. - Use `#toString()` instead. This method will be removed in the future as it causes confusion with `innerJoin(Seq, BiPredicate)`.
`default String`	`join(CharSequence delimiter)` Deprecated. - Use `Collectable.toString(CharSequence)` instead. This method will be removed in the future as it causes confusion with `innerJoin(Seq, BiPredicate)`.
`default String`	`join(CharSequence delimiter, CharSequence prefix, CharSequence suffix)` Deprecated. - Use `Collectable.toString(CharSequence, CharSequence, CharSequence)` instead. This method will be removed in the future as it causes confusion with `innerJoin(Seq, BiPredicate)`.
`static String`	`join(java.util.stream.Stream<?> stream)` Deprecated. - Use `#toString()` instead. This method will be removed in the future as it causes confusion with `innerJoin(Seq, BiPredicate)`.
`static String`	`join(java.util.stream.Stream<?> stream, CharSequence delimiter)` Deprecated. - Use `#toString()` instead. This method will be removed in the future as it causes confusion with `innerJoin(Seq, BiPredicate)`.
`static String`	`join(java.util.stream.Stream<?> stream, CharSequence delimiter, CharSequence prefix, CharSequence suffix)` Deprecated. - Use `#toString()` instead. This method will be removed in the future as it causes confusion with `innerJoin(Seq, BiPredicate)`.
`default <U> Seq<Tuple2<T,U>>`	`leftOuterJoin(Iterable<U> other, java.util.function.BiPredicate<? super T,? super U> predicate)` Left outer join 2 streams into one.
`default <U> Seq<Tuple2<T,U>>`	`leftOuterJoin(Seq<U> other, java.util.function.BiPredicate<? super T,? super U> predicate)` Left outer join 2 streams into one.
`default <U> Seq<Tuple2<T,U>>`	`leftOuterJoin(java.util.stream.Stream<U> other, java.util.function.BiPredicate<? super T,? super U> predicate)` Left outer join 2 streams into one.
`Seq<T>`	`limit(long maxSize)`
`static <T> Seq<T>`	`limit(java.util.stream.Stream<T> stream, long elements)` Returns a stream limited to n elements.
`default Seq<T>`	`limitUntil(java.util.function.Predicate<? super T> predicate)` Returns a stream limited to all elements for which a predicate evaluates to `false`.
`static <T> Seq<T>`	`limitUntil(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate)` Returns a stream limited to all elements for which a predicate evaluates to `false`.
`default Seq<T>`	`limitUntilClosed(java.util.function.Predicate<? super T> predicate)` Returns a stream limited to all elements for which a predicate evaluates to `false` plus the first element for which it evaluates to `true`.
`static <T> Seq<T>`	`limitUntilClosed(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate)` Returns a stream limited to all elements for which a predicate evaluates to `false` plus the first element for which it evaluates to `true`.
`default Seq<T>`	`limitWhile(java.util.function.Predicate<? super T> predicate)` Returns a stream limited to all elements for which a predicate evaluates to `true`.
`static <T> Seq<T>`	`limitWhile(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate)` Returns a stream limited to all elements for which a predicate evaluates to `true`.
`default Seq<T>`	`limitWhileClosed(java.util.function.Predicate<? super T> predicate)` Returns a stream limited to all elements for which a predicate evaluates to `true` plus the first element for which it evaluates to `false`.
`static <T> Seq<T>`	`limitWhileClosed(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate)` Returns a stream limited to all elements for which a predicate evaluates to `true` plus the first element for which it evaluates to `false`.
`<R> Seq<R>`	`map(java.util.function.Function<? super T,? extends R> mapper)`
`java.util.stream.DoubleStream`	`mapToDouble(java.util.function.ToDoubleFunction<? super T> mapper)`
`java.util.stream.IntStream`	`mapToInt(java.util.function.ToIntFunction<? super T> mapper)`
`java.util.stream.LongStream`	`mapToLong(java.util.function.ToLongFunction<? super T> mapper)`
`static <T> Seq<T>`	`of(T... values)`
`static <T> Seq<T>`	`of(T value)`
`default <U> Seq<U>`	`ofType(Class<U> type)` Keep only those elements in a stream that are of a given type.
`static <T,U> Seq<U>`	`ofType(java.util.stream.Stream<T> stream, Class<U> type)` Keep only those elements in a stream that are of a given type.
`Seq<T>`	`onClose(Runnable closeHandler)`
`default Seq<T>`	`onEmpty(T value)` Produce this stream, or an alternative stream from the `value`, in case this stream is empty.
`default Seq<T>`	`onEmptyGet(java.util.function.Supplier<T> supplier)` Produce this stream, or an alternative stream from the `supplier`, in case this stream is empty.
`default <X extends Throwable> Seq<T>`	`onEmptyThrow(java.util.function.Supplier<X> supplier)` Produce this stream, or an alternative stream from the `supplier`, in case this stream is empty.
`default Seq<T>`	`parallel()` Seq streams are always sequential and, as such, doesn't support parallelization.
`default Tuple2<Seq<T>,Seq<T>>`	`partition(java.util.function.Predicate<? super T> predicate)` Partition a stream into two given a predicate.
`static <T> Tuple2<Seq<T>,Seq<T>>`	`partition(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate)` Partition a stream into two given a predicate.
`Seq<T>`	`peek(java.util.function.Consumer<? super T> action)`
`default Seq<T>`	`prepend(Iterable<T> other)` Concatenate two streams.
`default Seq<T>`	`prepend(Seq<T> other)` Concatenate two streams.
`default Seq<T>`	`prepend(java.util.stream.Stream<T> other)` Concatenate two streams.
`default Seq<T>`	`prepend(T... other)` Concatenate two streams.
`default Seq<T>`	`prepend(T other)` Concatenate two streams.
`default void`	`print(PrintStream stream)` Print contents of this stream to the argument stream.
`default void`	`print(PrintWriter writer)` Print contents of this stream to the argument writer.
`default void`	`printErr()` Print contents of this stream to `System.err`.
`default void`	`printOut()` Print contents of this stream to `System.out`.
`static Seq<Byte>`	`range(byte from, byte to)` The range between two values.
`static Seq<Byte>`	`range(byte from, byte to, int step)` The range between two values.
`static Seq<Character>`	`range(char from, char to)` The range between two values.
`static Seq<Character>`	`range(char from, char to, int step)` The range between two values.
`static Seq<java.time.Instant>`	`range(java.time.Instant from, java.time.Instant to)` The range between two values.
`static Seq<java.time.Instant>`	`range(java.time.Instant from, java.time.Instant to, java.time.Duration step)` The range between two values.
`static Seq<Integer>`	`range(int from, int to)` The range between two values.
`static Seq<Integer>`	`range(int from, int to, int step)` The range between two values.
`static Seq<Long>`	`range(long from, long to)` The range between two values.
`static Seq<Long>`	`range(long from, long to, long step)` The range between two values.
`static Seq<Short>`	`range(short from, short to)` The range between two values.
`static Seq<Short>`	`range(short from, short to, int step)` The range between two values.
`static Seq<Byte>`	`rangeClosed(byte from, byte to)` The range between two values.
`static Seq<Byte>`	`rangeClosed(byte from, byte to, int step)` The range between two values.
`static Seq<Character>`	`rangeClosed(char from, char to)` The range between two values.
`static Seq<Character>`	`rangeClosed(char from, char to, int step)` The range between two values.
`static Seq<java.time.Instant>`	`rangeClosed(java.time.Instant from, java.time.Instant to)` The range between two values.
`static Seq<java.time.Instant>`	`rangeClosed(java.time.Instant from, java.time.Instant to, java.time.Duration step)` The range between two values.
`static Seq<Integer>`	`rangeClosed(int from, int to)` The range between two values.
`static Seq<Integer>`	`rangeClosed(int from, int to, int step)` The range between two values.
`static Seq<Long>`	`rangeClosed(long from, long to)` The range between two values.
`static Seq<Long>`	`rangeClosed(long from, long to, long step)` The range between two values.
`static Seq<Short>`	`rangeClosed(short from, short to)` The range between two values.
`static Seq<Short>`	`rangeClosed(short from, short to, int step)` The range between two values.
`default Seq<T>`	`remove(T other)` Return a new stream where the first occurrence of the argument is removed.
`default Seq<T>`	`removeAll(Iterable<T> other)` Return a new stream where all occurrences of the arguments are removed.
`default Seq<T>`	`removeAll(Seq<T> other)` Return a new stream where all occurrences of the arguments are removed.
`default Seq<T>`	`removeAll(java.util.stream.Stream<T> other)` Return a new stream where all occurrences of the arguments are removed.
`default Seq<T>`	`removeAll(T... other)` Return a new stream where all occurrences of the arguments are removed.
`default Seq<T>`	`retainAll(Iterable<T> other)` Return a new stream where only occurrences of the arguments are retained.
`default Seq<T>`	`retainAll(Seq<T> other)` Return a new stream where only occurrences of the arguments are retained.
`default Seq<T>`	`retainAll(java.util.stream.Stream<T> other)` Return a new stream where only occurrences of the arguments are retained.
`default Seq<T>`	`retainAll(T... other)` Return a new stream where only occurrences of the arguments are retained.
`default Seq<T>`	`reverse()` Reverse a stream.
`static <T> Seq<T>`	`reverse(Iterable<T> iterable)` Reverse a stream.
`static <T> Seq<T>`	`reverse(Seq<T> stream)` Reverse a stream.
`static <T> Seq<T>`	`reverse(java.util.stream.Stream<T> stream)` Reverse a stream.
`default <U> Seq<Tuple2<T,U>>`	`rightOuterJoin(Iterable<U> other, java.util.function.BiPredicate<? super T,? super U> predicate)` Right outer join 2 streams into one.
`default <U> Seq<Tuple2<T,U>>`	`rightOuterJoin(Seq<U> other, java.util.function.BiPredicate<? super T,? super U> predicate)` Right outer join 2 streams into one.
`default <U> Seq<Tuple2<T,U>>`	`rightOuterJoin(java.util.stream.Stream<U> other, java.util.function.BiPredicate<? super T,? super U> predicate)` Right outer join 2 streams into one.
`static <T,U> Seq<U>`	`scanLeft(Iterable<T> iterable, U seed, java.util.function.BiFunction<U,? super T,U> function)` Scan a stream to the left.
`static <T,U> Seq<U>`	`scanLeft(Seq<T> stream, U seed, java.util.function.BiFunction<U,? super T,U> function)` Scan a stream to the left.
`static <T,U> Seq<U>`	`scanLeft(java.util.stream.Stream<T> stream, U seed, java.util.function.BiFunction<U,? super T,U> function)` Scan a stream to the left.
`default <U> Seq<U>`	`scanLeft(U seed, java.util.function.BiFunction<U,? super T,U> function)` Scan a stream to the left.
`static <T,U> Seq<U>`	`scanRight(Iterable<T> iterable, U seed, java.util.function.BiFunction<? super T,U,U> function)` Scan a stream to the right.
`static <T,U> Seq<U>`	`scanRight(Seq<T> stream, U seed, java.util.function.BiFunction<? super T,U,U> function)` Scan a stream to the right.
`static <T,U> Seq<U>`	`scanRight(java.util.stream.Stream<T> stream, U seed, java.util.function.BiFunction<? super T,U,U> function)` Scan a stream to the right.
`default <U> Seq<U>`	`scanRight(U seed, java.util.function.BiFunction<? super T,U,U> function)` Scan a stream to the right.
`static Seq<Double>`	`seq(java.util.stream.DoubleStream stream)` Wrap a `IntStream` into a `Seq`.
`static Seq<Byte>`	`seq(InputStream is)` Wrap an `InputStream` into a `Seq`.
`static Seq<Integer>`	`seq(java.util.stream.IntStream stream)` Wrap a `IntStream` into a `Seq`.
`static <T> Seq<T>`	`seq(Iterable<T> iterable)` Wrap an `Iterable` into a `Seq`.
`static <T> Seq<T>`	`seq(Iterator<T> iterator)` Wrap an `Iterator` into a `Seq`.
`static Seq<Long>`	`seq(java.util.stream.LongStream stream)` Wrap a `IntStream` into a `Seq`.
`static <K,V> Seq<Tuple2<K,V>>`	`seq(Map<K,V> map)` Wrap a `Map` into a `Seq`.
`static <T> Seq<T>`	`seq(Optional<T> optional)` Wrap an `Optional` into a `Seq`.
`static Seq<Character>`	`seq(Reader reader)` Wrap a `Reader` into a `Seq`.
`static <T> Seq<T>`	`seq(Seq<T> stream)` Wrap a `Stream` into a `Seq`.
`static <T> Seq<T>`	`seq(Spliterator<T> spliterator)` Wrap a `Spliterator` into a `Seq`.
`static <T> Seq<T>`	`seq(java.util.stream.Stream<T> stream)` Wrap a `Stream` into a `Seq`.
`default Seq<T>`	`sequential()` Returns this stream.
`default Seq<T>`	`shuffle()` Shuffle a stream `// e.g. (2, 3, 1) Seq.of(1, 2, 3).shuffle()`
`static <T> Seq<T>`	`shuffle(Iterable<T> iterable)` Shuffle a stream `// e.g. (2, 3, 1) Seq.of(1, 2, 3).shuffle()`
`static <T> Seq<T>`	`shuffle(Iterable<T> iterable, Random random)` Shuffle a stream using specified source of randomness `// e.g. (2, 3, 1) Seq.of(1, 2, 3).shuffle(new Random())`
`default Seq<T>`	`shuffle(Random random)` Shuffle a stream using specified source of randomness `// e.g. (2, 3, 1) Seq.of(1, 2, 3).shuffle(new Random())`
`static <T> Seq<T>`	`shuffle(Seq<T> stream)` Shuffle a stream `// e.g. (2, 3, 1) Seq.of(1, 2, 3).shuffle()`
`static <T> Seq<T>`	`shuffle(Seq<T> stream, Random random)` Shuffle a stream using specified source of randomness `// e.g. (2, 3, 1) Seq.of(1, 2, 3).shuffle(new Random())`
`static <T> Seq<T>`	`shuffle(java.util.stream.Stream<T> stream)` Shuffle a stream `// e.g. (2, 3, 1) Seq.of(1, 2, 3).shuffle()`
`static <T> Seq<T>`	`shuffle(java.util.stream.Stream<T> stream, Random random)` Shuffle a stream using specified source of randomness `// e.g. (2, 3, 1) Seq.of(1, 2, 3).shuffle(new Random())`
`Seq<T>`	`skip(long n)`
`static <T> Seq<T>`	`skip(java.util.stream.Stream<T> stream, long elements)` Returns a stream with n elements skipped.
`default Seq<T>`	`skipUntil(java.util.function.Predicate<? super T> predicate)` Returns a stream with all elements skipped for which a predicate evaluates to `false`.
`static <T> Seq<T>`	`skipUntil(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate)` Returns a stream with all elements skipped for which a predicate evaluates to `false`.
`default Seq<T>`	`skipUntilClosed(java.util.function.Predicate<? super T> predicate)` Returns a stream with all elements skipped for which a predicate evaluates to `false` plus the first element for which it evaluates to `true`.
`static <T> Seq<T>`	`skipUntilClosed(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate)` Returns a stream with all elements skipped for which a predicate evaluates to `false` plus the first element for which it evaluates to `true`.
`default Seq<T>`	`skipWhile(java.util.function.Predicate<? super T> predicate)` Returns a stream with all elements skipped for which a predicate evaluates to `true`.
`static <T> Seq<T>`	`skipWhile(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate)` Returns a stream with all elements skipped for which a predicate evaluates to `true`.
`default Seq<T>`	`skipWhileClosed(java.util.function.Predicate<? super T> predicate)` Returns a stream with all elements skipped for which a predicate evaluates to `true` plus the first element for which it evaluates to false.
`static <T> Seq<T>`	`skipWhileClosed(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate)` Returns a stream with all elements skipped for which a predicate evaluates to `true` plus the first element for which it evaluates to `false`.
`default Seq<T>`	`slice(long from, long to)` Returns a limited interval from a given Stream.
`static <T> Seq<T>`	`slice(java.util.stream.Stream<T> stream, long from, long to)` Returns a limited interval from a given Stream.
`Seq<T>`	`sorted()`
`Seq<T>`	`sorted(Comparator<? super T> comparator)`
`default <U extends Comparable<? super U>> Seq<T>`	`sorted(java.util.function.Function<? super T,? extends U> function)` Sort by the results of function.
`default <U> Seq<T>`	`sorted(java.util.function.Function<? super T,? extends U> function, Comparator<? super U> comparator)` Sort by the results of function.
`default Tuple2<Seq<T>,Seq<T>>`	`splitAt(long position)` Split a stream at a given position.
`static <T> Tuple2<Seq<T>,Seq<T>>`	`splitAt(java.util.stream.Stream<T> stream, long position)` Split a stream at a given position.
`default Tuple2<Optional<T>,Seq<T>>`	`splitAtHead()` Split a stream at the head.
`static <T> Tuple2<Optional<T>,Seq<T>>`	`splitAtHead(java.util.stream.Stream<T> stream)` Split a stream at the head.
`default Spliterator<T>`	`spliterator()`
`java.util.stream.Stream<T>`	`stream()` The underlying `Stream` implementation.
`static <T,C extends Collection<T>> C`	`toCollection(java.util.stream.Stream<T> stream, java.util.function.Supplier<C> collectionFactory)` Collect a Stream into a List.
`static <T> List<T>`	`toList(java.util.stream.Stream<T> stream)` Collect a Stream into a List.
`static <T,K,V> Map<K,V>`	`toMap(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,? extends K> keyMapper, java.util.function.Function<? super T,? extends V> valueMapper)` Collect a Stream into a Map.
`static <T,K,V> Map<K,V>`	`toMap(java.util.stream.Stream<Tuple2<K,V>> stream)` Collect a Stream of `Tuple2` into a Map.
`static <T> Set<T>`	`toSet(java.util.stream.Stream<T> stream)` Collect a Stream into a Set.
`static String`	`toString(java.util.stream.Stream<?> stream)` Consume a stream and concatenate all elements.
`static String`	`toString(java.util.stream.Stream<?> stream, CharSequence delimiter)` Consume a stream and concatenate all elements using a separator.
`static <T,U> Seq<T>`	`unfold(U seed, java.util.function.Function<U,Optional<Tuple2<T,U>>> unfolder)` Unfold a function into a stream.
`default Seq<T>`	`unordered()` Returns this stream.
`static <T1,T2> Tuple2<Seq<T1>,Seq<T2>>`	`unzip(Iterable<Tuple2<T1,T2>> iterable)` Unzip one Stream into two.
`static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>>`	`unzip(Iterable<Tuple2<T1,T2>> iterable, java.util.function.BiFunction<T1,T2,Tuple2<U1,U2>> unzipper)` Unzip one Stream into two.
`static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>>`	`unzip(Iterable<Tuple2<T1,T2>> iterable, java.util.function.Function<T1,U1> leftUnzipper, java.util.function.Function<T2,U2> rightUnzipper)` Unzip one Stream into two.
`static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>>`	`unzip(Iterable<Tuple2<T1,T2>> iterable, java.util.function.Function<Tuple2<T1,T2>,Tuple2<U1,U2>> unzipper)` Unzip one Stream into two.
`static <T1,T2> Tuple2<Seq<T1>,Seq<T2>>`	`unzip(Seq<Tuple2<T1,T2>> stream)` Unzip one Stream into two.
`static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>>`	`unzip(Seq<Tuple2<T1,T2>> stream, java.util.function.BiFunction<T1,T2,Tuple2<U1,U2>> unzipper)` Unzip one Stream into two.
`static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>>`	`unzip(Seq<Tuple2<T1,T2>> stream, java.util.function.Function<T1,U1> leftUnzipper, java.util.function.Function<T2,U2> rightUnzipper)` Unzip one Stream into two.
`static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>>`	`unzip(Seq<Tuple2<T1,T2>> stream, java.util.function.Function<Tuple2<T1,T2>,Tuple2<U1,U2>> unzipper)` Unzip one Stream into two.
`static <T1,T2> Tuple2<Seq<T1>,Seq<T2>>`	`unzip(java.util.stream.Stream<Tuple2<T1,T2>> stream)` Unzip one Stream into two.
`static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>>`	`unzip(java.util.stream.Stream<Tuple2<T1,T2>> stream, java.util.function.BiFunction<T1,T2,Tuple2<U1,U2>> unzipper)` Unzip one Stream into two.
`static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>>`	`unzip(java.util.stream.Stream<Tuple2<T1,T2>> stream, java.util.function.Function<T1,U1> leftUnzipper, java.util.function.Function<T2,U2> rightUnzipper)` Unzip one Stream into two.
`static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>>`	`unzip(java.util.stream.Stream<Tuple2<T1,T2>> stream, java.util.function.Function<Tuple2<T1,T2>,Tuple2<U1,U2>> unzipper)` Unzip one Stream into two.
`default Seq<Window<T>>`	`window()` Map this stream to a windowed stream using the default partition and order.
`default Seq<Window<T>>`	`window(Comparator<? super T> orderBy)` Map this stream to a windowed stream using the default partition and a specific order.
`default Seq<Window<T>>`	`window(Comparator<? super T> orderBy, long lower, long upper)` Map this stream to a windowed stream using the default partition and a specific order with frame.
`default <U> Seq<Window<T>>`	`window(java.util.function.Function<? super T,? extends U> partitionBy)` Map this stream to a windowed stream using a specific partition and the default order.
`default <U> Seq<Window<T>>`	`window(java.util.function.Function<? super T,? extends U> partitionBy, Comparator<? super T> orderBy)` Map this stream to a windowed stream using a specific partition and order.
`default <U> Seq<Window<T>>`	`window(java.util.function.Function<? super T,? extends U> partitionBy, Comparator<? super T> orderBy, long lower, long upper)` Map this stream to a windowed stream using a specific partition and order with frame.
`default <U> Seq<Window<T>>`	`window(java.util.function.Function<? super T,? extends U> partitionBy, long lower, long upper)` Map this stream to a windowed stream using a specific partition and the default order.
`default Seq<Window<T>>`	`window(long lower, long upper)` Map this stream to a windowed stream using the default partition and order with frame.
`default Seq<Tuple1<Window<T>>>`	`window(WindowSpecification<T> specification1)` Map this stream to a windowed stream with 1 distinct windows.
`default Seq<Tuple2<Window<T>,Window<T>>>`	`window(WindowSpecification<T> specification1, WindowSpecification<T> specification2)` Map this stream to a windowed stream with 2 distinct windows.
`default Seq<Tuple3<Window<T>,Window<T>,Window<T>>>`	`window(WindowSpecification<T> specification1, WindowSpecification<T> specification2, WindowSpecification<T> specification3)` Map this stream to a windowed stream with 3 distinct windows.
`default Seq<Tuple4<Window<T>,Window<T>,Window<T>,Window<T>>>`	`window(WindowSpecification<T> specification1, WindowSpecification<T> specification2, WindowSpecification<T> specification3, WindowSpecification<T> specification4)` Map this stream to a windowed stream with 4 distinct windows.
`default Seq<Tuple5<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>>`	`window(WindowSpecification<T> specification1, WindowSpecification<T> specification2, WindowSpecification<T> specification3, WindowSpecification<T> specification4, WindowSpecification<T> specification5)` Map this stream to a windowed stream with 5 distinct windows.
`default Seq<Tuple6<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>>`	`window(WindowSpecification<T> specification1, WindowSpecification<T> specification2, WindowSpecification<T> specification3, WindowSpecification<T> specification4, WindowSpecification<T> specification5, WindowSpecification<T> specification6)` Map this stream to a windowed stream with 6 distinct windows.
`default Seq<Tuple7<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>>`	`window(WindowSpecification<T> specification1, WindowSpecification<T> specification2, WindowSpecification<T> specification3, WindowSpecification<T> specification4, WindowSpecification<T> specification5, WindowSpecification<T> specification6, WindowSpecification<T> specification7)` Map this stream to a windowed stream with 7 distinct windows.
`default Seq<Tuple8<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>>`	`window(WindowSpecification<T> specification1, WindowSpecification<T> specification2, WindowSpecification<T> specification3, WindowSpecification<T> specification4, WindowSpecification<T> specification5, WindowSpecification<T> specification6, WindowSpecification<T> specification7, WindowSpecification<T> specification8)` Map this stream to a windowed stream with 8 distinct windows.
`default Seq<Tuple9<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>>`	`window(WindowSpecification<T> specification1, WindowSpecification<T> specification2, WindowSpecification<T> specification3, WindowSpecification<T> specification4, WindowSpecification<T> specification5, WindowSpecification<T> specification6, WindowSpecification<T> specification7, WindowSpecification<T> specification8, WindowSpecification<T> specification9)` Map this stream to a windowed stream with 9 distinct windows.
`default Seq<Tuple10<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>>`	`window(WindowSpecification<T> specification1, WindowSpecification<T> specification2, WindowSpecification<T> specification3, WindowSpecification<T> specification4, WindowSpecification<T> specification5, WindowSpecification<T> specification6, WindowSpecification<T> specification7, WindowSpecification<T> specification8, WindowSpecification<T> specification9, WindowSpecification<T> specification10)` Map this stream to a windowed stream with 10 distinct windows.
`default Seq<Tuple11<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>>`	`window(WindowSpecification<T> specification1, WindowSpecification<T> specification2, WindowSpecification<T> specification3, WindowSpecification<T> specification4, WindowSpecification<T> specification5, WindowSpecification<T> specification6, WindowSpecification<T> specification7, WindowSpecification<T> specification8, WindowSpecification<T> specification9, WindowSpecification<T> specification10, WindowSpecification<T> specification11)` Map this stream to a windowed stream with 11 distinct windows.
`default Seq<Tuple12<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>>`	`window(WindowSpecification<T> specification1, WindowSpecification<T> specification2, WindowSpecification<T> specification3, WindowSpecification<T> specification4, WindowSpecification<T> specification5, WindowSpecification<T> specification6, WindowSpecification<T> specification7, WindowSpecification<T> specification8, WindowSpecification<T> specification9, WindowSpecification<T> specification10, WindowSpecification<T> specification11, WindowSpecification<T> specification12)` Map this stream to a windowed stream with 12 distinct windows.
`default Seq<Tuple13<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>>`	window(WindowSpecification<T> specification1, WindowSpecification<T> specification2, WindowSpecification<T> specification3, WindowSpecification<T> specification4, WindowSpecification<T> specification5, WindowSpecification<T> specification6, WindowSpecification<T> specification7, WindowSpecification<T> specification8, WindowSpecification<T> specification9, WindowSpecification<T> specification10, WindowSpecification<T> specification11, WindowSpecification<T> specification12, WindowSpecification<T> specification13) Map this stream to a windowed stream with 13 distinct windows.
`default Seq<Tuple14<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>>`	window(WindowSpecification<T> specification1, WindowSpecification<T> specification2, WindowSpecification<T> specification3, WindowSpecification<T> specification4, WindowSpecification<T> specification5, WindowSpecification<T> specification6, WindowSpecification<T> specification7, WindowSpecification<T> specification8, WindowSpecification<T> specification9, WindowSpecification<T> specification10, WindowSpecification<T> specification11, WindowSpecification<T> specification12, WindowSpecification<T> specification13, WindowSpecification<T> specification14) Map this stream to a windowed stream with 14 distinct windows.
`default Seq<Tuple15<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>>`	window(WindowSpecification<T> specification1, WindowSpecification<T> specification2, WindowSpecification<T> specification3, WindowSpecification<T> specification4, WindowSpecification<T> specification5, WindowSpecification<T> specification6, WindowSpecification<T> specification7, WindowSpecification<T> specification8, WindowSpecification<T> specification9, WindowSpecification<T> specification10, WindowSpecification<T> specification11, WindowSpecification<T> specification12, WindowSpecification<T> specification13, WindowSpecification<T> specification14, WindowSpecification<T> specification15) Map this stream to a windowed stream with 15 distinct windows.
`default Seq<Tuple16<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>>`	window(WindowSpecification<T> specification1, WindowSpecification<T> specification2, WindowSpecification<T> specification3, WindowSpecification<T> specification4, WindowSpecification<T> specification5, WindowSpecification<T> specification6, WindowSpecification<T> specification7, WindowSpecification<T> specification8, WindowSpecification<T> specification9, WindowSpecification<T> specification10, WindowSpecification<T> specification11, WindowSpecification<T> specification12, WindowSpecification<T> specification13, WindowSpecification<T> specification14, WindowSpecification<T> specification15, WindowSpecification<T> specification16) Map this stream to a windowed stream with 16 distinct windows.
`static <T1,T2> Seq<Tuple2<T1,T2>>`	`zip(Iterable<T1> i1, Iterable<T2> i2)` Zip 2 streams into one.
`static <T1,T2,R> Seq<R>`	`zip(Iterable<T1> i1, Iterable<T2> i2, java.util.function.BiFunction<? super T1,? super T2,? extends R> zipper)` Zip 2 streams into one using a `BiFunction` to produce resulting values.
`static <T1,T2,T3> Seq<Tuple3<T1,T2,T3>>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3)` Zip 3 streams into one.
`static <T1,T2,T3,R> Seq<R>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Function3<? super T1,? super T2,? super T3,? extends R> zipper)` Zip 3 streams into one using a `Function3` to produce resulting values.
`static <T1,T2,T3,T4> Seq<Tuple4<T1,T2,T3,T4>>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4)` Zip 4 streams into one.
`static <T1,T2,T3,T4,R> Seq<R>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)` Zip 4 streams into one using a `Function4` to produce resulting values.
`static <T1,T2,T3,T4,T5> Seq<Tuple5<T1,T2,T3,T4,T5>>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5)` Zip 5 streams into one.
`static <T1,T2,T3,T4,T5,R> Seq<R>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)` Zip 5 streams into one using a `Function5` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6> Seq<Tuple6<T1,T2,T3,T4,T5,T6>>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6)` Zip 6 streams into one.
`static <T1,T2,T3,T4,T5,T6,R> Seq<R>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)` Zip 6 streams into one using a `Function6` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7> Seq<Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7)` Zip 7 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,R> Seq<R>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)` Zip 7 streams into one using a `Function7` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Seq<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8)` Zip 8 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,R> Seq<R>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper)` Zip 8 streams into one using a `Function8` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Seq<Tuple9<T1,T2,T3,T4,T5,T6,T7,T8,T9>>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9)` Zip 9 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> Seq<R>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9, Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipper)` Zip 9 streams into one using a `Function9` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Seq<Tuple10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9, Iterable<T10> i10)` Zip 10 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,R> Seq<R>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9, Iterable<T10> i10, Function10<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? extends R> zipper)` Zip 10 streams into one using a `Function10` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Seq<Tuple11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9, Iterable<T10> i10, Iterable<T11> i11)` Zip 11 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,R> Seq<R>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9, Iterable<T10> i10, Iterable<T11> i11, Function11<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? extends R> zipper)` Zip 11 streams into one using a `Function11` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Seq<Tuple12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9, Iterable<T10> i10, Iterable<T11> i11, Iterable<T12> i12)` Zip 12 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,R> Seq<R>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9, Iterable<T10> i10, Iterable<T11> i11, Iterable<T12> i12, Function12<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? extends R> zipper)` Zip 12 streams into one using a `Function12` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Seq<Tuple13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9, Iterable<T10> i10, Iterable<T11> i11, Iterable<T12> i12, Iterable<T13> i13)` Zip 13 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,R> Seq<R>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9, Iterable<T10> i10, Iterable<T11> i11, Iterable<T12> i12, Iterable<T13> i13, Function13<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? extends R> zipper)` Zip 13 streams into one using a `Function13` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Seq<Tuple14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9, Iterable<T10> i10, Iterable<T11> i11, Iterable<T12> i12, Iterable<T13> i13, Iterable<T14> i14)` Zip 14 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,R> Seq<R>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9, Iterable<T10> i10, Iterable<T11> i11, Iterable<T12> i12, Iterable<T13> i13, Iterable<T14> i14, Function14<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? super T14,? extends R> zipper)` Zip 14 streams into one using a `Function14` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Seq<Tuple15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9, Iterable<T10> i10, Iterable<T11> i11, Iterable<T12> i12, Iterable<T13> i13, Iterable<T14> i14, Iterable<T15> i15)` Zip 15 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,R> Seq<R>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9, Iterable<T10> i10, Iterable<T11> i11, Iterable<T12> i12, Iterable<T13> i13, Iterable<T14> i14, Iterable<T15> i15, Function15<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? super T14,? super T15,? extends R> zipper)` Zip 15 streams into one using a `Function15` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Seq<Tuple16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>>`	`zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9, Iterable<T10> i10, Iterable<T11> i11, Iterable<T12> i12, Iterable<T13> i13, Iterable<T14> i14, Iterable<T15> i15, Iterable<T16> i16)` Zip 16 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,R> Seq<R>`	zip(Iterable<T1> i1, Iterable<T2> i2, Iterable<T3> i3, Iterable<T4> i4, Iterable<T5> i5, Iterable<T6> i6, Iterable<T7> i7, Iterable<T8> i8, Iterable<T9> i9, Iterable<T10> i10, Iterable<T11> i11, Iterable<T12> i12, Iterable<T13> i13, Iterable<T14> i14, Iterable<T15> i15, Iterable<T16> i16, Function16<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? super T14,? super T15,? super T16,? extends R> zipper) Zip 16 streams into one using a `Function16` to produce resulting values.
`default <U> Seq<Tuple2<T,U>>`	`zip(Iterable<U> other)` Zip two streams into one.
`default <U,R> Seq<R>`	`zip(Iterable<U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)` Zip two streams into one using a `BiFunction` to produce resulting values.
`static <T1,T2> Seq<Tuple2<T1,T2>>`	`zip(Seq<T1> s1, Seq<T2> s2)` Zip 2 streams into one.
`static <T1,T2,R> Seq<R>`	`zip(Seq<T1> s1, Seq<T2> s2, java.util.function.BiFunction<? super T1,? super T2,? extends R> zipper)` Zip 2 streams into one using a `BiFunction` to produce resulting values.
`static <T1,T2,T3> Seq<Tuple3<T1,T2,T3>>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3)` Zip 3 streams into one.
`static <T1,T2,T3,R> Seq<R>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Function3<? super T1,? super T2,? super T3,? extends R> zipper)` Zip 3 streams into one using a `Function3` to produce resulting values.
`static <T1,T2,T3,T4> Seq<Tuple4<T1,T2,T3,T4>>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4)` Zip 4 streams into one.
`static <T1,T2,T3,T4,R> Seq<R>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)` Zip 4 streams into one using a `Function4` to produce resulting values.
`static <T1,T2,T3,T4,T5> Seq<Tuple5<T1,T2,T3,T4,T5>>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5)` Zip 5 streams into one.
`static <T1,T2,T3,T4,T5,R> Seq<R>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)` Zip 5 streams into one using a `Function5` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6> Seq<Tuple6<T1,T2,T3,T4,T5,T6>>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6)` Zip 6 streams into one.
`static <T1,T2,T3,T4,T5,T6,R> Seq<R>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)` Zip 6 streams into one using a `Function6` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7> Seq<Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7)` Zip 7 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,R> Seq<R>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)` Zip 7 streams into one using a `Function7` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Seq<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8)` Zip 8 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,R> Seq<R>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper)` Zip 8 streams into one using a `Function8` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Seq<Tuple9<T1,T2,T3,T4,T5,T6,T7,T8,T9>>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9)` Zip 9 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> Seq<R>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9, Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipper)` Zip 9 streams into one using a `Function9` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Seq<Tuple10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9, Seq<T10> s10)` Zip 10 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,R> Seq<R>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9, Seq<T10> s10, Function10<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? extends R> zipper)` Zip 10 streams into one using a `Function10` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Seq<Tuple11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9, Seq<T10> s10, Seq<T11> s11)` Zip 11 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,R> Seq<R>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9, Seq<T10> s10, Seq<T11> s11, Function11<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? extends R> zipper)` Zip 11 streams into one using a `Function11` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Seq<Tuple12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9, Seq<T10> s10, Seq<T11> s11, Seq<T12> s12)` Zip 12 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,R> Seq<R>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9, Seq<T10> s10, Seq<T11> s11, Seq<T12> s12, Function12<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? extends R> zipper)` Zip 12 streams into one using a `Function12` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Seq<Tuple13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9, Seq<T10> s10, Seq<T11> s11, Seq<T12> s12, Seq<T13> s13)` Zip 13 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,R> Seq<R>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9, Seq<T10> s10, Seq<T11> s11, Seq<T12> s12, Seq<T13> s13, Function13<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? extends R> zipper)` Zip 13 streams into one using a `Function13` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Seq<Tuple14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9, Seq<T10> s10, Seq<T11> s11, Seq<T12> s12, Seq<T13> s13, Seq<T14> s14)` Zip 14 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,R> Seq<R>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9, Seq<T10> s10, Seq<T11> s11, Seq<T12> s12, Seq<T13> s13, Seq<T14> s14, Function14<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? super T14,? extends R> zipper)` Zip 14 streams into one using a `Function14` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Seq<Tuple15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9, Seq<T10> s10, Seq<T11> s11, Seq<T12> s12, Seq<T13> s13, Seq<T14> s14, Seq<T15> s15)` Zip 15 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,R> Seq<R>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9, Seq<T10> s10, Seq<T11> s11, Seq<T12> s12, Seq<T13> s13, Seq<T14> s14, Seq<T15> s15, Function15<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? super T14,? super T15,? extends R> zipper)` Zip 15 streams into one using a `Function15` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Seq<Tuple16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9, Seq<T10> s10, Seq<T11> s11, Seq<T12> s12, Seq<T13> s13, Seq<T14> s14, Seq<T15> s15, Seq<T16> s16)` Zip 16 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,R> Seq<R>`	`zip(Seq<T1> s1, Seq<T2> s2, Seq<T3> s3, Seq<T4> s4, Seq<T5> s5, Seq<T6> s6, Seq<T7> s7, Seq<T8> s8, Seq<T9> s9, Seq<T10> s10, Seq<T11> s11, Seq<T12> s12, Seq<T13> s13, Seq<T14> s14, Seq<T15> s15, Seq<T16> s16, Function16<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? super T14,? super T15,? super T16,? extends R> zipper)` Zip 16 streams into one using a `Function16` to produce resulting values.
`default <U> Seq<Tuple2<T,U>>`	`zip(Seq<U> other)` Zip two streams into one.
`default <U,R> Seq<R>`	`zip(Seq<U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)` Zip two streams into one using a `BiFunction` to produce resulting values.
`static <T1,T2> Seq<Tuple2<T1,T2>>`	`zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2)` Zip 2 streams into one.
`static <T1,T2,R> Seq<R>`	`zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.function.BiFunction<? super T1,? super T2,? extends R> zipper)` Zip 2 streams into one using a `BiFunction` to produce resulting values.
`static <T1,T2,T3> Seq<Tuple3<T1,T2,T3>>`	`zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3)` Zip 3 streams into one.
`static <T1,T2,T3,R> Seq<R>`	`zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, Function3<? super T1,? super T2,? super T3,? extends R> zipper)` Zip 3 streams into one using a `Function3` to produce resulting values.
`static <T1,T2,T3,T4> Seq<Tuple4<T1,T2,T3,T4>>`	`zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4)` Zip 4 streams into one.
`static <T1,T2,T3,T4,R> Seq<R>`	`zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)` Zip 4 streams into one using a `Function4` to produce resulting values.
`static <T1,T2,T3,T4,T5> Seq<Tuple5<T1,T2,T3,T4,T5>>`	`zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5)` Zip 5 streams into one.
`static <T1,T2,T3,T4,T5,R> Seq<R>`	`zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)` Zip 5 streams into one using a `Function5` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6> Seq<Tuple6<T1,T2,T3,T4,T5,T6>>`	`zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6)` Zip 6 streams into one.
`static <T1,T2,T3,T4,T5,T6,R> Seq<R>`	`zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)` Zip 6 streams into one using a `Function6` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7> Seq<Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	`zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7)` Zip 7 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,R> Seq<R>`	`zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)` Zip 7 streams into one using a `Function7` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Seq<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	`zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8)` Zip 8 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,R> Seq<R>`	`zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper)` Zip 8 streams into one using a `Function8` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Seq<Tuple9<T1,T2,T3,T4,T5,T6,T7,T8,T9>>`	`zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9)` Zip 9 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> Seq<R>`	`zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9, Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipper)` Zip 9 streams into one using a `Function9` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Seq<Tuple10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>>`	`zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9, java.util.stream.Stream<T10> s10)` Zip 10 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,R> Seq<R>`	`zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9, java.util.stream.Stream<T10> s10, Function10<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? extends R> zipper)` Zip 10 streams into one using a `Function10` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Seq<Tuple11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>>`	`zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9, java.util.stream.Stream<T10> s10, java.util.stream.Stream<T11> s11)` Zip 11 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,R> Seq<R>`	zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9, java.util.stream.Stream<T10> s10, java.util.stream.Stream<T11> s11, Function11<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? extends R> zipper) Zip 11 streams into one using a `Function11` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Seq<Tuple12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>>`	`zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9, java.util.stream.Stream<T10> s10, java.util.stream.Stream<T11> s11, java.util.stream.Stream<T12> s12)` Zip 12 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,R> Seq<R>`	zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9, java.util.stream.Stream<T10> s10, java.util.stream.Stream<T11> s11, java.util.stream.Stream<T12> s12, Function12<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? extends R> zipper) Zip 12 streams into one using a `Function12` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Seq<Tuple13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>>`	`zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9, java.util.stream.Stream<T10> s10, java.util.stream.Stream<T11> s11, java.util.stream.Stream<T12> s12, java.util.stream.Stream<T13> s13)` Zip 13 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,R> Seq<R>`	zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9, java.util.stream.Stream<T10> s10, java.util.stream.Stream<T11> s11, java.util.stream.Stream<T12> s12, java.util.stream.Stream<T13> s13, Function13<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? extends R> zipper) Zip 13 streams into one using a `Function13` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Seq<Tuple14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>>`	`zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9, java.util.stream.Stream<T10> s10, java.util.stream.Stream<T11> s11, java.util.stream.Stream<T12> s12, java.util.stream.Stream<T13> s13, java.util.stream.Stream<T14> s14)` Zip 14 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,R> Seq<R>`	zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9, java.util.stream.Stream<T10> s10, java.util.stream.Stream<T11> s11, java.util.stream.Stream<T12> s12, java.util.stream.Stream<T13> s13, java.util.stream.Stream<T14> s14, Function14<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? super T14,? extends R> zipper) Zip 14 streams into one using a `Function14` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Seq<Tuple15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>>`	zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9, java.util.stream.Stream<T10> s10, java.util.stream.Stream<T11> s11, java.util.stream.Stream<T12> s12, java.util.stream.Stream<T13> s13, java.util.stream.Stream<T14> s14, java.util.stream.Stream<T15> s15) Zip 15 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,R> Seq<R>`	zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9, java.util.stream.Stream<T10> s10, java.util.stream.Stream<T11> s11, java.util.stream.Stream<T12> s12, java.util.stream.Stream<T13> s13, java.util.stream.Stream<T14> s14, java.util.stream.Stream<T15> s15, Function15<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? super T14,? super T15,? extends R> zipper) Zip 15 streams into one using a `Function15` to produce resulting values.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Seq<Tuple16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>>`	zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9, java.util.stream.Stream<T10> s10, java.util.stream.Stream<T11> s11, java.util.stream.Stream<T12> s12, java.util.stream.Stream<T13> s13, java.util.stream.Stream<T14> s14, java.util.stream.Stream<T15> s15, java.util.stream.Stream<T16> s16) Zip 16 streams into one.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,R> Seq<R>`	zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, java.util.stream.Stream<T9> s9, java.util.stream.Stream<T10> s10, java.util.stream.Stream<T11> s11, java.util.stream.Stream<T12> s12, java.util.stream.Stream<T13> s13, java.util.stream.Stream<T14> s14, java.util.stream.Stream<T15> s15, java.util.stream.Stream<T16> s16, Function16<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? super T14,? super T15,? super T16,? extends R> zipper) Zip 16 streams into one using a `Function16` to produce resulting values.
`default <U> Seq<Tuple2<T,U>>`	`zip(java.util.stream.Stream<U> other)` Zip two streams into one.
`default <U,R> Seq<R>`	`zip(java.util.stream.Stream<U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)` Zip two streams into one using a `BiFunction` to produce resulting values.
`default Seq<Tuple2<T,Long>>`	`zipWithIndex()` Zip a Stream with a corresponding Stream of indexes.
`static <T> Seq<Tuple2<T,Long>>`	`zipWithIndex(Iterable<T> iterable)` Zip a Stream with a corresponding Stream of indexes.
`static <T> Seq<Tuple2<T,Long>>`	`zipWithIndex(Seq<T> stream)` Zip a Stream with a corresponding Stream of indexes.
`static <T> Seq<Tuple2<T,Long>>`	`zipWithIndex(java.util.stream.Stream<T> stream)` Zip a Stream with a corresponding Stream of indexes.

Methods inherited from interface java.util.stream.Stream
allMatch, anyMatch, builder, collect, collect, concat, findAny, findFirst, forEachOrdered, max, min, noneMatch, reduce, reduce, reduce, toArray, toArray

Methods inherited from interface java.util.stream.BaseStream
isParallel, iterator

Methods inherited from interface java.lang.Iterable
iterator

Methods inherited from interface org.jooq.lambda.Collectable
allMatch, anyMatch, avg, avg, avgDouble, avgInt, avgLong, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, countDistinct, countDistinctBy, max, max, max, max, maxBy, maxBy, median, median, medianBy, medianBy, min, min, min, min, minBy, minBy, mode, noneMatch, percentile, percentile, percentileBy, percentileBy, sum, sum, sumDouble, sumInt, sumLong, toCollection, toList, toList, toMap, toSet, toSet, toString, toString

Method Detail

stream
```
java.util.stream.Stream<T> stream()
```
The underlying Stream implementation.

crossJoin

default <U> Seq<Tuple2<T,U>> crossJoin(java.util.stream.Stream<U> other)

Cross join 2 streams into one.

 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))

crossJoin

default <U> Seq<Tuple2<T,U>> crossJoin(Iterable<U> other)

Cross join 2 streams into one.

 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))

crossJoin

default <U> Seq<Tuple2<T,U>> crossJoin(Seq<U> other)

Cross join 2 streams into one.

 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))

innerJoin

default <U> Seq<Tuple2<T,U>> innerJoin(java.util.stream.Stream<U> other,
                                       java.util.function.BiPredicate<? super T,? super U> predicate)

Inner join 2 streams into one.

 // (tuple(1, 1), tuple(2, 2))
 Seq.of(1, 2, 3).innerJoin(Seq.of(1, 2), t -> Objects.equals(t.v1, t.v2))

innerJoin

default <U> Seq<Tuple2<T,U>> innerJoin(Iterable<U> other,
                                       java.util.function.BiPredicate<? super T,? super U> predicate)

Inner join 2 streams into one.

 // (tuple(1, 1), tuple(2, 2))
 Seq.of(1, 2, 3).innerJoin(Seq.of(1, 2), t -> Objects.equals(t.v1, t.v2))

innerJoin

default <U> Seq<Tuple2<T,U>> innerJoin(Seq<U> other,
                                       java.util.function.BiPredicate<? super T,? super U> predicate)

Inner join 2 streams into one.

 // (tuple(1, 1), tuple(2, 2))
 Seq.of(1, 2, 3).innerJoin(Seq.of(1, 2), t -> Objects.equals(t.v1, t.v2))

leftOuterJoin

default <U> Seq<Tuple2<T,U>> leftOuterJoin(java.util.stream.Stream<U> other,
                                           java.util.function.BiPredicate<? super T,? super U> predicate)

Left outer join 2 streams into one.

 // (tuple(1, 1), tuple(2, 2), tuple(3, null))
 Seq.of(1, 2, 3).leftOuterJoin(Seq.of(1, 2), t -> Objects.equals(t.v1, t.v2))

leftOuterJoin

default <U> Seq<Tuple2<T,U>> leftOuterJoin(Iterable<U> other,
                                           java.util.function.BiPredicate<? super T,? super U> predicate)

Left outer join 2 streams into one.

 // (tuple(1, 1), tuple(2, 2), tuple(3, null))
 Seq.of(1, 2, 3).leftOuterJoin(Seq.of(1, 2), t -> Objects.equals(t.v1, t.v2))

leftOuterJoin

default <U> Seq<Tuple2<T,U>> leftOuterJoin(Seq<U> other,
                                           java.util.function.BiPredicate<? super T,? super U> predicate)

Left outer join 2 streams into one.

 // (tuple(1, 1), tuple(2, 2), tuple(3, null))
 Seq.of(1, 2, 3).leftOuterJoin(Seq.of(1, 2), t -> Objects.equals(t.v1, t.v2))

rightOuterJoin

default <U> Seq<Tuple2<T,U>> rightOuterJoin(java.util.stream.Stream<U> other,
                                            java.util.function.BiPredicate<? super T,? super U> predicate)

Right outer join 2 streams into one.

 // (tuple(1, 1), tuple(2, 2), tuple(null, 3))
 Seq.of(1, 2).rightOuterJoin(Seq.of(1, 2, 3), t -> Objects.equals(t.v1, t.v2))

rightOuterJoin

default <U> Seq<Tuple2<T,U>> rightOuterJoin(Iterable<U> other,
                                            java.util.function.BiPredicate<? super T,? super U> predicate)

Right outer join 2 streams into one.

 // (tuple(1, 1), tuple(2, 2), tuple(null, 3))
 Seq.of(1, 2).rightOuterJoin(Seq.of(1, 2, 3), t -> Objects.equals(t.v1, t.v2))

rightOuterJoin

default <U> Seq<Tuple2<T,U>> rightOuterJoin(Seq<U> other,
                                            java.util.function.BiPredicate<? super T,? super U> predicate)

Right outer join 2 streams into one.

 // (tuple(1, 1), tuple(2, 2), tuple(null, 3))
 Seq.of(1, 2).rightOuterJoin(Seq.of(1, 2, 3), t -> Objects.equals(t.v1, t.v2))

onEmpty
```
default Seq<T> onEmpty(T value)
```
Produce this stream, or an alternative stream from the value, in case this stream is empty.

onEmptyGet
```
default Seq<T> onEmptyGet(java.util.function.Supplier<T> supplier)
```
Produce this stream, or an alternative stream from the supplier, in case this stream is empty.

onEmptyThrow
```
default <X extends Throwable> Seq<T> onEmptyThrow(java.util.function.Supplier<X> supplier)
```
Produce this stream, or an alternative stream from the supplier, in case this stream is empty.

concat

default Seq<T> concat(java.util.stream.Stream<T> other)

Concatenate two streams.

 // (1, 2, 3, 4, 5, 6)
 Seq.of(1, 2, 3).concat(Seq.of(4, 5, 6))

See Also:: concat(Stream[])

concat

default Seq<T> concat(Iterable<T> other)

Concatenate two streams.

 // (1, 2, 3, 4, 5, 6)
 Seq.of(1, 2, 3).concat(Seq.of(4, 5, 6))

See Also:: concat(Stream[])

concat

default Seq<T> concat(Seq<T> other)

Concatenate two streams.

 // (1, 2, 3, 4, 5, 6)
 Seq.of(1, 2, 3).concat(Seq.of(4, 5, 6))

See Also:: concat(Stream[])

concat

default Seq<T> concat(T other)

Concatenate two streams.

 // (1, 2, 3, 4)
 Seq.of(1, 2, 3).concat(4)

See Also:: concat(Stream[])

concat

default Seq<T> concat(T... other)

Concatenate two streams.

 // (1, 2, 3, 4, 5, 6)
 Seq.of(1, 2, 3).concat(4, 5, 6)

See Also:: concat(Stream[])

append

default Seq<T> append(java.util.stream.Stream<T> other)

Concatenate two streams.

 // (1, 2, 3, 4, 5, 6)
 Seq.of(1, 2, 3).append(Seq.of(4, 5, 6))

See Also:: concat(Stream[])

append

default Seq<T> append(Iterable<T> other)

Concatenate two streams.

 // (1, 2, 3, 4, 5, 6)
 Seq.of(1, 2, 3).append(Seq.of(4, 5, 6))

See Also:: concat(Stream[])

append

default Seq<T> append(Seq<T> other)

Concatenate two streams.

 // (1, 2, 3, 4, 5, 6)
 Seq.of(1, 2, 3).append(Seq.of(4, 5, 6))

See Also:: concat(Stream[])

append

default Seq<T> append(T other)

Concatenate two streams.

 // (1, 2, 3, 4)
 Seq.of(1, 2, 3).append(4)

See Also:: concat(Stream[])

append

default Seq<T> append(T... other)

Concatenate two streams.

 // (1, 2, 3, 4, 5, 6)
 Seq.of(1, 2, 3).append(4, 5, 6)

See Also:: concat(Stream[])

prepend

default Seq<T> prepend(java.util.stream.Stream<T> other)

Concatenate two streams.

 // (1, 2, 3, 4, 5, 6)
 Seq.of(4, 5, 6).prepend(Seq.of(1, 2, 3))

See Also:: concat(Stream[])

prepend

default Seq<T> prepend(Iterable<T> other)

Concatenate two streams.

 // (1, 2, 3, 4, 5, 6)
 Seq.of(4, 5, 6).prepend(Seq.of(1, 2, 3))

See Also:: concat(Stream[])

prepend

default Seq<T> prepend(Seq<T> other)

Concatenate two streams.

 // (1, 2, 3, 4, 5, 6)
 Seq.of(4, 5, 6).prepend(Seq.of(1, 2, 3))

See Also:: concat(Stream[])

prepend

default Seq<T> prepend(T other)

Concatenate two streams.

 // (1, 2, 3, 4)
 Seq.of(2, 3, 4).prepend(1)

See Also:: concat(Stream[])

prepend

default Seq<T> prepend(T... other)

Concatenate two streams.

 // (1, 2, 3, 4, 5, 6)
 Seq.of(4, 5, 6).prepend(Seq.of(1, 2, 3))

See Also:: concat(Stream[])

contains

default boolean contains(T other)

Check whether this stream contains a given value.

 // true
 Seq.of(1, 2, 3).contains(2)









containsAll
default boolean containsAll(T... other)
Check whether this stream contains all given values.
 
 
 // true
 Seq.of(1, 2, 3).containsAll(2, 3)
 








containsAll
default boolean containsAll(java.util.stream.Stream<T> other)
Check whether this stream contains all given values.
 
 
 // true
 Seq.of(1, 2, 3).containsAll(2, 3)
 








containsAll
default boolean containsAll(Iterable<T> other)
Check whether this stream contains all given values.
 
 
 // true
 Seq.of(1, 2, 3).containsAll(2, 3)
 








containsAll
default boolean containsAll(Seq<T> other)
Check whether this stream contains all given values.
 
 
 // true
 Seq.of(1, 2, 3).containsAll(2, 3)
 










containsAny
default boolean containsAny(T... other)
Check whether this stream contains any of the given values.
 
 
 // true
 Seq.of(1, 2, 3).containsAny(2, 4)
 








containsAny
default boolean containsAny(java.util.stream.Stream<T> other)
Check whether this stream contains any of the given values.
 
 
 // true
 Seq.of(1, 2, 3).containsAny(2, 4)
 








containsAny
default boolean containsAny(Iterable<T> other)
Check whether this stream contains any of the given values.
 
 
 // true
 Seq.of(1, 2, 3).containsAny(2, 4)
 








containsAny
default boolean containsAny(Seq<T> other)
Check whether this stream contains any of the given values.
 
 
 // true
 Seq.of(1, 2, 3).containsAny(2, 4)
 








get
default Optional<T> get(long index)
Get a single element from the stream at a given index









remove
default Seq<T> remove(T other)
Return a new stream where the first occurrence of the argument is removed.
 
 
 // 1, 3, 2, 4
 Seq.of(1, 2, 3, 2, 4).remove(2)
 










removeAll
default Seq<T> removeAll(T... other)
Return a new stream where all occurrences of the arguments are removed.
 
 
 // 1, 4
 Seq.of(1, 2, 3, 2, 4).removeAll(2, 3)
 








removeAll
default Seq<T> removeAll(java.util.stream.Stream<T> other)
Return a new stream where all occurrences of the arguments are removed.
 
 
 // 1, 4
 Seq.of(1, 2, 3, 2, 4).removeAll(2, 3)
 








removeAll
default Seq<T> removeAll(Iterable<T> other)
Return a new stream where all occurrences of the arguments are removed.
 
 
 // 1, 4
 Seq.of(1, 2, 3, 2, 4).removeAll(2, 3)
 








removeAll
default Seq<T> removeAll(Seq<T> other)
Return a new stream where all occurrences of the arguments are removed.
 
 
 // 1, 4
 Seq.of(1, 2, 3, 2, 4).removeAll(2, 3)
 










retainAll
default Seq<T> retainAll(T... other)
Return a new stream where only occurrences of the arguments are retained.
 
 
 // 2, 3, 2
 Seq.of(1, 2, 3, 2, 4).retainAll(2, 3)
 








retainAll
default Seq<T> retainAll(java.util.stream.Stream<T> other)
Return a new stream where only occurrences of the arguments are retained.
 
 
 // 2, 3, 2
 Seq.of(1, 2, 3, 2, 4).retainAll(2, 3)
 








retainAll
default Seq<T> retainAll(Iterable<T> other)
Return a new stream where only occurrences of the arguments are retained.
 
 
 // 2, 3, 2
 Seq.of(1, 2, 3, 2, 4).retainAll(2, 3)
 








retainAll
default Seq<T> retainAll(Seq<T> other)
Return a new stream where only occurrences of the arguments are retained.
 
 
 // 2, 3, 2
 Seq.of(1, 2, 3, 2, 4).retainAll(2, 3)
 








cycle
default Seq<T> cycle()
Repeat a stream infinitely.
 
 
 // (1, 2, 3, 1, 2, 3, ...)
 Seq.of(1, 2, 3).cycle();
 

See Also:
cycle(Stream)








distinct
default <U> Seq<T> distinct(java.util.function.Function<? super T,? extends U> keyExtractor)
Get a stream of distinct keys.
 
 
 // (1, 2, 3)
 Seq.of(1, 1, 2, -2, 3).distinct(Math::abs)
 







zip
default <U> Seq<Tuple2<T,U>> zip(java.util.stream.Stream<U> other)
Zip two streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 

See Also:
zip(Stream, Stream)








zip
default <U> Seq<Tuple2<T,U>> zip(Iterable<U> other)
Zip two streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 

See Also:
zip(Stream, Stream)








zip
default <U> Seq<Tuple2<T,U>> zip(Seq<U> other)
Zip two streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 

See Also:
zip(Stream, Stream)








zip
default <U,R> Seq<R> zip(java.util.stream.Stream<U> other,
                         java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zip two streams into one using a BiFunction to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 

See Also:
zip(Seq, BiFunction)








zip
default <U,R> Seq<R> zip(Iterable<U> other,
                         java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zip two streams into one using a BiFunction to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 

See Also:
zip(Seq, BiFunction)








zip
default <U,R> Seq<R> zip(Seq<U> other,
                         java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zip two streams into one using a BiFunction to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 

See Also:
zip(Seq, BiFunction)








zipWithIndex
default Seq<Tuple2<T,Long>> zipWithIndex()
Zip a Stream with a corresponding Stream of indexes.
 
 
 // (tuple("a", 0), tuple("b", 1), tuple("c", 2))
 Seq.of("a", "b", "c").zipWithIndex()
 

See Also:
zipWithIndex(Stream)










foldLeft
default <U> U foldLeft(U seed,
                       java.util.function.BiFunction<U,? super T,U> function)
Fold a Stream to the left.
 
 
 // "abc"
 Seq.of("a", "b", "c").foldLeft("", (u, t) -> u + t)
 









foldRight
default <U> U foldRight(U seed,
                        java.util.function.BiFunction<? super T,U,U> function)
Fold a Stream to the right.
 
 
 // "cba"
 Seq.of("a", "b", "c").foldRight("", (t, u) -> u + t)
 









scanLeft
default <U> Seq<U> scanLeft(U seed,
                            java.util.function.BiFunction<U,? super T,U> function)
Scan a stream to the left.
 
 
 // ("", "a", "ab", "abc")
 Seq.of("a", "b", "c").scanLeft("", (u, t) -> u + t)
 









scanRight
default <U> Seq<U> scanRight(U seed,
                             java.util.function.BiFunction<? super T,U,U> function)
Scan a stream to the right.
 
 
 // ("", "c", "cb", "cba")
 Seq.of("a", "b", "c").scanRight("", (t, u) -> u + t)
 







reverse
default Seq<T> reverse()
Reverse a stream.
 
 
 // (3, 2, 1)
 Seq.of(1, 2, 3).reverse()
 







shuffle
default Seq<T> shuffle()
Shuffle a stream
 
 
 // e.g. (2, 3, 1)
 Seq.of(1, 2, 3).shuffle()
 







shuffle
default Seq<T> shuffle(Random random)
Shuffle a stream using specified source of randomness
 
 
 // e.g. (2, 3, 1)
 Seq.of(1, 2, 3).shuffle(new Random())
 







skipWhile
default Seq<T> skipWhile(java.util.function.Predicate<? super T> predicate)
Returns a stream with all elements skipped for which a predicate evaluates to true.
 
 
 // (3, 4, 5)
 Seq.of(1, 2, 3, 4, 5).skipWhile(i -> i < 3)
 

See Also:
skipWhile(Stream, Predicate)








skipWhileClosed
default Seq<T> skipWhileClosed(java.util.function.Predicate<? super T> predicate)
Returns a stream with all elements skipped for which a predicate evaluates to true
 plus the first element for which it evaluates to false.
 
 
 // (4, 5)
 Seq.of(1, 2, 3, 4, 5).skipWhileClosed(i -> i < 3)
 

See Also:
skipWhileClosed(Stream, Predicate)








skipUntil
default Seq<T> skipUntil(java.util.function.Predicate<? super T> predicate)
Returns a stream with all elements skipped for which a predicate evaluates to false.
 
 
 // (3, 4, 5)
 Seq.of(1, 2, 3, 4, 5).skipUntil(i -> i == 3)
 

See Also:
skipUntil(Stream, Predicate)








skipUntilClosed
default Seq<T> skipUntilClosed(java.util.function.Predicate<? super T> predicate)
Returns a stream with all elements skipped for which a predicate evaluates to false
 plus the first element for which it evaluates to true.
 
 
 // (4, 5)
 Seq.of(1, 2, 3, 4, 5).skipUntilClosed(i -> i == 3)
 

See Also:
skipUntilClosed(Stream, Predicate)








limitWhile
default Seq<T> limitWhile(java.util.function.Predicate<? super T> predicate)
Returns a stream limited to all elements for which a predicate evaluates to true.
 
 
 // (1, 2)
 Seq.of(1, 2, 3, 4, 5).limitWhile(i -> i < 3)
 

See Also:
limitWhile(Stream, Predicate)








limitWhileClosed
default Seq<T> limitWhileClosed(java.util.function.Predicate<? super T> predicate)
Returns a stream limited to all elements for which a predicate evaluates to true
 plus the first element for which it evaluates to false.
 
 
 // (1, 2, 3)
 Seq.of(1, 2, 3, 4, 5).limitWhileClosed(i -> i < 3)
 

See Also:
limitWhileClosed(Stream, Predicate)








limitUntil
default Seq<T> limitUntil(java.util.function.Predicate<? super T> predicate)
Returns a stream limited to all elements for which a predicate evaluates to false.
 
 
 // (1, 2)
 Seq.of(1, 2, 3, 4, 5).limitUntil(i -> i == 3)
 

See Also:
limitUntil(Stream, Predicate)








limitUntilClosed
default Seq<T> limitUntilClosed(java.util.function.Predicate<? super T> predicate)
Returns a stream limited to all elements for which a predicate evaluates to false
 plus the first element for which it evaluates to true.
 
 
 // (1, 2, 3)
 Seq.of(1, 2, 3, 4, 5).limitUntilClosed(i -> i == 3)
 

See Also:
limitUntilClosed(Stream, Predicate)










intersperse
default Seq<T> intersperse(T value)
Returns a stream with a given value interspersed between any two values of this stream.
 
 
 // (1, 0, 2, 0, 3, 0, 4)
 Seq.of(1, 2, 3, 4).intersperse(0)
 

See Also:
intersperse(Stream, Object)








duplicate
default Tuple2<Seq<T>,Seq<T>> duplicate()
Duplicate a Streams into two equivalent Streams.
 
 
 // tuple((1, 2, 3), (1, 2, 3))
 Seq.of(1, 2, 3).duplicate()
 

See Also:
duplicate(Stream)








grouped
default <K> Seq<Tuple2<K,Seq<T>>> grouped(java.util.function.Function<? super T,? extends K> classifier)
Classify this stream's elements according to a given classifier function.
 
 
 // Seq(tuple(1, Seq(1, 3, 5)), tuple(0, Seq(2, 4, 6)))
 Seq.of(1, 2, 3, 4, 5, 6).grouped(i -> i % 2)
 // Seq(tuple(true, Seq(1, 3, 5)), tuple(false, Seq(2, 4, 6)))
 Seq.of(1, 2, 3, 4, 5, 6).grouped(i -> i % 2 != 0)
 

 This is a non-terminal analog of groupBy(Function))

See Also:
groupBy(Function), 
partition(Predicate)








grouped
default <K,A,D> Seq<Tuple2<K,D>> grouped(java.util.function.Function<? super T,? extends K> classifier,
                                         java.util.stream.Collector<? super T,A,D> downstream)
Classify this stream's elements according to a given classifier function
 and collect each class's elements using a collector.
 
 
 // Seq(tuple(1, 9), tuple(0, 12))
 Seq.of(1, 2, 3, 4, 5, 6).grouped(i -> i % 2, Collectors.summingInt(i -> i))
 // Seq(tuple(true, 9), tuple(false, 12))
 Seq.of(1, 2, 3, 4, 5, 6).grouped(i -> i % 2 != 0, Collectors.summingInt(i -> i))
  This is a non-terminal analog of
 groupBy(Function, Collector))

See Also:
groupBy(Function, Collector)








partition
default Tuple2<Seq<T>,Seq<T>> partition(java.util.function.Predicate<? super T> predicate)
Partition a stream into two given a predicate.
 
 
 // tuple((1, 3, 5), (2, 4, 6))
 Seq.of(1, 2, 3, 4, 5, 6).partition(i -> i % 2 != 0)
 

See Also:
partition(Stream, Predicate)








splitAt
default Tuple2<Seq<T>,Seq<T>> splitAt(long position)
Split a stream at a given position.
 
 
 // tuple((1, 2, 3), (4, 5, 6))
 Seq.of(1, 2, 3, 4, 5, 6).splitAt(3)
 

See Also:
splitAt(Stream, long)








splitAtHead
default Tuple2<Optional<T>,Seq<T>> splitAtHead()
Split a stream at the head.
 
 
 // tuple(1, (2, 3, 4, 5, 6))
 Seq.of(1, 2, 3, 4, 5, 6).splitHead(3)
 

See Also:
splitAt(Stream, long)








slice
default Seq<T> slice(long from,
                     long to)
Returns a limited interval from a given Stream.
 
 
 // (4, 5)
 Seq.of(1, 2, 3, 4, 5, 6).slice(3, 5)
 

See Also:
slice(Stream, long, long)








isEmpty
default boolean isEmpty()
Check if the sequence has any elements







isNotEmpty
default boolean isNotEmpty()
Check if the sequence has no elements







sorted
default <U extends Comparable<? super U>> Seq<T> sorted(java.util.function.Function<? super T,? extends U> function)
Sort by the results of function.







sorted
default <U> Seq<T> sorted(java.util.function.Function<? super T,? extends U> function,
                          Comparator<? super U> comparator)
Sort by the results of function.







ofType
default <U> Seq<U> ofType(Class<U> type)
Keep only those elements in a stream that are of a given type.
 
 
 // (1, 2, 3)
 Seq.of(1, "a", 2, "b", 3).ofType(Integer.class)
 

See Also:
ofType(Stream, Class)








cast
default <U> Seq<U> cast(Class<U> type)
Cast all elements in a stream to a given type, possibly throwing a ClassCastException.
 
 
 // ClassCastException
 Seq.of(1, "a", 2, "b", 3).cast(Integer.class)
 

See Also:
cast(Stream, Class)








window
default Seq<Window<T>> window()
Map this stream to a windowed stream using the default partition and order.
 
 
 // (0, 1, 2, 3, 4)
 Seq.of(1, 2, 4, 2, 3).window().map(Window::rowNumber)
 







window
default Seq<Window<T>> window(long lower,
                              long upper)
Map this stream to a windowed stream using the default partition and order with frame.
 
 
 // (2, 4, 4, 4, 3)
 Seq.of(1, 2, 4, 2, 3).window(-1, 1).map(Window::max)
 







window
default Seq<Window<T>> window(Comparator<? super T> orderBy)
Map this stream to a windowed stream using the default partition and a specific order.
 
 
 // (0, 1, 4, 2, 3)
 Seq.of(1, 2, 4, 2, 3).window(naturalOrder()).map(Window::rowNumber)
 







window
default Seq<Window<T>> window(Comparator<? super T> orderBy,
                              long lower,
                              long upper)
Map this stream to a windowed stream using the default partition and a specific order with frame.
 
 
 // (1, 1, 3, 2, 2)
 Seq.of(1, 2, 4, 2, 3).window(naturalOrder(), -1, 1).map(Window::min)
 







window
default <U> Seq<Window<T>> window(java.util.function.Function<? super T,? extends U> partitionBy)
Map this stream to a windowed stream using a specific partition and the default order.
 
 
 // (1, 2, 2, 2, 1)
 Seq.of(1, 2, 4, 2, 3).window(i -> i % 2).map(Window::min)
 







window
default <U> Seq<Window<T>> window(java.util.function.Function<? super T,? extends U> partitionBy,
                                  long lower,
                                  long upper)
Map this stream to a windowed stream using a specific partition and the default order.
 
 
 // (3, 4, 4, 2, 3)
 Seq.of(1, 4, 2, 2, 3).window(i -> i % 2, -1, 1).map(Window::max)
 







window
default <U> Seq<Window<T>> window(java.util.function.Function<? super T,? extends U> partitionBy,
                                  Comparator<? super T> orderBy)
Map this stream to a windowed stream using a specific partition and order.
 
 
 // (1, 2, 4, 4, 3)
 Seq.of(1, 2, 4, 2, 3).window(i -> i % 2, naturalOrder()).map(Window::max)
 







window
default <U> Seq<Window<T>> window(java.util.function.Function<? super T,? extends U> partitionBy,
                                  Comparator<? super T> orderBy,
                                  long lower,
                                  long upper)
Map this stream to a windowed stream using a specific partition and order with frame.
 
 
 // (3, 2, 4, 4, 3)
 Seq.of(1, 2, 4, 2, 3).window(i -> i % 2, naturalOrder(), -1, 1).map(Window::max)
 







window
@Generated(value="This method was generated using jOOQ-tools")
default Seq<Tuple1<Window<T>>> window(WindowSpecification<T> specification1)
Map this stream to a windowed stream with 1 distinct windows.







window
@Generated(value="This method was generated using jOOQ-tools")
default Seq<Tuple2<Window<T>,Window<T>>> window(WindowSpecification<T> specification1,
                                                                                                                WindowSpecification<T> specification2)
Map this stream to a windowed stream with 2 distinct windows.







window
@Generated(value="This method was generated using jOOQ-tools")
default Seq<Tuple3<Window<T>,Window<T>,Window<T>>> window(WindowSpecification<T> specification1,
                                                                                                                          WindowSpecification<T> specification2,
                                                                                                                          WindowSpecification<T> specification3)
Map this stream to a windowed stream with 3 distinct windows.







window
@Generated(value="This method was generated using jOOQ-tools")
default Seq<Tuple4<Window<T>,Window<T>,Window<T>,Window<T>>> window(WindowSpecification<T> specification1,
                                                                                                                                    WindowSpecification<T> specification2,
                                                                                                                                    WindowSpecification<T> specification3,
                                                                                                                                    WindowSpecification<T> specification4)
Map this stream to a windowed stream with 4 distinct windows.







window
@Generated(value="This method was generated using jOOQ-tools")
default Seq<Tuple5<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>> window(WindowSpecification<T> specification1,
                                                                                                                                              WindowSpecification<T> specification2,
                                                                                                                                              WindowSpecification<T> specification3,
                                                                                                                                              WindowSpecification<T> specification4,
                                                                                                                                              WindowSpecification<T> specification5)
Map this stream to a windowed stream with 5 distinct windows.







window
@Generated(value="This method was generated using jOOQ-tools")
default Seq<Tuple6<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>> window(WindowSpecification<T> specification1,
                                                                                                                                                        WindowSpecification<T> specification2,
                                                                                                                                                        WindowSpecification<T> specification3,
                                                                                                                                                        WindowSpecification<T> specification4,
                                                                                                                                                        WindowSpecification<T> specification5,
                                                                                                                                                        WindowSpecification<T> specification6)
Map this stream to a windowed stream with 6 distinct windows.







window
@Generated(value="This method was generated using jOOQ-tools")
default Seq<Tuple7<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>> window(WindowSpecification<T> specification1,
                                                                                                                                                                  WindowSpecification<T> specification2,
                                                                                                                                                                  WindowSpecification<T> specification3,
                                                                                                                                                                  WindowSpecification<T> specification4,
                                                                                                                                                                  WindowSpecification<T> specification5,
                                                                                                                                                                  WindowSpecification<T> specification6,
                                                                                                                                                                  WindowSpecification<T> specification7)
Map this stream to a windowed stream with 7 distinct windows.







window
@Generated(value="This method was generated using jOOQ-tools")
default Seq<Tuple8<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>> window(WindowSpecification<T> specification1,
                                                                                                                                                                            WindowSpecification<T> specification2,
                                                                                                                                                                            WindowSpecification<T> specification3,
                                                                                                                                                                            WindowSpecification<T> specification4,
                                                                                                                                                                            WindowSpecification<T> specification5,
                                                                                                                                                                            WindowSpecification<T> specification6,
                                                                                                                                                                            WindowSpecification<T> specification7,
                                                                                                                                                                            WindowSpecification<T> specification8)
Map this stream to a windowed stream with 8 distinct windows.







window
@Generated(value="This method was generated using jOOQ-tools")
default Seq<Tuple9<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>> window(WindowSpecification<T> specification1,
                                                                                                                                                                                      WindowSpecification<T> specification2,
                                                                                                                                                                                      WindowSpecification<T> specification3,
                                                                                                                                                                                      WindowSpecification<T> specification4,
                                                                                                                                                                                      WindowSpecification<T> specification5,
                                                                                                                                                                                      WindowSpecification<T> specification6,
                                                                                                                                                                                      WindowSpecification<T> specification7,
                                                                                                                                                                                      WindowSpecification<T> specification8,
                                                                                                                                                                                      WindowSpecification<T> specification9)
Map this stream to a windowed stream with 9 distinct windows.







window
@Generated(value="This method was generated using jOOQ-tools")
default Seq<Tuple10<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>> window(WindowSpecification<T> specification1,
                                                                                                                                                                                                 WindowSpecification<T> specification2,
                                                                                                                                                                                                 WindowSpecification<T> specification3,
                                                                                                                                                                                                 WindowSpecification<T> specification4,
                                                                                                                                                                                                 WindowSpecification<T> specification5,
                                                                                                                                                                                                 WindowSpecification<T> specification6,
                                                                                                                                                                                                 WindowSpecification<T> specification7,
                                                                                                                                                                                                 WindowSpecification<T> specification8,
                                                                                                                                                                                                 WindowSpecification<T> specification9,
                                                                                                                                                                                                 WindowSpecification<T> specification10)
Map this stream to a windowed stream with 10 distinct windows.







window
@Generated(value="This method was generated using jOOQ-tools")
default Seq<Tuple11<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>> window(WindowSpecification<T> specification1,
                                                                                                                                                                                                           WindowSpecification<T> specification2,
                                                                                                                                                                                                           WindowSpecification<T> specification3,
                                                                                                                                                                                                           WindowSpecification<T> specification4,
                                                                                                                                                                                                           WindowSpecification<T> specification5,
                                                                                                                                                                                                           WindowSpecification<T> specification6,
                                                                                                                                                                                                           WindowSpecification<T> specification7,
                                                                                                                                                                                                           WindowSpecification<T> specification8,
                                                                                                                                                                                                           WindowSpecification<T> specification9,
                                                                                                                                                                                                           WindowSpecification<T> specification10,
                                                                                                                                                                                                           WindowSpecification<T> specification11)
Map this stream to a windowed stream with 11 distinct windows.







window
@Generated(value="This method was generated using jOOQ-tools")
default Seq<Tuple12<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>> window(WindowSpecification<T> specification1,
                                                                                                                                                                                                                     WindowSpecification<T> specification2,
                                                                                                                                                                                                                     WindowSpecification<T> specification3,
                                                                                                                                                                                                                     WindowSpecification<T> specification4,
                                                                                                                                                                                                                     WindowSpecification<T> specification5,
                                                                                                                                                                                                                     WindowSpecification<T> specification6,
                                                                                                                                                                                                                     WindowSpecification<T> specification7,
                                                                                                                                                                                                                     WindowSpecification<T> specification8,
                                                                                                                                                                                                                     WindowSpecification<T> specification9,
                                                                                                                                                                                                                     WindowSpecification<T> specification10,
                                                                                                                                                                                                                     WindowSpecification<T> specification11,
                                                                                                                                                                                                                     WindowSpecification<T> specification12)
Map this stream to a windowed stream with 12 distinct windows.







window
@Generated(value="This method was generated using jOOQ-tools")
default Seq<Tuple13<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>> window(WindowSpecification<T> specification1,
                                                                                                                                                                                                                               WindowSpecification<T> specification2,
                                                                                                                                                                                                                               WindowSpecification<T> specification3,
                                                                                                                                                                                                                               WindowSpecification<T> specification4,
                                                                                                                                                                                                                               WindowSpecification<T> specification5,
                                                                                                                                                                                                                               WindowSpecification<T> specification6,
                                                                                                                                                                                                                               WindowSpecification<T> specification7,
                                                                                                                                                                                                                               WindowSpecification<T> specification8,
                                                                                                                                                                                                                               WindowSpecification<T> specification9,
                                                                                                                                                                                                                               WindowSpecification<T> specification10,
                                                                                                                                                                                                                               WindowSpecification<T> specification11,
                                                                                                                                                                                                                               WindowSpecification<T> specification12,
                                                                                                                                                                                                                               WindowSpecification<T> specification13)
Map this stream to a windowed stream with 13 distinct windows.







window
@Generated(value="This method was generated using jOOQ-tools")
default Seq<Tuple14<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>> window(WindowSpecification<T> specification1,
                                                                                                                                                                                                                                         WindowSpecification<T> specification2,
                                                                                                                                                                                                                                         WindowSpecification<T> specification3,
                                                                                                                                                                                                                                         WindowSpecification<T> specification4,
                                                                                                                                                                                                                                         WindowSpecification<T> specification5,
                                                                                                                                                                                                                                         WindowSpecification<T> specification6,
                                                                                                                                                                                                                                         WindowSpecification<T> specification7,
                                                                                                                                                                                                                                         WindowSpecification<T> specification8,
                                                                                                                                                                                                                                         WindowSpecification<T> specification9,
                                                                                                                                                                                                                                         WindowSpecification<T> specification10,
                                                                                                                                                                                                                                         WindowSpecification<T> specification11,
                                                                                                                                                                                                                                         WindowSpecification<T> specification12,
                                                                                                                                                                                                                                         WindowSpecification<T> specification13,
                                                                                                                                                                                                                                         WindowSpecification<T> specification14)
Map this stream to a windowed stream with 14 distinct windows.







window
@Generated(value="This method was generated using jOOQ-tools")
default Seq<Tuple15<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>> window(WindowSpecification<T> specification1,
                                                                                                                                                                                                                                                   WindowSpecification<T> specification2,
                                                                                                                                                                                                                                                   WindowSpecification<T> specification3,
                                                                                                                                                                                                                                                   WindowSpecification<T> specification4,
                                                                                                                                                                                                                                                   WindowSpecification<T> specification5,
                                                                                                                                                                                                                                                   WindowSpecification<T> specification6,
                                                                                                                                                                                                                                                   WindowSpecification<T> specification7,
                                                                                                                                                                                                                                                   WindowSpecification<T> specification8,
                                                                                                                                                                                                                                                   WindowSpecification<T> specification9,
                                                                                                                                                                                                                                                   WindowSpecification<T> specification10,
                                                                                                                                                                                                                                                   WindowSpecification<T> specification11,
                                                                                                                                                                                                                                                   WindowSpecification<T> specification12,
                                                                                                                                                                                                                                                   WindowSpecification<T> specification13,
                                                                                                                                                                                                                                                   WindowSpecification<T> specification14,
                                                                                                                                                                                                                                                   WindowSpecification<T> specification15)
Map this stream to a windowed stream with 15 distinct windows.







window
@Generated(value="This method was generated using jOOQ-tools")
default Seq<Tuple16<Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>,Window<T>>> window(WindowSpecification<T> specification1,
                                                                                                                                                                                                                                                             WindowSpecification<T> specification2,
                                                                                                                                                                                                                                                             WindowSpecification<T> specification3,
                                                                                                                                                                                                                                                             WindowSpecification<T> specification4,
                                                                                                                                                                                                                                                             WindowSpecification<T> specification5,
                                                                                                                                                                                                                                                             WindowSpecification<T> specification6,
                                                                                                                                                                                                                                                             WindowSpecification<T> specification7,
                                                                                                                                                                                                                                                             WindowSpecification<T> specification8,
                                                                                                                                                                                                                                                             WindowSpecification<T> specification9,
                                                                                                                                                                                                                                                             WindowSpecification<T> specification10,
                                                                                                                                                                                                                                                             WindowSpecification<T> specification11,
                                                                                                                                                                                                                                                             WindowSpecification<T> specification12,
                                                                                                                                                                                                                                                             WindowSpecification<T> specification13,
                                                                                                                                                                                                                                                             WindowSpecification<T> specification14,
                                                                                                                                                                                                                                                             WindowSpecification<T> specification15,
                                                                                                                                                                                                                                                             WindowSpecification<T> specification16)
Map this stream to a windowed stream with 16 distinct windows.







groupBy
default <K> Map<K,List<T>> groupBy(java.util.function.Function<? super T,? extends K> classifier)
Shortcut for calling Stream.collect(Collector) with a
 Collectors.groupingBy(Function) collector.







groupBy
default <K,A,D> Map<K,D> groupBy(java.util.function.Function<? super T,? extends K> classifier,
                                 java.util.stream.Collector<? super T,A,D> downstream)
Shortcut for calling Stream.collect(Collector) with a
 Collectors.groupingBy(Function, Collector) collector.







groupBy
default <K,D,A,M extends Map<K,D>> M groupBy(java.util.function.Function<? super T,? extends K> classifier,
                                             java.util.function.Supplier<M> mapFactory,
                                             java.util.stream.Collector<? super T,A,D> downstream)
Shortcut for calling Stream.collect(Collector) with a
 Collectors.groupingBy(Function, Supplier, Collector) collector.







join
@Deprecated
default String join()
Deprecated. - Use #toString() instead. This method will be
 removed in the future as it causes confusion with
 innerJoin(Seq, BiPredicate).
Shortcut for calling Stream.collect(Collector) with a
 Collectors.joining()
 collector.







join
@Deprecated
default String join(CharSequence delimiter)
Deprecated. - Use Collectable.toString(CharSequence) instead. This method
 will be removed in the future as it causes confusion with
 innerJoin(Seq, BiPredicate).
Shortcut for calling Stream.collect(Collector) with a
 Collectors.joining(CharSequence)
 collector.







join
@Deprecated
default String join(CharSequence delimiter,
                                 CharSequence prefix,
                                 CharSequence suffix)
Deprecated. - Use
 Collectable.toString(CharSequence, CharSequence, CharSequence) instead. This
 method will be removed in the future as it causes confusion with
 innerJoin(Seq, BiPredicate).
Shortcut for calling Stream.collect(Collector) with a
 Collectors.joining(CharSequence, CharSequence, CharSequence)
 collector.









of
static <T> Seq<T> of(T value)

Specified by:
of in interface java.util.stream.Stream<T>
See Also:
Stream.of(Object)










of
@SafeVarargs
static <T> Seq<T> of(T... values)

Specified by:
of in interface java.util.stream.Stream<T>
See Also:
Stream.of(Object[])








range
static Seq<Byte> range(byte from,
                       byte to)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (exclusive)








range
static Seq<Byte> range(byte from,
                       byte to,
                       int step)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (exclusive)
step - The increase between two values








range
static Seq<Short> range(short from,
                        short to)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (exclusive)








range
static Seq<Short> range(short from,
                        short to,
                        int step)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (exclusive)
step - The increase between two values








range
static Seq<Character> range(char from,
                            char to)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (exclusive)








range
static Seq<Character> range(char from,
                            char to,
                            int step)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (exclusive)
step - The increase between two values








range
static Seq<Integer> range(int from,
                          int to)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (exclusive)








range
static Seq<Integer> range(int from,
                          int to,
                          int step)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (exclusive)
step - The increase between two values








range
static Seq<Long> range(long from,
                       long to)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (exclusive)








range
static Seq<Long> range(long from,
                       long to,
                       long step)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (exclusive)
step - The increase between two values








range
static Seq<java.time.Instant> range(java.time.Instant from,
                                    java.time.Instant to)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (exclusive)








range
static Seq<java.time.Instant> range(java.time.Instant from,
                                    java.time.Instant to,
                                    java.time.Duration step)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (exclusive)
step - The increase between two values








rangeClosed
static Seq<Byte> rangeClosed(byte from,
                             byte to)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (inclusive)








rangeClosed
static Seq<Byte> rangeClosed(byte from,
                             byte to,
                             int step)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (inclusive)
step - The increase between two values








rangeClosed
static Seq<Short> rangeClosed(short from,
                              short to)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (inclusive)








rangeClosed
static Seq<Short> rangeClosed(short from,
                              short to,
                              int step)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (inclusive)
step - The increase between two values








rangeClosed
static Seq<Character> rangeClosed(char from,
                                  char to)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (inclusive)








rangeClosed
static Seq<Character> rangeClosed(char from,
                                  char to,
                                  int step)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (inclusive)
step - The increase between two values








rangeClosed
static Seq<Integer> rangeClosed(int from,
                                int to)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (inclusive)








rangeClosed
static Seq<Integer> rangeClosed(int from,
                                int to,
                                int step)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (inclusive)
step - The increase between two values








rangeClosed
static Seq<Long> rangeClosed(long from,
                             long to)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (inclusive)








rangeClosed
static Seq<Long> rangeClosed(long from,
                             long to,
                             long step)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (inclusive)
step - The increase between two values








rangeClosed
static Seq<java.time.Instant> rangeClosed(java.time.Instant from,
                                          java.time.Instant to)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (exclusive)








rangeClosed
static Seq<java.time.Instant> rangeClosed(java.time.Instant from,
                                          java.time.Instant to,
                                          java.time.Duration step)
The range between two values.

Parameters:
from - The lower bound (inclusive)
to - The upper bound (exclusive)
step - The increase between two values








empty
static <T> Seq<T> empty()

Specified by:
empty in interface java.util.stream.Stream<T>
See Also:
Stream.empty()










iterate
static <T> Seq<T> iterate(T seed,
                          java.util.function.UnaryOperator<T> f)

Specified by:
iterate in interface java.util.stream.Stream<T>
See Also:
Stream.iterate(Object, UnaryOperator)








generate
static Seq<Void> generate()

See Also:
Stream.generate(Supplier)










generate
static <T> Seq<T> generate(T value)

Specified by:
generate in interface java.util.stream.Stream<T>
See Also:
Stream.generate(Supplier)








generate
static <T> Seq<T> generate(java.util.function.Supplier<T> s)

Specified by:
generate in interface java.util.stream.Stream<T>
See Also:
Stream.generate(Supplier)








seq
static <T> Seq<T> seq(java.util.stream.Stream<T> stream)
Wrap a Stream into a Seq.







seq
static <T> Seq<T> seq(Seq<T> stream)
Wrap a Stream into a Seq.







seq
static Seq<Integer> seq(java.util.stream.IntStream stream)
Wrap a IntStream into a Seq.







seq
static Seq<Long> seq(java.util.stream.LongStream stream)
Wrap a IntStream into a Seq.







seq
static Seq<Double> seq(java.util.stream.DoubleStream stream)
Wrap a IntStream into a Seq.







seq
static <T> Seq<T> seq(Iterable<T> iterable)
Wrap an Iterable into a Seq.







seq
static <T> Seq<T> seq(Iterator<T> iterator)
Wrap an Iterator into a Seq.







seq
static <T> Seq<T> seq(Spliterator<T> spliterator)
Wrap a Spliterator into a Seq.







seq
static <K,V> Seq<Tuple2<K,V>> seq(Map<K,V> map)
Wrap a Map into a Seq.







seq
static <T> Seq<T> seq(Optional<T> optional)
Wrap an Optional into a Seq.







seq
static Seq<Byte> seq(InputStream is)
Wrap an InputStream into a Seq.
 
 Client code must close the InputStream. All
 IOException's thrown be the InputStream are wrapped
 by UncheckedIOException's.







seq
static Seq<Character> seq(Reader reader)
Wrap a Reader into a Seq.
 
 Client code must close the Reader. All
 IOException's thrown be the InputStream are wrapped
 by UncheckedIOException's.







cycle
static <T> Seq<T> cycle(java.util.stream.Stream<T> stream)
Repeat a stream infinitely.
 
 
 // (1, 2, 3, 1, 2, 3, ...)
 Seq.of(1, 2, 3).cycle();
 







cycle
static <T> Seq<T> cycle(Iterable<T> iterable)
Repeat a stream infinitely.
 
 
 // (1, 2, 3, 1, 2, 3, ...)
 Seq.of(1, 2, 3).cycle();
 







cycle
static <T> Seq<T> cycle(Seq<T> stream)
Repeat a stream infinitely.
 
 
 // (1, 2, 3, 1, 2, 3, ...)
 Seq.of(1, 2, 3).cycle();
 







unzip
static <T1,T2> Tuple2<Seq<T1>,Seq<T2>> unzip(java.util.stream.Stream<Tuple2<T1,T2>> stream)
Unzip one Stream into two.
 
 
 // tuple((1, 2, 3), (a, b, c))
 Seq.unzip(Seq.of(tuple(1, "a"), tuple(2, "b"), tuple(3, "c")));
 







unzip
static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>> unzip(java.util.stream.Stream<Tuple2<T1,T2>> stream,
                                                   java.util.function.Function<T1,U1> leftUnzipper,
                                                   java.util.function.Function<T2,U2> rightUnzipper)
Unzip one Stream into two.
 
 
 // tuple((1, 2, 3), (a, b, c))
 Seq.unzip(Seq.of(tuple(1, "a"), tuple(2, "b"), tuple(3, "c")));
 







unzip
static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>> unzip(java.util.stream.Stream<Tuple2<T1,T2>> stream,
                                                   java.util.function.Function<Tuple2<T1,T2>,Tuple2<U1,U2>> unzipper)
Unzip one Stream into two.
 
 
 // tuple((1, 2, 3), (a, b, c))
 Seq.unzip(Seq.of(tuple(1, "a"), tuple(2, "b"), tuple(3, "c")));
 







unzip
static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>> unzip(java.util.stream.Stream<Tuple2<T1,T2>> stream,
                                                   java.util.function.BiFunction<T1,T2,Tuple2<U1,U2>> unzipper)
Unzip one Stream into two.
 
 
 // tuple((1, 2, 3), (a, b, c))
 Seq.unzip(Seq.of(tuple(1, "a"), tuple(2, "b"), tuple(3, "c")));
 







unzip
static <T1,T2> Tuple2<Seq<T1>,Seq<T2>> unzip(Iterable<Tuple2<T1,T2>> iterable)
Unzip one Stream into two.
 
 
 // tuple((1, 2, 3), (a, b, c))
 Seq.unzip(Seq.of(tuple(1, "a"), tuple(2, "b"), tuple(3, "c")));
 







unzip
static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>> unzip(Iterable<Tuple2<T1,T2>> iterable,
                                                   java.util.function.Function<T1,U1> leftUnzipper,
                                                   java.util.function.Function<T2,U2> rightUnzipper)
Unzip one Stream into two.
 
 
 // tuple((1, 2, 3), (a, b, c))
 Seq.unzip(Seq.of(tuple(1, "a"), tuple(2, "b"), tuple(3, "c")));
 







unzip
static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>> unzip(Iterable<Tuple2<T1,T2>> iterable,
                                                   java.util.function.Function<Tuple2<T1,T2>,Tuple2<U1,U2>> unzipper)
Unzip one Stream into two.
 
 
 // tuple((1, 2, 3), (a, b, c))
 Seq.unzip(Seq.of(tuple(1, "a"), tuple(2, "b"), tuple(3, "c")));
 







unzip
static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>> unzip(Iterable<Tuple2<T1,T2>> iterable,
                                                   java.util.function.BiFunction<T1,T2,Tuple2<U1,U2>> unzipper)
Unzip one Stream into two.
 
 
 // tuple((1, 2, 3), (a, b, c))
 Seq.unzip(Seq.of(tuple(1, "a"), tuple(2, "b"), tuple(3, "c")));
 







unzip
static <T1,T2> Tuple2<Seq<T1>,Seq<T2>> unzip(Seq<Tuple2<T1,T2>> stream)
Unzip one Stream into two.
 
 
 // tuple((1, 2, 3), (a, b, c))
 Seq.unzip(Seq.of(tuple(1, "a"), tuple(2, "b"), tuple(3, "c")));
 







unzip
static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>> unzip(Seq<Tuple2<T1,T2>> stream,
                                                   java.util.function.Function<T1,U1> leftUnzipper,
                                                   java.util.function.Function<T2,U2> rightUnzipper)
Unzip one Stream into two.
 
 
 // tuple((1, 2, 3), (a, b, c))
 Seq.unzip(Seq.of(tuple(1, "a"), tuple(2, "b"), tuple(3, "c")));
 







unzip
static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>> unzip(Seq<Tuple2<T1,T2>> stream,
                                                   java.util.function.Function<Tuple2<T1,T2>,Tuple2<U1,U2>> unzipper)
Unzip one Stream into two.
 
 
 // tuple((1, 2, 3), (a, b, c))
 Seq.unzip(Seq.of(tuple(1, "a"), tuple(2, "b"), tuple(3, "c")));
 







unzip
static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>> unzip(Seq<Tuple2<T1,T2>> stream,
                                                   java.util.function.BiFunction<T1,T2,Tuple2<U1,U2>> unzipper)
Unzip one Stream into two.
 
 
 // tuple((1, 2, 3), (a, b, c))
 Seq.unzip(Seq.of(tuple(1, "a"), tuple(2, "b"), tuple(3, "c")));
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2> Seq<Tuple2<T1,T2>> zip(java.util.stream.Stream<T1> s1,
                                                                                                      java.util.stream.Stream<T2> s2)
Zip 2 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3> Seq<Tuple3<T1,T2,T3>> zip(java.util.stream.Stream<T1> s1,
                                                                                                            java.util.stream.Stream<T2> s2,
                                                                                                            java.util.stream.Stream<T3> s3)
Zip 3 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4> Seq<Tuple4<T1,T2,T3,T4>> zip(java.util.stream.Stream<T1> s1,
                                                                                                                  java.util.stream.Stream<T2> s2,
                                                                                                                  java.util.stream.Stream<T3> s3,
                                                                                                                  java.util.stream.Stream<T4> s4)
Zip 4 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5> Seq<Tuple5<T1,T2,T3,T4,T5>> zip(java.util.stream.Stream<T1> s1,
                                                                                                                        java.util.stream.Stream<T2> s2,
                                                                                                                        java.util.stream.Stream<T3> s3,
                                                                                                                        java.util.stream.Stream<T4> s4,
                                                                                                                        java.util.stream.Stream<T5> s5)
Zip 5 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6> Seq<Tuple6<T1,T2,T3,T4,T5,T6>> zip(java.util.stream.Stream<T1> s1,
                                                                                                                              java.util.stream.Stream<T2> s2,
                                                                                                                              java.util.stream.Stream<T3> s3,
                                                                                                                              java.util.stream.Stream<T4> s4,
                                                                                                                              java.util.stream.Stream<T5> s5,
                                                                                                                              java.util.stream.Stream<T6> s6)
Zip 6 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7> Seq<Tuple7<T1,T2,T3,T4,T5,T6,T7>> zip(java.util.stream.Stream<T1> s1,
                                                                                                                                    java.util.stream.Stream<T2> s2,
                                                                                                                                    java.util.stream.Stream<T3> s3,
                                                                                                                                    java.util.stream.Stream<T4> s4,
                                                                                                                                    java.util.stream.Stream<T5> s5,
                                                                                                                                    java.util.stream.Stream<T6> s6,
                                                                                                                                    java.util.stream.Stream<T7> s7)
Zip 7 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8> Seq<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>> zip(java.util.stream.Stream<T1> s1,
                                                                                                                                          java.util.stream.Stream<T2> s2,
                                                                                                                                          java.util.stream.Stream<T3> s3,
                                                                                                                                          java.util.stream.Stream<T4> s4,
                                                                                                                                          java.util.stream.Stream<T5> s5,
                                                                                                                                          java.util.stream.Stream<T6> s6,
                                                                                                                                          java.util.stream.Stream<T7> s7,
                                                                                                                                          java.util.stream.Stream<T8> s8)
Zip 8 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Seq<Tuple9<T1,T2,T3,T4,T5,T6,T7,T8,T9>> zip(java.util.stream.Stream<T1> s1,
                                                                                                                                                java.util.stream.Stream<T2> s2,
                                                                                                                                                java.util.stream.Stream<T3> s3,
                                                                                                                                                java.util.stream.Stream<T4> s4,
                                                                                                                                                java.util.stream.Stream<T5> s5,
                                                                                                                                                java.util.stream.Stream<T6> s6,
                                                                                                                                                java.util.stream.Stream<T7> s7,
                                                                                                                                                java.util.stream.Stream<T8> s8,
                                                                                                                                                java.util.stream.Stream<T9> s9)
Zip 9 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Seq<Tuple10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>> zip(java.util.stream.Stream<T1> s1,
                                                                                                                                                         java.util.stream.Stream<T2> s2,
                                                                                                                                                         java.util.stream.Stream<T3> s3,
                                                                                                                                                         java.util.stream.Stream<T4> s4,
                                                                                                                                                         java.util.stream.Stream<T5> s5,
                                                                                                                                                         java.util.stream.Stream<T6> s6,
                                                                                                                                                         java.util.stream.Stream<T7> s7,
                                                                                                                                                         java.util.stream.Stream<T8> s8,
                                                                                                                                                         java.util.stream.Stream<T9> s9,
                                                                                                                                                         java.util.stream.Stream<T10> s10)
Zip 10 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Seq<Tuple11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>> zip(java.util.stream.Stream<T1> s1,
                                                                                                                                                                 java.util.stream.Stream<T2> s2,
                                                                                                                                                                 java.util.stream.Stream<T3> s3,
                                                                                                                                                                 java.util.stream.Stream<T4> s4,
                                                                                                                                                                 java.util.stream.Stream<T5> s5,
                                                                                                                                                                 java.util.stream.Stream<T6> s6,
                                                                                                                                                                 java.util.stream.Stream<T7> s7,
                                                                                                                                                                 java.util.stream.Stream<T8> s8,
                                                                                                                                                                 java.util.stream.Stream<T9> s9,
                                                                                                                                                                 java.util.stream.Stream<T10> s10,
                                                                                                                                                                 java.util.stream.Stream<T11> s11)
Zip 11 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Seq<Tuple12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>> zip(java.util.stream.Stream<T1> s1,
                                                                                                                                                                         java.util.stream.Stream<T2> s2,
                                                                                                                                                                         java.util.stream.Stream<T3> s3,
                                                                                                                                                                         java.util.stream.Stream<T4> s4,
                                                                                                                                                                         java.util.stream.Stream<T5> s5,
                                                                                                                                                                         java.util.stream.Stream<T6> s6,
                                                                                                                                                                         java.util.stream.Stream<T7> s7,
                                                                                                                                                                         java.util.stream.Stream<T8> s8,
                                                                                                                                                                         java.util.stream.Stream<T9> s9,
                                                                                                                                                                         java.util.stream.Stream<T10> s10,
                                                                                                                                                                         java.util.stream.Stream<T11> s11,
                                                                                                                                                                         java.util.stream.Stream<T12> s12)
Zip 12 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Seq<Tuple13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>> zip(java.util.stream.Stream<T1> s1,
                                                                                                                                                                                 java.util.stream.Stream<T2> s2,
                                                                                                                                                                                 java.util.stream.Stream<T3> s3,
                                                                                                                                                                                 java.util.stream.Stream<T4> s4,
                                                                                                                                                                                 java.util.stream.Stream<T5> s5,
                                                                                                                                                                                 java.util.stream.Stream<T6> s6,
                                                                                                                                                                                 java.util.stream.Stream<T7> s7,
                                                                                                                                                                                 java.util.stream.Stream<T8> s8,
                                                                                                                                                                                 java.util.stream.Stream<T9> s9,
                                                                                                                                                                                 java.util.stream.Stream<T10> s10,
                                                                                                                                                                                 java.util.stream.Stream<T11> s11,
                                                                                                                                                                                 java.util.stream.Stream<T12> s12,
                                                                                                                                                                                 java.util.stream.Stream<T13> s13)
Zip 13 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Seq<Tuple14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>> zip(java.util.stream.Stream<T1> s1,
                                                                                                                                                                                         java.util.stream.Stream<T2> s2,
                                                                                                                                                                                         java.util.stream.Stream<T3> s3,
                                                                                                                                                                                         java.util.stream.Stream<T4> s4,
                                                                                                                                                                                         java.util.stream.Stream<T5> s5,
                                                                                                                                                                                         java.util.stream.Stream<T6> s6,
                                                                                                                                                                                         java.util.stream.Stream<T7> s7,
                                                                                                                                                                                         java.util.stream.Stream<T8> s8,
                                                                                                                                                                                         java.util.stream.Stream<T9> s9,
                                                                                                                                                                                         java.util.stream.Stream<T10> s10,
                                                                                                                                                                                         java.util.stream.Stream<T11> s11,
                                                                                                                                                                                         java.util.stream.Stream<T12> s12,
                                                                                                                                                                                         java.util.stream.Stream<T13> s13,
                                                                                                                                                                                         java.util.stream.Stream<T14> s14)
Zip 14 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Seq<Tuple15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>> zip(java.util.stream.Stream<T1> s1,
                                                                                                                                                                                                 java.util.stream.Stream<T2> s2,
                                                                                                                                                                                                 java.util.stream.Stream<T3> s3,
                                                                                                                                                                                                 java.util.stream.Stream<T4> s4,
                                                                                                                                                                                                 java.util.stream.Stream<T5> s5,
                                                                                                                                                                                                 java.util.stream.Stream<T6> s6,
                                                                                                                                                                                                 java.util.stream.Stream<T7> s7,
                                                                                                                                                                                                 java.util.stream.Stream<T8> s8,
                                                                                                                                                                                                 java.util.stream.Stream<T9> s9,
                                                                                                                                                                                                 java.util.stream.Stream<T10> s10,
                                                                                                                                                                                                 java.util.stream.Stream<T11> s11,
                                                                                                                                                                                                 java.util.stream.Stream<T12> s12,
                                                                                                                                                                                                 java.util.stream.Stream<T13> s13,
                                                                                                                                                                                                 java.util.stream.Stream<T14> s14,
                                                                                                                                                                                                 java.util.stream.Stream<T15> s15)
Zip 15 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Seq<Tuple16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>> zip(java.util.stream.Stream<T1> s1,
                                                                                                                                                                                                         java.util.stream.Stream<T2> s2,
                                                                                                                                                                                                         java.util.stream.Stream<T3> s3,
                                                                                                                                                                                                         java.util.stream.Stream<T4> s4,
                                                                                                                                                                                                         java.util.stream.Stream<T5> s5,
                                                                                                                                                                                                         java.util.stream.Stream<T6> s6,
                                                                                                                                                                                                         java.util.stream.Stream<T7> s7,
                                                                                                                                                                                                         java.util.stream.Stream<T8> s8,
                                                                                                                                                                                                         java.util.stream.Stream<T9> s9,
                                                                                                                                                                                                         java.util.stream.Stream<T10> s10,
                                                                                                                                                                                                         java.util.stream.Stream<T11> s11,
                                                                                                                                                                                                         java.util.stream.Stream<T12> s12,
                                                                                                                                                                                                         java.util.stream.Stream<T13> s13,
                                                                                                                                                                                                         java.util.stream.Stream<T14> s14,
                                                                                                                                                                                                         java.util.stream.Stream<T15> s15,
                                                                                                                                                                                                         java.util.stream.Stream<T16> s16)
Zip 16 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2> Seq<Tuple2<T1,T2>> zip(Iterable<T1> i1,
                                                                                                      Iterable<T2> i2)
Zip 2 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3> Seq<Tuple3<T1,T2,T3>> zip(Iterable<T1> i1,
                                                                                                            Iterable<T2> i2,
                                                                                                            Iterable<T3> i3)
Zip 3 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4> Seq<Tuple4<T1,T2,T3,T4>> zip(Iterable<T1> i1,
                                                                                                                  Iterable<T2> i2,
                                                                                                                  Iterable<T3> i3,
                                                                                                                  Iterable<T4> i4)
Zip 4 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5> Seq<Tuple5<T1,T2,T3,T4,T5>> zip(Iterable<T1> i1,
                                                                                                                        Iterable<T2> i2,
                                                                                                                        Iterable<T3> i3,
                                                                                                                        Iterable<T4> i4,
                                                                                                                        Iterable<T5> i5)
Zip 5 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6> Seq<Tuple6<T1,T2,T3,T4,T5,T6>> zip(Iterable<T1> i1,
                                                                                                                              Iterable<T2> i2,
                                                                                                                              Iterable<T3> i3,
                                                                                                                              Iterable<T4> i4,
                                                                                                                              Iterable<T5> i5,
                                                                                                                              Iterable<T6> i6)
Zip 6 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7> Seq<Tuple7<T1,T2,T3,T4,T5,T6,T7>> zip(Iterable<T1> i1,
                                                                                                                                    Iterable<T2> i2,
                                                                                                                                    Iterable<T3> i3,
                                                                                                                                    Iterable<T4> i4,
                                                                                                                                    Iterable<T5> i5,
                                                                                                                                    Iterable<T6> i6,
                                                                                                                                    Iterable<T7> i7)
Zip 7 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8> Seq<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>> zip(Iterable<T1> i1,
                                                                                                                                          Iterable<T2> i2,
                                                                                                                                          Iterable<T3> i3,
                                                                                                                                          Iterable<T4> i4,
                                                                                                                                          Iterable<T5> i5,
                                                                                                                                          Iterable<T6> i6,
                                                                                                                                          Iterable<T7> i7,
                                                                                                                                          Iterable<T8> i8)
Zip 8 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Seq<Tuple9<T1,T2,T3,T4,T5,T6,T7,T8,T9>> zip(Iterable<T1> i1,
                                                                                                                                                Iterable<T2> i2,
                                                                                                                                                Iterable<T3> i3,
                                                                                                                                                Iterable<T4> i4,
                                                                                                                                                Iterable<T5> i5,
                                                                                                                                                Iterable<T6> i6,
                                                                                                                                                Iterable<T7> i7,
                                                                                                                                                Iterable<T8> i8,
                                                                                                                                                Iterable<T9> i9)
Zip 9 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Seq<Tuple10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>> zip(Iterable<T1> i1,
                                                                                                                                                         Iterable<T2> i2,
                                                                                                                                                         Iterable<T3> i3,
                                                                                                                                                         Iterable<T4> i4,
                                                                                                                                                         Iterable<T5> i5,
                                                                                                                                                         Iterable<T6> i6,
                                                                                                                                                         Iterable<T7> i7,
                                                                                                                                                         Iterable<T8> i8,
                                                                                                                                                         Iterable<T9> i9,
                                                                                                                                                         Iterable<T10> i10)
Zip 10 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Seq<Tuple11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>> zip(Iterable<T1> i1,
                                                                                                                                                                 Iterable<T2> i2,
                                                                                                                                                                 Iterable<T3> i3,
                                                                                                                                                                 Iterable<T4> i4,
                                                                                                                                                                 Iterable<T5> i5,
                                                                                                                                                                 Iterable<T6> i6,
                                                                                                                                                                 Iterable<T7> i7,
                                                                                                                                                                 Iterable<T8> i8,
                                                                                                                                                                 Iterable<T9> i9,
                                                                                                                                                                 Iterable<T10> i10,
                                                                                                                                                                 Iterable<T11> i11)
Zip 11 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Seq<Tuple12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>> zip(Iterable<T1> i1,
                                                                                                                                                                         Iterable<T2> i2,
                                                                                                                                                                         Iterable<T3> i3,
                                                                                                                                                                         Iterable<T4> i4,
                                                                                                                                                                         Iterable<T5> i5,
                                                                                                                                                                         Iterable<T6> i6,
                                                                                                                                                                         Iterable<T7> i7,
                                                                                                                                                                         Iterable<T8> i8,
                                                                                                                                                                         Iterable<T9> i9,
                                                                                                                                                                         Iterable<T10> i10,
                                                                                                                                                                         Iterable<T11> i11,
                                                                                                                                                                         Iterable<T12> i12)
Zip 12 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Seq<Tuple13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>> zip(Iterable<T1> i1,
                                                                                                                                                                                 Iterable<T2> i2,
                                                                                                                                                                                 Iterable<T3> i3,
                                                                                                                                                                                 Iterable<T4> i4,
                                                                                                                                                                                 Iterable<T5> i5,
                                                                                                                                                                                 Iterable<T6> i6,
                                                                                                                                                                                 Iterable<T7> i7,
                                                                                                                                                                                 Iterable<T8> i8,
                                                                                                                                                                                 Iterable<T9> i9,
                                                                                                                                                                                 Iterable<T10> i10,
                                                                                                                                                                                 Iterable<T11> i11,
                                                                                                                                                                                 Iterable<T12> i12,
                                                                                                                                                                                 Iterable<T13> i13)
Zip 13 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Seq<Tuple14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>> zip(Iterable<T1> i1,
                                                                                                                                                                                         Iterable<T2> i2,
                                                                                                                                                                                         Iterable<T3> i3,
                                                                                                                                                                                         Iterable<T4> i4,
                                                                                                                                                                                         Iterable<T5> i5,
                                                                                                                                                                                         Iterable<T6> i6,
                                                                                                                                                                                         Iterable<T7> i7,
                                                                                                                                                                                         Iterable<T8> i8,
                                                                                                                                                                                         Iterable<T9> i9,
                                                                                                                                                                                         Iterable<T10> i10,
                                                                                                                                                                                         Iterable<T11> i11,
                                                                                                                                                                                         Iterable<T12> i12,
                                                                                                                                                                                         Iterable<T13> i13,
                                                                                                                                                                                         Iterable<T14> i14)
Zip 14 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Seq<Tuple15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>> zip(Iterable<T1> i1,
                                                                                                                                                                                                 Iterable<T2> i2,
                                                                                                                                                                                                 Iterable<T3> i3,
                                                                                                                                                                                                 Iterable<T4> i4,
                                                                                                                                                                                                 Iterable<T5> i5,
                                                                                                                                                                                                 Iterable<T6> i6,
                                                                                                                                                                                                 Iterable<T7> i7,
                                                                                                                                                                                                 Iterable<T8> i8,
                                                                                                                                                                                                 Iterable<T9> i9,
                                                                                                                                                                                                 Iterable<T10> i10,
                                                                                                                                                                                                 Iterable<T11> i11,
                                                                                                                                                                                                 Iterable<T12> i12,
                                                                                                                                                                                                 Iterable<T13> i13,
                                                                                                                                                                                                 Iterable<T14> i14,
                                                                                                                                                                                                 Iterable<T15> i15)
Zip 15 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Seq<Tuple16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>> zip(Iterable<T1> i1,
                                                                                                                                                                                                         Iterable<T2> i2,
                                                                                                                                                                                                         Iterable<T3> i3,
                                                                                                                                                                                                         Iterable<T4> i4,
                                                                                                                                                                                                         Iterable<T5> i5,
                                                                                                                                                                                                         Iterable<T6> i6,
                                                                                                                                                                                                         Iterable<T7> i7,
                                                                                                                                                                                                         Iterable<T8> i8,
                                                                                                                                                                                                         Iterable<T9> i9,
                                                                                                                                                                                                         Iterable<T10> i10,
                                                                                                                                                                                                         Iterable<T11> i11,
                                                                                                                                                                                                         Iterable<T12> i12,
                                                                                                                                                                                                         Iterable<T13> i13,
                                                                                                                                                                                                         Iterable<T14> i14,
                                                                                                                                                                                                         Iterable<T15> i15,
                                                                                                                                                                                                         Iterable<T16> i16)
Zip 16 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2> Seq<Tuple2<T1,T2>> zip(Seq<T1> s1,
                                                                                                      Seq<T2> s2)
Zip 2 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3> Seq<Tuple3<T1,T2,T3>> zip(Seq<T1> s1,
                                                                                                            Seq<T2> s2,
                                                                                                            Seq<T3> s3)
Zip 3 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4> Seq<Tuple4<T1,T2,T3,T4>> zip(Seq<T1> s1,
                                                                                                                  Seq<T2> s2,
                                                                                                                  Seq<T3> s3,
                                                                                                                  Seq<T4> s4)
Zip 4 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5> Seq<Tuple5<T1,T2,T3,T4,T5>> zip(Seq<T1> s1,
                                                                                                                        Seq<T2> s2,
                                                                                                                        Seq<T3> s3,
                                                                                                                        Seq<T4> s4,
                                                                                                                        Seq<T5> s5)
Zip 5 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6> Seq<Tuple6<T1,T2,T3,T4,T5,T6>> zip(Seq<T1> s1,
                                                                                                                              Seq<T2> s2,
                                                                                                                              Seq<T3> s3,
                                                                                                                              Seq<T4> s4,
                                                                                                                              Seq<T5> s5,
                                                                                                                              Seq<T6> s6)
Zip 6 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7> Seq<Tuple7<T1,T2,T3,T4,T5,T6,T7>> zip(Seq<T1> s1,
                                                                                                                                    Seq<T2> s2,
                                                                                                                                    Seq<T3> s3,
                                                                                                                                    Seq<T4> s4,
                                                                                                                                    Seq<T5> s5,
                                                                                                                                    Seq<T6> s6,
                                                                                                                                    Seq<T7> s7)
Zip 7 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8> Seq<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>> zip(Seq<T1> s1,
                                                                                                                                          Seq<T2> s2,
                                                                                                                                          Seq<T3> s3,
                                                                                                                                          Seq<T4> s4,
                                                                                                                                          Seq<T5> s5,
                                                                                                                                          Seq<T6> s6,
                                                                                                                                          Seq<T7> s7,
                                                                                                                                          Seq<T8> s8)
Zip 8 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Seq<Tuple9<T1,T2,T3,T4,T5,T6,T7,T8,T9>> zip(Seq<T1> s1,
                                                                                                                                                Seq<T2> s2,
                                                                                                                                                Seq<T3> s3,
                                                                                                                                                Seq<T4> s4,
                                                                                                                                                Seq<T5> s5,
                                                                                                                                                Seq<T6> s6,
                                                                                                                                                Seq<T7> s7,
                                                                                                                                                Seq<T8> s8,
                                                                                                                                                Seq<T9> s9)
Zip 9 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Seq<Tuple10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>> zip(Seq<T1> s1,
                                                                                                                                                         Seq<T2> s2,
                                                                                                                                                         Seq<T3> s3,
                                                                                                                                                         Seq<T4> s4,
                                                                                                                                                         Seq<T5> s5,
                                                                                                                                                         Seq<T6> s6,
                                                                                                                                                         Seq<T7> s7,
                                                                                                                                                         Seq<T8> s8,
                                                                                                                                                         Seq<T9> s9,
                                                                                                                                                         Seq<T10> s10)
Zip 10 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Seq<Tuple11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>> zip(Seq<T1> s1,
                                                                                                                                                                 Seq<T2> s2,
                                                                                                                                                                 Seq<T3> s3,
                                                                                                                                                                 Seq<T4> s4,
                                                                                                                                                                 Seq<T5> s5,
                                                                                                                                                                 Seq<T6> s6,
                                                                                                                                                                 Seq<T7> s7,
                                                                                                                                                                 Seq<T8> s8,
                                                                                                                                                                 Seq<T9> s9,
                                                                                                                                                                 Seq<T10> s10,
                                                                                                                                                                 Seq<T11> s11)
Zip 11 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Seq<Tuple12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>> zip(Seq<T1> s1,
                                                                                                                                                                         Seq<T2> s2,
                                                                                                                                                                         Seq<T3> s3,
                                                                                                                                                                         Seq<T4> s4,
                                                                                                                                                                         Seq<T5> s5,
                                                                                                                                                                         Seq<T6> s6,
                                                                                                                                                                         Seq<T7> s7,
                                                                                                                                                                         Seq<T8> s8,
                                                                                                                                                                         Seq<T9> s9,
                                                                                                                                                                         Seq<T10> s10,
                                                                                                                                                                         Seq<T11> s11,
                                                                                                                                                                         Seq<T12> s12)
Zip 12 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Seq<Tuple13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>> zip(Seq<T1> s1,
                                                                                                                                                                                 Seq<T2> s2,
                                                                                                                                                                                 Seq<T3> s3,
                                                                                                                                                                                 Seq<T4> s4,
                                                                                                                                                                                 Seq<T5> s5,
                                                                                                                                                                                 Seq<T6> s6,
                                                                                                                                                                                 Seq<T7> s7,
                                                                                                                                                                                 Seq<T8> s8,
                                                                                                                                                                                 Seq<T9> s9,
                                                                                                                                                                                 Seq<T10> s10,
                                                                                                                                                                                 Seq<T11> s11,
                                                                                                                                                                                 Seq<T12> s12,
                                                                                                                                                                                 Seq<T13> s13)
Zip 13 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Seq<Tuple14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>> zip(Seq<T1> s1,
                                                                                                                                                                                         Seq<T2> s2,
                                                                                                                                                                                         Seq<T3> s3,
                                                                                                                                                                                         Seq<T4> s4,
                                                                                                                                                                                         Seq<T5> s5,
                                                                                                                                                                                         Seq<T6> s6,
                                                                                                                                                                                         Seq<T7> s7,
                                                                                                                                                                                         Seq<T8> s8,
                                                                                                                                                                                         Seq<T9> s9,
                                                                                                                                                                                         Seq<T10> s10,
                                                                                                                                                                                         Seq<T11> s11,
                                                                                                                                                                                         Seq<T12> s12,
                                                                                                                                                                                         Seq<T13> s13,
                                                                                                                                                                                         Seq<T14> s14)
Zip 14 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Seq<Tuple15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>> zip(Seq<T1> s1,
                                                                                                                                                                                                 Seq<T2> s2,
                                                                                                                                                                                                 Seq<T3> s3,
                                                                                                                                                                                                 Seq<T4> s4,
                                                                                                                                                                                                 Seq<T5> s5,
                                                                                                                                                                                                 Seq<T6> s6,
                                                                                                                                                                                                 Seq<T7> s7,
                                                                                                                                                                                                 Seq<T8> s8,
                                                                                                                                                                                                 Seq<T9> s9,
                                                                                                                                                                                                 Seq<T10> s10,
                                                                                                                                                                                                 Seq<T11> s11,
                                                                                                                                                                                                 Seq<T12> s12,
                                                                                                                                                                                                 Seq<T13> s13,
                                                                                                                                                                                                 Seq<T14> s14,
                                                                                                                                                                                                 Seq<T15> s15)
Zip 15 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Seq<Tuple16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>> zip(Seq<T1> s1,
                                                                                                                                                                                                         Seq<T2> s2,
                                                                                                                                                                                                         Seq<T3> s3,
                                                                                                                                                                                                         Seq<T4> s4,
                                                                                                                                                                                                         Seq<T5> s5,
                                                                                                                                                                                                         Seq<T6> s6,
                                                                                                                                                                                                         Seq<T7> s7,
                                                                                                                                                                                                         Seq<T8> s8,
                                                                                                                                                                                                         Seq<T9> s9,
                                                                                                                                                                                                         Seq<T10> s10,
                                                                                                                                                                                                         Seq<T11> s11,
                                                                                                                                                                                                         Seq<T12> s12,
                                                                                                                                                                                                         Seq<T13> s13,
                                                                                                                                                                                                         Seq<T14> s14,
                                                                                                                                                                                                         Seq<T15> s15,
                                                                                                                                                                                                         Seq<T16> s16)
Zip 16 streams into one.
 
 
 // (tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,R> Seq<R> zip(java.util.stream.Stream<T1> s1,
                                                                                            java.util.stream.Stream<T2> s2,
                                                                                            java.util.function.BiFunction<? super T1,? super T2,? extends R> zipper)
Zip 2 streams into one using a BiFunction to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,R> Seq<R> zip(java.util.stream.Stream<T1> s1,
                                                                                               java.util.stream.Stream<T2> s2,
                                                                                               java.util.stream.Stream<T3> s3,
                                                                                               Function3<? super T1,? super T2,? super T3,? extends R> zipper)
Zip 3 streams into one using a Function3 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,R> Seq<R> zip(java.util.stream.Stream<T1> s1,
                                                                                                  java.util.stream.Stream<T2> s2,
                                                                                                  java.util.stream.Stream<T3> s3,
                                                                                                  java.util.stream.Stream<T4> s4,
                                                                                                  Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)
Zip 4 streams into one using a Function4 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,R> Seq<R> zip(java.util.stream.Stream<T1> s1,
                                                                                                     java.util.stream.Stream<T2> s2,
                                                                                                     java.util.stream.Stream<T3> s3,
                                                                                                     java.util.stream.Stream<T4> s4,
                                                                                                     java.util.stream.Stream<T5> s5,
                                                                                                     Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)
Zip 5 streams into one using a Function5 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,R> Seq<R> zip(java.util.stream.Stream<T1> s1,
                                                                                                        java.util.stream.Stream<T2> s2,
                                                                                                        java.util.stream.Stream<T3> s3,
                                                                                                        java.util.stream.Stream<T4> s4,
                                                                                                        java.util.stream.Stream<T5> s5,
                                                                                                        java.util.stream.Stream<T6> s6,
                                                                                                        Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)
Zip 6 streams into one using a Function6 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,R> Seq<R> zip(java.util.stream.Stream<T1> s1,
                                                                                                           java.util.stream.Stream<T2> s2,
                                                                                                           java.util.stream.Stream<T3> s3,
                                                                                                           java.util.stream.Stream<T4> s4,
                                                                                                           java.util.stream.Stream<T5> s5,
                                                                                                           java.util.stream.Stream<T6> s6,
                                                                                                           java.util.stream.Stream<T7> s7,
                                                                                                           Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)
Zip 7 streams into one using a Function7 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,R> Seq<R> zip(java.util.stream.Stream<T1> s1,
                                                                                                              java.util.stream.Stream<T2> s2,
                                                                                                              java.util.stream.Stream<T3> s3,
                                                                                                              java.util.stream.Stream<T4> s4,
                                                                                                              java.util.stream.Stream<T5> s5,
                                                                                                              java.util.stream.Stream<T6> s6,
                                                                                                              java.util.stream.Stream<T7> s7,
                                                                                                              java.util.stream.Stream<T8> s8,
                                                                                                              Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper)
Zip 8 streams into one using a Function8 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> Seq<R> zip(java.util.stream.Stream<T1> s1,
                                                                                                                 java.util.stream.Stream<T2> s2,
                                                                                                                 java.util.stream.Stream<T3> s3,
                                                                                                                 java.util.stream.Stream<T4> s4,
                                                                                                                 java.util.stream.Stream<T5> s5,
                                                                                                                 java.util.stream.Stream<T6> s6,
                                                                                                                 java.util.stream.Stream<T7> s7,
                                                                                                                 java.util.stream.Stream<T8> s8,
                                                                                                                 java.util.stream.Stream<T9> s9,
                                                                                                                 Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipper)
Zip 9 streams into one using a Function9 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,R> Seq<R> zip(java.util.stream.Stream<T1> s1,
                                                                                                                     java.util.stream.Stream<T2> s2,
                                                                                                                     java.util.stream.Stream<T3> s3,
                                                                                                                     java.util.stream.Stream<T4> s4,
                                                                                                                     java.util.stream.Stream<T5> s5,
                                                                                                                     java.util.stream.Stream<T6> s6,
                                                                                                                     java.util.stream.Stream<T7> s7,
                                                                                                                     java.util.stream.Stream<T8> s8,
                                                                                                                     java.util.stream.Stream<T9> s9,
                                                                                                                     java.util.stream.Stream<T10> s10,
                                                                                                                     Function10<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? extends R> zipper)
Zip 10 streams into one using a Function10 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,R> Seq<R> zip(java.util.stream.Stream<T1> s1,
                                                                                                                         java.util.stream.Stream<T2> s2,
                                                                                                                         java.util.stream.Stream<T3> s3,
                                                                                                                         java.util.stream.Stream<T4> s4,
                                                                                                                         java.util.stream.Stream<T5> s5,
                                                                                                                         java.util.stream.Stream<T6> s6,
                                                                                                                         java.util.stream.Stream<T7> s7,
                                                                                                                         java.util.stream.Stream<T8> s8,
                                                                                                                         java.util.stream.Stream<T9> s9,
                                                                                                                         java.util.stream.Stream<T10> s10,
                                                                                                                         java.util.stream.Stream<T11> s11,
                                                                                                                         Function11<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? extends R> zipper)
Zip 11 streams into one using a Function11 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,R> Seq<R> zip(java.util.stream.Stream<T1> s1,
                                                                                                                             java.util.stream.Stream<T2> s2,
                                                                                                                             java.util.stream.Stream<T3> s3,
                                                                                                                             java.util.stream.Stream<T4> s4,
                                                                                                                             java.util.stream.Stream<T5> s5,
                                                                                                                             java.util.stream.Stream<T6> s6,
                                                                                                                             java.util.stream.Stream<T7> s7,
                                                                                                                             java.util.stream.Stream<T8> s8,
                                                                                                                             java.util.stream.Stream<T9> s9,
                                                                                                                             java.util.stream.Stream<T10> s10,
                                                                                                                             java.util.stream.Stream<T11> s11,
                                                                                                                             java.util.stream.Stream<T12> s12,
                                                                                                                             Function12<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? extends R> zipper)
Zip 12 streams into one using a Function12 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,R> Seq<R> zip(java.util.stream.Stream<T1> s1,
                                                                                                                                 java.util.stream.Stream<T2> s2,
                                                                                                                                 java.util.stream.Stream<T3> s3,
                                                                                                                                 java.util.stream.Stream<T4> s4,
                                                                                                                                 java.util.stream.Stream<T5> s5,
                                                                                                                                 java.util.stream.Stream<T6> s6,
                                                                                                                                 java.util.stream.Stream<T7> s7,
                                                                                                                                 java.util.stream.Stream<T8> s8,
                                                                                                                                 java.util.stream.Stream<T9> s9,
                                                                                                                                 java.util.stream.Stream<T10> s10,
                                                                                                                                 java.util.stream.Stream<T11> s11,
                                                                                                                                 java.util.stream.Stream<T12> s12,
                                                                                                                                 java.util.stream.Stream<T13> s13,
                                                                                                                                 Function13<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? extends R> zipper)
Zip 13 streams into one using a Function13 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,R> Seq<R> zip(java.util.stream.Stream<T1> s1,
                                                                                                                                     java.util.stream.Stream<T2> s2,
                                                                                                                                     java.util.stream.Stream<T3> s3,
                                                                                                                                     java.util.stream.Stream<T4> s4,
                                                                                                                                     java.util.stream.Stream<T5> s5,
                                                                                                                                     java.util.stream.Stream<T6> s6,
                                                                                                                                     java.util.stream.Stream<T7> s7,
                                                                                                                                     java.util.stream.Stream<T8> s8,
                                                                                                                                     java.util.stream.Stream<T9> s9,
                                                                                                                                     java.util.stream.Stream<T10> s10,
                                                                                                                                     java.util.stream.Stream<T11> s11,
                                                                                                                                     java.util.stream.Stream<T12> s12,
                                                                                                                                     java.util.stream.Stream<T13> s13,
                                                                                                                                     java.util.stream.Stream<T14> s14,
                                                                                                                                     Function14<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? super T14,? extends R> zipper)
Zip 14 streams into one using a Function14 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,R> Seq<R> zip(java.util.stream.Stream<T1> s1,
                                                                                                                                         java.util.stream.Stream<T2> s2,
                                                                                                                                         java.util.stream.Stream<T3> s3,
                                                                                                                                         java.util.stream.Stream<T4> s4,
                                                                                                                                         java.util.stream.Stream<T5> s5,
                                                                                                                                         java.util.stream.Stream<T6> s6,
                                                                                                                                         java.util.stream.Stream<T7> s7,
                                                                                                                                         java.util.stream.Stream<T8> s8,
                                                                                                                                         java.util.stream.Stream<T9> s9,
                                                                                                                                         java.util.stream.Stream<T10> s10,
                                                                                                                                         java.util.stream.Stream<T11> s11,
                                                                                                                                         java.util.stream.Stream<T12> s12,
                                                                                                                                         java.util.stream.Stream<T13> s13,
                                                                                                                                         java.util.stream.Stream<T14> s14,
                                                                                                                                         java.util.stream.Stream<T15> s15,
                                                                                                                                         Function15<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? super T14,? super T15,? extends R> zipper)
Zip 15 streams into one using a Function15 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,R> Seq<R> zip(java.util.stream.Stream<T1> s1,
                                                                                                                                             java.util.stream.Stream<T2> s2,
                                                                                                                                             java.util.stream.Stream<T3> s3,
                                                                                                                                             java.util.stream.Stream<T4> s4,
                                                                                                                                             java.util.stream.Stream<T5> s5,
                                                                                                                                             java.util.stream.Stream<T6> s6,
                                                                                                                                             java.util.stream.Stream<T7> s7,
                                                                                                                                             java.util.stream.Stream<T8> s8,
                                                                                                                                             java.util.stream.Stream<T9> s9,
                                                                                                                                             java.util.stream.Stream<T10> s10,
                                                                                                                                             java.util.stream.Stream<T11> s11,
                                                                                                                                             java.util.stream.Stream<T12> s12,
                                                                                                                                             java.util.stream.Stream<T13> s13,
                                                                                                                                             java.util.stream.Stream<T14> s14,
                                                                                                                                             java.util.stream.Stream<T15> s15,
                                                                                                                                             java.util.stream.Stream<T16> s16,
                                                                                                                                             Function16<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? super T14,? super T15,? super T16,? extends R> zipper)
Zip 16 streams into one using a Function16 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,R> Seq<R> zip(Iterable<T1> i1,
                                                                                            Iterable<T2> i2,
                                                                                            java.util.function.BiFunction<? super T1,? super T2,? extends R> zipper)
Zip 2 streams into one using a BiFunction to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,R> Seq<R> zip(Iterable<T1> i1,
                                                                                               Iterable<T2> i2,
                                                                                               Iterable<T3> i3,
                                                                                               Function3<? super T1,? super T2,? super T3,? extends R> zipper)
Zip 3 streams into one using a Function3 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,R> Seq<R> zip(Iterable<T1> i1,
                                                                                                  Iterable<T2> i2,
                                                                                                  Iterable<T3> i3,
                                                                                                  Iterable<T4> i4,
                                                                                                  Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)
Zip 4 streams into one using a Function4 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,R> Seq<R> zip(Iterable<T1> i1,
                                                                                                     Iterable<T2> i2,
                                                                                                     Iterable<T3> i3,
                                                                                                     Iterable<T4> i4,
                                                                                                     Iterable<T5> i5,
                                                                                                     Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)
Zip 5 streams into one using a Function5 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,R> Seq<R> zip(Iterable<T1> i1,
                                                                                                        Iterable<T2> i2,
                                                                                                        Iterable<T3> i3,
                                                                                                        Iterable<T4> i4,
                                                                                                        Iterable<T5> i5,
                                                                                                        Iterable<T6> i6,
                                                                                                        Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)
Zip 6 streams into one using a Function6 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,R> Seq<R> zip(Iterable<T1> i1,
                                                                                                           Iterable<T2> i2,
                                                                                                           Iterable<T3> i3,
                                                                                                           Iterable<T4> i4,
                                                                                                           Iterable<T5> i5,
                                                                                                           Iterable<T6> i6,
                                                                                                           Iterable<T7> i7,
                                                                                                           Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)
Zip 7 streams into one using a Function7 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,R> Seq<R> zip(Iterable<T1> i1,
                                                                                                              Iterable<T2> i2,
                                                                                                              Iterable<T3> i3,
                                                                                                              Iterable<T4> i4,
                                                                                                              Iterable<T5> i5,
                                                                                                              Iterable<T6> i6,
                                                                                                              Iterable<T7> i7,
                                                                                                              Iterable<T8> i8,
                                                                                                              Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper)
Zip 8 streams into one using a Function8 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> Seq<R> zip(Iterable<T1> i1,
                                                                                                                 Iterable<T2> i2,
                                                                                                                 Iterable<T3> i3,
                                                                                                                 Iterable<T4> i4,
                                                                                                                 Iterable<T5> i5,
                                                                                                                 Iterable<T6> i6,
                                                                                                                 Iterable<T7> i7,
                                                                                                                 Iterable<T8> i8,
                                                                                                                 Iterable<T9> i9,
                                                                                                                 Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipper)
Zip 9 streams into one using a Function9 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,R> Seq<R> zip(Iterable<T1> i1,
                                                                                                                     Iterable<T2> i2,
                                                                                                                     Iterable<T3> i3,
                                                                                                                     Iterable<T4> i4,
                                                                                                                     Iterable<T5> i5,
                                                                                                                     Iterable<T6> i6,
                                                                                                                     Iterable<T7> i7,
                                                                                                                     Iterable<T8> i8,
                                                                                                                     Iterable<T9> i9,
                                                                                                                     Iterable<T10> i10,
                                                                                                                     Function10<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? extends R> zipper)
Zip 10 streams into one using a Function10 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,R> Seq<R> zip(Iterable<T1> i1,
                                                                                                                         Iterable<T2> i2,
                                                                                                                         Iterable<T3> i3,
                                                                                                                         Iterable<T4> i4,
                                                                                                                         Iterable<T5> i5,
                                                                                                                         Iterable<T6> i6,
                                                                                                                         Iterable<T7> i7,
                                                                                                                         Iterable<T8> i8,
                                                                                                                         Iterable<T9> i9,
                                                                                                                         Iterable<T10> i10,
                                                                                                                         Iterable<T11> i11,
                                                                                                                         Function11<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? extends R> zipper)
Zip 11 streams into one using a Function11 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,R> Seq<R> zip(Iterable<T1> i1,
                                                                                                                             Iterable<T2> i2,
                                                                                                                             Iterable<T3> i3,
                                                                                                                             Iterable<T4> i4,
                                                                                                                             Iterable<T5> i5,
                                                                                                                             Iterable<T6> i6,
                                                                                                                             Iterable<T7> i7,
                                                                                                                             Iterable<T8> i8,
                                                                                                                             Iterable<T9> i9,
                                                                                                                             Iterable<T10> i10,
                                                                                                                             Iterable<T11> i11,
                                                                                                                             Iterable<T12> i12,
                                                                                                                             Function12<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? extends R> zipper)
Zip 12 streams into one using a Function12 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,R> Seq<R> zip(Iterable<T1> i1,
                                                                                                                                 Iterable<T2> i2,
                                                                                                                                 Iterable<T3> i3,
                                                                                                                                 Iterable<T4> i4,
                                                                                                                                 Iterable<T5> i5,
                                                                                                                                 Iterable<T6> i6,
                                                                                                                                 Iterable<T7> i7,
                                                                                                                                 Iterable<T8> i8,
                                                                                                                                 Iterable<T9> i9,
                                                                                                                                 Iterable<T10> i10,
                                                                                                                                 Iterable<T11> i11,
                                                                                                                                 Iterable<T12> i12,
                                                                                                                                 Iterable<T13> i13,
                                                                                                                                 Function13<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? extends R> zipper)
Zip 13 streams into one using a Function13 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,R> Seq<R> zip(Iterable<T1> i1,
                                                                                                                                     Iterable<T2> i2,
                                                                                                                                     Iterable<T3> i3,
                                                                                                                                     Iterable<T4> i4,
                                                                                                                                     Iterable<T5> i5,
                                                                                                                                     Iterable<T6> i6,
                                                                                                                                     Iterable<T7> i7,
                                                                                                                                     Iterable<T8> i8,
                                                                                                                                     Iterable<T9> i9,
                                                                                                                                     Iterable<T10> i10,
                                                                                                                                     Iterable<T11> i11,
                                                                                                                                     Iterable<T12> i12,
                                                                                                                                     Iterable<T13> i13,
                                                                                                                                     Iterable<T14> i14,
                                                                                                                                     Function14<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? super T14,? extends R> zipper)
Zip 14 streams into one using a Function14 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,R> Seq<R> zip(Iterable<T1> i1,
                                                                                                                                         Iterable<T2> i2,
                                                                                                                                         Iterable<T3> i3,
                                                                                                                                         Iterable<T4> i4,
                                                                                                                                         Iterable<T5> i5,
                                                                                                                                         Iterable<T6> i6,
                                                                                                                                         Iterable<T7> i7,
                                                                                                                                         Iterable<T8> i8,
                                                                                                                                         Iterable<T9> i9,
                                                                                                                                         Iterable<T10> i10,
                                                                                                                                         Iterable<T11> i11,
                                                                                                                                         Iterable<T12> i12,
                                                                                                                                         Iterable<T13> i13,
                                                                                                                                         Iterable<T14> i14,
                                                                                                                                         Iterable<T15> i15,
                                                                                                                                         Function15<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? super T14,? super T15,? extends R> zipper)
Zip 15 streams into one using a Function15 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,R> Seq<R> zip(Iterable<T1> i1,
                                                                                                                                             Iterable<T2> i2,
                                                                                                                                             Iterable<T3> i3,
                                                                                                                                             Iterable<T4> i4,
                                                                                                                                             Iterable<T5> i5,
                                                                                                                                             Iterable<T6> i6,
                                                                                                                                             Iterable<T7> i7,
                                                                                                                                             Iterable<T8> i8,
                                                                                                                                             Iterable<T9> i9,
                                                                                                                                             Iterable<T10> i10,
                                                                                                                                             Iterable<T11> i11,
                                                                                                                                             Iterable<T12> i12,
                                                                                                                                             Iterable<T13> i13,
                                                                                                                                             Iterable<T14> i14,
                                                                                                                                             Iterable<T15> i15,
                                                                                                                                             Iterable<T16> i16,
                                                                                                                                             Function16<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? super T14,? super T15,? super T16,? extends R> zipper)
Zip 16 streams into one using a Function16 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,R> Seq<R> zip(Seq<T1> s1,
                                                                                            Seq<T2> s2,
                                                                                            java.util.function.BiFunction<? super T1,? super T2,? extends R> zipper)
Zip 2 streams into one using a BiFunction to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,R> Seq<R> zip(Seq<T1> s1,
                                                                                               Seq<T2> s2,
                                                                                               Seq<T3> s3,
                                                                                               Function3<? super T1,? super T2,? super T3,? extends R> zipper)
Zip 3 streams into one using a Function3 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,R> Seq<R> zip(Seq<T1> s1,
                                                                                                  Seq<T2> s2,
                                                                                                  Seq<T3> s3,
                                                                                                  Seq<T4> s4,
                                                                                                  Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)
Zip 4 streams into one using a Function4 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,R> Seq<R> zip(Seq<T1> s1,
                                                                                                     Seq<T2> s2,
                                                                                                     Seq<T3> s3,
                                                                                                     Seq<T4> s4,
                                                                                                     Seq<T5> s5,
                                                                                                     Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)
Zip 5 streams into one using a Function5 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,R> Seq<R> zip(Seq<T1> s1,
                                                                                                        Seq<T2> s2,
                                                                                                        Seq<T3> s3,
                                                                                                        Seq<T4> s4,
                                                                                                        Seq<T5> s5,
                                                                                                        Seq<T6> s6,
                                                                                                        Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)
Zip 6 streams into one using a Function6 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,R> Seq<R> zip(Seq<T1> s1,
                                                                                                           Seq<T2> s2,
                                                                                                           Seq<T3> s3,
                                                                                                           Seq<T4> s4,
                                                                                                           Seq<T5> s5,
                                                                                                           Seq<T6> s6,
                                                                                                           Seq<T7> s7,
                                                                                                           Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)
Zip 7 streams into one using a Function7 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,R> Seq<R> zip(Seq<T1> s1,
                                                                                                              Seq<T2> s2,
                                                                                                              Seq<T3> s3,
                                                                                                              Seq<T4> s4,
                                                                                                              Seq<T5> s5,
                                                                                                              Seq<T6> s6,
                                                                                                              Seq<T7> s7,
                                                                                                              Seq<T8> s8,
                                                                                                              Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper)
Zip 8 streams into one using a Function8 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> Seq<R> zip(Seq<T1> s1,
                                                                                                                 Seq<T2> s2,
                                                                                                                 Seq<T3> s3,
                                                                                                                 Seq<T4> s4,
                                                                                                                 Seq<T5> s5,
                                                                                                                 Seq<T6> s6,
                                                                                                                 Seq<T7> s7,
                                                                                                                 Seq<T8> s8,
                                                                                                                 Seq<T9> s9,
                                                                                                                 Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipper)
Zip 9 streams into one using a Function9 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,R> Seq<R> zip(Seq<T1> s1,
                                                                                                                     Seq<T2> s2,
                                                                                                                     Seq<T3> s3,
                                                                                                                     Seq<T4> s4,
                                                                                                                     Seq<T5> s5,
                                                                                                                     Seq<T6> s6,
                                                                                                                     Seq<T7> s7,
                                                                                                                     Seq<T8> s8,
                                                                                                                     Seq<T9> s9,
                                                                                                                     Seq<T10> s10,
                                                                                                                     Function10<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? extends R> zipper)
Zip 10 streams into one using a Function10 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,R> Seq<R> zip(Seq<T1> s1,
                                                                                                                         Seq<T2> s2,
                                                                                                                         Seq<T3> s3,
                                                                                                                         Seq<T4> s4,
                                                                                                                         Seq<T5> s5,
                                                                                                                         Seq<T6> s6,
                                                                                                                         Seq<T7> s7,
                                                                                                                         Seq<T8> s8,
                                                                                                                         Seq<T9> s9,
                                                                                                                         Seq<T10> s10,
                                                                                                                         Seq<T11> s11,
                                                                                                                         Function11<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? extends R> zipper)
Zip 11 streams into one using a Function11 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,R> Seq<R> zip(Seq<T1> s1,
                                                                                                                             Seq<T2> s2,
                                                                                                                             Seq<T3> s3,
                                                                                                                             Seq<T4> s4,
                                                                                                                             Seq<T5> s5,
                                                                                                                             Seq<T6> s6,
                                                                                                                             Seq<T7> s7,
                                                                                                                             Seq<T8> s8,
                                                                                                                             Seq<T9> s9,
                                                                                                                             Seq<T10> s10,
                                                                                                                             Seq<T11> s11,
                                                                                                                             Seq<T12> s12,
                                                                                                                             Function12<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? extends R> zipper)
Zip 12 streams into one using a Function12 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,R> Seq<R> zip(Seq<T1> s1,
                                                                                                                                 Seq<T2> s2,
                                                                                                                                 Seq<T3> s3,
                                                                                                                                 Seq<T4> s4,
                                                                                                                                 Seq<T5> s5,
                                                                                                                                 Seq<T6> s6,
                                                                                                                                 Seq<T7> s7,
                                                                                                                                 Seq<T8> s8,
                                                                                                                                 Seq<T9> s9,
                                                                                                                                 Seq<T10> s10,
                                                                                                                                 Seq<T11> s11,
                                                                                                                                 Seq<T12> s12,
                                                                                                                                 Seq<T13> s13,
                                                                                                                                 Function13<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? extends R> zipper)
Zip 13 streams into one using a Function13 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,R> Seq<R> zip(Seq<T1> s1,
                                                                                                                                     Seq<T2> s2,
                                                                                                                                     Seq<T3> s3,
                                                                                                                                     Seq<T4> s4,
                                                                                                                                     Seq<T5> s5,
                                                                                                                                     Seq<T6> s6,
                                                                                                                                     Seq<T7> s7,
                                                                                                                                     Seq<T8> s8,
                                                                                                                                     Seq<T9> s9,
                                                                                                                                     Seq<T10> s10,
                                                                                                                                     Seq<T11> s11,
                                                                                                                                     Seq<T12> s12,
                                                                                                                                     Seq<T13> s13,
                                                                                                                                     Seq<T14> s14,
                                                                                                                                     Function14<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? super T14,? extends R> zipper)
Zip 14 streams into one using a Function14 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,R> Seq<R> zip(Seq<T1> s1,
                                                                                                                                         Seq<T2> s2,
                                                                                                                                         Seq<T3> s3,
                                                                                                                                         Seq<T4> s4,
                                                                                                                                         Seq<T5> s5,
                                                                                                                                         Seq<T6> s6,
                                                                                                                                         Seq<T7> s7,
                                                                                                                                         Seq<T8> s8,
                                                                                                                                         Seq<T9> s9,
                                                                                                                                         Seq<T10> s10,
                                                                                                                                         Seq<T11> s11,
                                                                                                                                         Seq<T12> s12,
                                                                                                                                         Seq<T13> s13,
                                                                                                                                         Seq<T14> s14,
                                                                                                                                         Seq<T15> s15,
                                                                                                                                         Function15<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? super T14,? super T15,? extends R> zipper)
Zip 15 streams into one using a Function15 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zip
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,R> Seq<R> zip(Seq<T1> s1,
                                                                                                                                             Seq<T2> s2,
                                                                                                                                             Seq<T3> s3,
                                                                                                                                             Seq<T4> s4,
                                                                                                                                             Seq<T5> s5,
                                                                                                                                             Seq<T6> s6,
                                                                                                                                             Seq<T7> s7,
                                                                                                                                             Seq<T8> s8,
                                                                                                                                             Seq<T9> s9,
                                                                                                                                             Seq<T10> s10,
                                                                                                                                             Seq<T11> s11,
                                                                                                                                             Seq<T12> s12,
                                                                                                                                             Seq<T13> s13,
                                                                                                                                             Seq<T14> s14,
                                                                                                                                             Seq<T15> s15,
                                                                                                                                             Seq<T16> s16,
                                                                                                                                             Function16<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? super T10,? super T11,? super T12,? super T13,? super T14,? super T15,? super T16,? extends R> zipper)
Zip 16 streams into one using a Function16 to produce resulting values.
 
 
 // ("1:a", "2:b", "3:c")
 Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)
 







zipWithIndex
static <T> Seq<Tuple2<T,Long>> zipWithIndex(java.util.stream.Stream<T> stream)
Zip a Stream with a corresponding Stream of indexes.
 
 
 // (tuple("a", 0), tuple("b", 1), tuple("c", 2))
 Seq.of("a", "b", "c").zipWithIndex()
 







zipWithIndex
static <T> Seq<Tuple2<T,Long>> zipWithIndex(Iterable<T> iterable)
Zip a Stream with a corresponding Stream of indexes.
 
 
 // (tuple("a", 0), tuple("b", 1), tuple("c", 2))
 Seq.of("a", "b", "c").zipWithIndex()
 







zipWithIndex
static <T> Seq<Tuple2<T,Long>> zipWithIndex(Seq<T> stream)
Zip a Stream with a corresponding Stream of indexes.
 
 
 // (tuple("a", 0), tuple("b", 1), tuple("c", 2))
 Seq.of("a", "b", "c").zipWithIndex()
 









foldLeft
static <T,U> U foldLeft(java.util.stream.Stream<T> stream,
                        U seed,
                        java.util.function.BiFunction<U,? super T,U> function)
Fold a stream to the left.
 
 
 // "abc"
 Seq.of("a", "b", "c").foldLeft("", (u, t) -> u + t)
 









foldLeft
static <T,U> U foldLeft(Iterable<T> iterable,
                        U seed,
                        java.util.function.BiFunction<U,? super T,U> function)
Fold a stream to the left.
 
 
 // "abc"
 Seq.of("a", "b", "c").foldLeft("", (u, t) -> u + t)
 









foldLeft
static <T,U> U foldLeft(Seq<T> stream,
                        U seed,
                        java.util.function.BiFunction<U,? super T,U> function)
Fold a stream to the left.
 
 
 // "abc"
 Seq.of("a", "b", "c").foldLeft("", (u, t) -> u + t)
 









foldRight
static <T,U> U foldRight(java.util.stream.Stream<T> stream,
                         U seed,
                         java.util.function.BiFunction<? super T,U,U> function)
Fold a stream to the right.
 
 
 // "cba"
 Seq.of("a", "b", "c").foldRight("", (t, u) -> u + t)
 









foldRight
static <T,U> U foldRight(Iterable<T> iterable,
                         U seed,
                         java.util.function.BiFunction<? super T,U,U> function)
Fold a stream to the right.
 
 
 // "cba"
 Seq.of("a", "b", "c").foldRight("", (t, u) -> u + t)
 









foldRight
static <T,U> U foldRight(Seq<T> stream,
                         U seed,
                         java.util.function.BiFunction<? super T,U,U> function)
Fold a stream to the right.
 
 
 // "cba"
 Seq.of("a", "b", "c").foldRight("", (t, u) -> u + t)
 









scanLeft
static <T,U> Seq<U> scanLeft(java.util.stream.Stream<T> stream,
                             U seed,
                             java.util.function.BiFunction<U,? super T,U> function)
Scan a stream to the left.
 
 
 // ("", "a", "ab", "abc")
 Seq.of("a", "b", "c").scanLeft("", (u, t) -> u + t)
 









scanLeft
static <T,U> Seq<U> scanLeft(Iterable<T> iterable,
                             U seed,
                             java.util.function.BiFunction<U,? super T,U> function)
Scan a stream to the left.
 
 
 // ("", "a", "ab", "abc")
 Seq.of("a", "b", "c").scanLeft("", (u, t) -> u + t)
 









scanLeft
static <T,U> Seq<U> scanLeft(Seq<T> stream,
                             U seed,
                             java.util.function.BiFunction<U,? super T,U> function)
Scan a stream to the left.
 
 
 // ("", "a", "ab", "abc")
 Seq.of("a", "b", "c").scanLeft("", (u, t) -> u + t)
 









scanRight
static <T,U> Seq<U> scanRight(java.util.stream.Stream<T> stream,
                              U seed,
                              java.util.function.BiFunction<? super T,U,U> function)
Scan a stream to the right.
 
 
 // ("", "c", "cb", "cba")
 Seq.of("a", "b", "c").scanRight("", (t, u) -> u + t)
 









scanRight
static <T,U> Seq<U> scanRight(Iterable<T> iterable,
                              U seed,
                              java.util.function.BiFunction<? super T,U,U> function)
Scan a stream to the right.
 
 
 // ("", "c", "cb", "cba")
 Seq.of("a", "b", "c").scanRight("", (t, u) -> u + t)
 









scanRight
static <T,U> Seq<U> scanRight(Seq<T> stream,
                              U seed,
                              java.util.function.BiFunction<? super T,U,U> function)
Scan a stream to the right.
 
 
 // ("", "c", "cb", "cba")
 Seq.of("a", "b", "c").scanRight("", (t, u) -> u + t)
 









unfold
static <T,U> Seq<T> unfold(U seed,
                           java.util.function.Function<U,Optional<Tuple2<T,U>>> unfolder)
Unfold a function into a stream.
 
 
 // (1, 2, 3, 4, 5)
 Seq.unfold(1, i -> i <= 6 ? Optional.of(tuple(i, i + 1)) : Optional.empty())
 







reverse
static <T> Seq<T> reverse(java.util.stream.Stream<T> stream)
Reverse a stream.
 
 
 // (3, 2, 1)
 Seq.of(1, 2, 3).reverse()
 







reverse
static <T> Seq<T> reverse(Iterable<T> iterable)
Reverse a stream.
 
 
 // (3, 2, 1)
 Seq.of(1, 2, 3).reverse()
 







reverse
static <T> Seq<T> reverse(Seq<T> stream)
Reverse a stream.
 
 
 // (3, 2, 1)
 Seq.of(1, 2, 3).reverse()
 







shuffle
static <T> Seq<T> shuffle(java.util.stream.Stream<T> stream)
Shuffle a stream
 
 
 // e.g. (2, 3, 1)
 Seq.of(1, 2, 3).shuffle()
 







shuffle
static <T> Seq<T> shuffle(Iterable<T> iterable)
Shuffle a stream
 
 
 // e.g. (2, 3, 1)
 Seq.of(1, 2, 3).shuffle()
 







shuffle
static <T> Seq<T> shuffle(Seq<T> stream)
Shuffle a stream
 
 
 // e.g. (2, 3, 1)
 Seq.of(1, 2, 3).shuffle()
 







shuffle
static <T> Seq<T> shuffle(java.util.stream.Stream<T> stream,
                          Random random)
Shuffle a stream using specified source of randomness
 
 
 // e.g. (2, 3, 1)
 Seq.of(1, 2, 3).shuffle(new Random())
 







shuffle
static <T> Seq<T> shuffle(Iterable<T> iterable,
                          Random random)
Shuffle a stream using specified source of randomness
 
 
 // e.g. (2, 3, 1)
 Seq.of(1, 2, 3).shuffle(new Random())
 







shuffle
static <T> Seq<T> shuffle(Seq<T> stream,
                          Random random)
Shuffle a stream using specified source of randomness
 
 
 // e.g. (2, 3, 1)
 Seq.of(1, 2, 3).shuffle(new Random())
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2> Seq<Tuple2<T1,T2>> crossJoin(java.util.stream.Stream<T1> s1,
                                                                                                            java.util.stream.Stream<T2> s2)
Cross join 2 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3> Seq<Tuple3<T1,T2,T3>> crossJoin(java.util.stream.Stream<T1> s1,
                                                                                                                  java.util.stream.Stream<T2> s2,
                                                                                                                  java.util.stream.Stream<T3> s3)
Cross join 3 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4> Seq<Tuple4<T1,T2,T3,T4>> crossJoin(java.util.stream.Stream<T1> s1,
                                                                                                                        java.util.stream.Stream<T2> s2,
                                                                                                                        java.util.stream.Stream<T3> s3,
                                                                                                                        java.util.stream.Stream<T4> s4)
Cross join 4 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5> Seq<Tuple5<T1,T2,T3,T4,T5>> crossJoin(java.util.stream.Stream<T1> s1,
                                                                                                                              java.util.stream.Stream<T2> s2,
                                                                                                                              java.util.stream.Stream<T3> s3,
                                                                                                                              java.util.stream.Stream<T4> s4,
                                                                                                                              java.util.stream.Stream<T5> s5)
Cross join 5 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6> Seq<Tuple6<T1,T2,T3,T4,T5,T6>> crossJoin(java.util.stream.Stream<T1> s1,
                                                                                                                                    java.util.stream.Stream<T2> s2,
                                                                                                                                    java.util.stream.Stream<T3> s3,
                                                                                                                                    java.util.stream.Stream<T4> s4,
                                                                                                                                    java.util.stream.Stream<T5> s5,
                                                                                                                                    java.util.stream.Stream<T6> s6)
Cross join 6 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7> Seq<Tuple7<T1,T2,T3,T4,T5,T6,T7>> crossJoin(java.util.stream.Stream<T1> s1,
                                                                                                                                          java.util.stream.Stream<T2> s2,
                                                                                                                                          java.util.stream.Stream<T3> s3,
                                                                                                                                          java.util.stream.Stream<T4> s4,
                                                                                                                                          java.util.stream.Stream<T5> s5,
                                                                                                                                          java.util.stream.Stream<T6> s6,
                                                                                                                                          java.util.stream.Stream<T7> s7)
Cross join 7 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8> Seq<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>> crossJoin(java.util.stream.Stream<T1> s1,
                                                                                                                                                java.util.stream.Stream<T2> s2,
                                                                                                                                                java.util.stream.Stream<T3> s3,
                                                                                                                                                java.util.stream.Stream<T4> s4,
                                                                                                                                                java.util.stream.Stream<T5> s5,
                                                                                                                                                java.util.stream.Stream<T6> s6,
                                                                                                                                                java.util.stream.Stream<T7> s7,
                                                                                                                                                java.util.stream.Stream<T8> s8)
Cross join 8 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Seq<Tuple9<T1,T2,T3,T4,T5,T6,T7,T8,T9>> crossJoin(java.util.stream.Stream<T1> s1,
                                                                                                                                                      java.util.stream.Stream<T2> s2,
                                                                                                                                                      java.util.stream.Stream<T3> s3,
                                                                                                                                                      java.util.stream.Stream<T4> s4,
                                                                                                                                                      java.util.stream.Stream<T5> s5,
                                                                                                                                                      java.util.stream.Stream<T6> s6,
                                                                                                                                                      java.util.stream.Stream<T7> s7,
                                                                                                                                                      java.util.stream.Stream<T8> s8,
                                                                                                                                                      java.util.stream.Stream<T9> s9)
Cross join 9 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Seq<Tuple10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>> crossJoin(java.util.stream.Stream<T1> s1,
                                                                                                                                                               java.util.stream.Stream<T2> s2,
                                                                                                                                                               java.util.stream.Stream<T3> s3,
                                                                                                                                                               java.util.stream.Stream<T4> s4,
                                                                                                                                                               java.util.stream.Stream<T5> s5,
                                                                                                                                                               java.util.stream.Stream<T6> s6,
                                                                                                                                                               java.util.stream.Stream<T7> s7,
                                                                                                                                                               java.util.stream.Stream<T8> s8,
                                                                                                                                                               java.util.stream.Stream<T9> s9,
                                                                                                                                                               java.util.stream.Stream<T10> s10)
Cross join 10 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Seq<Tuple11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>> crossJoin(java.util.stream.Stream<T1> s1,
                                                                                                                                                                       java.util.stream.Stream<T2> s2,
                                                                                                                                                                       java.util.stream.Stream<T3> s3,
                                                                                                                                                                       java.util.stream.Stream<T4> s4,
                                                                                                                                                                       java.util.stream.Stream<T5> s5,
                                                                                                                                                                       java.util.stream.Stream<T6> s6,
                                                                                                                                                                       java.util.stream.Stream<T7> s7,
                                                                                                                                                                       java.util.stream.Stream<T8> s8,
                                                                                                                                                                       java.util.stream.Stream<T9> s9,
                                                                                                                                                                       java.util.stream.Stream<T10> s10,
                                                                                                                                                                       java.util.stream.Stream<T11> s11)
Cross join 11 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Seq<Tuple12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>> crossJoin(java.util.stream.Stream<T1> s1,
                                                                                                                                                                               java.util.stream.Stream<T2> s2,
                                                                                                                                                                               java.util.stream.Stream<T3> s3,
                                                                                                                                                                               java.util.stream.Stream<T4> s4,
                                                                                                                                                                               java.util.stream.Stream<T5> s5,
                                                                                                                                                                               java.util.stream.Stream<T6> s6,
                                                                                                                                                                               java.util.stream.Stream<T7> s7,
                                                                                                                                                                               java.util.stream.Stream<T8> s8,
                                                                                                                                                                               java.util.stream.Stream<T9> s9,
                                                                                                                                                                               java.util.stream.Stream<T10> s10,
                                                                                                                                                                               java.util.stream.Stream<T11> s11,
                                                                                                                                                                               java.util.stream.Stream<T12> s12)
Cross join 12 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Seq<Tuple13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>> crossJoin(java.util.stream.Stream<T1> s1,
                                                                                                                                                                                       java.util.stream.Stream<T2> s2,
                                                                                                                                                                                       java.util.stream.Stream<T3> s3,
                                                                                                                                                                                       java.util.stream.Stream<T4> s4,
                                                                                                                                                                                       java.util.stream.Stream<T5> s5,
                                                                                                                                                                                       java.util.stream.Stream<T6> s6,
                                                                                                                                                                                       java.util.stream.Stream<T7> s7,
                                                                                                                                                                                       java.util.stream.Stream<T8> s8,
                                                                                                                                                                                       java.util.stream.Stream<T9> s9,
                                                                                                                                                                                       java.util.stream.Stream<T10> s10,
                                                                                                                                                                                       java.util.stream.Stream<T11> s11,
                                                                                                                                                                                       java.util.stream.Stream<T12> s12,
                                                                                                                                                                                       java.util.stream.Stream<T13> s13)
Cross join 13 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Seq<Tuple14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>> crossJoin(java.util.stream.Stream<T1> s1,
                                                                                                                                                                                               java.util.stream.Stream<T2> s2,
                                                                                                                                                                                               java.util.stream.Stream<T3> s3,
                                                                                                                                                                                               java.util.stream.Stream<T4> s4,
                                                                                                                                                                                               java.util.stream.Stream<T5> s5,
                                                                                                                                                                                               java.util.stream.Stream<T6> s6,
                                                                                                                                                                                               java.util.stream.Stream<T7> s7,
                                                                                                                                                                                               java.util.stream.Stream<T8> s8,
                                                                                                                                                                                               java.util.stream.Stream<T9> s9,
                                                                                                                                                                                               java.util.stream.Stream<T10> s10,
                                                                                                                                                                                               java.util.stream.Stream<T11> s11,
                                                                                                                                                                                               java.util.stream.Stream<T12> s12,
                                                                                                                                                                                               java.util.stream.Stream<T13> s13,
                                                                                                                                                                                               java.util.stream.Stream<T14> s14)
Cross join 14 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Seq<Tuple15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>> crossJoin(java.util.stream.Stream<T1> s1,
                                                                                                                                                                                                       java.util.stream.Stream<T2> s2,
                                                                                                                                                                                                       java.util.stream.Stream<T3> s3,
                                                                                                                                                                                                       java.util.stream.Stream<T4> s4,
                                                                                                                                                                                                       java.util.stream.Stream<T5> s5,
                                                                                                                                                                                                       java.util.stream.Stream<T6> s6,
                                                                                                                                                                                                       java.util.stream.Stream<T7> s7,
                                                                                                                                                                                                       java.util.stream.Stream<T8> s8,
                                                                                                                                                                                                       java.util.stream.Stream<T9> s9,
                                                                                                                                                                                                       java.util.stream.Stream<T10> s10,
                                                                                                                                                                                                       java.util.stream.Stream<T11> s11,
                                                                                                                                                                                                       java.util.stream.Stream<T12> s12,
                                                                                                                                                                                                       java.util.stream.Stream<T13> s13,
                                                                                                                                                                                                       java.util.stream.Stream<T14> s14,
                                                                                                                                                                                                       java.util.stream.Stream<T15> s15)
Cross join 15 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Seq<Tuple16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>> crossJoin(java.util.stream.Stream<T1> s1,
                                                                                                                                                                                                               java.util.stream.Stream<T2> s2,
                                                                                                                                                                                                               java.util.stream.Stream<T3> s3,
                                                                                                                                                                                                               java.util.stream.Stream<T4> s4,
                                                                                                                                                                                                               java.util.stream.Stream<T5> s5,
                                                                                                                                                                                                               java.util.stream.Stream<T6> s6,
                                                                                                                                                                                                               java.util.stream.Stream<T7> s7,
                                                                                                                                                                                                               java.util.stream.Stream<T8> s8,
                                                                                                                                                                                                               java.util.stream.Stream<T9> s9,
                                                                                                                                                                                                               java.util.stream.Stream<T10> s10,
                                                                                                                                                                                                               java.util.stream.Stream<T11> s11,
                                                                                                                                                                                                               java.util.stream.Stream<T12> s12,
                                                                                                                                                                                                               java.util.stream.Stream<T13> s13,
                                                                                                                                                                                                               java.util.stream.Stream<T14> s14,
                                                                                                                                                                                                               java.util.stream.Stream<T15> s15,
                                                                                                                                                                                                               java.util.stream.Stream<T16> s16)
Cross join 16 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2> Seq<Tuple2<T1,T2>> crossJoin(Iterable<T1> i1,
                                                                                                            Iterable<T2> i2)
Cross join 2 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3> Seq<Tuple3<T1,T2,T3>> crossJoin(Iterable<T1> i1,
                                                                                                                  Iterable<T2> i2,
                                                                                                                  Iterable<T3> i3)
Cross join 3 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4> Seq<Tuple4<T1,T2,T3,T4>> crossJoin(Iterable<T1> i1,
                                                                                                                        Iterable<T2> i2,
                                                                                                                        Iterable<T3> i3,
                                                                                                                        Iterable<T4> i4)
Cross join 4 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5> Seq<Tuple5<T1,T2,T3,T4,T5>> crossJoin(Iterable<T1> i1,
                                                                                                                              Iterable<T2> i2,
                                                                                                                              Iterable<T3> i3,
                                                                                                                              Iterable<T4> i4,
                                                                                                                              Iterable<T5> i5)
Cross join 5 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6> Seq<Tuple6<T1,T2,T3,T4,T5,T6>> crossJoin(Iterable<T1> i1,
                                                                                                                                    Iterable<T2> i2,
                                                                                                                                    Iterable<T3> i3,
                                                                                                                                    Iterable<T4> i4,
                                                                                                                                    Iterable<T5> i5,
                                                                                                                                    Iterable<T6> i6)
Cross join 6 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7> Seq<Tuple7<T1,T2,T3,T4,T5,T6,T7>> crossJoin(Iterable<T1> i1,
                                                                                                                                          Iterable<T2> i2,
                                                                                                                                          Iterable<T3> i3,
                                                                                                                                          Iterable<T4> i4,
                                                                                                                                          Iterable<T5> i5,
                                                                                                                                          Iterable<T6> i6,
                                                                                                                                          Iterable<T7> i7)
Cross join 7 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8> Seq<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>> crossJoin(Iterable<T1> i1,
                                                                                                                                                Iterable<T2> i2,
                                                                                                                                                Iterable<T3> i3,
                                                                                                                                                Iterable<T4> i4,
                                                                                                                                                Iterable<T5> i5,
                                                                                                                                                Iterable<T6> i6,
                                                                                                                                                Iterable<T7> i7,
                                                                                                                                                Iterable<T8> i8)
Cross join 8 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Seq<Tuple9<T1,T2,T3,T4,T5,T6,T7,T8,T9>> crossJoin(Iterable<T1> i1,
                                                                                                                                                      Iterable<T2> i2,
                                                                                                                                                      Iterable<T3> i3,
                                                                                                                                                      Iterable<T4> i4,
                                                                                                                                                      Iterable<T5> i5,
                                                                                                                                                      Iterable<T6> i6,
                                                                                                                                                      Iterable<T7> i7,
                                                                                                                                                      Iterable<T8> i8,
                                                                                                                                                      Iterable<T9> i9)
Cross join 9 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Seq<Tuple10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>> crossJoin(Iterable<T1> i1,
                                                                                                                                                               Iterable<T2> i2,
                                                                                                                                                               Iterable<T3> i3,
                                                                                                                                                               Iterable<T4> i4,
                                                                                                                                                               Iterable<T5> i5,
                                                                                                                                                               Iterable<T6> i6,
                                                                                                                                                               Iterable<T7> i7,
                                                                                                                                                               Iterable<T8> i8,
                                                                                                                                                               Iterable<T9> i9,
                                                                                                                                                               Iterable<T10> i10)
Cross join 10 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Seq<Tuple11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>> crossJoin(Iterable<T1> i1,
                                                                                                                                                                       Iterable<T2> i2,
                                                                                                                                                                       Iterable<T3> i3,
                                                                                                                                                                       Iterable<T4> i4,
                                                                                                                                                                       Iterable<T5> i5,
                                                                                                                                                                       Iterable<T6> i6,
                                                                                                                                                                       Iterable<T7> i7,
                                                                                                                                                                       Iterable<T8> i8,
                                                                                                                                                                       Iterable<T9> i9,
                                                                                                                                                                       Iterable<T10> i10,
                                                                                                                                                                       Iterable<T11> i11)
Cross join 11 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Seq<Tuple12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>> crossJoin(Iterable<T1> i1,
                                                                                                                                                                               Iterable<T2> i2,
                                                                                                                                                                               Iterable<T3> i3,
                                                                                                                                                                               Iterable<T4> i4,
                                                                                                                                                                               Iterable<T5> i5,
                                                                                                                                                                               Iterable<T6> i6,
                                                                                                                                                                               Iterable<T7> i7,
                                                                                                                                                                               Iterable<T8> i8,
                                                                                                                                                                               Iterable<T9> i9,
                                                                                                                                                                               Iterable<T10> i10,
                                                                                                                                                                               Iterable<T11> i11,
                                                                                                                                                                               Iterable<T12> i12)
Cross join 12 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Seq<Tuple13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>> crossJoin(Iterable<T1> i1,
                                                                                                                                                                                       Iterable<T2> i2,
                                                                                                                                                                                       Iterable<T3> i3,
                                                                                                                                                                                       Iterable<T4> i4,
                                                                                                                                                                                       Iterable<T5> i5,
                                                                                                                                                                                       Iterable<T6> i6,
                                                                                                                                                                                       Iterable<T7> i7,
                                                                                                                                                                                       Iterable<T8> i8,
                                                                                                                                                                                       Iterable<T9> i9,
                                                                                                                                                                                       Iterable<T10> i10,
                                                                                                                                                                                       Iterable<T11> i11,
                                                                                                                                                                                       Iterable<T12> i12,
                                                                                                                                                                                       Iterable<T13> i13)
Cross join 13 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Seq<Tuple14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>> crossJoin(Iterable<T1> i1,
                                                                                                                                                                                               Iterable<T2> i2,
                                                                                                                                                                                               Iterable<T3> i3,
                                                                                                                                                                                               Iterable<T4> i4,
                                                                                                                                                                                               Iterable<T5> i5,
                                                                                                                                                                                               Iterable<T6> i6,
                                                                                                                                                                                               Iterable<T7> i7,
                                                                                                                                                                                               Iterable<T8> i8,
                                                                                                                                                                                               Iterable<T9> i9,
                                                                                                                                                                                               Iterable<T10> i10,
                                                                                                                                                                                               Iterable<T11> i11,
                                                                                                                                                                                               Iterable<T12> i12,
                                                                                                                                                                                               Iterable<T13> i13,
                                                                                                                                                                                               Iterable<T14> i14)
Cross join 14 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Seq<Tuple15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>> crossJoin(Iterable<T1> i1,
                                                                                                                                                                                                       Iterable<T2> i2,
                                                                                                                                                                                                       Iterable<T3> i3,
                                                                                                                                                                                                       Iterable<T4> i4,
                                                                                                                                                                                                       Iterable<T5> i5,
                                                                                                                                                                                                       Iterable<T6> i6,
                                                                                                                                                                                                       Iterable<T7> i7,
                                                                                                                                                                                                       Iterable<T8> i8,
                                                                                                                                                                                                       Iterable<T9> i9,
                                                                                                                                                                                                       Iterable<T10> i10,
                                                                                                                                                                                                       Iterable<T11> i11,
                                                                                                                                                                                                       Iterable<T12> i12,
                                                                                                                                                                                                       Iterable<T13> i13,
                                                                                                                                                                                                       Iterable<T14> i14,
                                                                                                                                                                                                       Iterable<T15> i15)
Cross join 15 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Seq<Tuple16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>> crossJoin(Iterable<T1> i1,
                                                                                                                                                                                                               Iterable<T2> i2,
                                                                                                                                                                                                               Iterable<T3> i3,
                                                                                                                                                                                                               Iterable<T4> i4,
                                                                                                                                                                                                               Iterable<T5> i5,
                                                                                                                                                                                                               Iterable<T6> i6,
                                                                                                                                                                                                               Iterable<T7> i7,
                                                                                                                                                                                                               Iterable<T8> i8,
                                                                                                                                                                                                               Iterable<T9> i9,
                                                                                                                                                                                                               Iterable<T10> i10,
                                                                                                                                                                                                               Iterable<T11> i11,
                                                                                                                                                                                                               Iterable<T12> i12,
                                                                                                                                                                                                               Iterable<T13> i13,
                                                                                                                                                                                                               Iterable<T14> i14,
                                                                                                                                                                                                               Iterable<T15> i15,
                                                                                                                                                                                                               Iterable<T16> i16)
Cross join 16 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2> Seq<Tuple2<T1,T2>> crossJoin(Seq<T1> s1,
                                                                                                            Seq<T2> s2)
Cross join 2 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3> Seq<Tuple3<T1,T2,T3>> crossJoin(Seq<T1> s1,
                                                                                                                  Seq<T2> s2,
                                                                                                                  Seq<T3> s3)
Cross join 3 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4> Seq<Tuple4<T1,T2,T3,T4>> crossJoin(Seq<T1> s1,
                                                                                                                        Seq<T2> s2,
                                                                                                                        Seq<T3> s3,
                                                                                                                        Seq<T4> s4)
Cross join 4 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5> Seq<Tuple5<T1,T2,T3,T4,T5>> crossJoin(Seq<T1> s1,
                                                                                                                              Seq<T2> s2,
                                                                                                                              Seq<T3> s3,
                                                                                                                              Seq<T4> s4,
                                                                                                                              Seq<T5> s5)
Cross join 5 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6> Seq<Tuple6<T1,T2,T3,T4,T5,T6>> crossJoin(Seq<T1> s1,
                                                                                                                                    Seq<T2> s2,
                                                                                                                                    Seq<T3> s3,
                                                                                                                                    Seq<T4> s4,
                                                                                                                                    Seq<T5> s5,
                                                                                                                                    Seq<T6> s6)
Cross join 6 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7> Seq<Tuple7<T1,T2,T3,T4,T5,T6,T7>> crossJoin(Seq<T1> s1,
                                                                                                                                          Seq<T2> s2,
                                                                                                                                          Seq<T3> s3,
                                                                                                                                          Seq<T4> s4,
                                                                                                                                          Seq<T5> s5,
                                                                                                                                          Seq<T6> s6,
                                                                                                                                          Seq<T7> s7)
Cross join 7 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8> Seq<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>> crossJoin(Seq<T1> s1,
                                                                                                                                                Seq<T2> s2,
                                                                                                                                                Seq<T3> s3,
                                                                                                                                                Seq<T4> s4,
                                                                                                                                                Seq<T5> s5,
                                                                                                                                                Seq<T6> s6,
                                                                                                                                                Seq<T7> s7,
                                                                                                                                                Seq<T8> s8)
Cross join 8 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Seq<Tuple9<T1,T2,T3,T4,T5,T6,T7,T8,T9>> crossJoin(Seq<T1> s1,
                                                                                                                                                      Seq<T2> s2,
                                                                                                                                                      Seq<T3> s3,
                                                                                                                                                      Seq<T4> s4,
                                                                                                                                                      Seq<T5> s5,
                                                                                                                                                      Seq<T6> s6,
                                                                                                                                                      Seq<T7> s7,
                                                                                                                                                      Seq<T8> s8,
                                                                                                                                                      Seq<T9> s9)
Cross join 9 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Seq<Tuple10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>> crossJoin(Seq<T1> s1,
                                                                                                                                                               Seq<T2> s2,
                                                                                                                                                               Seq<T3> s3,
                                                                                                                                                               Seq<T4> s4,
                                                                                                                                                               Seq<T5> s5,
                                                                                                                                                               Seq<T6> s6,
                                                                                                                                                               Seq<T7> s7,
                                                                                                                                                               Seq<T8> s8,
                                                                                                                                                               Seq<T9> s9,
                                                                                                                                                               Seq<T10> s10)
Cross join 10 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Seq<Tuple11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>> crossJoin(Seq<T1> s1,
                                                                                                                                                                       Seq<T2> s2,
                                                                                                                                                                       Seq<T3> s3,
                                                                                                                                                                       Seq<T4> s4,
                                                                                                                                                                       Seq<T5> s5,
                                                                                                                                                                       Seq<T6> s6,
                                                                                                                                                                       Seq<T7> s7,
                                                                                                                                                                       Seq<T8> s8,
                                                                                                                                                                       Seq<T9> s9,
                                                                                                                                                                       Seq<T10> s10,
                                                                                                                                                                       Seq<T11> s11)
Cross join 11 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Seq<Tuple12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>> crossJoin(Seq<T1> s1,
                                                                                                                                                                               Seq<T2> s2,
                                                                                                                                                                               Seq<T3> s3,
                                                                                                                                                                               Seq<T4> s4,
                                                                                                                                                                               Seq<T5> s5,
                                                                                                                                                                               Seq<T6> s6,
                                                                                                                                                                               Seq<T7> s7,
                                                                                                                                                                               Seq<T8> s8,
                                                                                                                                                                               Seq<T9> s9,
                                                                                                                                                                               Seq<T10> s10,
                                                                                                                                                                               Seq<T11> s11,
                                                                                                                                                                               Seq<T12> s12)
Cross join 12 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Seq<Tuple13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>> crossJoin(Seq<T1> s1,
                                                                                                                                                                                       Seq<T2> s2,
                                                                                                                                                                                       Seq<T3> s3,
                                                                                                                                                                                       Seq<T4> s4,
                                                                                                                                                                                       Seq<T5> s5,
                                                                                                                                                                                       Seq<T6> s6,
                                                                                                                                                                                       Seq<T7> s7,
                                                                                                                                                                                       Seq<T8> s8,
                                                                                                                                                                                       Seq<T9> s9,
                                                                                                                                                                                       Seq<T10> s10,
                                                                                                                                                                                       Seq<T11> s11,
                                                                                                                                                                                       Seq<T12> s12,
                                                                                                                                                                                       Seq<T13> s13)
Cross join 13 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Seq<Tuple14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>> crossJoin(Seq<T1> s1,
                                                                                                                                                                                               Seq<T2> s2,
                                                                                                                                                                                               Seq<T3> s3,
                                                                                                                                                                                               Seq<T4> s4,
                                                                                                                                                                                               Seq<T5> s5,
                                                                                                                                                                                               Seq<T6> s6,
                                                                                                                                                                                               Seq<T7> s7,
                                                                                                                                                                                               Seq<T8> s8,
                                                                                                                                                                                               Seq<T9> s9,
                                                                                                                                                                                               Seq<T10> s10,
                                                                                                                                                                                               Seq<T11> s11,
                                                                                                                                                                                               Seq<T12> s12,
                                                                                                                                                                                               Seq<T13> s13,
                                                                                                                                                                                               Seq<T14> s14)
Cross join 14 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Seq<Tuple15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>> crossJoin(Seq<T1> s1,
                                                                                                                                                                                                       Seq<T2> s2,
                                                                                                                                                                                                       Seq<T3> s3,
                                                                                                                                                                                                       Seq<T4> s4,
                                                                                                                                                                                                       Seq<T5> s5,
                                                                                                                                                                                                       Seq<T6> s6,
                                                                                                                                                                                                       Seq<T7> s7,
                                                                                                                                                                                                       Seq<T8> s8,
                                                                                                                                                                                                       Seq<T9> s9,
                                                                                                                                                                                                       Seq<T10> s10,
                                                                                                                                                                                                       Seq<T11> s11,
                                                                                                                                                                                                       Seq<T12> s12,
                                                                                                                                                                                                       Seq<T13> s13,
                                                                                                                                                                                                       Seq<T14> s14,
                                                                                                                                                                                                       Seq<T15> s15)
Cross join 15 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







crossJoin
@Generated(value="This method was generated using jOOQ-tools")
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Seq<Tuple16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>> crossJoin(Seq<T1> s1,
                                                                                                                                                                                                               Seq<T2> s2,
                                                                                                                                                                                                               Seq<T3> s3,
                                                                                                                                                                                                               Seq<T4> s4,
                                                                                                                                                                                                               Seq<T5> s5,
                                                                                                                                                                                                               Seq<T6> s6,
                                                                                                                                                                                                               Seq<T7> s7,
                                                                                                                                                                                                               Seq<T8> s8,
                                                                                                                                                                                                               Seq<T9> s9,
                                                                                                                                                                                                               Seq<T10> s10,
                                                                                                                                                                                                               Seq<T11> s11,
                                                                                                                                                                                                               Seq<T12> s12,
                                                                                                                                                                                                               Seq<T13> s13,
                                                                                                                                                                                                               Seq<T14> s14,
                                                                                                                                                                                                               Seq<T15> s15,
                                                                                                                                                                                                               Seq<T16> s16)
Cross join 16 streams into one.
 
 
 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 







concat
@SafeVarargs
static <T> Seq<T> concat(java.util.stream.Stream<T>... streams)
Concatenate a number of streams.
 
 
 // (1, 2, 3, 4, 5, 6)
 Seq.of(1, 2, 3).concat(Seq.of(4, 5, 6))
 







concat
@SafeVarargs
static <T> Seq<T> concat(Iterable<T>... iterables)
Concatenate a number of streams.
 
 
 // (1, 2, 3, 4, 5, 6)
 Seq.of(1, 2, 3).concat(Seq.of(4, 5, 6))
 







concat
@SafeVarargs
static <T> Seq<T> concat(Seq<T>... streams)
Concatenate a number of streams.
 
 
 // (1, 2, 3, 4, 5, 6)
 Seq.of(1, 2, 3).concat(Seq.of(4, 5, 6))
 







duplicate
static <T> Tuple2<Seq<T>,Seq<T>> duplicate(java.util.stream.Stream<T> stream)
Duplicate a Streams into two equivalent Streams.
 
 
 // tuple((1, 2, 3), (1, 2, 3))
 Seq.of(1, 2, 3).duplicate()
 







toString
static String toString(java.util.stream.Stream<?> stream)
Consume a stream and concatenate all elements.







toString
static String toString(java.util.stream.Stream<?> stream,
                       CharSequence delimiter)
Consume a stream and concatenate all elements using a separator.







toCollection
static <T,C extends Collection<T>> C toCollection(java.util.stream.Stream<T> stream,
                                                  java.util.function.Supplier<C> collectionFactory)
Collect a Stream into a List.







toList
static <T> List<T> toList(java.util.stream.Stream<T> stream)
Collect a Stream into a List.







toSet
static <T> Set<T> toSet(java.util.stream.Stream<T> stream)
Collect a Stream into a Set.







toMap
static <T,K,V> Map<K,V> toMap(java.util.stream.Stream<Tuple2<K,V>> stream)
Collect a Stream of Tuple2 into a Map.







toMap
static <T,K,V> Map<K,V> toMap(java.util.stream.Stream<T> stream,
                              java.util.function.Function<? super T,? extends K> keyMapper,
                              java.util.function.Function<? super T,? extends V> valueMapper)
Collect a Stream into a Map.







slice
static <T> Seq<T> slice(java.util.stream.Stream<T> stream,
                        long from,
                        long to)
Returns a limited interval from a given Stream.
 
 
 // (4, 5)
 Seq.of(1, 2, 3, 4, 5, 6).slice(3, 5)
 







skip
static <T> Seq<T> skip(java.util.stream.Stream<T> stream,
                       long elements)
Returns a stream with n elements skipped.
 
 
 // (4, 5, 6)
 Seq.of(1, 2, 3, 4, 5, 6).skip(3)
 







skipWhile
static <T> Seq<T> skipWhile(java.util.stream.Stream<T> stream,
                            java.util.function.Predicate<? super T> predicate)
Returns a stream with all elements skipped for which a predicate evaluates to true.
 
 
 // (3, 4, 5)
 Seq.of(1, 2, 3, 4, 5).skipWhile(i -> i < 3)
 







skipWhileClosed
static <T> Seq<T> skipWhileClosed(java.util.stream.Stream<T> stream,
                                  java.util.function.Predicate<? super T> predicate)
Returns a stream with all elements skipped for which a predicate evaluates to true
 plus the first element for which it evaluates to false.
 
 
 // (4, 5)
 Seq.of(1, 2, 3, 4, 5).skipWhileClosed(i -> i < 3)
 







skipUntil
static <T> Seq<T> skipUntil(java.util.stream.Stream<T> stream,
                            java.util.function.Predicate<? super T> predicate)
Returns a stream with all elements skipped for which a predicate evaluates to false.
 
 
 // (3, 4, 5)
 Seq.of(1, 2, 3, 4, 5).skipUntil(i -> i == 3)
 







skipUntilClosed
static <T> Seq<T> skipUntilClosed(java.util.stream.Stream<T> stream,
                                  java.util.function.Predicate<? super T> predicate)
Returns a stream with all elements skipped for which a predicate evaluates to false
 plus the first element for which it evaluates to true.
 
 
 // (4, 5)
 Seq.of(1, 2, 3, 4, 5).skipUntilClosed(i -> i == 3)
 







limit
static <T> Seq<T> limit(java.util.stream.Stream<T> stream,
                        long elements)
Returns a stream limited to n elements.
 
 
 // (1, 2, 3)
 Seq.of(1, 2, 3, 4, 5, 6).limit(3)
 







limitWhile
static <T> Seq<T> limitWhile(java.util.stream.Stream<T> stream,
                             java.util.function.Predicate<? super T> predicate)
Returns a stream limited to all elements for which a predicate evaluates to true.
 
 
 // (1, 2)
 Seq.of(1, 2, 3, 4, 5).limitWhile(i -> i < 3)
 







limitWhileClosed
static <T> Seq<T> limitWhileClosed(java.util.stream.Stream<T> stream,
                                   java.util.function.Predicate<? super T> predicate)
Returns a stream limited to all elements for which a predicate evaluates to true
 plus the first element for which it evaluates to false.
 
 
 // (1, 2, 3)
 Seq.of(1, 2, 3, 4, 5).limitWhileClosed(i -> i < 3)
 







limitUntil
static <T> Seq<T> limitUntil(java.util.stream.Stream<T> stream,
                             java.util.function.Predicate<? super T> predicate)
Returns a stream limited to all elements for which a predicate evaluates to false.
 
 
 // (1, 2)
 Seq.of(1, 2, 3, 4, 5).limitUntil(i -> i == 3)
 







limitUntilClosed
static <T> Seq<T> limitUntilClosed(java.util.stream.Stream<T> stream,
                                   java.util.function.Predicate<? super T> predicate)
Returns a stream limited to all elements for which a predicate evaluates to false
 plus the first element for which it evaluates to true.
 
 
 // (1, 2, 3)
 Seq.of(1, 2, 3, 4, 5).limitUntilClosed(i -> i == 3)
 









intersperse
static <T> Seq<T> intersperse(java.util.stream.Stream<T> stream,
                              T value)
Returns a stream with a given value interspersed between any two values of this stream.
 
 
 // (1, 0, 2, 0, 3, 0, 4)
 Seq.of(1, 2, 3, 4).intersperse(0)
 







grouped
static <K,T> Seq<Tuple2<K,Seq<T>>> grouped(java.util.stream.Stream<T> stream,
                                           java.util.function.Function<? super T,? extends K> classifier)
Classify this stream's elements according to a given classifier function
 
 
 // Seq(tuple(1, Seq(1, 3, 5)), tuple(0, Seq(2, 4, 6)))
 Seq.of(1, 2, 3, 4, 5, 6).grouped(i -> i % 2 )
 // Seq(tuple(true, Seq(1, 3, 5)), tuple(false, Seq(2, 4, 6)))
 Seq.of(1, 2, 3, 4, 5, 6).grouped(i -> i % 2 != 0)
 

 This is a non-terminal analog of groupBy(Stream, Function))

See Also:
groupBy(Function), 
partition(Predicate)








grouped
static <K,T> Seq<Tuple2<K,Seq<T>>> grouped(Iterable<T> iterable,
                                           java.util.function.Function<? super T,? extends K> classifier)
Classify this stream's elements according to a given classifier function
 
 
 // Seq(tuple(1, Seq(1, 3, 5)), tuple(0, Seq(2, 4, 6)))
 Seq.of(1, 2, 3, 4, 5, 6).grouped(i -> i % 2 )
 // Seq(tuple(true, Seq(1, 3, 5)), tuple(false, Seq(2, 4, 6)))
 Seq.of(1, 2, 3, 4, 5, 6).grouped(i -> i % 2 != 0)
 

 This is a non-terminal analog of groupBy(Stream, Function))

See Also:
groupBy(Function), 
partition(Predicate)








grouped
static <K,T> Seq<Tuple2<K,Seq<T>>> grouped(Seq<T> seq,
                                           java.util.function.Function<? super T,? extends K> classifier)
Classify this stream's elements according to a given classifier function
 
 
 // Seq(tuple(1, Seq(1, 3, 5)), tuple(0, Seq(2, 4, 6)))
 Seq.of(1, 2, 3, 4, 5, 6).grouped(i -> i % 2 )
 // Seq(tuple(true, Seq(1, 3, 5)), tuple(false, Seq(2, 4, 6)))
 Seq.of(1, 2, 3, 4, 5, 6).grouped(i -> i % 2 != 0)
 

 This is a non-terminal analog of groupBy(Stream, Function))

See Also:
groupBy(Function), 
partition(Predicate)








grouped
static <K,T,A,D> Seq<Tuple2<K,D>> grouped(java.util.stream.Stream<T> stream,
                                          java.util.function.Function<? super T,? extends K> classifier,
                                          java.util.stream.Collector<? super T,A,D> downstream)
Classify this stream's elements according to a given classifier function
 and collect each class's elements using a collector.
 
 
 // Seq(tuple(1, 9), tuple(0, 12))
 Seq.of(1, 2, 3, 4, 5, 6).grouped(i -> i % 2, Collectors.summingInt(i -> i))
 // Seq(tuple(true, 9), tuple(false, 12))
 Seq.of(1, 2, 3, 4, 5, 6).grouped(i -> i % 2 != 0, Collectors.summingInt(i -> i))
  This is a non-terminal analog of
 groupBy(Function, Collector))

See Also:
groupBy(Function, Collector)








grouped
static <K,T,A,D> Seq<Tuple2<K,D>> grouped(Iterable<T> iterable,
                                          java.util.function.Function<? super T,? extends K> classifier,
                                          java.util.stream.Collector<? super T,A,D> downstream)
Classify this stream's elements according to a given classifier function
 and collect each class's elements using a collector.
 
 
 // Seq(tuple(1, 9), tuple(0, 12))
 Seq.of(1, 2, 3, 4, 5, 6).grouped(i -> i % 2, Collectors.summingInt(i -> i))
 // Seq(tuple(true, 9), tuple(false, 12))
 Seq.of(1, 2, 3, 4, 5, 6).grouped(i -> i % 2 != 0, Collectors.summingInt(i -> i))
  This is a non-terminal analog of
 groupBy(Function, Collector))

See Also:
groupBy(Function, Collector)








grouped
static <K,T,A,D> Seq<Tuple2<K,D>> grouped(Seq<T> seq,
                                          java.util.function.Function<? super T,? extends K> classifier,
                                          java.util.stream.Collector<? super T,A,D> downstream)
Classify this stream's elements according to a given classifier function
 and collect each class's elements using a collector.
 
 
 // Seq(tuple(1, 9), tuple(0, 12))
 Seq.of(1, 2, 3, 4, 5, 6).grouped(i -> i % 2, Collectors.summingInt(i -> i))
 // Seq(tuple(true, 9), tuple(false, 12))
 Seq.of(1, 2, 3, 4, 5, 6).grouped(i -> i % 2 != 0, Collectors.summingInt(i -> i))
  This is a non-terminal analog of
 groupBy(Function, Collector))

See Also:
groupBy(Function, Collector)








partition
static <T> Tuple2<Seq<T>,Seq<T>> partition(java.util.stream.Stream<T> stream,
                                           java.util.function.Predicate<? super T> predicate)
Partition a stream into two given a predicate.
 
 
 // tuple((1, 3, 5), (2, 4, 6))
 Seq.of(1, 2, 3, 4, 5, 6).partition(i -> i % 2 != 0)
 







splitAt
static <T> Tuple2<Seq<T>,Seq<T>> splitAt(java.util.stream.Stream<T> stream,
                                         long position)
Split a stream at a given position.
 
 
 // tuple((1, 2, 3), (4, 5, 6))
 Seq.of(1, 2, 3, 4, 5, 6).splitAt(3)
 







splitAtHead
static <T> Tuple2<Optional<T>,Seq<T>> splitAtHead(java.util.stream.Stream<T> stream)
Split a stream at the head.
 
 
 // tuple(1, (2, 3, 4, 5, 6))
 Seq.of(1, 2, 3, 4, 5, 6).splitHead(3)
 







ofType
static <T,U> Seq<U> ofType(java.util.stream.Stream<T> stream,
                           Class<U> type)
Keep only those elements in a stream that are of a given type.
 
 
 // (1, 2, 3)
 Seq.of(1, "a", 2, "b", 3).ofType(Integer.class)
 







cast
static <T,U> Seq<U> cast(java.util.stream.Stream<T> stream,
                         Class<U> type)
Cast all elements in a stream to a given type, possibly throwing a ClassCastException.
 
 
 // ClassCastException
 Seq.of(1, "a", 2, "b", 3).cast(Integer.class)
 







groupBy
static <T,K> Map<K,List<T>> groupBy(java.util.stream.Stream<T> stream,
                                    java.util.function.Function<? super T,? extends K> classifier)
Shortcut for calling Stream.collect(Collector) with a
 Collectors.groupingBy(Function) collector.







groupBy
static <T,K,A,D> Map<K,D> groupBy(java.util.stream.Stream<T> stream,
                                  java.util.function.Function<? super T,? extends K> classifier,
                                  java.util.stream.Collector<? super T,A,D> downstream)
Shortcut for calling Stream.collect(Collector) with a
 Collectors.groupingBy(Function, Collector) collector.







groupBy
static <T,K,D,A,M extends Map<K,D>> M groupBy(java.util.stream.Stream<T> stream,
                                              java.util.function.Function<? super T,? extends K> classifier,
                                              java.util.function.Supplier<M> mapFactory,
                                              java.util.stream.Collector<? super T,A,D> downstream)
Shortcut for calling Stream.collect(Collector) with a
 Collectors.groupingBy(Function, Supplier, Collector) collector.







join
@Deprecated
static String join(java.util.stream.Stream<?> stream)
Deprecated. - Use #toString() instead. This method will be
 removed in the future as it causes confusion with
 innerJoin(Seq, BiPredicate).
Shortcut for calling Stream.collect(Collector) with a
 Collectors.joining()
 collector.







join
@Deprecated
static String join(java.util.stream.Stream<?> stream,
                                CharSequence delimiter)
Deprecated. - Use #toString() instead. This method will be
 removed in the future as it causes confusion with
 innerJoin(Seq, BiPredicate).
Shortcut for calling Stream.collect(Collector) with a
 Collectors.joining(CharSequence)
 collector.







join
@Deprecated
static String join(java.util.stream.Stream<?> stream,
                                CharSequence delimiter,
                                CharSequence prefix,
                                CharSequence suffix)
Deprecated. - Use #toString() instead. This method will be
 removed in the future as it causes confusion with
 innerJoin(Seq, BiPredicate).
Shortcut for calling Stream.collect(Collector) with a
 Collectors.joining(CharSequence, CharSequence, CharSequence)
 collector.







filter
Seq<T> filter(java.util.function.Predicate<? super T> predicate)

Specified by:
filter in interface java.util.stream.Stream<T>








map
<R> Seq<R> map(java.util.function.Function<? super T,? extends R> mapper)

Specified by:
map in interface java.util.stream.Stream<T>








mapToInt
java.util.stream.IntStream mapToInt(java.util.function.ToIntFunction<? super T> mapper)

Specified by:
mapToInt in interface java.util.stream.Stream<T>








mapToLong
java.util.stream.LongStream mapToLong(java.util.function.ToLongFunction<? super T> mapper)

Specified by:
mapToLong in interface java.util.stream.Stream<T>








mapToDouble
java.util.stream.DoubleStream mapToDouble(java.util.function.ToDoubleFunction<? super T> mapper)

Specified by:
mapToDouble in interface java.util.stream.Stream<T>








flatMap
<R> Seq<R> flatMap(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> mapper)

Specified by:
flatMap in interface java.util.stream.Stream<T>








flatMapToInt
java.util.stream.IntStream flatMapToInt(java.util.function.Function<? super T,? extends java.util.stream.IntStream> mapper)

Specified by:
flatMapToInt in interface java.util.stream.Stream<T>








flatMapToLong
java.util.stream.LongStream flatMapToLong(java.util.function.Function<? super T,? extends java.util.stream.LongStream> mapper)

Specified by:
flatMapToLong in interface java.util.stream.Stream<T>








flatMapToDouble
java.util.stream.DoubleStream flatMapToDouble(java.util.function.Function<? super T,? extends java.util.stream.DoubleStream> mapper)

Specified by:
flatMapToDouble in interface java.util.stream.Stream<T>








distinct
Seq<T> distinct()

Specified by:
distinct in interface java.util.stream.Stream<T>








sorted
Seq<T> sorted()

Specified by:
sorted in interface java.util.stream.Stream<T>








sorted
Seq<T> sorted(Comparator<? super T> comparator)

Specified by:
sorted in interface java.util.stream.Stream<T>








peek
Seq<T> peek(java.util.function.Consumer<? super T> action)

Specified by:
peek in interface java.util.stream.Stream<T>








limit
Seq<T> limit(long maxSize)

Specified by:
limit in interface java.util.stream.Stream<T>








skip
Seq<T> skip(long n)

Specified by:
skip in interface java.util.stream.Stream<T>








onClose
Seq<T> onClose(Runnable closeHandler)

Specified by:
onClose in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>








close
void close()

Specified by:
close in interface AutoCloseable
Specified by:
close in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>








count
long count()
Description copied from interface: Collectable
Count the values in this collectable.

Specified by:
count in interface Collectable<T>
Specified by:
count in interface java.util.stream.Stream<T>








sequential
default Seq<T> sequential()
Returns this stream. All Seq streams are sequential, hence the name.

Specified by:
sequential in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>
Returns:
this stream unmodified








parallel
default Seq<T> parallel()
Seq streams are always sequential and, as such, doesn't support
 parallelization.

Specified by:
parallel in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>
Returns:
this sequential stream unmodified
See Also:
jOOL Issue #130








unordered
default Seq<T> unordered()
Returns this stream. All Seq streams are ordered so this method has
 no effect.

Specified by:
unordered in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>
Returns:
this stream unmodified








spliterator
default Spliterator<T> spliterator()

Specified by:
spliterator in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>
Specified by:
spliterator in interface Iterable<T>








forEach
default void forEach(java.util.function.Consumer<? super T> action)

Specified by:
forEach in interface Iterable<T>
Specified by:
forEach in interface java.util.stream.Stream<T>








format
String format()
Generate a nicely formatted representation of this stream.
 
 Clients should not rely on the concrete formatting of this method, which
 is intended for debugging convenience only.







printOut
default void printOut()
Print contents of this stream to System.out.







printErr
default void printErr()
Print contents of this stream to System.err.







print
default void print(PrintWriter writer)
Print contents of this stream to the argument writer.







print
default void print(PrintStream stream)
Print contents of this stream to the argument stream.

Interface Seq<T>

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.stream.Stream

Method Summary

Methods inherited from interface java.util.stream.Stream

Methods inherited from interface java.util.stream.BaseStream

Methods inherited from interface java.lang.Iterable

Methods inherited from interface org.jooq.lambda.Collectable

Method Detail

stream

crossJoin

crossJoin

crossJoin

innerJoin

innerJoin

innerJoin

leftOuterJoin

leftOuterJoin

leftOuterJoin

rightOuterJoin

rightOuterJoin

rightOuterJoin

onEmpty

onEmptyGet

onEmptyThrow

concat

concat

concat

concat

concat

append

append

append

append

append

prepend

prepend

prepend

prepend

prepend

contains

containsAll

containsAll

containsAll

containsAll

containsAny

containsAny

containsAny

containsAny

get

remove

removeAll

removeAll

removeAll

removeAll

retainAll

retainAll

retainAll

retainAll

cycle

distinct

zip

zip

zip

zip

zip

zip

zipWithIndex

foldLeft

foldRight

scanLeft

scanRight

reverse

shuffle

shuffle

skipWhile

skipWhileClosed

skipUntil

skipUntilClosed

limitWhile