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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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
final class	Array<T>	Array is an immutable Traversable wrapper for Object[] containing elements of type T.
final 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 final class	List.Cons<T>	Non-empty List, consisting of a head and a tail.
static final class	List.Nil<T>	Representation of the singleton empty List.
final 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 final class	Stream.Empty<T>	The empty Stream.
static final class	StreamModule.AppendElements<T>
static final class	StreamModule.ConsImpl<T>
final class	Vector<T>	Vector is the default Seq implementation that provides effectively constant time access to any element.

Classes in io.vavr.collection that implement interfaces with type arguments of type Seq

Modifier and Type	Class	Description
static final class	IteratorModule.GroupedIterator<T>

Fields in io.vavr.collection declared as Seq

Modifier and Type	Field	Description
(package private) final Seq<PriorityQueueBase.Node<T>>	PriorityQueueBase.Node.children
private final 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, Consumer<? super 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, Function<? super Iterable<T>, S> ofAll)
(package private) static <T, U, R extends Seq<T>> R	Collections.sortBy(Seq<? extends T> source, Comparator<? super U> comparator, Function<? super T, ? extends U> mapper, Collector<T,?,R> collector)
(package private) static <T, U extends Seq<T>, V extends Seq<U>> V	Collections.transpose(V matrix, Function<Iterable<U>, V> rowFactory, Function<T[],U> columnFactory)
(package private) static <T, U extends Seq<T>, V extends Seq<U>> V	Collections.transpose(V matrix, Function<Iterable<U>, V> rowFactory, Function<T[],U> columnFactory)
private static <T, U extends Seq<T>, V extends Seq<U>> V	Collections.transposeNonEmptyMatrix(V matrix, Function<Iterable<U>, V> rowFactory, Function<T[],U> columnFactory)
private static <T, U extends Seq<T>, V extends Seq<U>> V	Collections.transposeNonEmptyMatrix(V matrix, Function<Iterable<U>, V> rowFactory, 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 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 Consumer<? super List<T>> action)	Creates an immutable List view of this Seq and passes it to the given action.
Seq<T>	Seq.asJavaMutable(@NonNull Consumer<? super 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 Comparator<? super T> comparator)
<U> Seq<T>	Seq.distinctBy(@NonNull Function<? super T, ? extends U> keyExtractor)
default Seq<T>	Tree.distinctBy(@NonNull Comparator<? super T> comparator)
default <U> Seq<T>	Tree.distinctBy(@NonNull Function<? super T, ? extends U> keyExtractor)
Seq<T>	Seq.distinctByKeepLast(@NonNull Comparator<? super T> comparator)	Returns a sequence with duplicate elements removed, as determined by the provided comparator.
<U> Seq<T>	Seq.distinctByKeepLast(@NonNull 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 Predicate<? super T> predicate)	Drops elements from the end of the sequence until an element satisfies the given predicate.
Seq<T>	Seq.dropRightWhile(@NonNull Predicate<? super T> predicate)	Drops elements from the end of the sequence while the given predicate holds.
Seq<T>	Seq.dropUntil(@NonNull Predicate<? super T> predicate)
default Seq<T>	Tree.dropUntil(@NonNull Predicate<? super T> predicate)
Seq<T>	Seq.dropWhile(@NonNull Predicate<? super T> predicate)
default Seq<T>	Tree.dropWhile(@NonNull Predicate<? super T> predicate)
Seq<T>	Seq.filter(@NonNull Predicate<? super T> predicate)
default Seq<T>	Tree.filter(@NonNull Predicate<? super T> predicate)
default <U> Seq<U>	Map.flatMap(@NonNull Function<? super Tuple2<K,V>, ? extends Iterable<? extends U>> mapper)	Flat-maps this entries to a sequence of values.
default <U> Seq<U>	Multimap.flatMap(@NonNull Function<? super Tuple2<K,V>, ? extends Iterable<? extends U>> mapper)	Flat-maps this entries to a sequence of values.
<U> Seq<U>	Seq.flatMap(@NonNull Function<? super T, ? extends Iterable<? extends U>> mapper)
Seq<T>	Seq.init()
default Seq<T>	Tree.init()
private static <T> Seq<PriorityQueueBase.Node<T>>	PriorityQueueBase.ins(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 invalid input: '<' rank t' then t :: t' :: ts * else ins (link (t, t'), ts)
(package private) static <T> Seq<PriorityQueueBase.Node<T>>	PriorityQueueBase.insert(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 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 Function<? super Tuple2<K,V>, ? extends U> mapper)	Maps the Map entries to a sequence of values.
default <U> Seq<U>	Multimap.map(@NonNull Function<? super Tuple2<K,V>, ? extends U> mapper)	Maps the Multimap entries to a sequence of values.
<U> Seq<U>	Seq.map(@NonNull 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<Void>	Map.mapToVoid()
default Seq<Void>	Multimap.mapToVoid()
default Seq<Void>	Seq.mapToVoid()
(package private) static <T> Seq<PriorityQueueBase.Node<T>>	PriorityQueueBase.meld(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(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 invalid input: '<' rank t2 then t1 :: meldUniq (ts1, t2 :: ts2) * else if rank t2 invalid input: '<' 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(Iterable<? extends T> other)
Seq<T>	Seq.orElse(@NonNull Supplier<? extends Iterable<? extends T>> supplier)
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 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 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 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(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 Predicate<? super T> predicate)
default Seq<T>	Tree.reject(@NonNull 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 Iterable<? extends T> elements)	Returns a new sequence with all occurrences of the given elements removed.
Seq<T>	Seq.removeAll(@NonNull Predicate<? super T> predicate)	Deprecated. Please use Seq.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 Predicate<T> predicate)	Returns a new sequence with the first element that satisfies the given predicate removed.
Seq<T>	Seq.removeLast(@NonNull 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 Iterable<? extends T> elements)
default Seq<T>	Tree.retainAll(@NonNull 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 BiFunction<? super T, ? super T, ? extends T> operation)
default Seq<T>	Tree.scan(T zero, @NonNull BiFunction<? super T, ? super T, ? extends T> operation)
default <U> Seq<U>	Map.scanLeft(U zero, @NonNull BiFunction<? super U, ? super Tuple2<K,V>, ? extends U> operation)
default <U> Seq<U>	Multimap.scanLeft(U zero, @NonNull BiFunction<? super U, ? super Tuple2<K,V>, ? extends U> operation)
<U> Seq<U>	Seq.scanLeft(U zero, @NonNull BiFunction<? super U, ? super T, ? extends U> operation)
default <U> Seq<U>	Tree.scanLeft(U zero, @NonNull BiFunction<? super U, ? super T, ? extends U> operation)
default <U> Seq<U>	Map.scanRight(U zero, @NonNull BiFunction<? super Tuple2<K,V>, ? super U, ? extends U> operation)
default <U> Seq<U>	Multimap.scanRight(U zero, @NonNull BiFunction<? super Tuple2<K,V>, ? super U, ? extends U> operation)
<U> Seq<U>	Seq.scanRight(U zero, @NonNull BiFunction<? super T, ? super U, ? extends U> operation)
default <U> Seq<U>	Tree.scanRight(U zero, @NonNull 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 Comparator<? super U> comparator, 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 Comparable<? super U>> Seq<T>	Seq.sortBy(@NonNull 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 Comparator<? super T> comparator)	Returns a new sequence with elements sorted according to the given Comparator.
Seq<CharSeq>	CharSeq.split(String regex)	Splits this string around matches of the given regular expression.
Seq<CharSeq>	CharSeq.split(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 Predicate<? super T> predicate)	Takes elements from the end of the sequence until an element satisfies the given predicate.
Seq<T>	Seq.takeRightWhile(@NonNull Predicate<? super T> predicate)	Takes elements from the end of the sequence while the given predicate holds.
Seq<T>	Seq.takeUntil(@NonNull Predicate<? super T> predicate)
default Seq<T>	Tree.takeUntil(@NonNull Predicate<? super T> predicate)
Seq<T>	Seq.takeWhile(@NonNull Predicate<? super T> predicate)
default Seq<T>	Tree.takeWhile(@NonNull 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(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 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 Iterable<? extends U> that)
default <U> Seq<Tuple2<Tuple2<K,V>, U>>	Multimap.zip(@NonNull Iterable<? extends U> that)
<U> Seq<Tuple2<T,U>>	Seq.zip(@NonNull Iterable<? extends U> that)
default <U> Seq<Tuple2<Tuple2<K,V>, U>>	Map.zipAll(@NonNull Iterable<? extends U> that, Tuple2<K,V> thisElem, U thatElem)
default <U> Seq<Tuple2<Tuple2<K,V>, U>>	Multimap.zipAll(@NonNull Iterable<? extends U> that, Tuple2<K,V> thisElem, U thatElem)
<U> Seq<Tuple2<T,U>>	Seq.zipAll(@NonNull Iterable<? extends U> that, T thisElem, U thatElem)
default <U,R> Seq<R>	Map.zipWith(@NonNull Iterable<? extends U> that, BiFunction<? super Tuple2<K,V>, ? super U, ? extends R> mapper)
default <U,R> Seq<R>	Multimap.zipWith(@NonNull Iterable<? extends U> that, BiFunction<? super Tuple2<K,V>, ? super U, ? extends R> mapper)
<U,R> Seq<R>	Seq.zipWith(@NonNull Iterable<? extends U> that, BiFunction<? super T, ? super U, ? extends R> mapper)
default Seq<Tuple2<Tuple2<K,V>, Integer>>	Map.zipWithIndex()
default <U> Seq<U>	Map.zipWithIndex(@NonNull BiFunction<? super Tuple2<K,V>, ? super Integer, ? extends U> mapper)
default Seq<Tuple2<Tuple2<K,V>, Integer>>	Multimap.zipWithIndex()
default <U> Seq<U>	Multimap.zipWithIndex(@NonNull BiFunction<? super Tuple2<K,V>, ? super Integer, ? extends U> mapper)
Seq<Tuple2<T,Integer>>	Seq.zipWithIndex()
<U> Seq<U>	Seq.zipWithIndex(@NonNull BiFunction<? super T, ? super 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(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 Function<? super T, ? extends C> classifier)
default <C> Map<C,Seq<T>>	Tree.groupBy(@NonNull 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 Predicate<? super T> predicate)
Tuple2<? extends Seq<T>, ? extends Seq<T>>	Seq.partition(@NonNull Predicate<? super T> predicate)
default Tuple2<Seq<T>,Seq<T>>	Tree.partition(@NonNull Predicate<? super T> predicate)
default Tuple2<Seq<T>,Seq<T>>	Tree.partition(@NonNull Predicate<? super T> predicate)
Seq<? extends Seq<T>>	Seq.permutations()	Returns all unique permutations of this sequence.
default Iterator<Seq<T>>	Iterator.slideBy(@NonNull Function<? super T, ?> classifier)
Iterator<? extends Seq<T>>	Seq.slideBy(@NonNull Function<? super T, ?> classifier)
default Iterator<Seq<T>>	Tree.slideBy(@NonNull 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 Predicate<? super T> predicate)
Tuple2<? extends Seq<T>, ? extends Seq<T>>	Seq.span(@NonNull Predicate<? super T> predicate)
default Tuple2<Seq<T>,Seq<T>>	Tree.span(@NonNull Predicate<? super T> predicate)
default Tuple2<Seq<T>,Seq<T>>	Tree.span(@NonNull 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 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 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 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 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 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 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 Function<? super Tuple2<K,V>, Tuple2<? extends T1, ? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Map.unzip(@NonNull Function<? super Tuple2<K,V>, Tuple2<? extends T1, ? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Multimap.unzip(@NonNull 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 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 Function<? super Tuple2<K,V>, Tuple2<? extends T1, ? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Multimap.unzip(@NonNull Function<? super Tuple2<K,V>, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<? extends Seq<T1>, ? extends Seq<T2>>	Seq.unzip(@NonNull Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<? extends Seq<T1>, ? extends Seq<T2>>	Seq.unzip(@NonNull Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Map.unzip3(@NonNull 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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(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, Object object)
(package private) static <T> PriorityQueueBase.Node<T>	PriorityQueueBase.findMin(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(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 invalid input: '<' rank t' then t :: t' :: ts * else ins (link (t, t'), ts)
(package private) static <T> Seq<PriorityQueueBase.Node<T>>	PriorityQueueBase.insert(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(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(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 invalid input: '<' rank t2 then t1 :: meldUniq (ts1, t2 :: ts2) * else if rank t2 invalid input: '<' 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(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, Comparator<? super U> comparator, Function<? super T, ? extends U> mapper, Collector<T,?,R> collector)
private static <T> Seq<PriorityQueueBase.Node<T>>	PriorityQueueBase.uniqify(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

Modifier	Constructor	Description
private	Node(T root, int rank, Seq<PriorityQueueBase.Node<T>> children)
private	PriorityQueue(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 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 Executor executor, @NonNull 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 Iterable<? extends T> values, @NonNull 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 Executor executor, @NonNull Iterable<? extends T> values, @NonNull 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 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 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 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 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 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 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 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 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 Iterable<? extends T> values, @NonNull 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 Iterable<? extends T> values, @NonNull 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 Iterable<? extends T> values, @NonNull 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 Iterable<? extends T> values, @NonNull 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 Iterable<? extends T> values, @NonNull 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 Iterable<? extends T> values, @NonNull 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 Iterable<? extends T> values, @NonNull 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 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 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 Iterable<? extends T> values, @NonNull 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>>.