org.jooq.lambda

Interface Seq<T>

    • Method Detail

      • stream

        Stream<T> stream()
        The underlying Stream implementation.

      • crossJoin

        default <U> Seq<Tuple2<T,U>> crossJoin(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(Stream<U> other,
                                       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,
                                       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,
                                       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(Stream<U> other,
                                           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,
                                           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,
                                           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(Stream<U> other,
                                            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,
                                            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,
                                            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(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(Supplier<X> supplier)
        Produce this stream, or an alternative stream from the supplier, in case this stream is empty.

      • concat

        default Seq<T> concat(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(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(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(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(Stream<T> other)
        Check whether this stream contains any of the given values. 

        
 // true
 Seq.of(1, 2, 3).containsAny(2, 4)

      • containsAny

        default boolean containsAny(Iterable<T> other)
        Check whether this stream contains any of the given values. 

        
 // true
 Seq.of(1, 2, 3).containsAny(2, 4)

      • containsAny

        default boolean containsAny(Seq<T> other)
        Check whether this stream contains any of the given values. 

        
 // true
 Seq.of(1, 2, 3).containsAny(2, 4)

      • get

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

      • findFirst

        default Optional<T> findFirst(Predicate<? super T> predicate)
        Get a single element from the stream given a predicate.

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

      • cycle

        default Seq<T> cycle(long times)
        Repeat a stream a certain amount of times. 

        
 // ()
 Seq.of(1, 2, 3).cycle(0);
 
 // (1, 2, 3)
 Seq.of(1, 2, 3).cycle(1);
 
 // (1, 2, 3, 1, 2, 3, 1, 2, 3)
 Seq.of(1, 2, 3).cycle(3);
        See Also:
        cycle(Stream, long)

      • distinct

        default <U> Seq<T> distinct(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(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(Stream<U> other,
                         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,
                         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,
                         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,
                       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,
                        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,
                            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,
                             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(Predicate<? super T> predicate)
        Returns a stream with all elements skipped for which a predicate evaluates to true. 

        
 // (3, 4, 5)
 Seq.of(1, 2, 3, 4, 5).skipWhile(i -> i < 3)
        See Also:
        skipWhile(Stream, Predicate)

      • skipWhileClosed

        default Seq<T> skipWhileClosed(Predicate<? super T> predicate)
        Returns a stream with all elements skipped for which a predicate evaluates to true plus the first element for which it evaluates to false. 

        
 // (4, 5)
 Seq.of(1, 2, 3, 4, 5).skipWhileClosed(i -> i < 3)
        See Also:
        skipWhileClosed(Stream, Predicate)

      • skipUntil

        default Seq<T> skipUntil(Predicate<? super T> predicate)
        Returns a stream with all elements skipped for which a predicate evaluates to false. 

        
 // (3, 4, 5)
 Seq.of(1, 2, 3, 4, 5).skipUntil(i -> i == 3)
        See Also:
        skipUntil(Stream, Predicate)

      • skipUntilClosed

        default Seq<T> skipUntilClosed(Predicate<? super T> predicate)
        Returns a stream with all elements skipped for which a predicate evaluates to false plus the first element for which it evaluates to true. 

        
 // (4, 5)
 Seq.of(1, 2, 3, 4, 5).skipUntilClosed(i -> i == 3)
        See Also:
        skipUntilClosed(Stream, Predicate)

      • limitWhile

        default Seq<T> limitWhile(Predicate<? super T> predicate)
        Returns a stream limited to all elements for which a predicate evaluates to true. 

        
 // (1, 2)
 Seq.of(1, 2, 3, 4, 5).limitWhile(i -> i < 3)
        See Also:
        limitWhile(Stream, Predicate)

      • limitWhileClosed

        default Seq<T> limitWhileClosed(Predicate<? super T> predicate)
        Returns a stream limited to all elements for which a predicate evaluates to true plus the first element for which it evaluates to false. 

        
 // (1, 2, 3)
 Seq.of(1, 2, 3, 4, 5).limitWhileClosed(i -> i < 3)
        See Also:
        limitWhileClosed(Stream, Predicate)

      • limitUntil

        default Seq<T> limitUntil(Predicate<? super T> predicate)
        Returns a stream limited to all elements for which a predicate evaluates to false. 

        
 // (1, 2)
 Seq.of(1, 2, 3, 4, 5).limitUntil(i -> i == 3)
        See Also:
        limitUntil(Stream, Predicate)

      • limitUntilClosed

        default Seq<T> limitUntilClosed(Predicate<? super T> predicate)
        Returns a stream limited to all elements for which a predicate evaluates to false plus the first element for which it evaluates to true. 

        
 // (1, 2, 3)
 Seq.of(1, 2, 3, 4, 5).limitUntilClosed(i -> i == 3)
        See Also:
        limitUntilClosed(Stream, Predicate)

      • intersperse

        default Seq<T> intersperse(T value)
        Returns a stream with a given value interspersed between any two values of this stream. 

        
 // (1, 0, 2, 0, 3, 0, 4)
 Seq.of(1, 2, 3, 4).intersperse(0)
        See Also:
        intersperse(Stream, Object)

      • duplicate

        default Tuple2<Seq<T>,Seq<T>> duplicate()
        Duplicate a Streams into two equivalent Streams. 

        
 // tuple((1, 2, 3), (1, 2, 3))
 Seq.of(1, 2, 3).duplicate()
        See Also:
        duplicate(Stream)

      • grouped

        default <K> Seq<Tuple2<K,Seq<T>>> grouped(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(Function<? super T,? extends K> classifier,
                                         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)

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

      • slice

        default Seq<T> slice(long from,
                     long to)
        Returns a limited interval from a given Stream. 

        
 // (4, 5)
 Seq.of(1, 2, 3, 4, 5, 6).slice(3, 5)
        See Also:
        slice(Stream, long, long)

      • isEmpty

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

      • isNotEmpty

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

      • sorted

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

      • sorted

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

      • ofType

        default <U> Seq<U> ofType(Class<U> type)
        Keep only those elements in a stream that are of a given type. 

        
 // (1, 2, 3)
 Seq.of(1, "a", 2, "b", 3).ofType(Integer.class)
        See Also:
        ofType(Stream, Class)

      • cast

        default <U> Seq<U> cast(Class<U> type)
        Cast all elements in a stream to a given type, possibly throwing a ClassCastException. 

        
 // ClassCastException
 Seq.of(1, "a", 2, "b", 3).cast(Integer.class)
        See Also:
        cast(Stream, Class)

      • sliding

        default Seq<Seq<T>> sliding(long size)
        Map this stream to a stream containing a sliding window over the previous stream. 

        
 // ((1, 2, 3), (2, 3, 4), (3, 4, 5))
 .of(1, 2, 3, 4, 5).sliding(3);

        This is equivalent as using the more verbose window function version: 

        
 int n = 3;
 Seq.of(1, 2, 3, 4, 5)
    .window(0, n - 1)
    .filter(w -> w.count() == n)
    .map(w -> w.toList());

      • window

        default Seq<Window<T>> window()
        Map this stream to a windowed stream using the default partition and order. 

        
 // (0, 1, 2, 3, 4)
 Seq.of(1, 2, 4, 2, 3).window().map(Window::rowNumber)

      • window

        default Seq<Window<T>> window(long lower,
                              long upper)
        Map this stream to a windowed stream using the default partition and order with frame. 

        
 // (2, 4, 4, 4, 3)
 Seq.of(1, 2, 4, 2, 3).window(-1, 1).map(Window::max)

      • window

        default Seq<Window<T>> window(Comparator<? super T> orderBy)
        Map this stream to a windowed stream using the default partition and a specific order. 

        
 // (0, 1, 4, 2, 3)
 Seq.of(1, 2, 4, 2, 3).window(naturalOrder()).map(Window::rowNumber)

      • window

        default Seq<Window<T>> window(Comparator<? super T> orderBy,
                              long lower,
                              long upper)
        Map this stream to a windowed stream using the default partition and a specific order with frame. 

        
 // (1, 1, 3, 2, 2)
 Seq.of(1, 2, 4, 2, 3).window(naturalOrder(), -1, 1).map(Window::min)

      • window

        default <U> Seq<Window<T>> window(Function<? super T,? extends U> partitionBy)
        Map this stream to a windowed stream using a specific partition and the default order. 

        
 // (1, 2, 2, 2, 1)
 Seq.of(1, 2, 4, 2, 3).window(i -> i % 2).map(Window::min)

      • window

        default <U> Seq<Window<T>> window(Function<? super T,? extends U> partitionBy,
                                  long lower,
                                  long upper)
        Map this stream to a windowed stream using a specific partition and the default order. 

        
 // (3, 4, 4, 2, 3)
 Seq.of(1, 4, 2, 2, 3).window(i -> i % 2, -1, 1).map(Window::max)

      • window

        default <U> Seq<Window<T>> window(Function<? super T,? extends U> partitionBy,
                                  Comparator<? super T> orderBy)
        Map this stream to a windowed stream using a specific partition and order. 

        
 // (1, 2, 4, 4, 3)
 Seq.of(1, 2, 4, 2, 3).window(i -> i % 2, naturalOrder()).map(Window::max)

      • window

        default <U> Seq<Window<T>> window(Function<? super T,? extends U> partitionBy,
                                  Comparator<? super T> orderBy,
                                  long lower,
                                  long upper)
        Map this stream to a windowed stream using a specific partition and order with frame. 

        
 // (3, 2, 4, 4, 3)
 Seq.of(1, 2, 4, 2, 3).window(i -> i % 2, naturalOrder(), -1, 1).map(Window::max)

      • 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<Instant> range(Instant from,
                          Instant to)
        The range between two values.
        Parameters:
        from - The lower bound (inclusive)
        to - The upper bound (exclusive)

      • range

        static Seq<Instant> range(Instant from,
                          Instant to,
                          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<Instant> rangeClosed(Instant from,
                                Instant to)
        The range between two values.
        Parameters:
        from - The lower bound (inclusive)
        to - The upper bound (exclusive)

      • rangeClosed

        static Seq<Instant> rangeClosed(Instant from,
                                Instant to,
                                Duration step)
        The range between two values.
        Parameters:
        from - The lower bound (inclusive)
        to - The upper bound (exclusive)
        step - The increase between two values

      • seq

        static <T> Seq<T> seq(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 <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.

      • cycle

        static <T> Seq<T> cycle(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();

      • cycle

        static <T> Seq<T> cycle(Stream<T> stream,
                        long times)
        Repeat a stream a certain amount of times. 

        
 // ()
 Seq.of(1, 2, 3).cycle(0);
 
 // (1, 2, 3)
 Seq.of(1, 2, 3).cycle(1);
 
 // (1, 2, 3, 1, 2, 3, 1, 2, 3)
 Seq.of(1, 2, 3).cycle(3);
        See Also:
        cycle(Stream)

      • cycle

        static <T> Seq<T> cycle(Iterable<T> iterable,
                        long times)
        Repeat a stream a certain amount of times. 

        
 // ()
 Seq.of(1, 2, 3).cycle(0);
 
 // (1, 2, 3)
 Seq.of(1, 2, 3).cycle(1);
 
 // (1, 2, 3, 1, 2, 3, 1, 2, 3)
 Seq.of(1, 2, 3).cycle(3);
        See Also:
        cycle(Stream)

      • cycle

        static <T> Seq<T> cycle(Seq<T> stream,
                        long times)
        Repeat a stream a certain amount of times. 

        
 // ()
 Seq.of(1, 2, 3).cycle(0);
 
 // (1, 2, 3)
 Seq.of(1, 2, 3).cycle(1);
 
 // (1, 2, 3, 1, 2, 3, 1, 2, 3)
 Seq.of(1, 2, 3).cycle(3);
        See Also:
        cycle(Stream)

      • unzip

        static <T1,T2> Tuple2<Seq<T1>,Seq<T2>> unzip(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(Stream<Tuple2<T1,T2>> stream,
                                                   Function<T1,U1> leftUnzipper,
                                                   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(Stream<Tuple2<T1,T2>> stream,
                                                   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(Stream<Tuple2<T1,T2>> stream,
                                                   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,
                                                   Function<T1,U1> leftUnzipper,
                                                   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,
                                                   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,
                                                   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,
                                                   Function<T1,U1> leftUnzipper,
                                                   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,
                                                   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,
                                                   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(Stream<T1> s1,
                                                                                                     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(Stream<T1> s1,
                                                                                                           Stream<T2> s2,
                                                                                                           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(Stream<T1> s1,
                                                                                                                 Stream<T2> s2,
                                                                                                                 Stream<T3> s3,
                                                                                                                 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(Stream<T1> s1,
                                                                                                                       Stream<T2> s2,
                                                                                                                       Stream<T3> s3,
                                                                                                                       Stream<T4> s4,
                                                                                                                       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(Stream<T1> s1,
                                                                                                                             Stream<T2> s2,
                                                                                                                             Stream<T3> s3,
                                                                                                                             Stream<T4> s4,
                                                                                                                             Stream<T5> s5,
                                                                                                                             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(Stream<T1> s1,
                                                                                                                                   Stream<T2> s2,
                                                                                                                                   Stream<T3> s3,
                                                                                                                                   Stream<T4> s4,
                                                                                                                                   Stream<T5> s5,
                                                                                                                                   Stream<T6> s6,
                                                                                                                                   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(Stream<T1> s1,
                                                                                                                                         Stream<T2> s2,
                                                                                                                                         Stream<T3> s3,
                                                                                                                                         Stream<T4> s4,
                                                                                                                                         Stream<T5> s5,
                                                                                                                                         Stream<T6> s6,
                                                                                                                                         Stream<T7> s7,
                                                                                                                                         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(Stream<T1> s1,
                                                                                                                                               Stream<T2> s2,
                                                                                                                                               Stream<T3> s3,
                                                                                                                                               Stream<T4> s4,
                                                                                                                                               Stream<T5> s5,
                                                                                                                                               Stream<T6> s6,
                                                                                                                                               Stream<T7> s7,
                                                                                                                                               Stream<T8> s8,
                                                                                                                                               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(Stream<T1> s1,
                                                                                                                                                        Stream<T2> s2,
                                                                                                                                                        Stream<T3> s3,
                                                                                                                                                        Stream<T4> s4,
                                                                                                                                                        Stream<T5> s5,
                                                                                                                                                        Stream<T6> s6,
                                                                                                                                                        Stream<T7> s7,
                                                                                                                                                        Stream<T8> s8,
                                                                                                                                                        Stream<T9> s9,
                                                                                                                                                        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(Stream<T1> s1,
                                                                                                                                                                Stream<T2> s2,
                                                                                                                                                                Stream<T3> s3,
                                                                                                                                                                Stream<T4> s4,
                                                                                                                                                                Stream<T5> s5,
                                                                                                                                                                Stream<T6> s6,
                                                                                                                                                                Stream<T7> s7,
                                                                                                                                                                Stream<T8> s8,
                                                                                                                                                                Stream<T9> s9,
                                                                                                                                                                Stream<T10> s10,
                                                                                                                                                                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(Stream<T1> s1,
                                                                                                                                                                        Stream<T2> s2,
                                                                                                                                                                        Stream<T3> s3,
                                                                                                                                                                        Stream<T4> s4,
                                                                                                                                                                        Stream<T5> s5,
                                                                                                                                                                        Stream<T6> s6,
                                                                                                                                                                        Stream<T7> s7,
                                                                                                                                                                        Stream<T8> s8,
                                                                                                                                                                        Stream<T9> s9,
                                                                                                                                                                        Stream<T10> s10,
                                                                                                                                                                        Stream<T11> s11,
                                                                                                                                                                        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(Stream<T1> s1,
                                                                                                                                                                                Stream<T2> s2,
                                                                                                                                                                                Stream<T3> s3,
                                                                                                                                                                                Stream<T4> s4,
                                                                                                                                                                                Stream<T5> s5,
                                                                                                                                                                                Stream<T6> s6,
                                                                                                                                                                                Stream<T7> s7,
                                                                                                                                                                                Stream<T8> s8,
                                                                                                                                                                                Stream<T9> s9,
                                                                                                                                                                                Stream<T10> s10,
                                                                                                                                                                                Stream<T11> s11,
                                                                                                                                                                                Stream<T12> s12,
                                                                                                                                                                                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> 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> 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(Stream<T1> s1,
                                                                                           Stream<T2> s2,
                                                                                           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(Stream<T1> s1,
                                                                                              Stream<T2> s2,
                                                                                              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(Stream<T1> s1,
                                                                                                 Stream<T2> s2,
                                                                                                 Stream<T3> s3,
                                                                                                 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(Stream<T1> s1,
                                                                                                    Stream<T2> s2,
                                                                                                    Stream<T3> s3,
                                                                                                    Stream<T4> s4,
                                                                                                    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(Stream<T1> s1,
                                                                                                       Stream<T2> s2,
                                                                                                       Stream<T3> s3,
                                                                                                       Stream<T4> s4,
                                                                                                       Stream<T5> s5,
                                                                                                       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(Stream<T1> s1,
                                                                                                          Stream<T2> s2,
                                                                                                          Stream<T3> s3,
                                                                                                          Stream<T4> s4,
                                                                                                          Stream<T5> s5,
                                                                                                          Stream<T6> s6,
                                                                                                          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(Stream<T1> s1,
                                                                                                             Stream<T2> s2,
                                                                                                             Stream<T3> s3,
                                                                                                             Stream<T4> s4,
                                                                                                             Stream<T5> s5,
                                                                                                             Stream<T6> s6,
                                                                                                             Stream<T7> s7,
                                                                                                             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(Stream<T1> s1,
                                                                                                                Stream<T2> s2,
                                                                                                                Stream<T3> s3,
                                                                                                                Stream<T4> s4,
                                                                                                                Stream<T5> s5,
                                                                                                                Stream<T6> s6,
                                                                                                                Stream<T7> s7,
                                                                                                                Stream<T8> s8,
                                                                                                                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(Stream<T1> s1,
                                                                                                                    Stream<T2> s2,
                                                                                                                    Stream<T3> s3,
                                                                                                                    Stream<T4> s4,
                                                                                                                    Stream<T5> s5,
                                                                                                                    Stream<T6> s6,
                                                                                                                    Stream<T7> s7,
                                                                                                                    Stream<T8> s8,
                                                                                                                    Stream<T9> s9,
                                                                                                                    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(Stream<T1> s1,
                                                                                                                        Stream<T2> s2,
                                                                                                                        Stream<T3> s3,
                                                                                                                        Stream<T4> s4,
                                                                                                                        Stream<T5> s5,
                                                                                                                        Stream<T6> s6,
                                                                                                                        Stream<T7> s7,
                                                                                                                        Stream<T8> s8,
                                                                                                                        Stream<T9> s9,
                                                                                                                        Stream<T10> s10,
                                                                                                                        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(Stream<T1> s1,
                                                                                                                            Stream<T2> s2,
                                                                                                                            Stream<T3> s3,
                                                                                                                            Stream<T4> s4,
                                                                                                                            Stream<T5> s5,
                                                                                                                            Stream<T6> s6,
                                                                                                                            Stream<T7> s7,
                                                                                                                            Stream<T8> s8,
                                                                                                                            Stream<T9> s9,
                                                                                                                            Stream<T10> s10,
                                                                                                                            Stream<T11> s11,
                                                                                                                            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(Stream<T1> s1,
                                                                                                                                Stream<T2> s2,
                                                                                                                                Stream<T3> s3,
                                                                                                                                Stream<T4> s4,
                                                                                                                                Stream<T5> s5,
                                                                                                                                Stream<T6> s6,
                                                                                                                                Stream<T7> s7,
                                                                                                                                Stream<T8> s8,
                                                                                                                                Stream<T9> s9,
                                                                                                                                Stream<T10> s10,
                                                                                                                                Stream<T11> s11,
                                                                                                                                Stream<T12> s12,
                                                                                                                                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(Stream<T1> s1,
                                                                                                                                    Stream<T2> s2,
                                                                                                                                    Stream<T3> s3,
                                                                                                                                    Stream<T4> s4,
                                                                                                                                    Stream<T5> s5,
                                                                                                                                    Stream<T6> s6,
                                                                                                                                    Stream<T7> s7,
                                                                                                                                    Stream<T8> s8,
                                                                                                                                    Stream<T9> s9,
                                                                                                                                    Stream<T10> s10,
                                                                                                                                    Stream<T11> s11,
                                                                                                                                    Stream<T12> s12,
                                                                                                                                    Stream<T13> s13,
                                                                                                                                    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(Stream<T1> s1,
                                                                                                                                        Stream<T2> s2,
                                                                                                                                        Stream<T3> s3,
                                                                                                                                        Stream<T4> s4,
                                                                                                                                        Stream<T5> s5,
                                                                                                                                        Stream<T6> s6,
                                                                                                                                        Stream<T7> s7,
                                                                                                                                        Stream<T8> s8,
                                                                                                                                        Stream<T9> s9,
                                                                                                                                        Stream<T10> s10,
                                                                                                                                        Stream<T11> s11,
                                                                                                                                        Stream<T12> s12,
                                                                                                                                        Stream<T13> s13,
                                                                                                                                        Stream<T14> s14,
                                                                                                                                        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(Stream<T1> s1,
                                                                                                                                            Stream<T2> s2,
                                                                                                                                            Stream<T3> s3,
                                                                                                                                            Stream<T4> s4,
                                                                                                                                            Stream<T5> s5,
                                                                                                                                            Stream<T6> s6,
                                                                                                                                            Stream<T7> s7,
                                                                                                                                            Stream<T8> s8,
                                                                                                                                            Stream<T9> s9,
                                                                                                                                            Stream<T10> s10,
                                                                                                                                            Stream<T11> s11,
                                                                                                                                            Stream<T12> s12,
                                                                                                                                            Stream<T13> s13,
                                                                                                                                            Stream<T14> s14,
                                                                                                                                            Stream<T15> s15,
                                                                                                                                            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,
                                                                                           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,R> Seq<R> zip(Seq<T1> s1,
                                                                                           Seq<T2> s2,
                                                                                           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(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(Stream<T> stream,
                        U seed,
                        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,
                        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,
                        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(Stream<T> stream,
                         U seed,
                         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,
                         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,
                         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(Stream<T> stream,
                             U seed,
                             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,
                             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,
                             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(Stream<T> stream,
                              U seed,
                              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,
                              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,
                              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,
                           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(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(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(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(Stream<T1> s1,
                                                                                                           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(Stream<T1> s1,
                                                                                                                 Stream<T2> s2,
                                                                                                                 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(Stream<T1> s1,
                                                                                                                       Stream<T2> s2,
                                                                                                                       Stream<T3> s3,
                                                                                                                       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(Stream<T1> s1,
                                                                                                                             Stream<T2> s2,
                                                                                                                             Stream<T3> s3,
                                                                                                                             Stream<T4> s4,
                                                                                                                             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(Stream<T1> s1,
                                                                                                                                   Stream<T2> s2,
                                                                                                                                   Stream<T3> s3,
                                                                                                                                   Stream<T4> s4,
                                                                                                                                   Stream<T5> s5,
                                                                                                                                   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(Stream<T1> s1,
                                                                                                                                         Stream<T2> s2,
                                                                                                                                         Stream<T3> s3,
                                                                                                                                         Stream<T4> s4,
                                                                                                                                         Stream<T5> s5,
                                                                                                                                         Stream<T6> s6,
                                                                                                                                         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(Stream<T1> s1,
                                                                                                                                               Stream<T2> s2,
                                                                                                                                               Stream<T3> s3,
                                                                                                                                               Stream<T4> s4,
                                                                                                                                               Stream<T5> s5,
                                                                                                                                               Stream<T6> s6,
                                                                                                                                               Stream<T7> s7,
                                                                                                                                               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(Stream<T1> s1,
                                                                                                                                                     Stream<T2> s2,
                                                                                                                                                     Stream<T3> s3,
                                                                                                                                                     Stream<T4> s4,
                                                                                                                                                     Stream<T5> s5,
                                                                                                                                                     Stream<T6> s6,
                                                                                                                                                     Stream<T7> s7,
                                                                                                                                                     Stream<T8> s8,
                                                                                                                                                     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(Stream<T1> s1,
                                                                                                                                                              Stream<T2> s2,
                                                                                                                                                              Stream<T3> s3,
                                                                                                                                                              Stream<T4> s4,
                                                                                                                                                              Stream<T5> s5,
                                                                                                                                                              Stream<T6> s6,
                                                                                                                                                              Stream<T7> s7,
                                                                                                                                                              Stream<T8> s8,
                                                                                                                                                              Stream<T9> s9,
                                                                                                                                                              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(Stream<T1> s1,
                                                                                                                                                                      Stream<T2> s2,
                                                                                                                                                                      Stream<T3> s3,
                                                                                                                                                                      Stream<T4> s4,
                                                                                                                                                                      Stream<T5> s5,
                                                                                                                                                                      Stream<T6> s6,
                                                                                                                                                                      Stream<T7> s7,
                                                                                                                                                                      Stream<T8> s8,
                                                                                                                                                                      Stream<T9> s9,
                                                                                                                                                                      Stream<T10> s10,
                                                                                                                                                                      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(Stream<T1> s1,
                                                                                                                                                                              Stream<T2> s2,
                                                                                                                                                                              Stream<T3> s3,
                                                                                                                                                                              Stream<T4> s4,
                                                                                                                                                                              Stream<T5> s5,
                                                                                                                                                                              Stream<T6> s6,
                                                                                                                                                                              Stream<T7> s7,
                                                                                                                                                                              Stream<T8> s8,
                                                                                                                                                                              Stream<T9> s9,
                                                                                                                                                                              Stream<T10> s10,
                                                                                                                                                                              Stream<T11> s11,
                                                                                                                                                                              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(Stream<T1> s1,
                                                                                                                                                                                      Stream<T2> s2,
                                                                                                                                                                                      Stream<T3> s3,
                                                                                                                                                                                      Stream<T4> s4,
                                                                                                                                                                                      Stream<T5> s5,
                                                                                                                                                                                      Stream<T6> s6,
                                                                                                                                                                                      Stream<T7> s7,
                                                                                                                                                                                      Stream<T8> s8,
                                                                                                                                                                                      Stream<T9> s9,
                                                                                                                                                                                      Stream<T10> s10,
                                                                                                                                                                                      Stream<T11> s11,
                                                                                                                                                                                      Stream<T12> s12,
                                                                                                                                                                                      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(Stream<T1> s1,
                                                                                                                                                                                              Stream<T2> s2,
                                                                                                                                                                                              Stream<T3> s3,
                                                                                                                                                                                              Stream<T4> s4,
                                                                                                                                                                                              Stream<T5> s5,
                                                                                                                                                                                              Stream<T6> s6,
                                                                                                                                                                                              Stream<T7> s7,
                                                                                                                                                                                              Stream<T8> s8,
                                                                                                                                                                                              Stream<T9> s9,
                                                                                                                                                                                              Stream<T10> s10,
                                                                                                                                                                                              Stream<T11> s11,
                                                                                                                                                                                              Stream<T12> s12,
                                                                                                                                                                                              Stream<T13> s13,
                                                                                                                                                                                              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(Stream<T1> s1,
                                                                                                                                                                                                      Stream<T2> s2,
                                                                                                                                                                                                      Stream<T3> s3,
                                                                                                                                                                                                      Stream<T4> s4,
                                                                                                                                                                                                      Stream<T5> s5,
                                                                                                                                                                                                      Stream<T6> s6,
                                                                                                                                                                                                      Stream<T7> s7,
                                                                                                                                                                                                      Stream<T8> s8,
                                                                                                                                                                                                      Stream<T9> s9,
                                                                                                                                                                                                      Stream<T10> s10,
                                                                                                                                                                                                      Stream<T11> s11,
                                                                                                                                                                                                      Stream<T12> s12,
                                                                                                                                                                                                      Stream<T13> s13,
                                                                                                                                                                                                      Stream<T14> s14,
                                                                                                                                                                                                      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(Stream<T1> s1,
                                                                                                                                                                                                              Stream<T2> s2,
                                                                                                                                                                                                              Stream<T3> s3,
                                                                                                                                                                                                              Stream<T4> s4,
                                                                                                                                                                                                              Stream<T5> s5,
                                                                                                                                                                                                              Stream<T6> s6,
                                                                                                                                                                                                              Stream<T7> s7,
                                                                                                                                                                                                              Stream<T8> s8,
                                                                                                                                                                                                              Stream<T9> s9,
                                                                                                                                                                                                              Stream<T10> s10,
                                                                                                                                                                                                              Stream<T11> s11,
                                                                                                                                                                                                              Stream<T12> s12,
                                                                                                                                                                                                              Stream<T13> s13,
                                                                                                                                                                                                              Stream<T14> s14,
                                                                                                                                                                                                              Stream<T15> s15,
                                                                                                                                                                                                              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> 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(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(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(Stream<?> stream)
        Consume a stream and concatenate all elements.

      • toString

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

      • toCollection

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

      • toList

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

      • toSet

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

      • toMap

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

      • toMap

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

      • slice

        static <T> Seq<T> slice(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(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(Stream<T> stream,
                            Predicate<? super T> predicate)
        Returns a stream with all elements skipped for which a predicate evaluates to true. 

        
 // (3, 4, 5)
 Seq.of(1, 2, 3, 4, 5).skipWhile(i -> i < 3)

      • skipWhileClosed

        static <T> Seq<T> skipWhileClosed(Stream<T> stream,
                                  Predicate<? super T> predicate)
        Returns a stream with all elements skipped for which a predicate evaluates to true plus the first element for which it evaluates to false. 

        
 // (4, 5)
 Seq.of(1, 2, 3, 4, 5).skipWhileClosed(i -> i < 3)

      • skipUntil

        static <T> Seq<T> skipUntil(Stream<T> stream,
                            Predicate<? super T> predicate)
        Returns a stream with all elements skipped for which a predicate evaluates to false. 

        
 // (3, 4, 5)
 Seq.of(1, 2, 3, 4, 5).skipUntil(i -> i == 3)

      • skipUntilClosed

        static <T> Seq<T> skipUntilClosed(Stream<T> stream,
                                  Predicate<? super T> predicate)
        Returns a stream with all elements skipped for which a predicate evaluates to false plus the first element for which it evaluates to true. 

        
 // (4, 5)
 Seq.of(1, 2, 3, 4, 5).skipUntilClosed(i -> i == 3)

      • limit

        static <T> Seq<T> limit(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(Stream<T> stream,
                             Predicate<? super T> predicate)
        Returns a stream limited to all elements for which a predicate evaluates to true. 

        
 // (1, 2)
 Seq.of(1, 2, 3, 4, 5).limitWhile(i -> i < 3)

      • limitWhileClosed

        static <T> Seq<T> limitWhileClosed(Stream<T> stream,
                                   Predicate<? super T> predicate)
        Returns a stream limited to all elements for which a predicate evaluates to true plus the first element for which it evaluates to false. 

        
 // (1, 2, 3)
 Seq.of(1, 2, 3, 4, 5).limitWhileClosed(i -> i < 3)

      • limitUntil

        static <T> Seq<T> limitUntil(Stream<T> stream,
                             Predicate<? super T> predicate)
        Returns a stream limited to all elements for which a predicate evaluates to false. 

        
 // (1, 2)
 Seq.of(1, 2, 3, 4, 5).limitUntil(i -> i == 3)

      • limitUntilClosed

        static <T> Seq<T> limitUntilClosed(Stream<T> stream,
                                   Predicate<? super T> predicate)
        Returns a stream limited to all elements for which a predicate evaluates to false plus the first element for which it evaluates to true. 

        
 // (1, 2, 3)
 Seq.of(1, 2, 3, 4, 5).limitUntilClosed(i -> i == 3)

      • intersperse

        static <T> Seq<T> intersperse(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(Stream<T> stream,
                                           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,
                                           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,
                                           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(Stream<T> stream,
                                          Function<? super T,? extends K> classifier,
                                          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,
                                          Function<? super T,? extends K> classifier,
                                          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,
                                          Function<? super T,? extends K> classifier,
                                          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(Stream<T> stream,
                                           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(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(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(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(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)

      • map

        <R> Seq<R> map(Function<? super T,? extends R> mapper)

      • distinct

        Seq<T> distinct()

      • sorted

        Seq<T> sorted()

      • limit

        Seq<T> limit(long maxSize)

      • skip

        Seq<T> skip(long n)

      • close

        void close()

      • count

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

      • sequential

        default Seq<T> sequential()
        Returns this stream. All Seq streams are sequential, hence the name.
        Specified by:
        sequential in interface  BaseStream<T,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  BaseStream<T,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  BaseStream<T,Stream<T>>
        Returns:
        this stream unmodified

      • forEach

        default void forEach(Consumer<? super T> action)

      • format

        String format()
        Generate a nicely formatted representation of this stream.

        Clients should not rely on the concrete formatting of this method, which is intended for debugging convenience only.

      • printOut

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

      • printErr

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

      • print

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

      • print

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