Uses of Interface
io.vavr.collection.Seq

Packages that use Seq

Package	Description
io.vavr	Beside API the io.vavr package contains core types like (Checked)Functions and Tuples.
io.vavr.collection	Purely functional collections based on Traversable.
io.vavr.concurrent	This package contains basic building blocks for creating fast, asynchronous, non-blocking parallel code.
io.vavr.control	Control structures like the disjoint union type Either, the optional value type Option and Try for exception handling.

Uses of Seq in io.vavr

Methods in io.vavr that return Seq

Modifier and Type	Method	Description
static <T> Seq<T>	API.Seq()	Alias for List.empty()
static <T> Seq<T>	API.Seq(T element)	Alias for List.of(Object)
static <T> Seq<T>	API.Seq(T @NonNull ... elements)	Alias for List.of(Object...)
Seq<?>	Tuple.toSeq()	Converts this tuple to a sequence.
Seq<?>	Tuple0.toSeq()
Seq<?>	Tuple1.toSeq()
Seq<?>	Tuple2.toSeq()
Seq<?>	Tuple3.toSeq()
Seq<?>	Tuple4.toSeq()
Seq<?>	Tuple5.toSeq()
Seq<?>	Tuple6.toSeq()
Seq<?>	Tuple7.toSeq()
Seq<?>	Tuple8.toSeq()

Methods in io.vavr that return types with arguments of type Seq

Modifier and Type	Method	Description
static <T> Lazy<Seq<T>>	Lazy.sequence(@NonNull java.lang.Iterable<? extends Lazy<? extends T>> values)	Combines multiple Lazy instances into a single Lazy containing a sequence of their evaluated values.
static <T1> Tuple1<Seq<T1>>	Tuple.sequence1(@NonNull java.lang.Iterable<? extends Tuple1<? extends T1>> tuples)	Turns a sequence of Tuple1 into a Tuple1 of Seq.
static <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Tuple.sequence2(@NonNull java.lang.Iterable<? extends Tuple2<? extends T1,? extends T2>> tuples)	Turns a sequence of Tuple2 into a Tuple2 of Seqs.
static <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Tuple.sequence2(@NonNull java.lang.Iterable<? extends Tuple2<? extends T1,? extends T2>> tuples)	Turns a sequence of Tuple2 into a Tuple2 of Seqs.
static <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Tuple.sequence3(@NonNull java.lang.Iterable<? extends Tuple3<? extends T1,? extends T2,? extends T3>> tuples)	Turns a sequence of Tuple3 into a Tuple3 of Seqs.
static <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Tuple.sequence3(@NonNull java.lang.Iterable<? extends Tuple3<? extends T1,? extends T2,? extends T3>> tuples)	Turns a sequence of Tuple3 into a Tuple3 of Seqs.
static <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Tuple.sequence3(@NonNull java.lang.Iterable<? extends Tuple3<? extends T1,? extends T2,? extends T3>> tuples)	Turns a sequence of Tuple3 into a Tuple3 of Seqs.
static <T1,T2,T3,T4> Tuple4<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>>	Tuple.sequence4(@NonNull java.lang.Iterable<? extends Tuple4<? extends T1,? extends T2,? extends T3,? extends T4>> tuples)	Turns a sequence of Tuple4 into a Tuple4 of Seqs.
static <T1,T2,T3,T4> Tuple4<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>>	Tuple.sequence4(@NonNull java.lang.Iterable<? extends Tuple4<? extends T1,? extends T2,? extends T3,? extends T4>> tuples)	Turns a sequence of Tuple4 into a Tuple4 of Seqs.
static <T1,T2,T3,T4> Tuple4<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>>	Tuple.sequence4(@NonNull java.lang.Iterable<? extends Tuple4<? extends T1,? extends T2,? extends T3,? extends T4>> tuples)	Turns a sequence of Tuple4 into a Tuple4 of Seqs.
static <T1,T2,T3,T4> Tuple4<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>>	Tuple.sequence4(@NonNull java.lang.Iterable<? extends Tuple4<? extends T1,? extends T2,? extends T3,? extends T4>> tuples)	Turns a sequence of Tuple4 into a Tuple4 of Seqs.
static <T1,T2,T3,T4,T5> Tuple5<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>>	Tuple.sequence5(@NonNull java.lang.Iterable<? extends Tuple5<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5>> tuples)	Turns a sequence of Tuple5 into a Tuple5 of Seqs.
static <T1,T2,T3,T4,T5> Tuple5<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>>	Tuple.sequence5(@NonNull java.lang.Iterable<? extends Tuple5<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5>> tuples)	Turns a sequence of Tuple5 into a Tuple5 of Seqs.
static <T1,T2,T3,T4,T5> Tuple5<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>>	Tuple.sequence5(@NonNull java.lang.Iterable<? extends Tuple5<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5>> tuples)	Turns a sequence of Tuple5 into a Tuple5 of Seqs.
static <T1,T2,T3,T4,T5> Tuple5<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>>	Tuple.sequence5(@NonNull java.lang.Iterable<? extends Tuple5<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5>> tuples)	Turns a sequence of Tuple5 into a Tuple5 of Seqs.
static <T1,T2,T3,T4,T5> Tuple5<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>>	Tuple.sequence5(@NonNull java.lang.Iterable<? extends Tuple5<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5>> tuples)	Turns a sequence of Tuple5 into a Tuple5 of Seqs.
static <T1,T2,T3,T4,T5,T6> Tuple6<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>,Seq<T6>>	Tuple.sequence6(@NonNull java.lang.Iterable<? extends Tuple6<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5,? extends T6>> tuples)	Turns a sequence of Tuple6 into a Tuple6 of Seqs.
static <T1,T2,T3,T4,T5,T6> Tuple6<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>,Seq<T6>>	Tuple.sequence6(@NonNull java.lang.Iterable<? extends Tuple6<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5,? extends T6>> tuples)	Turns a sequence of Tuple6 into a Tuple6 of Seqs.
static <T1,T2,T3,T4,T5,T6> Tuple6<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>,Seq<T6>>	Tuple.sequence6(@NonNull java.lang.Iterable<? extends Tuple6<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5,? extends T6>> tuples)	Turns a sequence of Tuple6 into a Tuple6 of Seqs.
static <T1,T2,T3,T4,T5,T6> Tuple6<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>,Seq<T6>>	Tuple.sequence6(@NonNull java.lang.Iterable<? extends Tuple6<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5,? extends T6>> tuples)	Turns a sequence of Tuple6 into a Tuple6 of Seqs.
static <T1,T2,T3,T4,T5,T6> Tuple6<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>,Seq<T6>>	Tuple.sequence6(@NonNull java.lang.Iterable<? extends Tuple6<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5,? extends T6>> tuples)	Turns a sequence of Tuple6 into a Tuple6 of Seqs.
static <T1,T2,T3,T4,T5,T6> Tuple6<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>,Seq<T6>>	Tuple.sequence6(@NonNull java.lang.Iterable<? extends Tuple6<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5,? extends T6>> tuples)	Turns a sequence of Tuple6 into a Tuple6 of Seqs.
static <T1,T2,T3,T4,T5,T6,T7> Tuple7<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>,Seq<T6>,Seq<T7>>	Tuple.sequence7(@NonNull java.lang.Iterable<? extends Tuple7<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5,? extends T6,? extends T7>> tuples)	Turns a sequence of Tuple7 into a Tuple7 of Seqs.
static <T1,T2,T3,T4,T5,T6,T7> Tuple7<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>,Seq<T6>,Seq<T7>>	Tuple.sequence7(@NonNull java.lang.Iterable<? extends Tuple7<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5,? extends T6,? extends T7>> tuples)	Turns a sequence of Tuple7 into a Tuple7 of Seqs.
static <T1,T2,T3,T4,T5,T6,T7> Tuple7<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>,Seq<T6>,Seq<T7>>	Tuple.sequence7(@NonNull java.lang.Iterable<? extends Tuple7<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5,? extends T6,? extends T7>> tuples)	Turns a sequence of Tuple7 into a Tuple7 of Seqs.
static <T1,T2,T3,T4,T5,T6,T7> Tuple7<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>,Seq<T6>,Seq<T7>>	Tuple.sequence7(@NonNull java.lang.Iterable<? extends Tuple7<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5,? extends T6,? extends T7>> tuples)	Turns a sequence of Tuple7 into a Tuple7 of Seqs.
static <T1,T2,T3,T4,T5,T6,T7> Tuple7<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>,Seq<T6>,Seq<T7>>	Tuple.sequence7(@NonNull java.lang.Iterable<? extends Tuple7<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5,? extends T6,? extends T7>> tuples)	Turns a sequence of Tuple7 into a Tuple7 of Seqs.
static <T1,T2,T3,T4,T5,T6,T7> Tuple7<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>,Seq<T6>,Seq<T7>>	Tuple.sequence7(@NonNull java.lang.Iterable<? extends Tuple7<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5,? extends T6,? extends T7>> tuples)	Turns a sequence of Tuple7 into a Tuple7 of Seqs.
static <T1,T2,T3,T4,T5,T6,T7> Tuple7<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>,Seq<T6>,Seq<T7>>	Tuple.sequence7(@NonNull java.lang.Iterable<? extends Tuple7<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5,? extends T6,? extends T7>> tuples)	Turns a sequence of Tuple7 into a Tuple7 of Seqs.
static <T1,T2,T3,T4,T5,T6,T7,T8> Tuple8<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>,Seq<T6>,Seq<T7>,Seq<T8>>	Tuple.sequence8(@NonNull java.lang.Iterable<? extends Tuple8<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5,? extends T6,? extends T7,? extends T8>> tuples)	Turns a sequence of Tuple8 into a Tuple8 of Seqs.
static <T1,T2,T3,T4,T5,T6,T7,T8> Tuple8<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>,Seq<T6>,Seq<T7>,Seq<T8>>	Tuple.sequence8(@NonNull java.lang.Iterable<? extends Tuple8<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5,? extends T6,? extends T7,? extends T8>> tuples)	Turns a sequence of Tuple8 into a Tuple8 of Seqs.
static <T1,T2,T3,T4,T5,T6,T7,T8> Tuple8<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>,Seq<T6>,Seq<T7>,Seq<T8>>	Tuple.sequence8(@NonNull java.lang.Iterable<? extends Tuple8<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5,? extends T6,? extends T7,? extends T8>> tuples)	Turns a sequence of Tuple8 into a Tuple8 of Seqs.
static <T1,T2,T3,T4,T5,T6,T7,T8> Tuple8<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>,Seq<T6>,Seq<T7>,Seq<T8>>	Tuple.sequence8(@NonNull java.lang.Iterable<? extends Tuple8<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5,? extends T6,? extends T7,? extends T8>> tuples)	Turns a sequence of Tuple8 into a Tuple8 of Seqs.
static <T1,T2,T3,T4,T5,T6,T7,T8> Tuple8<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>,Seq<T6>,Seq<T7>,Seq<T8>>	Tuple.sequence8(@NonNull java.lang.Iterable<? extends Tuple8<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5,? extends T6,? extends T7,? extends T8>> tuples)	Turns a sequence of Tuple8 into a Tuple8 of Seqs.
static <T1,T2,T3,T4,T5,T6,T7,T8> Tuple8<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>,Seq<T6>,Seq<T7>,Seq<T8>>	Tuple.sequence8(@NonNull java.lang.Iterable<? extends Tuple8<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5,? extends T6,? extends T7,? extends T8>> tuples)	Turns a sequence of Tuple8 into a Tuple8 of Seqs.
static <T1,T2,T3,T4,T5,T6,T7,T8> Tuple8<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>,Seq<T6>,Seq<T7>,Seq<T8>>	Tuple.sequence8(@NonNull java.lang.Iterable<? extends Tuple8<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5,? extends T6,? extends T7,? extends T8>> tuples)	Turns a sequence of Tuple8 into a Tuple8 of Seqs.
static <T1,T2,T3,T4,T5,T6,T7,T8> Tuple8<Seq<T1>,Seq<T2>,Seq<T3>,Seq<T4>,Seq<T5>,Seq<T6>,Seq<T7>,Seq<T8>>	Tuple.sequence8(@NonNull java.lang.Iterable<? extends Tuple8<? extends T1,? extends T2,? extends T3,? extends T4,? extends T5,? extends T6,? extends T7,? extends T8>> tuples)	Turns a sequence of Tuple8 into a Tuple8 of Seqs.

Uses of Seq in io.vavr.collection

Classes in io.vavr.collection with type parameters of type Seq

Modifier and Type	Class	Description
(package private) static class	JavaConverters.ListView<T,C extends Seq<T>>
private static class	JavaConverters.ListView.Iterator<T,C extends Seq<T>>
private static class	JavaConverters.ListView.ListIterator<T,C extends Seq<T>>

Subinterfaces of Seq in io.vavr.collection

Modifier and Type	Interface	Description
interface	IndexedSeq<T>	Represents an immutable, indexed sequence of elements.
interface	LinearSeq<T>	Interface for immutable, linear sequences.
interface	List<T>	An immutable List is an eager sequence of elements.
interface	Stream<T>	An immutable Stream is lazy sequence of elements which may be infinitely long.

Classes in io.vavr.collection that implement Seq

Modifier and Type	Class	Description
class	Array<T>	Array is an immutable Traversable wrapper for Object[] containing elements of type T.
class	CharSeq	The CharSeq (read: character sequence) collection essentially is a rich String wrapper having all operations we know from the functional Vavr collections.
static class	List.Cons<T>	Non-empty List, consisting of a head and a tail.
static class	List.Nil<T>	Representation of the singleton empty List.
class	Queue<T>	An immutable Queue stores elements allowing a first-in-first-out (FIFO) retrieval.
static class	Stream.Cons<T>	Non-empty Stream, consisting of a head, and tail.
static class	Stream.Empty<T>	The empty Stream.
static class	StreamModule.AppendElements<T>
static class	StreamModule.ConsImpl<T>
class	Vector<T>	Vector is the default Seq implementation that provides effectively constant time access to any element.

Fields in io.vavr.collection declared as Seq

Modifier and Type	Field	Description
(package private) Seq<PriorityQueueBase.Node<T>>	PriorityQueueBase.Node.children
private Seq<PriorityQueueBase.Node<T>>	PriorityQueue.forest

Methods in io.vavr.collection with type parameters of type Seq

Modifier and Type	Method	Description
(package private) static <T,C extends Seq<T>> C	Collections.asJava(C source, java.util.function.Consumer<? super java.util.List<T>> action, JavaConverters.ChangePolicy changePolicy)
(package private) static <T,C extends Seq<T>> JavaConverters.ListView<T,C>	JavaConverters.asJava(C seq, JavaConverters.ChangePolicy changePolicy)
(package private) static <T,S extends Seq<T>> Iterator<S>	Collections.crossProduct(S empty, S seq, int power)
(package private) static <T,C extends Seq<T>> C	Collections.rotateLeft(C source, int n)
(package private) static <T,C extends Seq<T>> C	Collections.rotateRight(C source, int n)
(package private) static <T,S extends Seq<T>> S	Collections.shuffle(S source, java.util.function.Function<? super java.lang.Iterable<T>,S> ofAll)
(package private) static <T,U,R extends Seq<T>> R	Collections.sortBy(Seq<? extends T> source, java.util.Comparator<? super U> comparator, java.util.function.Function<? super T,? extends U> mapper, java.util.stream.Collector<T,?,R> collector)
(package private) static <T,U extends Seq<T>,V extends Seq<U>> V	Collections.transpose(V matrix, java.util.function.Function<java.lang.Iterable<U>,V> rowFactory, java.util.function.Function<T[],U> columnFactory)
(package private) static <T,U extends Seq<T>,V extends Seq<U>> V	Collections.transpose(V matrix, java.util.function.Function<java.lang.Iterable<U>,V> rowFactory, java.util.function.Function<T[],U> columnFactory)
private static <T,U extends Seq<T>,V extends Seq<U>> V	Collections.transposeNonEmptyMatrix(V matrix, java.util.function.Function<java.lang.Iterable<U>,V> rowFactory, java.util.function.Function<T[],U> columnFactory)
private static <T,U extends Seq<T>,V extends Seq<U>> V	Collections.transposeNonEmptyMatrix(V matrix, java.util.function.Function<java.lang.Iterable<U>,V> rowFactory, java.util.function.Function<T[],U> columnFactory)

Methods in io.vavr.collection that return Seq

Modifier and Type	Method	Description
Seq<T>	Seq.append(T element)	Returns a new sequence with the given element appended at the end.
Seq<T>	Seq.appendAll(@NonNull java.lang.Iterable<? extends T> elements)	Returns a new sequence with all elements from the given Iterable appended at the end of this sequence.
(package private) Seq<PriorityQueueBase.Node<T>>	PriorityQueueBase.Node.appendTo(Seq<PriorityQueueBase.Node<T>> forest)
Seq<T>	Seq.asJava(@NonNull java.util.function.Consumer<? super java.util.List<T>> action)	Creates an immutable List view of this Seq and passes it to the given action.
Seq<T>	Seq.asJavaMutable(@NonNull java.util.function.Consumer<? super java.util.List<T>> action)	Creates a mutable List view of this Seq and passes it to the given action.
default <R> Seq<R>	Map.collect(@NonNull PartialFunction<? super Tuple2<K,V>,? extends R> partialFunction)
default <R> Seq<R>	Multimap.collect(@NonNull PartialFunction<? super Tuple2<K,V>,? extends R> partialFunction)
<R> Seq<R>	Seq.collect(@NonNull PartialFunction<? super T,? extends R> partialFunction)
Seq<? extends Seq<T>>	Seq.combinations()	Returns a sequence containing all combinations of elements from this sequence, for all sizes from 0 to length().
Seq<? extends Seq<T>>	Seq.combinations(int k)	Returns all subsets of this sequence containing exactly k distinct elements, i.e., the k-combinations of this sequence.
Seq<T>	Seq.distinct()
default Seq<T>	Tree.distinct()
Seq<T>	Seq.distinctBy(@NonNull java.util.Comparator<? super T> comparator)
<U> Seq<T>	Seq.distinctBy(@NonNull java.util.function.Function<? super T,? extends U> keyExtractor)
default Seq<T>	Tree.distinctBy(@NonNull java.util.Comparator<? super T> comparator)
default <U> Seq<T>	Tree.distinctBy(@NonNull java.util.function.Function<? super T,? extends U> keyExtractor)
Seq<T>	Seq.distinctByKeepLast(@NonNull java.util.Comparator<? super T> comparator)	Returns a sequence with duplicate elements removed, as determined by the provided comparator.
<U> Seq<T>	Seq.distinctByKeepLast(@NonNull java.util.function.Function<? super T,? extends U> keyExtractor)	Returns a sequence with duplicates removed based on a key extracted from each element.
Seq<T>	Seq.drop(int n)
default Seq<T>	Tree.drop(int n)
Seq<T>	Seq.dropRight(int n)
default Seq<T>	Tree.dropRight(int n)
Seq<T>	Seq.dropRightUntil(@NonNull java.util.function.Predicate<? super T> predicate)	Drops elements from the end of the sequence until an element satisfies the given predicate.
Seq<T>	Seq.dropRightWhile(@NonNull java.util.function.Predicate<? super T> predicate)	Drops elements from the end of the sequence while the given predicate holds.
Seq<T>	Seq.dropUntil(@NonNull java.util.function.Predicate<? super T> predicate)
default Seq<T>	Tree.dropUntil(@NonNull java.util.function.Predicate<? super T> predicate)
Seq<T>	Seq.dropWhile(@NonNull java.util.function.Predicate<? super T> predicate)
default Seq<T>	Tree.dropWhile(@NonNull java.util.function.Predicate<? super T> predicate)
Seq<T>	Seq.filter(@NonNull java.util.function.Predicate<? super T> predicate)
default Seq<T>	Tree.filter(@NonNull java.util.function.Predicate<? super T> predicate)
default <U> Seq<U>	Map.flatMap(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends java.lang.Iterable<? extends U>> mapper)	Flat-maps this entries to a sequence of values.
default <U> Seq<U>	Multimap.flatMap(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends java.lang.Iterable<? extends U>> mapper)	Flat-maps this entries to a sequence of values.
<U> Seq<U>	Seq.flatMap(@NonNull java.util.function.Function<? super T,? extends java.lang.Iterable<? extends U>> mapper)
Seq<T>	Seq.init()
default Seq<T>	Tree.init()
private static <T> Seq<PriorityQueueBase.Node<T>>	PriorityQueueBase.ins(java.util.Comparator<? super T> comparator, PriorityQueueBase.Node<T> tree, Seq<PriorityQueueBase.Node<T>> forest)	fun ins (t, []) = [t] * | ins (t, t' :: ts) = (∗ rank t ≤ rank t' ∗) * if rank t < rank t' then t :: t' :: ts * else ins (link (t, t'), ts)
(package private) static <T> Seq<PriorityQueueBase.Node<T>>	PriorityQueueBase.insert(java.util.Comparator<? super T> comparator, T element, Seq<PriorityQueueBase.Node<T>> forest)	fun insert (x, ts as t1 :: t2 :: rest) = * if rank t1 = rank t2 then skewLink(Node(x,0,[]),t1,t2) :: rest * else Node (x,0,[]) :: ts * | insert (x, ts) = Node (x,0,[]) :: ts
Seq<T>	Seq.insert(int index, T element)	Returns a new sequence with the given element inserted at the specified index.
Seq<T>	Seq.insertAll(int index, @NonNull java.lang.Iterable<? extends T> elements)	Returns a new sequence with the given elements inserted at the specified index.
Seq<T>	Seq.intersperse(T element)	Returns a new sequence where the given element is inserted between all elements of this sequence.
Seq<T>	Seq.leftPadTo(int length, T element)	Returns a new sequence with this sequence padded on the left with the given element until the specified target length is reached.
default <U> Seq<U>	Map.map(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends U> mapper)	Maps the Map entries to a sequence of values.
default <U> Seq<U>	Multimap.map(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends U> mapper)	Maps the Multimap entries to a sequence of values.
<U> Seq<U>	Seq.map(@NonNull java.util.function.Function<? super T,? extends U> mapper)
default <U> Seq<U>	Map.mapTo(U value)
default <U> Seq<U>	Multimap.mapTo(U value)
default <U> Seq<U>	Seq.mapTo(U value)
default Seq<java.lang.Void>	Map.mapToVoid()
default Seq<java.lang.Void>	Multimap.mapToVoid()
default Seq<java.lang.Void>	Seq.mapToVoid()
(package private) static <T> Seq<PriorityQueueBase.Node<T>>	PriorityQueueBase.meld(java.util.Comparator<? super T> comparator, Seq<PriorityQueueBase.Node<T>> source, Seq<PriorityQueueBase.Node<T>> target)	fun meld (ts, ts') = meldUniq (uniqify ts, uniqify ts')
private static <T> Seq<PriorityQueueBase.Node<T>>	PriorityQueueBase.meldUnique(java.util.Comparator<? super T> comparator, Seq<PriorityQueueBase.Node<T>> forest1, Seq<PriorityQueueBase.Node<T>> forest2)	fun meldUniq ([], ts) = ts * | meldUniq (ts, []) = ts * | meldUniq (t1 :: ts1, t2 :: ts2) = * if rank t1 < rank t2 then t1 :: meldUniq (ts1, t2 :: ts2) * else if rank t2 < rank t1 then t2 :: meldUniq (t1 :: ts1, ts2) * else ins (link (t1, t2), meldUniq (ts1, ts2))
static <T> Seq<T>	Seq.narrow(Seq<? extends T> seq)	Narrows a Seq<? extends T> to Seq<T> via a safe unchecked cast.
Seq<T>	IteratorModule.GroupedIterator.next()
Seq<T>	Seq.orElse(@NonNull java.util.function.Supplier<? extends java.lang.Iterable<? extends T>> supplier)
Seq<T>	Seq.orElse(java.lang.Iterable<? extends T> other)
Seq<T>	Seq.padTo(int length, T element)	Returns a new sequence with this sequence padded on the right with the given element until the specified target length is reached.
Seq<T>	Seq.patch(int from, @NonNull java.lang.Iterable<? extends T> that, int replaced)	Returns a new sequence in which a slice of elements in this sequence is replaced by the elements of another sequence.
Seq<T>	Seq.peek(@NonNull java.util.function.Consumer<? super T> action)
Seq<? extends Seq<T>>	Seq.permutations()	Returns all unique permutations of this sequence.
Seq<T>	Seq.prepend(T element)	Returns a new sequence with the given element prepended to this sequence.
Seq<T>	Seq.prependAll(@NonNull java.lang.Iterable<? extends T> elements)	Returns a new sequence with all given elements prepended to this sequence.
private static <T> Seq<PriorityQueueBase.Node<T>>	PriorityQueueBase.rebuild(java.util.Comparator<? super T> comparator, Seq<PriorityQueueBase.Node<T>> forest)	Separate the rank 0 trees from the rest, rebuild the 0 rank ones and merge them back
Seq<T>	Seq.reject(@NonNull java.util.function.Predicate<? super T> predicate)
default Seq<T>	Tree.reject(@NonNull java.util.function.Predicate<? super T> predicate)
Seq<T>	Seq.remove(T element)	Returns a new sequence with the first occurrence of the given element removed.
Seq<T>	Seq.removeAll(@NonNull java.lang.Iterable<? extends T> elements)	Returns a new sequence with all occurrences of the given elements removed.
Seq<T>	Seq.removeAll(@NonNull java.util.function.Predicate<? super T> predicate)	Deprecated. Please use reject(Predicate)
Seq<T>	Seq.removeAll(T element)	Returns a new sequence with all occurrences of the given element removed.
Seq<T>	Seq.removeAt(int index)	Returns a new sequence with the element at the specified position removed.
Seq<T>	Seq.removeFirst(@NonNull java.util.function.Predicate<T> predicate)	Returns a new sequence with the first element that satisfies the given predicate removed.
Seq<T>	Seq.removeLast(@NonNull java.util.function.Predicate<T> predicate)	Returns a new sequence with the last element that satisfies the given predicate removed.
Seq<T>	Seq.replace(T currentElement, T newElement)
Seq<T>	Seq.replaceAll(T currentElement, T newElement)
Seq<T>	Seq.retainAll(@NonNull java.lang.Iterable<? extends T> elements)
default Seq<T>	Tree.retainAll(@NonNull java.lang.Iterable<? extends T> elements)
Seq<T>	Seq.reverse()	Returns a new sequence with the order of elements reversed.
Seq<T>	Seq.rotateLeft(int n)	Returns a new sequence with the elements circularly rotated to the left by the specified distance.
Seq<T>	Seq.rotateRight(int n)	Returns a new sequence with the elements circularly rotated to the right by the specified distance.
Seq<T>	Seq.scan(T zero, @NonNull java.util.function.BiFunction<? super T,? super T,? extends T> operation)
default Seq<T>	Tree.scan(T zero, @NonNull java.util.function.BiFunction<? super T,? super T,? extends T> operation)
default <U> Seq<U>	Map.scanLeft(U zero, @NonNull java.util.function.BiFunction<? super U,? super Tuple2<K,V>,? extends U> operation)
default <U> Seq<U>	Multimap.scanLeft(U zero, @NonNull java.util.function.BiFunction<? super U,? super Tuple2<K,V>,? extends U> operation)
<U> Seq<U>	Seq.scanLeft(U zero, @NonNull java.util.function.BiFunction<? super U,? super T,? extends U> operation)
default <U> Seq<U>	Tree.scanLeft(U zero, @NonNull java.util.function.BiFunction<? super U,? super T,? extends U> operation)
default <U> Seq<U>	Map.scanRight(U zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super U,? extends U> operation)
default <U> Seq<U>	Multimap.scanRight(U zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super U,? extends U> operation)
<U> Seq<U>	Seq.scanRight(U zero, @NonNull java.util.function.BiFunction<? super T,? super U,? extends U> operation)
default <U> Seq<U>	Tree.scanRight(U zero, @NonNull java.util.function.BiFunction<? super T,? super U,? extends U> operation)
Seq<T>	Seq.shuffle()	Returns a new sequence with the elements randomly shuffled.
Seq<T>	Seq.slice(int beginIndex, int endIndex)	Returns a subsequence (slice) of this sequence, starting at beginIndex (inclusive) and ending at endIndex (exclusive).
<U> Seq<T>	Seq.sortBy(@NonNull java.util.Comparator<? super U> comparator, java.util.function.Function<? super T,? extends U> mapper)	Returns a new sequence sorted by comparing elements in a different domain defined by the given mapper, using the provided comparator.
<U extends java.lang.Comparable<? super U>> Seq<T>	Seq.sortBy(@NonNull java.util.function.Function<? super T,? extends U> mapper)	Returns a new sequence sorted by comparing elements in a different domain defined by the given mapper.
Seq<T>	Seq.sorted()	Returns a new sequence with elements sorted according to their natural order.
Seq<T>	Seq.sorted(@NonNull java.util.Comparator<? super T> comparator)	Returns a new sequence with elements sorted according to the given Comparator.
Seq<CharSeq>	CharSeq.split(java.lang.String regex)	Splits this string around matches of the given regular expression.
Seq<CharSeq>	CharSeq.split(java.lang.String regex, int limit)	Splits this string around matches of the given regular expression.
Seq<T>	Seq.subSequence(int beginIndex)	Returns a Seq that is a subsequence of this sequence, starting from the specified beginIndex and extending to the end of this sequence.
Seq<T>	Seq.subSequence(int beginIndex, int endIndex)	Returns a Seq that is a subsequence of this sequence, starting from the specified beginIndex (inclusive) and ending at endIndex (exclusive).
Seq<T>	Seq.tail()
default Seq<T>	Tree.tail()
Seq<T>	Seq.take(int n)
default Seq<T>	Tree.take(int n)
Seq<T>	Seq.takeRight(int n)
default Seq<T>	Tree.takeRight(int n)
Seq<T>	Seq.takeRightUntil(@NonNull java.util.function.Predicate<? super T> predicate)	Takes elements from the end of the sequence until an element satisfies the given predicate.
Seq<T>	Seq.takeRightWhile(@NonNull java.util.function.Predicate<? super T> predicate)	Takes elements from the end of the sequence while the given predicate holds.
Seq<T>	Seq.takeUntil(@NonNull java.util.function.Predicate<? super T> predicate)
default Seq<T>	Tree.takeUntil(@NonNull java.util.function.Predicate<? super T> predicate)
Seq<T>	Seq.takeWhile(@NonNull java.util.function.Predicate<? super T> predicate)
default Seq<T>	Tree.takeWhile(@NonNull java.util.function.Predicate<? super T> predicate)
default Seq<Tree.Node<T>>	Tree.traverse()	Traverses this tree in Tree.Order.PRE_ORDER.
default Seq<Tree.Node<T>>	Tree.traverse(@NonNull Tree.Order order)	Traverses this tree in a specific order.
private static <T> Seq<PriorityQueueBase.Node<T>>	PriorityQueueBase.uniqify(java.util.Comparator<? super T> comparator, Seq<PriorityQueueBase.Node<T>> forest)	fun uniqify [] = [] * | uniqify (t :: ts) = ins (t, ts) (∗ eliminate initial duplicate ∗)
Seq<T>	Seq.update(int index, @NonNull java.util.function.Function<? super T,? extends T> updater)	Returns a new Seq with the element at the specified index updated using the given function.
Seq<T>	Seq.update(int index, T element)	Returns a new Seq with the element at the specified index replaced by the given value.
Seq<V>	LinkedHashMap.values()
Seq<V>	Map.values()	Returns a new Seq that contains the values of this Map.
default Seq<T>	Tree.values()	Traverses this tree values in Tree.Order.PRE_ORDER.
default Seq<T>	Tree.values(@NonNull Tree.Order order)	Traverses this tree values in a specific order.
Seq<V>	TreeMap.values()
default <U> Seq<Tuple2<Tuple2<K,V>,U>>	Map.zip(@NonNull java.lang.Iterable<? extends U> that)
default <U> Seq<Tuple2<Tuple2<K,V>,U>>	Multimap.zip(@NonNull java.lang.Iterable<? extends U> that)
<U> Seq<Tuple2<T,U>>	Seq.zip(@NonNull java.lang.Iterable<? extends U> that)
default <U> Seq<Tuple2<Tuple2<K,V>,U>>	Map.zipAll(@NonNull java.lang.Iterable<? extends U> that, Tuple2<K,V> thisElem, U thatElem)
default <U> Seq<Tuple2<Tuple2<K,V>,U>>	Multimap.zipAll(@NonNull java.lang.Iterable<? extends U> that, Tuple2<K,V> thisElem, U thatElem)
<U> Seq<Tuple2<T,U>>	Seq.zipAll(@NonNull java.lang.Iterable<? extends U> that, T thisElem, U thatElem)
default <U,R> Seq<R>	Map.zipWith(@NonNull java.lang.Iterable<? extends U> that, java.util.function.BiFunction<? super Tuple2<K,V>,? super U,? extends R> mapper)
default <U,R> Seq<R>	Multimap.zipWith(@NonNull java.lang.Iterable<? extends U> that, java.util.function.BiFunction<? super Tuple2<K,V>,? super U,? extends R> mapper)
<U,R> Seq<R>	Seq.zipWith(@NonNull java.lang.Iterable<? extends U> that, java.util.function.BiFunction<? super T,? super U,? extends R> mapper)
default Seq<Tuple2<Tuple2<K,V>,java.lang.Integer>>	Map.zipWithIndex()
default <U> Seq<U>	Map.zipWithIndex(@NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super java.lang.Integer,? extends U> mapper)
default Seq<Tuple2<Tuple2<K,V>,java.lang.Integer>>	Multimap.zipWithIndex()
default <U> Seq<U>	Multimap.zipWithIndex(@NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super java.lang.Integer,? extends U> mapper)
Seq<Tuple2<T,java.lang.Integer>>	Seq.zipWithIndex()
<U> Seq<U>	Seq.zipWithIndex(@NonNull java.util.function.BiFunction<? super T,? super java.lang.Integer,? extends U> mapper)

Methods in io.vavr.collection that return types with arguments of type Seq

Modifier and Type	Method	Description
Seq<? extends Seq<T>>	Seq.combinations()	Returns a sequence containing all combinations of elements from this sequence, for all sizes from 0 to length().
Seq<? extends Seq<T>>	Seq.combinations(int k)	Returns all subsets of this sequence containing exactly k distinct elements, i.e., the k-combinations of this sequence.
Iterator<? extends Seq<T>>	Seq.crossProduct(int power)	Returns the n-ary Cartesian power (cross product) of this sequence.
(package private) static <T> Tuple2<T,Seq<PriorityQueueBase.Node<T>>>	PriorityQueueBase.deleteMin(java.util.Comparator<? super T> comparator, Seq<PriorityQueueBase.Node<T>> forest)	fun deleteMin [] = raise EMPTY * | deleteMin ts = * val (Node (x,r,c), ts) = getMin ts * val (ts',xs') = split ([],[],c) * in fold insert xs' (meld (ts, ts')) end
<C> Map<C,? extends Seq<T>>	Seq.groupBy(@NonNull java.util.function.Function<? super T,? extends C> classifier)
default <C> Map<C,Seq<T>>	Tree.groupBy(@NonNull java.util.function.Function<? super T,? extends C> classifier)
default Iterator<Seq<T>>	Iterator.grouped(int size)
Iterator<? extends Seq<T>>	Seq.grouped(int size)
default Iterator<Seq<T>>	Tree.grouped(int size)
Option<? extends Seq<T>>	Seq.initOption()
default Option<Seq<T>>	Tree.initOption()
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.partition(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.partition(@NonNull java.util.function.Predicate<? super T> predicate)
default Tuple2<Seq<T>,Seq<T>>	Tree.partition(@NonNull java.util.function.Predicate<? super T> predicate)
default Tuple2<Seq<T>,Seq<T>>	Tree.partition(@NonNull java.util.function.Predicate<? super T> predicate)
Seq<? extends Seq<T>>	Seq.permutations()	Returns all unique permutations of this sequence.
default Iterator<Seq<T>>	Iterator.slideBy(@NonNull java.util.function.Function<? super T,?> classifier)
Iterator<? extends Seq<T>>	Seq.slideBy(@NonNull java.util.function.Function<? super T,?> classifier)
default Iterator<Seq<T>>	Tree.slideBy(@NonNull java.util.function.Function<? super T,?> classifier)
default Iterator<Seq<T>>	Iterator.sliding(int size)
default Iterator<Seq<T>>	Iterator.sliding(int size, int step)
Iterator<? extends Seq<T>>	Seq.sliding(int size)
Iterator<? extends Seq<T>>	Seq.sliding(int size, int step)
default Iterator<Seq<T>>	Tree.sliding(int size)
default Iterator<Seq<T>>	Tree.sliding(int size, int step)
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.span(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.span(@NonNull java.util.function.Predicate<? super T> predicate)
default Tuple2<Seq<T>,Seq<T>>	Tree.span(@NonNull java.util.function.Predicate<? super T> predicate)
default Tuple2<Seq<T>,Seq<T>>	Tree.span(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.splitAt(int n)	Splits this sequence at the specified index.
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.splitAt(int n)	Splits this sequence at the specified index.
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.splitAt(@NonNull java.util.function.Predicate<? super T> predicate)	Splits this sequence at the first element satisfying the given predicate.
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.splitAt(@NonNull java.util.function.Predicate<? super T> predicate)	Splits this sequence at the first element satisfying the given predicate.
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.splitAtInclusive(@NonNull java.util.function.Predicate<? super T> predicate)	Splits this sequence at the first element satisfying the given predicate, including the element in the first part.
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.splitAtInclusive(@NonNull java.util.function.Predicate<? super T> predicate)	Splits this sequence at the first element satisfying the given predicate, including the element in the first part.
Option<? extends Seq<T>>	Seq.tailOption()
default Option<Seq<T>>	Tree.tailOption()
default Tuple2<Seq<K>,Seq<V>>	Map.unzip()	Unzips the entries of this Map by treating each key-value pair as an element, and splitting them into two separate Seq collections - one for keys and one for values.
default Tuple2<Seq<K>,Seq<V>>	Map.unzip()	Unzips the entries of this Map by treating each key-value pair as an element, and splitting them into two separate Seq collections - one for keys and one for values.
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Map.unzip(@NonNull java.util.function.BiFunction<? super K,? super V,Tuple2<? extends T1,? extends T2>> unzipper)	Unzips the entries of this Map by mapping each key-value pair to a tuple.
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Map.unzip(@NonNull java.util.function.BiFunction<? super K,? super V,Tuple2<? extends T1,? extends T2>> unzipper)	Unzips the entries of this Map by mapping each key-value pair to a tuple.
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Map.unzip(@NonNull java.util.function.Function<? super Tuple2<K,V>,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Map.unzip(@NonNull java.util.function.Function<? super Tuple2<K,V>,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Multimap.unzip(@NonNull java.util.function.BiFunction<? super K,? super V,Tuple2<? extends T1,? extends T2>> unzipper)	Unzips the entries of this Multimap by mapping each key-value pair to a pair and splitting them into two separate Seq collections.
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Multimap.unzip(@NonNull java.util.function.BiFunction<? super K,? super V,Tuple2<? extends T1,? extends T2>> unzipper)	Unzips the entries of this Multimap by mapping each key-value pair to a pair and splitting them into two separate Seq collections.
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Multimap.unzip(@NonNull java.util.function.Function<? super Tuple2<K,V>,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Multimap.unzip(@NonNull java.util.function.Function<? super Tuple2<K,V>,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<? extends Seq<T1>,? extends Seq<T2>>	Seq.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<? extends Seq<T1>,? extends Seq<T2>>	Seq.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Map.unzip3(@NonNull java.util.function.BiFunction<? super K,? super V,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)	Unzips the entries of this Map by mapping each key-value pair to a triple.
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Map.unzip3(@NonNull java.util.function.BiFunction<? super K,? super V,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)	Unzips the entries of this Map by mapping each key-value pair to a triple.
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Map.unzip3(@NonNull java.util.function.BiFunction<? super K,? super V,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)	Unzips the entries of this Map by mapping each key-value pair to a triple.
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Map.unzip3(@NonNull java.util.function.Function<? super Tuple2<K,V>,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Map.unzip3(@NonNull java.util.function.Function<? super Tuple2<K,V>,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Map.unzip3(@NonNull java.util.function.Function<? super Tuple2<K,V>,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Multimap.unzip3(@NonNull java.util.function.BiFunction<? super K,? super V,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)	Unzips the entries of this Multimap by mapping each key-value pair to a triple and splitting them into three separate Seq collections.
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Multimap.unzip3(@NonNull java.util.function.BiFunction<? super K,? super V,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)	Unzips the entries of this Multimap by mapping each key-value pair to a triple and splitting them into three separate Seq collections.
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Multimap.unzip3(@NonNull java.util.function.BiFunction<? super K,? super V,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)	Unzips the entries of this Multimap by mapping each key-value pair to a triple and splitting them into three separate Seq collections.
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Multimap.unzip3(@NonNull java.util.function.Function<? super Tuple2<K,V>,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Multimap.unzip3(@NonNull java.util.function.Function<? super Tuple2<K,V>,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Multimap.unzip3(@NonNull java.util.function.Function<? super Tuple2<K,V>,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)
<T1,T2,T3> Tuple3<? extends Seq<T1>,? extends Seq<T2>,? extends Seq<T3>>	Seq.unzip3(@NonNull java.util.function.Function<? super T,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)
<T1,T2,T3> Tuple3<? extends Seq<T1>,? extends Seq<T2>,? extends Seq<T3>>	Seq.unzip3(@NonNull java.util.function.Function<? super T,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)
<T1,T2,T3> Tuple3<? extends Seq<T1>,? extends Seq<T2>,? extends Seq<T3>>	Seq.unzip3(@NonNull java.util.function.Function<? super T,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)

Methods in io.vavr.collection with parameters of type Seq

Modifier and Type	Method	Description
(package private) Seq<PriorityQueueBase.Node<T>>	PriorityQueueBase.Node.appendTo(Seq<PriorityQueueBase.Node<T>> forest)
(package private) static <T> Tuple2<T,Seq<PriorityQueueBase.Node<T>>>	PriorityQueueBase.deleteMin(java.util.Comparator<? super T> comparator, Seq<PriorityQueueBase.Node<T>> forest)	fun deleteMin [] = raise EMPTY * | deleteMin ts = * val (Node (x,r,c), ts) = getMin ts * val (ts',xs') = split ([],[],c) * in fold insert xs' (meld (ts, ts')) end
default boolean	IndexedSeq.endsWith(@NonNull Seq<? extends T> that)
default boolean	Seq.endsWith(@NonNull Seq<? extends T> that)	Checks whether this sequence ends with the given sequence.
(package private) static <V> boolean	Collections.equals(Seq<V> source, java.lang.Object object)
(package private) static <T> PriorityQueueBase.Node<T>	PriorityQueueBase.findMin(java.util.Comparator<? super T> comparator, Seq<PriorityQueueBase.Node<T>> forest)	Find the minimum root in the forest
private static <T> Seq<PriorityQueueBase.Node<T>>	PriorityQueueBase.ins(java.util.Comparator<? super T> comparator, PriorityQueueBase.Node<T> tree, Seq<PriorityQueueBase.Node<T>> forest)	fun ins (t, []) = [t] * | ins (t, t' :: ts) = (∗ rank t ≤ rank t' ∗) * if rank t < rank t' then t :: t' :: ts * else ins (link (t, t'), ts)
(package private) static <T> Seq<PriorityQueueBase.Node<T>>	PriorityQueueBase.insert(java.util.Comparator<? super T> comparator, T element, Seq<PriorityQueueBase.Node<T>> forest)	fun insert (x, ts as t1 :: t2 :: rest) = * if rank t1 = rank t2 then skewLink(Node(x,0,[]),t1,t2) :: rest * else Node (x,0,[]) :: ts * | insert (x, ts) = Node (x,0,[]) :: ts
(package private) static <T> Seq<PriorityQueueBase.Node<T>>	PriorityQueueBase.meld(java.util.Comparator<? super T> comparator, Seq<PriorityQueueBase.Node<T>> source, Seq<PriorityQueueBase.Node<T>> target)	fun meld (ts, ts') = meldUniq (uniqify ts, uniqify ts')
private static <T> Seq<PriorityQueueBase.Node<T>>	PriorityQueueBase.meldUnique(java.util.Comparator<? super T> comparator, Seq<PriorityQueueBase.Node<T>> forest1, Seq<PriorityQueueBase.Node<T>> forest2)	fun meldUniq ([], ts) = ts * | meldUniq (ts, []) = ts * | meldUniq (t1 :: ts1, t2 :: ts2) = * if rank t1 < rank t2 then t1 :: meldUniq (ts1, t2 :: ts2) * else if rank t2 < rank t1 then t2 :: meldUniq (t1 :: ts1, ts2) * else ins (link (t1, t2), meldUniq (ts1, ts2))
static <T> Seq<T>	Seq.narrow(Seq<? extends T> seq)	Narrows a Seq<? extends T> to Seq<T> via a safe unchecked cast.
(package private) static <T> PriorityQueueBase.Node<T>	PriorityQueueBase.Node.of(T value, int rank, Seq<PriorityQueueBase.Node<T>> children)
private static <T> Seq<PriorityQueueBase.Node<T>>	PriorityQueueBase.rebuild(java.util.Comparator<? super T> comparator, Seq<PriorityQueueBase.Node<T>> forest)	Separate the rank 0 trees from the rest, rebuild the 0 rank ones and merge them back
(package private) static <T,U,R extends Seq<T>> R	Collections.sortBy(Seq<? extends T> source, java.util.Comparator<? super U> comparator, java.util.function.Function<? super T,? extends U> mapper, java.util.stream.Collector<T,?,R> collector)
private static <T> Seq<PriorityQueueBase.Node<T>>	PriorityQueueBase.uniqify(java.util.Comparator<? super T> comparator, Seq<PriorityQueueBase.Node<T>> forest)	fun uniqify [] = [] * | uniqify (t :: ts) = ins (t, ts) (∗ eliminate initial duplicate ∗)
private PriorityQueue<T>	PriorityQueue.with(Seq<PriorityQueueBase.Node<T>> forest, int size)

Constructors in io.vavr.collection with parameters of type Seq

Constructor	Description
Node(T root, int rank, Seq<PriorityQueueBase.Node<T>> children)
PriorityQueue(java.util.Comparator<? super T> comparator, Seq<PriorityQueueBase.Node<T>> forest, int size)

Uses of Seq in io.vavr.concurrent

Methods in io.vavr.concurrent that return types with arguments of type Seq

Modifier and Type	Method	Description
static <T> Future<Seq<T>>	Future.sequence(@NonNull java.lang.Iterable<? extends Future<? extends T>> futures)	Reduces multiple Future instances into a single Future by transforming an Iterable<Future<? extends T>> into a Future<Seq<T>>.
static <T> Future<Seq<T>>	Future.sequence(@NonNull java.util.concurrent.Executor executor, @NonNull java.lang.Iterable<? extends Future<? extends T>> futures)	Reduces multiple Future instances into a single Future by transforming an Iterable<Future<? extends T>> into a Future<Seq<T>>.
static <T,U> Future<Seq<U>>	Future.traverse(@NonNull java.lang.Iterable<? extends T> values, @NonNull java.util.function.Function<? super T,? extends Future<? extends U>> mapper)	Maps the values of an iterable in parallel to a sequence of mapped values, producing a single Future by transforming an Iterable<? extends T> into a Future<Seq<U>>.
static <T,U> Future<Seq<U>>	Future.traverse(@NonNull java.util.concurrent.Executor executor, @NonNull java.lang.Iterable<? extends T> values, @NonNull java.util.function.Function<? super T,? extends Future<? extends U>> mapper)	Maps the values of an iterable in parallel to a sequence of mapped values, producing a single Future by transforming an Iterable<? extends T> into a Future<Seq<U>>.

Uses of Seq in io.vavr.control

Methods in io.vavr.control that return types with arguments of type Seq

Modifier and Type	Method	Description
default <U> Validation<Seq<E>,U>	Validation.ap(@NonNull Validation<Seq<E>,? extends java.util.function.Function<? super T,? extends U>> validation)	Applies a validation containing a function to this validation's value, combining errors if both are invalid.
<R> Validation<Seq<E>,R>	Validation.Builder.ap(Function2<T1,T2,R> f)	Applies a binary function to the values of the two validations held by this builder.
<R> Validation<Seq<E>,R>	Validation.Builder3.ap(Function3<T1,T2,T3,R> f)	Applies a ternary function to the values of the three validations held by this builder.
<R> Validation<Seq<E>,R>	Validation.Builder4.ap(Function4<T1,T2,T3,T4,R> f)	Applies a quaternary function to the values of the four validations held by this builder.
<R> Validation<Seq<E>,R>	Validation.Builder5.ap(Function5<T1,T2,T3,T4,T5,R> f)	Applies a quinary function to the values of the five validations held by this builder.
<R> Validation<Seq<E>,R>	Validation.Builder6.ap(Function6<T1,T2,T3,T4,T5,T6,R> f)	Applies a senary function to the values of the six validations held by this builder.
<R> Validation<Seq<E>,R>	Validation.Builder7.ap(Function7<T1,T2,T3,T4,T5,T6,T7,R> f)	Applies a septenary function to the values of the seven validations held by this builder.
<R> Validation<Seq<E>,R>	Validation.Builder8.ap(Function8<T1,T2,T3,T4,T5,T6,T7,T8,R> f)	Applies an octonary function to the values of the eight validations held by this builder.
static <L,R> Either<Seq<L>,Seq<R>>	Either.sequence(@NonNull java.lang.Iterable<? extends Either<? extends L,? extends R>> eithers)	Transforms an Iterable of Either<L, R> into a single Either<Seq<L>, Seq<R>>.
static <L,R> Either<Seq<L>,Seq<R>>	Either.sequence(@NonNull java.lang.Iterable<? extends Either<? extends L,? extends R>> eithers)	Transforms an Iterable of Either<L, R> into a single Either<Seq<L>, Seq<R>>.
static <T> Option<Seq<T>>	Option.sequence(@NonNull java.lang.Iterable<? extends Option<? extends T>> values)	Reduces multiple Option values into a single Option by transforming an Iterable<Option<? extends T>> into an Option<Seq<T>>.
static <T> Try<Seq<T>>	Try.sequence(@NonNull java.lang.Iterable<? extends Try<? extends T>> values)	Transforms an Iterable of Try instances into a single Try containing a Seq of all successful results.
static <E,T> Validation<Seq<E>,Seq<T>>	Validation.sequence(@NonNull java.lang.Iterable<? extends Validation<? extends Seq<? extends E>,? extends T>> values)	Reduces many Validation instances into a single Validation by transforming an Iterable<Validation<? extends T>> into a Validation<Seq<T>>.
static <E,T> Validation<Seq<E>,Seq<T>>	Validation.sequence(@NonNull java.lang.Iterable<? extends Validation<? extends Seq<? extends E>,? extends T>> values)	Reduces many Validation instances into a single Validation by transforming an Iterable<Validation<? extends T>> into a Validation<Seq<T>>.
static <L,R> Either<L,Seq<R>>	Either.sequenceRight(@NonNull java.lang.Iterable<? extends Either<? extends L,? extends R>> eithers)	Transforms an Iterable of Either<L, R> into a single Either<L, Seq<R>>.
static <L,R,T> Either<Seq<L>,Seq<R>>	Either.traverse(@NonNull java.lang.Iterable<? extends T> values, @NonNull java.util.function.Function<? super T,? extends Either<? extends L,? extends R>> mapper)	Transforms an Iterable of values into a single Either<Seq<L>, Seq<R>> by applying a mapping function that returns an Either for each value.
static <L,R,T> Either<Seq<L>,Seq<R>>	Either.traverse(@NonNull java.lang.Iterable<? extends T> values, @NonNull java.util.function.Function<? super T,? extends Either<? extends L,? extends R>> mapper)	Transforms an Iterable of values into a single Either<Seq<L>, Seq<R>> by applying a mapping function that returns an Either for each value.
static <T,U> Option<Seq<U>>	Option.traverse(@NonNull java.lang.Iterable<? extends T> values, @NonNull java.util.function.Function<? super T,? extends Option<? extends U>> mapper)	Maps the elements of an iterable into Option values and collects the results into a single Option.
static <T,U> Try<Seq<U>>	Try.traverse(@NonNull java.lang.Iterable<? extends T> values, @NonNull java.util.function.Function<? super T,? extends Try<? extends U>> mapper)	Transforms an Iterable of values into a single Try containing a Seq of mapped results.
static <E,T,U> Validation<Seq<E>,Seq<U>>	Validation.traverse(@NonNull java.lang.Iterable<? extends T> values, @NonNull java.util.function.Function<? super T,? extends Validation<? extends Seq<? extends E>,? extends U>> mapper)	Maps the values of an iterable to a sequence of mapped values into a single Validation by transforming an Iterable<? extends T> into a Validation<Seq<U>>.
static <E,T,U> Validation<Seq<E>,Seq<U>>	Validation.traverse(@NonNull java.lang.Iterable<? extends T> values, @NonNull java.util.function.Function<? super T,? extends Validation<? extends Seq<? extends E>,? extends U>> mapper)	Maps the values of an iterable to a sequence of mapped values into a single Validation by transforming an Iterable<? extends T> into a Validation<Seq<U>>.
static <L,R,T> Either<L,Seq<R>>	Either.traverseRight(@NonNull java.lang.Iterable<? extends T> values, @NonNull java.util.function.Function<? super T,? extends Either<? extends L,? extends R>> mapper)	Transforms an Iterable of values into a single Either<Seq<L>, Seq<R>> by applying a mapping function that returns an Either for each element.

Method parameters in io.vavr.control with type arguments of type Seq

Modifier and Type	Method	Description
default <U> Validation<Seq<E>,U>	Validation.ap(@NonNull Validation<Seq<E>,? extends java.util.function.Function<? super T,? extends U>> validation)	Applies a validation containing a function to this validation's value, combining errors if both are invalid.
static <E,T> Validation<Seq<E>,Seq<T>>	Validation.sequence(@NonNull java.lang.Iterable<? extends Validation<? extends Seq<? extends E>,? extends T>> values)	Reduces many Validation instances into a single Validation by transforming an Iterable<Validation<? extends T>> into a Validation<Seq<T>>.
static <E,T,U> Validation<Seq<E>,Seq<U>>	Validation.traverse(@NonNull java.lang.Iterable<? extends T> values, @NonNull java.util.function.Function<? super T,? extends Validation<? extends Seq<? extends E>,? extends U>> mapper)	Maps the values of an iterable to a sequence of mapped values into a single Validation by transforming an Iterable<? extends T> into a Validation<Seq<U>>.