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

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>	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	Description
final class	Array<T>	Array is a 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)	Appends an element to this.
Seq<T>	Seq.appendAll(Iterable<? extends T> elements)	Appends all given elements to this.
(package private) Seq<PriorityQueueBase.Node<T>>	PriorityQueueBase.Node.appendTo(Seq<PriorityQueueBase.Node<T>> forest)
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.
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)
<R> Seq<R>	Seq.collect(PartialFunction<? super T, ? 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.
Seq<T>	Seq.distinct()
default Seq<T>	Tree.distinct()
Seq<T>	Seq.distinctBy(Comparator<? super T> comparator)
<U> Seq<T>	Seq.distinctBy(Function<? super T, ? extends U> keyExtractor)
default Seq<T>	Tree.distinctBy(Comparator<? super T> comparator)
default <U> Seq<T>	Tree.distinctBy(Function<? super T, ? extends U> keyExtractor)
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(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.
Seq<T>	Seq.dropUntil(Predicate<? super T> predicate)
default Seq<T>	Tree.dropUntil(Predicate<? super T> predicate)
Seq<T>	Seq.dropWhile(Predicate<? super T> predicate)
default Seq<T>	Tree.dropWhile(Predicate<? super T> predicate)
Seq<T>	Seq.filter(Predicate<? super T> predicate)
default Seq<T>	Tree.filter(Predicate<? super T> predicate)
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.
<U> Seq<U>	Seq.flatMap(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)	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.
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.
<U> Seq<U>	Seq.map(Function<? super T, ? extends U> mapper)
(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 widened Seq<? extends T> to Seq<T> by performing a type-safe cast.
Seq<T>	IteratorModule.GroupedIterator.next()
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.
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(Predicate<? super T> predicate)
default Seq<T>	Tree.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 Seq.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)
Seq<T>	Seq.retainAll(Iterable<? extends T> elements)
default Seq<T>	Tree.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.
Seq<T>	Seq.scan(T zero, BiFunction<? super T, ? super T, ? extends T> operation)
default Seq<T>	Tree.scan(T zero, BiFunction<? super T, ? super T, ? extends T> 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)
<U> Seq<U>	Seq.scanLeft(U zero, BiFunction<? super U, ? super T, ? extends U> operation)
default <U> Seq<U>	Tree.scanLeft(U zero, BiFunction<? super U, ? super T, ? 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)
<U> Seq<U>	Seq.scanRight(U zero, BiFunction<? super T, ? super U, ? extends U> operation)
default <U> Seq<U>	Tree.scanRight(U zero, BiFunction<? super T, ? 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.
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(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.
Seq<T>	Seq.takeUntil(Predicate<? super T> predicate)
default Seq<T>	Tree.takeUntil(Predicate<? super T> predicate)
Seq<T>	Seq.takeWhile(Predicate<? super T> predicate)
default Seq<T>	Tree.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.
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, 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>	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(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(Iterable<? extends U> that)
default <U> Seq<Tuple2<Tuple2<K,V>, U>>	Multimap.zip(Iterable<? extends U> that)
<U> Seq<Tuple2<T,U>>	Seq.zip(Iterable<? extends U> that)
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> Seq<Tuple2<T,U>>	Seq.zipAll(Iterable<? extends U> that, T thisElem, U thatElem)
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)
<U,R> Seq<R>	Seq.zipWith(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(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(BiFunction<? super Tuple2<K,V>, ? super Integer, ? extends U> mapper)
Seq<Tuple2<T,Integer>>	Seq.zipWithIndex()
<U> Seq<U>	Seq.zipWithIndex(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 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.
(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(Function<? super T, ? extends C> classifier)
default <C> Map<C,Seq<T>>	Tree.groupBy(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(Predicate<? super T> predicate)
Tuple2<? extends Seq<T>, ? extends Seq<T>>	Seq.partition(Predicate<? super T> predicate)
default Tuple2<Seq<T>,Seq<T>>	Tree.partition(Predicate<? super T> predicate)
default Tuple2<Seq<T>,Seq<T>>	Tree.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)
Iterator<? extends Seq<T>>	Seq.slideBy(Function<? super T, ?> classifier)
default Iterator<Seq<T>>	Tree.slideBy(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(Predicate<? super T> predicate)
Tuple2<? extends Seq<T>, ? extends Seq<T>>	Seq.span(Predicate<? super T> predicate)
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.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.
Option<? extends Seq<T>>	Seq.tailOption()
default Option<Seq<T>>	Tree.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>>	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(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(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)
<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,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>>	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(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(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)
<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)

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(Seq<? extends T> that)
default boolean	Seq.endsWith(Seq<? extends T> that)	Tests 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 widened Seq<? extends T> to Seq<T> by performing a type-safe 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(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(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,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>>.
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>>.

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(Validation<Seq<E>, ? extends Function<? super T, ? extends U>> validation)
<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)
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	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>>.