org.jooq.lambda

Interface Seq<T>

All Superinterfaces:

AutoCloseable, java.util.stream.BaseStream<T,java.util.stream.Stream<T>>, Iterable<T>, java.util.stream.Stream<T>

public interface Seq<T>
extends java.util.stream.Stream<T>, Iterable<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

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()
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)
static Seq<Void>	generate()
static <T> Seq<T>	generate(java.util.function.Supplier<T> s)
static <T> Seq<T>	generate(T value)
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() Shortcut for calling Stream.collect(Collector) with a Collectors.joining() collector.
default String	join(CharSequence delimiter) Shortcut for calling Stream.collect(Collector) with a Collectors.joining(CharSequence) collector.
default String	join(CharSequence delimiter, CharSequence prefix, CharSequence suffix) Shortcut for calling Stream.collect(Collector) with a Collectors.joining(CharSequence, CharSequence, CharSequence) collector.
static String	join(java.util.stream.Stream<?> stream) Shortcut for calling Stream.collect(Collector) with a Collectors.joining() collector.
static String	join(java.util.stream.Stream<?> stream, CharSequence delimiter) Shortcut for calling Stream.collect(Collector) with a Collectors.joining(CharSequence) collector.
static String	join(java.util.stream.Stream<?> stream, CharSequence delimiter, CharSequence prefix, CharSequence suffix) Shortcut for calling Stream.collect(Collector) with a Collectors.joining(CharSequence, CharSequence, CharSequence) collector.
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 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.
<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)
default <U extends Comparable<U>> Optional<T>	maxBy(java.util.function.Function<? super T,? extends U> function) Get the maximum value by a function.
default <U> Optional<T>	maxBy(java.util.function.Function<? super T,? extends U> function, Comparator<? super U> comparator) Get the maximum value by a function.
default <U extends Comparable<U>> Optional<T>	minBy(java.util.function.Function<? super T,? extends U> function) Get the minimum value by a function.
default <U> Optional<T>	minBy(java.util.function.Function<? super T,? extends U> function, Comparator<? super U> comparator) Get the minimum value by a function.
default Optional<T>	mode() Get the mode, i.e. the value that appears most often in the stream.
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>	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>	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 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.
default <C extends Collection<T>> C	toCollection(java.util.function.Supplier<C> collectionFactory) Collect a Stream into a Collection.
default List<T>	toList() Collect a Stream into a List.
static <T> List<T>	toList(java.util.stream.Stream<T> stream) Collect a Stream into a List.
default <L extends List<T>> L	toList(java.util.function.Supplier<L> listFactory) Collect a Stream into a List.
default <K,V> Map<K,V>	toMap(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<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.
default Set<T>	toSet() Collect a Stream into a Set.
static <T> Set<T>	toSet(java.util.stream.Stream<T> stream) Collect a Stream into a Set.
default <S extends Set<T>> S	toSet(java.util.function.Supplier<S> setFactory) 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, String separator) Consume a stream and concatenate all elements using a separator.
default String	toString(String separator) Consume a stream and concatenate aTll 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.
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

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)
 

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)

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)

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)

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)

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)

toCollection

default <C extends Collection<T>> C toCollection(java.util.function.Supplier<C> collectionFactory)

Collect a Stream into a Collection.

See Also:

toCollection(Stream, Supplier)

toList

default List<T> toList()

Collect a Stream into a List.

See Also:

toList(Stream)

toList

default <L extends List<T>> L toList(java.util.function.Supplier<L> listFactory)

Collect a Stream into a List.

See Also:

toList(Stream)

toSet

default Set<T> toSet()

Collect a Stream into a Set.

See Also:

toSet(Stream)

toSet

default <S extends Set<T>> S toSet(java.util.function.Supplier<S> setFactory)

Collect a Stream into a Set.

See Also:

toSet(Stream)

toMap

default <K,V> Map<K,V> toMap(java.util.function.Function<? super T,? extends K> keyMapper,
                             java.util.function.Function<? super T,? extends V> valueMapper)

Collect a Stream into a Map.

See Also:

toMap(Stream, Function, Function)

toString

default String toString(String separator)

Consume a stream and concatenate aTll elements using a separator.

mode

default Optional<T> mode()

Get the mode, i.e. the value that appears most often in the stream.

minBy

default <U extends Comparable<U>> Optional<T> minBy(java.util.function.Function<? super T,? extends U> function)

Get the minimum value by a function.

minBy

default <U> Optional<T> minBy(java.util.function.Function<? super T,? extends U> function,
                              Comparator<? super U> comparator)

Get the minimum value by a function.

maxBy

default <U extends Comparable<U>> Optional<T> maxBy(java.util.function.Function<? super T,? extends U> function)

Get the maximum value by a function.

maxBy

default <U> Optional<T> maxBy(java.util.function.Function<? super T,? extends U> function,
                              Comparator<? super U> comparator)

Get the maximum value by a function.

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.

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)

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

default String join()

Shortcut for calling Stream.collect(Collector) with a Collectors.joining() collector.

join

default String join(CharSequence delimiter)

Shortcut for calling Stream.collect(Collector) with a Collectors.joining(CharSequence) collector.

join

default String join(CharSequence delimiter,
                    CharSequence prefix,
                    CharSequence suffix)

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,
                       String separator)

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)
 

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)
 

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)
 

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 true.

 // (1, 2)
 Seq.of(1, 2, 3, 4, 5).limitUntil(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

static String join(java.util.stream.Stream<?> stream)

Shortcut for calling Stream.collect(Collector) with a Collectors.joining() collector.

join

static String join(java.util.stream.Stream<?> stream,
                   CharSequence delimiter)

Shortcut for calling Stream.collect(Collector) with a Collectors.joining(CharSequence) collector.

join

static String join(java.util.stream.Stream<?> stream,
                   CharSequence delimiter,
                   CharSequence prefix,
                   CharSequence suffix)

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()

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>

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.