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 and Description
static <T> Seq<T>	API.Seq() Alias for List.empty()
static <T> Seq<T>	API.Seq(T... elements) Alias for List.of(Object...)
static <T> Seq<T>	API.Seq(T element) Alias for List.of(Object)
Seq<?>	Tuple6.toSeq()
Seq<?>	Tuple4.toSeq()
Seq<?>	Tuple0.toSeq()
Seq<?>	Tuple.toSeq() Converts this tuple to a sequence.
Seq<?>	Tuple2.toSeq()
Seq<?>	Tuple5.toSeq()
Seq<?>	Tuple7.toSeq()
Seq<?>	Tuple3.toSeq()
Seq<?>	Tuple1.toSeq()
Seq<?>	Tuple8.toSeq()

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

Modifier and Type	Method and Description
static <T> Lazy<Seq<T>>	Lazy.sequence(Iterable<? extends Lazy<? extends T>> values) Reduces many Lazy values into a single Lazy by transforming an Iterable<Lazy<? extends T>> into a Lazy<Seq<T>>.
static <T1> Tuple1<Seq<T1>>	Tuple.sequence1(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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

Subinterfaces of Seq in io.vavr.collection

Modifier and Type	Interface and Description
interface	IndexedSeq<T> Interface for immutable, indexed sequences.
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 and Description
class	Array<T> Array is a 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.
class	Vector<T> Vector is the default Seq implementation that provides effectively constant time access to any element.

Methods in io.vavr.collection that return Seq

Modifier and Type	Method and Description
Seq<T>	Seq.append(T element) Appends an element to this.
Seq<T>	Seq.appendAll(Iterable<? extends T> elements) Appends all given elements to this.
Seq<T>	Seq.asJava(Consumer<? super List<T>> action) Creates an immutable List view on top of this Seq that is passed to the given action.
Seq<T>	Seq.asJavaMutable(Consumer<? super List<T>> action) Creates a mutable List view on top of this Seq that is passed to the given action.
<R> Seq<R>	Seq.collect(PartialFunction<? super T,? extends R> partialFunction)
default <R> Seq<R>	Map.collect(PartialFunction<? super Tuple2<K,V>,? extends R> partialFunction)
default <R> Seq<R>	Multimap.collect(PartialFunction<? super Tuple2<K,V>,? extends R> partialFunction)
Seq<? extends Seq<T>>	Seq.combinations() Returns the union of all combinations from k = 0 to length().
Seq<? extends Seq<T>>	Seq.combinations(int k) Returns the k-combination of this traversable, i.e.
default Seq<T>	Tree.distinct()
Seq<T>	Seq.distinct()
default Seq<T>	Tree.distinctBy(Comparator<? super T> comparator)
Seq<T>	Seq.distinctBy(Comparator<? super T> comparator)
default <U> Seq<T>	Tree.distinctBy(Function<? super T,? extends U> keyExtractor)
<U> Seq<T>	Seq.distinctBy(Function<? super T,? extends U> keyExtractor)
default Seq<T>	Tree.drop(int n)
Seq<T>	Seq.drop(int n)
default Seq<T>	Tree.dropRight(int n)
Seq<T>	Seq.dropRight(int n)
Seq<T>	Seq.dropRightUntil(Predicate<? super T> predicate) Drops elements until the predicate holds for the current element, starting from the end.
Seq<T>	Seq.dropRightWhile(Predicate<? super T> predicate) Drops elements while the predicate holds for the current element, starting from the end.
default Seq<T>	Tree.dropUntil(Predicate<? super T> predicate)
Seq<T>	Seq.dropUntil(Predicate<? super T> predicate)
default Seq<T>	Tree.dropWhile(Predicate<? super T> predicate)
Seq<T>	Seq.dropWhile(Predicate<? super T> predicate)
default Seq<T>	Tree.filter(Predicate<? super T> predicate)
Seq<T>	Seq.filter(Predicate<? super T> predicate)
<U> Seq<U>	Seq.flatMap(Function<? super T,? extends Iterable<? extends U>> mapper)
default <U> Seq<U>	Map.flatMap(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(Function<? super Tuple2<K,V>,? extends Iterable<? extends U>> mapper) Flat-maps this entries to a sequence of values.
default Seq<T>	Tree.init()
Seq<T>	Seq.init()
Seq<T>	Seq.insert(int index, T element) Inserts the given element at the specified index.
Seq<T>	Seq.insertAll(int index, Iterable<? extends T> elements) Inserts the given elements at the specified index.
Seq<T>	Seq.intersperse(T element) Inserts an element between all elements of this Traversable.
Seq<T>	Seq.leftPadTo(int length, T element) A copy of this sequence with an element prepended until a given target length is reached.
<U> Seq<U>	Seq.map(Function<? super T,? extends U> mapper)
default <U> Seq<U>	Map.map(Function<? super Tuple2<K,V>,? extends U> mapper) Maps the Map entries to a sequence of values.
default <U> Seq<U>	Multimap.map(Function<? super Tuple2<K,V>,? extends U> mapper) Maps the Multimap entries to a sequence of values.
static <T> Seq<T>	Seq.narrow(Seq<? extends T> seq) Narrows a widened Seq<? extends T> to Seq<T> by performing a type-safe cast.
Seq<T>	Seq.orElse(Iterable<? extends T> other)
Seq<T>	Seq.orElse(Supplier<? extends Iterable<? extends T>> supplier)
Seq<T>	Seq.padTo(int length, T element) A copy of this sequence with an element appended until a given target length is reached.
Seq<T>	Seq.patch(int from, Iterable<? extends T> that, int replaced) Produces a new list where a slice of elements in this list is replaced by another sequence.
Seq<T>	Seq.peek(Consumer<? super T> action)
Seq<? extends Seq<T>>	Seq.permutations() Computes all unique permutations.
Seq<T>	Seq.prepend(T element) Prepends an element to this.
Seq<T>	Seq.prependAll(Iterable<? extends T> elements) Prepends all given elements to this.
default Seq<T>	Tree.reject(Predicate<? super T> predicate)
Seq<T>	Seq.reject(Predicate<? super T> predicate)
Seq<T>	Seq.remove(T element) Removes the first occurrence of the given element.
Seq<T>	Seq.removeAll(Iterable<? extends T> elements) Removes all occurrences of the given elements.
Seq<T>	Seq.removeAll(Predicate<? super T> predicate) Deprecated. Please use reject(Predicate)
Seq<T>	Seq.removeAll(T element) Removes all occurrences of the given element.
Seq<T>	Seq.removeAt(int index) Removes the element at the specified position in this sequence.
Seq<T>	Seq.removeFirst(Predicate<T> predicate) Removes the first occurrence that satisfy predicate
Seq<T>	Seq.removeLast(Predicate<T> predicate) Removes the last occurrence that satisfy predicate
Seq<T>	Seq.replace(T currentElement, T newElement)
Seq<T>	Seq.replaceAll(T currentElement, T newElement)
default Seq<T>	Tree.retainAll(Iterable<? extends T> elements)
Seq<T>	Seq.retainAll(Iterable<? extends T> elements)
Seq<T>	Seq.reverse() Reverses the order of elements.
Seq<T>	Seq.rotateLeft(int n) Circular rotates the elements by the specified distance to the left direction.
Seq<T>	Seq.rotateRight(int n) Circular rotates the elements by the specified distance to the right direction.
default Seq<T>	Tree.scan(T zero, BiFunction<? super T,? super T,? extends T> operation)
Seq<T>	Seq.scan(T zero, BiFunction<? super T,? super T,? extends T> operation)
default <U> Seq<U>	Tree.scanLeft(U zero, BiFunction<? super U,? super T,? extends U> operation)
<U> Seq<U>	Seq.scanLeft(U zero, BiFunction<? super U,? super T,? extends U> operation)
default <U> Seq<U>	Map.scanLeft(U zero, BiFunction<? super U,? super Tuple2<K,V>,? extends U> operation)
default <U> Seq<U>	Multimap.scanLeft(U zero, BiFunction<? super U,? super Tuple2<K,V>,? extends U> operation)
default <U> Seq<U>	Tree.scanRight(U zero, BiFunction<? super T,? super U,? extends U> operation)
<U> Seq<U>	Seq.scanRight(U zero, BiFunction<? super T,? super U,? extends U> operation)
default <U> Seq<U>	Map.scanRight(U zero, BiFunction<? super Tuple2<K,V>,? super U,? extends U> operation)
default <U> Seq<U>	Multimap.scanRight(U zero, BiFunction<? super Tuple2<K,V>,? super U,? extends U> operation)
Seq<T>	Seq.shuffle() Randomize the order of the elements in the current sequence.
Seq<T>	Seq.slice(int beginIndex, int endIndex) Returns a Seq that is a slice of this.
<U> Seq<T>	Seq.sortBy(Comparator<? super U> comparator, Function<? super T,? extends U> mapper) Sorts this elements by comparing the elements in a different domain, using the given mapper.
<U extends Comparable<? super U>> Seq<T>	Seq.sortBy(Function<? super T,? extends U> mapper) Sorts this elements by comparing the elements in a different domain, using the given mapper.
Seq<T>	Seq.sorted() Sorts this elements according to their natural order.
Seq<T>	Seq.sorted(Comparator<? super T> comparator) Sorts this elements according to the provided 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.
Seq<T>	Seq.subSequence(int beginIndex, int endIndex) Returns a Seq that is a subsequence of this.
default Seq<T>	Tree.tail()
Seq<T>	Seq.tail()
default Seq<T>	Tree.take(int n)
Seq<T>	Seq.take(int n)
default Seq<T>	Tree.takeRight(int n)
Seq<T>	Seq.takeRight(int n)
Seq<T>	Seq.takeRightUntil(Predicate<? super T> predicate) Takes elements until the predicate holds for the current element, starting from the end.
Seq<T>	Seq.takeRightWhile(Predicate<? super T> predicate) Takes elements while the predicate holds for the current element, starting from the end.
default Seq<T>	Tree.takeUntil(Predicate<? super T> predicate)
Seq<T>	Seq.takeUntil(Predicate<? super T> predicate)
default Seq<T>	Tree.takeWhile(Predicate<? super T> predicate)
Seq<T>	Seq.takeWhile(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(Tree.Order order) Traverses this tree in a specific order.
Seq<T>	Seq.update(int index, Function<? super T,? extends T> updater) Updates the given element at the specified index using the specified function.
Seq<T>	Seq.update(int index, T element) Updates the given element at the specified index.
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.
Seq<V>	TreeMap.values()
Seq<V>	LinkedHashMap.values()
default Seq<T>	Tree.values(Tree.Order order) Traverses this tree values in a specific order.
default <U> Seq<Tuple2<Tuple2<K,V>,U>>	Map.zip(Iterable<? extends U> that)
<U> Seq<Tuple2<T,U>>	Seq.zip(Iterable<? extends U> that)
default <U> Seq<Tuple2<Tuple2<K,V>,U>>	Multimap.zip(Iterable<? extends U> that)
<U> Seq<Tuple2<T,U>>	Seq.zipAll(Iterable<? extends U> that, T thisElem, U thatElem)
default <U> Seq<Tuple2<Tuple2<K,V>,U>>	Map.zipAll(Iterable<? extends U> that, Tuple2<K,V> thisElem, U thatElem)
default <U> Seq<Tuple2<Tuple2<K,V>,U>>	Multimap.zipAll(Iterable<? extends U> that, Tuple2<K,V> thisElem, U thatElem)
<U,R> Seq<R>	Seq.zipWith(Iterable<? extends U> that, BiFunction<? super T,? super U,? extends R> mapper)
default <U,R> Seq<R>	Map.zipWith(Iterable<? extends U> that, BiFunction<? super Tuple2<K,V>,? super U,? extends R> mapper)
default <U,R> Seq<R>	Multimap.zipWith(Iterable<? extends U> that, BiFunction<? super Tuple2<K,V>,? super U,? extends R> mapper)
default Seq<Tuple2<Tuple2<K,V>,Integer>>	Map.zipWithIndex()
Seq<Tuple2<T,Integer>>	Seq.zipWithIndex()
default Seq<Tuple2<Tuple2<K,V>,Integer>>	Multimap.zipWithIndex()
<U> Seq<U>	Seq.zipWithIndex(BiFunction<? super T,? super Integer,? extends U> mapper)
default <U> Seq<U>	Map.zipWithIndex(BiFunction<? super Tuple2<K,V>,? super Integer,? extends U> mapper)
default <U> Seq<U>	Multimap.zipWithIndex(BiFunction<? super Tuple2<K,V>,? super Integer,? extends U> mapper)

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

Modifier and Type	Method and Description
Seq<? extends Seq<T>>	Seq.combinations() Returns the union of all combinations from k = 0 to length().
Seq<? extends Seq<T>>	Seq.combinations(int k) Returns the k-combination of this traversable, i.e.
Iterator<? extends Seq<T>>	Seq.crossProduct(int power) Calculates the n-ary cartesian power (or cross product or simply product) of this.
default <C> Map<C,Seq<T>>	Tree.groupBy(Function<? super T,? extends C> classifier)
<C> Map<C,? extends Seq<T>>	Seq.groupBy(Function<? super T,? extends C> classifier)
default Iterator<Seq<T>>	Iterator.grouped(int size)
default Iterator<Seq<T>>	Tree.grouped(int size)
Iterator<? extends Seq<T>>	Seq.grouped(int size)
default Option<Seq<T>>	Tree.initOption()
Option<? extends Seq<T>>	Seq.initOption()
default Tuple2<Seq<T>,Seq<T>>	Tree.partition(Predicate<? super T> predicate)
default Tuple2<Seq<T>,Seq<T>>	Tree.partition(Predicate<? super T> predicate)
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.partition(Predicate<? super T> predicate)
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.partition(Predicate<? super T> predicate)
Seq<? extends Seq<T>>	Seq.permutations() Computes all unique permutations.
default Iterator<Seq<T>>	Iterator.slideBy(Function<? super T,?> classifier)
default Iterator<Seq<T>>	Tree.slideBy(Function<? super T,?> classifier)
Iterator<? extends Seq<T>>	Seq.slideBy(Function<? super T,?> classifier)
default Iterator<Seq<T>>	Iterator.sliding(int size)
default Iterator<Seq<T>>	Tree.sliding(int size)
Iterator<? extends Seq<T>>	Seq.sliding(int size)
default Iterator<Seq<T>>	Iterator.sliding(int size, int step)
default Iterator<Seq<T>>	Tree.sliding(int size, int step)
Iterator<? extends Seq<T>>	Seq.sliding(int size, int step)
default Tuple2<Seq<T>,Seq<T>>	Tree.span(Predicate<? super T> predicate)
default Tuple2<Seq<T>,Seq<T>>	Tree.span(Predicate<? super T> predicate)
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.span(Predicate<? super T> predicate)
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.span(Predicate<? super T> predicate)
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.splitAt(int n) Splits a Seq at the specified index.
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.splitAt(int n) Splits a Seq at the specified index.
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.splitAt(Predicate<? super T> predicate) Splits a sequence at the first element which satisfies the Predicate, e.g.
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.splitAt(Predicate<? super T> predicate) Splits a sequence at the first element which satisfies the Predicate, e.g.
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.splitAtInclusive(Predicate<? super T> predicate) Splits a sequence at the first element which satisfies the Predicate, e.g.
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.splitAtInclusive(Predicate<? super T> predicate) Splits a sequence at the first element which satisfies the Predicate, e.g.
default Option<Seq<T>>	Tree.tailOption()
Option<? extends Seq<T>>	Seq.tailOption()
default Tuple2<Seq<K>,Seq<V>>	Map.unzip()
default Tuple2<Seq<K>,Seq<V>>	Map.unzip()
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Map.unzip(BiFunction<? super K,? super V,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Map.unzip(BiFunction<? super K,? super V,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Multimap.unzip(BiFunction<? super K,? super V,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Multimap.unzip(BiFunction<? super K,? super V,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<? extends Seq<T1>,? extends Seq<T2>>	Seq.unzip(Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<? extends Seq<T1>,? extends Seq<T2>>	Seq.unzip(Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Map.unzip(Function<? super Tuple2<K,V>,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Map.unzip(Function<? super Tuple2<K,V>,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Multimap.unzip(Function<? super Tuple2<K,V>,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Multimap.unzip(Function<? super Tuple2<K,V>,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Map.unzip3(BiFunction<? super K,? super V,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Map.unzip3(BiFunction<? super K,? super V,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Map.unzip3(BiFunction<? super K,? super V,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Multimap.unzip3(BiFunction<? super K,? super V,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Multimap.unzip3(BiFunction<? super K,? super V,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Multimap.unzip3(BiFunction<? super K,? super V,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)
<T1,T2,T3> Tuple3<? extends Seq<T1>,? extends Seq<T2>,? extends Seq<T3>>	Seq.unzip3(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(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(Function<? super T,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Map.unzip3(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(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(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(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(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(Function<? super Tuple2<K,V>,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)

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

Modifier and Type	Method and Description
default boolean	IndexedSeq.endsWith(Seq<? extends T> that)
default boolean	Seq.endsWith(Seq<? extends T> that) Tests whether this sequence ends with the given sequence.
static <T> Seq<T>	Seq.narrow(Seq<? extends T> seq) Narrows a widened Seq<? extends T> to Seq<T> by performing a type-safe cast.

Uses of Seq in io.vavr.concurrent

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

Modifier and Type	Method and Description
static <T> Future<Seq<T>>	Future.sequence(Executor executor, Iterable<? extends Future<? extends T>> futures) Reduces many Futures into a single Future by transforming an Iterable<Future<? extends T>> into a Future<Seq<T>>.
static <T> Future<Seq<T>>	Future.sequence(Iterable<? extends Future<? extends T>> futures) Reduces many Futures into a single Future by transforming an Iterable<Future<? extends T>> into a Future<Seq<T>>.
static <T,U> Future<Seq<U>>	Future.traverse(Executor executor, Iterable<? extends T> values, Function<? super T,? extends Future<? extends U>> mapper) Maps the values of an iterable in parallel to a sequence of mapped values into a single Future by transforming an Iterable<? extends T> into a Future<Seq<U>>.
static <T,U> Future<Seq<U>>	Future.traverse(Iterable<? extends T> values, Function<? super T,? extends Future<? extends U>> mapper) Maps the values of an iterable in parallel to a sequence of mapped values into 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 and Description
<R> Validation<Seq<E>,R>	Validation.Builder.ap(Function2<T1,T2,R> f)
<R> Validation<Seq<E>,R>	Validation.Builder3.ap(Function3<T1,T2,T3,R> f)
<R> Validation<Seq<E>,R>	Validation.Builder4.ap(Function4<T1,T2,T3,T4,R> f)
<R> Validation<Seq<E>,R>	Validation.Builder5.ap(Function5<T1,T2,T3,T4,T5,R> f)
<R> Validation<Seq<E>,R>	Validation.Builder6.ap(Function6<T1,T2,T3,T4,T5,T6,R> f)
<R> Validation<Seq<E>,R>	Validation.Builder7.ap(Function7<T1,T2,T3,T4,T5,T6,T7,R> f)
<R> Validation<Seq<E>,R>	Validation.Builder8.ap(Function8<T1,T2,T3,T4,T5,T6,T7,T8,R> f)
default <U> Validation<Seq<E>,U>	Validation.ap(Validation<Seq<E>,? extends Function<? super T,? extends U>> validation)
static <L,R> Either<Seq<L>,Seq<R>>	Either.sequence(Iterable<? extends Either<? extends L,? extends R>> eithers) Reduces many Eithers into a single Either by transforming an Iterable<Either<L, R>> into a Either<Seq<L>, Seq<R>>.
static <L,R> Either<Seq<L>,Seq<R>>	Either.sequence(Iterable<? extends Either<? extends L,? extends R>> eithers) Reduces many Eithers into a single Either by transforming an Iterable<Either<L, R>> into a Either<Seq<L>, Seq<R>>.
static <T> Option<Seq<T>>	Option.sequence(Iterable<? extends Option<? extends T>> values) Reduces many Options into a single Option by transforming an Iterable<Option<? extends T>> into a Option<Seq<T>>.
static <T> Try<Seq<T>>	Try.sequence(Iterable<? extends Try<? extends T>> values) Reduces many Trys into a single Try by transforming an Iterable<Try<? extends T>> into a Try<Seq<T>>.
static <E,T> Validation<Seq<E>,Seq<T>>	Validation.sequence(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(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(Iterable<? extends Either<? extends L,? extends R>> eithers) Reduces many Eithers into a single Either by transforming an Iterable<Either<L, R>> into a Either<L, Seq<R>>.
static <L,R,T> Either<Seq<L>,Seq<R>>	Either.traverse(Iterable<? extends T> values, Function<? super T,? extends Either<? extends L,? extends R>> mapper) Maps the values of an iterable to a sequence of mapped values into a single Either by transforming an Iterable<? extends T> into a Either<Seq<U>>.
static <L,R,T> Either<Seq<L>,Seq<R>>	Either.traverse(Iterable<? extends T> values, Function<? super T,? extends Either<? extends L,? extends R>> mapper) Maps the values of an iterable to a sequence of mapped values into a single Either by transforming an Iterable<? extends T> into a Either<Seq<U>>.
static <T,U> Option<Seq<U>>	Option.traverse(Iterable<? extends T> values, Function<? super T,? extends Option<? extends U>> mapper) Maps the values of an iterable to a sequence of mapped values into a single Option by transforming an Iterable<? extends T> into a Option<Seq<U>>.
static <T,U> Try<Seq<U>>	Try.traverse(Iterable<? extends T> values, Function<? super T,? extends Try<? extends U>> mapper) Maps the values of an iterable to a sequence of mapped values into a single Try by transforming an Iterable<? extends T> into a Try<Seq<U>>.
static <E,T,U> Validation<Seq<E>,Seq<U>>	Validation.traverse(Iterable<? extends T> values, 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(Iterable<? extends T> values, 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(Iterable<? extends T> values, Function<? super T,? extends Either<? extends L,? extends R>> mapper) Maps the values of an iterable to a sequence of mapped values into a single Either by transforming an Iterable<? extends T> into a Either<Seq<U>>.

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

Modifier and Type	Method and Description
default <U> Validation<Seq<E>,U>	Validation.ap(Validation<Seq<E>,? extends Function<? super T,? extends U>> validation)
static <E,T> Validation<Seq<E>,Seq<T>>	Validation.sequence(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(Iterable<? extends T> values, 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>>.