Uses of Class
io.vavr.Tuple2

Packages that use Tuple2

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.

Uses of Tuple2 in io.vavr

Methods in io.vavr with type parameters of type Tuple2

Modifier and Type	Method	Description
static <T,K,V,E extends Tuple2<? extends K,? extends V>,R extends Map<K,V>> R	ValueModule.toMap(Value<T> value, R empty, java.util.function.Function<E,R> ofElement, java.util.function.Function<java.lang.Iterable<E>,R> ofAll, java.util.function.Function<? super T,? extends E> f)

Methods in io.vavr that return Tuple2

Modifier and Type	Method	Description
<T2> Tuple2<T1,T2>	Tuple1.append(T2 t2)	Append a value to this tuple.
<T1,T2> Tuple2<T1,T2>	Tuple0.concat(@NonNull Tuple2<T1,T2> tuple)	Concat a tuple's values to this tuple.
<T2> Tuple2<T1,T2>	Tuple1.concat(@NonNull Tuple1<T2> tuple)	Concat a tuple's values to this tuple.
(package private) static <T> Tuple2<T,List<T>>	$.Cons(List.Cons<T> cons)
static <T1,T2> Tuple2<T1,T2>	Tuple.fromEntry(@NonNull java.util.Map.Entry<? extends T1,? extends T2> entry)	Creates a Tuple2 from a Map.Entry.
<U1,U2> Tuple2<U1,U2>	Tuple2.map(@NonNull java.util.function.BiFunction<? super T1,? super T2,Tuple2<U1,U2>> mapper)	Maps the components of this tuple using a mapper function.
<U1,U2> Tuple2<U1,U2>	Tuple2.map(@NonNull java.util.function.Function<? super T1,? extends U1> f1, @NonNull java.util.function.Function<? super T2,? extends U2> f2)	Maps the components of this tuple using a mapper function for each component.
<U> Tuple2<U,T2>	Tuple2.map1(java.util.function.Function<? super T1,? extends U> mapper)	Maps the 1st component of this tuple to a new value.
<U> Tuple2<T1,U>	Tuple2.map2(java.util.function.Function<? super T2,? extends U> mapper)	Maps the 2nd component of this tuple to a new value.
static <T1,T2> Tuple2<T1,T2>	Tuple.narrow(Tuple2<? extends T1,? extends T2> t)	Narrows a widened Tuple2<? extends T1, ? extends T2> to Tuple2<T1, T2>.
static <T1,T2> Tuple2<T1,T2>	Tuple.of(T1 t1, T2 t2)	Creates a tuple of two elements.
static <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Tuple.sequence2(@NonNull java.lang.Iterable<? extends Tuple2<? extends T1,? extends T2>> tuples)	Turns a sequence of Tuple2 into a Tuple2 of Seqs.
Tuple2<T2,T1>	Tuple2.swap()	Swaps the elements of this Tuple.
static <T1,T2> Tuple2<T1,T2>	API.Tuple(T1 t1, T2 t2)	Alias for Tuple.of(Object, Object) Creates a tuple of two elements.
(package private) static <T1,T2> Tuple2<T1,T2>	$.Tuple2(Tuple2<T1,T2> tuple2)
Tuple2<T1,T2>	Tuple2.update1(T1 value)	Sets the 1st element of this tuple to the given value.
Tuple2<T1,T2>	Tuple2.update2(T2 value)	Sets the 2nd element of this tuple to the given value.

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

Modifier and Type	Method	Description
static <T1,T2,_1 extends T1,_2 extends T2> API.Match.Pattern2<Tuple2<T1,T2>,_1,_2>	Patterns.$Tuple2(API.Match.Pattern<_1,?> p1, API.Match.Pattern<_2,?> p2)
static <T1,T2> java.util.Comparator<Tuple2<T1,T2>>	Tuple2.comparator(java.util.Comparator<? super T1> t1Comp, java.util.Comparator<? super T2> t2Comp)
default CheckedFunction1<Tuple2<T1,T2>,R>	CheckedFunction2.tupled()	Returns a tupled version of this function.
default Function1<Tuple2<T1,T2>,R>	Function2.tupled()	Returns a tupled version of this function.

Methods in io.vavr with parameters of type Tuple2

Modifier and Type	Method	Description
private static <U1 extends java.lang.Comparable<? super U1>,U2 extends java.lang.Comparable<? super U2>> int	Tuple2.compareTo(Tuple2<?,?> o1, Tuple2<?,?> o2)
int	Tuple2.compareTo(Tuple2<T1,T2> that)
<T1,T2> Tuple2<T1,T2>	Tuple0.concat(@NonNull Tuple2<T1,T2> tuple)	Concat a tuple's values to this tuple.
<T2,T3> Tuple3<T1,T2,T3>	Tuple1.concat(@NonNull Tuple2<T2,T3> tuple)	Concat a tuple's values to this tuple.
<T3,T4> Tuple4<T1,T2,T3,T4>	Tuple2.concat(@NonNull Tuple2<T3,T4> tuple)	Concat a tuple's values to this tuple.
<T4,T5> Tuple5<T1,T2,T3,T4,T5>	Tuple3.concat(@NonNull Tuple2<T4,T5> tuple)	Concat a tuple's values to this tuple.
<T5,T6> Tuple6<T1,T2,T3,T4,T5,T6>	Tuple4.concat(@NonNull Tuple2<T5,T6> tuple)	Concat a tuple's values to this tuple.
<T6,T7> Tuple7<T1,T2,T3,T4,T5,T6,T7>	Tuple5.concat(@NonNull Tuple2<T6,T7> tuple)	Concat a tuple's values to this tuple.
<T7,T8> Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>	Tuple6.concat(@NonNull Tuple2<T7,T8> tuple)	Concat a tuple's values to this tuple.
static <K,V> Map<K,V>	API.LinkedMap(Tuple2<? extends K,? extends V> @NonNull ... entries)	Deprecated. Will be removed in a future version.
static <K,V> Map<K,V>	API.Map(Tuple2<? extends K,? extends V> @NonNull ... entries)	Deprecated. Will be removed in a future version.
static <T1,T2> Tuple2<T1,T2>	Tuple.narrow(Tuple2<? extends T1,? extends T2> t)	Narrows a widened Tuple2<? extends T1, ? extends T2> to Tuple2<T1, T2>.
static <K,V> SortedMap<K,V>	API.SortedMap(@NonNull java.util.Comparator<? super K> keyComparator, Tuple2<? extends K,? extends V> @NonNull ... entries)	Deprecated. Will be removed in a future version.
static <K extends java.lang.Comparable<? super K>,V> SortedMap<K,V>	API.SortedMap(Tuple2<? extends K,? extends V> @NonNull ... entries)	Deprecated. Will be removed in a future version.
(package private) static <T1,T2> Tuple2<T1,T2>	$.Tuple2(Tuple2<T1,T2> tuple2)

Method parameters in io.vavr with type arguments of type Tuple2

Modifier and Type	Method	Description
<U1,U2> Tuple2<U1,U2>	Tuple2.map(@NonNull java.util.function.BiFunction<? super T1,? super T2,Tuple2<U1,U2>> mapper)	Maps the components of this tuple using a mapper function.
static <T,T1 extends U1,U1,T2 extends U2,U2> API.Match.Pattern2<T,T1,T2>	API.Match.Pattern2.of(@NonNull java.lang.Class<? super T> type, @NonNull API.Match.Pattern<T1,?> p1, @NonNull API.Match.Pattern<T2,?> p2, @NonNull java.util.function.Function<T,Tuple2<U1,U2>> unapply)	Static factory for a API.Match.Pattern2 based on a Class, 2 API.Match.Patterns to decompose it to and a mapper to aggregate result back into a Tuple2
static <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Tuple.sequence2(@NonNull java.lang.Iterable<? extends Tuple2<? extends T1,? extends T2>> tuples)	Turns a sequence of Tuple2 into a Tuple2 of Seqs.
default <K,V> java.util.Map<K,V>	Value.toJavaMap(@NonNull java.util.function.Function<? super T,? extends Tuple2<? extends K,? extends V>> f)	Converts this to a mutable Map.
default <K,V,MAP extends java.util.Map<K,V>> MAP	Value.toJavaMap(@NonNull java.util.function.Supplier<MAP> factory, @NonNull java.util.function.Function<? super T,? extends Tuple2<? extends K,? extends V>> f)	Converts this to a specific mutable Map.
default <K,V> Map<K,V>	Value.toLinkedMap(@NonNull java.util.function.Function<? super T,? extends Tuple2<? extends K,? extends V>> f)	Converts this to a Map.
default <K,V> Map<K,V>	Value.toMap(@NonNull java.util.function.Function<? super T,? extends Tuple2<? extends K,? extends V>> f)	Converts this to a Map.
default <K,V> SortedMap<K,V>	Value.toSortedMap(@NonNull java.util.Comparator<? super K> comparator, @NonNull java.util.function.Function<? super T,? extends Tuple2<? extends K,? extends V>> f)	Converts this to a Map.
default <K extends java.lang.Comparable<? super K>,V> SortedMap<K,V>	Value.toSortedMap(@NonNull java.util.function.Function<? super T,? extends Tuple2<? extends K,? extends V>> f)	Converts this to a Map.

Uses of Tuple2 in io.vavr.collection

Fields in io.vavr.collection with type parameters of type Tuple2

Modifier and Type	Field	Description
private RedBlackTree<Tuple2<K,V>>	TreeMap.entries
private Queue<Tuple2<K,V>>	LinkedHashMap.list

Methods in io.vavr.collection that return Tuple2

Modifier and Type	Method	Description
private static <T> Tuple2<? extends RedBlackTree<T>,java.lang.Boolean>	RedBlackTreeModule.Node.blackify(RedBlackTree<T> tree)
Tuple2<V,HashMap<K,V>>	HashMap.computeIfAbsent(K key, @NonNull java.util.function.Function<? super K,? extends V> mappingFunction)
Tuple2<V,LinkedHashMap<K,V>>	LinkedHashMap.computeIfAbsent(K key, @NonNull java.util.function.Function<? super K,? extends V> mappingFunction)
Tuple2<V,? extends Map<K,V>>	Map.computeIfAbsent(K key, @NonNull java.util.function.Function<? super K,? extends V> mappingFunction)	If the specified key is not already associated with a value, attempts to compute its value using the given mapping function and enters it into this map.
(package private) static <K,V,M extends Map<K,V>> Tuple2<V,M>	Maps.computeIfAbsent(M map, K key, java.util.function.Function<? super K,? extends V> mappingFunction)
Tuple2<V,? extends SortedMap<K,V>>	SortedMap.computeIfAbsent(K key, @NonNull java.util.function.Function<? super K,? extends V> mappingFunction)
Tuple2<V,TreeMap<K,V>>	TreeMap.computeIfAbsent(K key, @NonNull java.util.function.Function<? super K,? extends V> mappingFunction)
Tuple2<Option<V>,HashMap<K,V>>	HashMap.computeIfPresent(K key, @NonNull java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction)
Tuple2<Option<V>,LinkedHashMap<K,V>>	LinkedHashMap.computeIfPresent(K key, @NonNull java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction)
Tuple2<Option<V>,? extends Map<K,V>>	Map.computeIfPresent(K key, @NonNull java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction)	If the value for the specified key is present, attempts to compute a new mapping given the key and its current mapped value.
(package private) static <K,V,M extends Map<K,V>> Tuple2<Option<V>,M>	Maps.computeIfPresent(M map, K key, java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction)
Tuple2<Option<V>,? extends SortedMap<K,V>>	SortedMap.computeIfPresent(K key, @NonNull java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction)
Tuple2<Option<V>,TreeMap<K,V>>	TreeMap.computeIfPresent(K key, @NonNull java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction)
(package private) static <T> Tuple2<? extends RedBlackTree<T>,java.lang.Boolean>	RedBlackTreeModule.Node.delete(RedBlackTree<T> tree, T value)
(package private) static <T> Tuple2<T,Seq<PriorityQueueBase.Node<T>>>	PriorityQueueBase.deleteMin(java.util.Comparator<? super T> comparator, Seq<PriorityQueueBase.Node<T>> forest)	fun deleteMin [] = raise EMPTY * | deleteMin ts = * val (Node (x,r,c), ts) = getMin ts * val (ts',xs') = split ([],[],c) * in fold insert xs' (meld (ts, ts')) end
Tuple2<T,Q>	AbstractQueue.dequeue()	Removes an element from this Queue.
Tuple2<T,PriorityQueue<T>>	PriorityQueue.dequeue()
static <T> Tuple2<Iterator<T>,Iterator<T>>	IteratorModule.duplicate(Iterator<T> iterator)	Creates two new iterators that both iterates over the same elements as this iterator and in the same order.
static <K,V> Tuple2<K,V>	Map.entry(K key, V value)	Creates a key/value pair for use with Map factories.
private static <T> Tuple2<LinearSeq<T>,java.lang.Integer>	LinearSeqModule.Slice.findNextSlice(LinearSeq<T> source, LinearSeq<T> slice)
Tuple2<K,V>	AbstractMultimap.head()
Tuple2<K,V>	HashMap.head()
Tuple2<K,V>	LinkedHashMap.head()
Tuple2<K,V>	TreeMap.head()
Tuple2<K,V>	AbstractMultimap.last()
Tuple2<K,V>	HashMap.last()
Tuple2<K,V>	LinkedHashMap.last()
default Tuple2<K,V>	SortedMap.last()
Tuple2<K,V>	TreeMap.last()
Tuple2<M,M>	AbstractMultimap.partition(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<Array<T>,Array<T>>	Array.partition(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<BitSet<T>,BitSet<T>>	BitSet.partition(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<BitSet<T>,BitSet<T>>	BitSetModule.AbstractBitSet.partition(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<CharSeq,CharSeq>	CharSeq.partition(@NonNull java.util.function.Predicate<? super java.lang.Character> predicate)
(package private) static <C extends Traversable<T>,T> Tuple2<C,C>	Collections.partition(C collection, java.util.function.Function<java.lang.Iterable<T>,C> creator, java.util.function.Predicate<? super T> predicate)
Tuple2<HashMap<K,V>,HashMap<K,V>>	HashMap.partition(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<HashSet<T>,HashSet<T>>	HashSet.partition(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<? extends IndexedSeq<T>,? extends IndexedSeq<T>>	IndexedSeq.partition(@NonNull java.util.function.Predicate<? super T> predicate)
default Tuple2<Iterator<T>,Iterator<T>>	Iterator.partition(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<? extends LinearSeq<T>,? extends LinearSeq<T>>	LinearSeq.partition(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<LinkedHashMap<K,V>,LinkedHashMap<K,V>>	LinkedHashMap.partition(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<LinkedHashSet<T>,LinkedHashSet<T>>	LinkedHashSet.partition(@NonNull java.util.function.Predicate<? super T> predicate)
default Tuple2<List<T>,List<T>>	List.partition(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<? extends Map<K,V>,? extends Map<K,V>>	Map.partition(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
(package private) static <K,V,M extends Map<K,V>> Tuple2<M,M>	Maps.partition(M map, Maps.OfEntries<K,V,M> ofEntries, java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends Multimap<K,V>,? extends Multimap<K,V>>	Multimap.partition(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends PriorityQueue<T>,? extends PriorityQueue<T>>	PriorityQueue.partition(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<Queue<T>,Queue<T>>	Queue.partition(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.partition(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<? extends Set<T>,? extends Set<T>>	Set.partition(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<? extends SortedMap<K,V>,? extends SortedMap<K,V>>	SortedMap.partition(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends SortedMultimap<K,V>,? extends SortedMultimap<K,V>>	SortedMultimap.partition(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends SortedSet<T>,? extends SortedSet<T>>	SortedSet.partition(@NonNull java.util.function.Predicate<? super T> predicate)
default Tuple2<Stream<T>,Stream<T>>	Stream.partition(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<? extends Traversable<T>,? extends Traversable<T>>	Traversable.partition(@NonNull java.util.function.Predicate<? super T> predicate)	Splits this Traversable into two partitions according to a predicate.
default Tuple2<Seq<T>,Seq<T>>	Tree.partition(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<TreeMap<K,V>,TreeMap<K,V>>	TreeMap.partition(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<TreeSet<T>,TreeSet<T>>	TreeSet.partition(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<Vector<T>,Vector<T>>	Vector.partition(@NonNull java.util.function.Predicate<? super T> predicate)
default Tuple2<T,List<T>>	List.pop2()	Removes the head element from this List.
Tuple2<M,M>	AbstractMultimap.span(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<Array<T>,Array<T>>	Array.span(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<BitSet<T>,BitSet<T>>	BitSet.span(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<BitSet<T>,BitSet<T>>	BitSetModule.AbstractBitSet.span(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<CharSeq,CharSeq>	CharSeq.span(@NonNull java.util.function.Predicate<? super java.lang.Character> predicate)
Tuple2<HashMap<K,V>,HashMap<K,V>>	HashMap.span(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<HashSet<T>,HashSet<T>>	HashSet.span(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<? extends IndexedSeq<T>,? extends IndexedSeq<T>>	IndexedSeq.span(@NonNull java.util.function.Predicate<? super T> predicate)
default Tuple2<Iterator<T>,Iterator<T>>	Iterator.span(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<? extends LinearSeq<T>,? extends LinearSeq<T>>	LinearSeq.span(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<LinkedHashMap<K,V>,LinkedHashMap<K,V>>	LinkedHashMap.span(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<LinkedHashSet<T>,LinkedHashSet<T>>	LinkedHashSet.span(@NonNull java.util.function.Predicate<? super T> predicate)
default Tuple2<List<T>,List<T>>	List.span(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<? extends Map<K,V>,? extends Map<K,V>>	Map.span(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
(package private) static <K,V,M extends Map<K,V>> Tuple2<M,M>	Maps.span(M map, Maps.OfEntries<K,V,M> ofEntries, java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends Multimap<K,V>,? extends Multimap<K,V>>	Multimap.span(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends PriorityQueue<T>,? extends PriorityQueue<T>>	PriorityQueue.span(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<Queue<T>,Queue<T>>	Queue.span(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.span(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<? extends Set<T>,? extends Set<T>>	Set.span(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<? extends SortedMap<K,V>,? extends SortedMap<K,V>>	SortedMap.span(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends SortedMultimap<K,V>,? extends SortedMultimap<K,V>>	SortedMultimap.span(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends SortedSet<T>,? extends SortedSet<T>>	SortedSet.span(@NonNull java.util.function.Predicate<? super T> predicate)
default Tuple2<Stream<T>,Stream<T>>	Stream.span(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<? extends Traversable<T>,? extends Traversable<T>>	Traversable.span(@NonNull java.util.function.Predicate<? super T> predicate)	Splits this Traversable into a prefix and remainder according to the given predicate.
default Tuple2<Seq<T>,Seq<T>>	Tree.span(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<TreeMap<K,V>,TreeMap<K,V>>	TreeMap.span(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<TreeSet<T>,TreeSet<T>>	TreeSet.span(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<Vector<T>,Vector<T>>	Vector.span(@NonNull java.util.function.Predicate<? super T> predicate)
(package private) static <T> Tuple2<RedBlackTree<T>,RedBlackTree<T>>	RedBlackTreeModule.Node.split(RedBlackTree<T> tree, T value)
Tuple2<Array<T>,Array<T>>	Array.splitAt(int n)
Tuple2<Array<T>,Array<T>>	Array.splitAt(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<CharSeq,CharSeq>	CharSeq.splitAt(int n)
Tuple2<CharSeq,CharSeq>	CharSeq.splitAt(@NonNull java.util.function.Predicate<? super java.lang.Character> predicate)
default Tuple2<List<T>,List<T>>	List.splitAt(int n)
default Tuple2<List<T>,List<T>>	List.splitAt(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<Queue<T>,Queue<T>>	Queue.splitAt(int n)
Tuple2<Queue<T>,Queue<T>>	Queue.splitAt(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.splitAt(int n)	Splits this sequence at the specified index.
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.splitAt(@NonNull java.util.function.Predicate<? super T> predicate)	Splits this sequence at the first element satisfying the given predicate.
default Tuple2<Stream<T>,Stream<T>>	Stream.splitAt(int n)
default Tuple2<Stream<T>,Stream<T>>	Stream.splitAt(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<Vector<T>,Vector<T>>	Vector.splitAt(int n)
Tuple2<Vector<T>,Vector<T>>	Vector.splitAt(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<Array<T>,Array<T>>	Array.splitAtInclusive(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<CharSeq,CharSeq>	CharSeq.splitAtInclusive(@NonNull java.util.function.Predicate<? super java.lang.Character> predicate)
default Tuple2<List<T>,List<T>>	List.splitAtInclusive(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<Queue<T>,Queue<T>>	Queue.splitAtInclusive(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<? extends Seq<T>,? extends Seq<T>>	Seq.splitAtInclusive(@NonNull java.util.function.Predicate<? super T> predicate)	Splits this sequence at the first element satisfying the given predicate, including the element in the first part.
default Tuple2<Stream<T>,Stream<T>>	Stream.splitAtInclusive(@NonNull java.util.function.Predicate<? super T> predicate)
Tuple2<Vector<T>,Vector<T>>	Vector.splitAtInclusive(@NonNull java.util.function.Predicate<? super T> predicate)
private Tuple2<CharSeq,CharSeq>	CharSeq.splitByBuilder(java.lang.StringBuilder sb)
static <T> Tuple2<List<T>,List<T>>	ListModule.SplitAt.splitByPredicateReversed(List<T> source, @NonNull java.util.function.Predicate<? super T> predicate)
private static <T> Tuple2<RedBlackTreeModule.Node<T>,java.lang.Boolean>	RedBlackTreeModule.Node.unbalancedLeft(RedBlackTree.Color color, int blackHeight, RedBlackTree<T> left, T value, RedBlackTree<T> right, RedBlackTreeModule.Empty<T> empty)
private static <T> Tuple2<RedBlackTreeModule.Node<T>,java.lang.Boolean>	RedBlackTreeModule.Node.unbalancedRight(RedBlackTree.Color color, int blackHeight, RedBlackTree<T> left, T value, RedBlackTree<T> right, RedBlackTreeModule.Empty<T> empty)
<T1,T2> Tuple2<Array<T1>,Array<T2>>	Array.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2> Tuple2<TreeSet<T1>,TreeSet<T2>>	BitSet.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<IndexedSeq<T1>,IndexedSeq<T2>>	CharSeq.unzip(@NonNull java.util.function.Function<? super java.lang.Character,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<HashSet<T1>,HashSet<T2>>	HashSet.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<? extends IndexedSeq<T1>,? extends IndexedSeq<T2>>	IndexedSeq.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2> Tuple2<Iterator<T1>,Iterator<T2>>	Iterator.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<? extends LinearSeq<T1>,? extends LinearSeq<T2>>	LinearSeq.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<LinkedHashSet<T1>,LinkedHashSet<T2>>	LinkedHashSet.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2> Tuple2<List<T1>,List<T2>>	List.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
default Tuple2<Seq<K>,Seq<V>>	Map.unzip()	Unzips the entries of this Map by treating each key-value pair as an element, and splitting them into two separate Seq collections - one for keys and one for values.
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Map.unzip(@NonNull java.util.function.BiFunction<? super K,? super V,Tuple2<? extends T1,? extends T2>> unzipper)	Unzips the entries of this Map by mapping each key-value pair to a tuple.
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Map.unzip(@NonNull java.util.function.Function<? super Tuple2<K,V>,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Multimap.unzip(@NonNull java.util.function.BiFunction<? super K,? super V,Tuple2<? extends T1,? extends T2>> unzipper)	Unzips the entries of this Multimap by mapping each key-value pair to a pair and splitting them into two separate Seq collections.
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Multimap.unzip(@NonNull java.util.function.Function<? super Tuple2<K,V>,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<? extends PriorityQueue<T1>,? extends PriorityQueue<T2>>	PriorityQueue.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<Queue<T1>,Queue<T2>>	Queue.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<? extends Seq<T1>,? extends Seq<T2>>	Seq.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<? extends Set<T1>,? extends Set<T2>>	Set.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<? extends SortedSet<T1>,? extends SortedSet<T2>>	SortedSet.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2> Tuple2<Stream<T1>,Stream<T2>>	Stream.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<? extends Traversable<T1>,? extends Traversable<T2>>	Traversable.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)	Unzips the elements of this Traversable by mapping each element to a pair and splitting them into two separate Traversable collections.
default <T1,T2> Tuple2<Tree<T1>,Tree<T2>>	Tree.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
static <T,T1,T2> Tuple2<Tree.Node<T1>,Tree.Node<T2>>	TreeModule.unzip(@NonNull Tree.Node<T> node, @NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<TreeSet<T1>,TreeSet<T2>>	TreeSet.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<Vector<T1>,Vector<T2>>	Vector.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)

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

Modifier and Type	Method	Description
static <K,V> java.util.stream.Collector<Tuple2<K,V>,java.util.ArrayList<Tuple2<K,V>>,HashMap<K,V>>	HashMap.collector()	Returns a Collector which may be used in conjunction with Stream.collect(java.util.stream.Collector) to obtain a HashMap.
static <K,V> java.util.stream.Collector<Tuple2<K,V>,java.util.ArrayList<Tuple2<K,V>>,HashMap<K,V>>	HashMap.collector()	Returns a Collector which may be used in conjunction with Stream.collect(java.util.stream.Collector) to obtain a HashMap.
<K,V2 extends V> java.util.stream.Collector<Tuple2<K,V2>,java.util.ArrayList<Tuple2<K,V2>>,Multimap<K,V2>>	HashMultimap.Builder.collector()	Returns a Collector which may be used in conjunction with Stream.collect(Collector) to obtain a HashMultimap.
<K,V2 extends V> java.util.stream.Collector<Tuple2<K,V2>,java.util.ArrayList<Tuple2<K,V2>>,Multimap<K,V2>>	HashMultimap.Builder.collector()	Returns a Collector which may be used in conjunction with Stream.collect(Collector) to obtain a HashMultimap.
static <K,V> java.util.stream.Collector<Tuple2<K,V>,java.util.ArrayList<Tuple2<K,V>>,LinkedHashMap<K,V>>	LinkedHashMap.collector()	Returns a Collector which may be used in conjunction with Stream.collect(java.util.stream.Collector) to obtain a LinkedHashMap.
static <K,V> java.util.stream.Collector<Tuple2<K,V>,java.util.ArrayList<Tuple2<K,V>>,LinkedHashMap<K,V>>	LinkedHashMap.collector()	Returns a Collector which may be used in conjunction with Stream.collect(java.util.stream.Collector) to obtain a LinkedHashMap.
<K,V2 extends V> java.util.stream.Collector<Tuple2<K,V2>,java.util.ArrayList<Tuple2<K,V2>>,Multimap<K,V2>>	LinkedHashMultimap.Builder.collector()	Returns a Collector which may be used in conjunction with Stream.collect(Collector) to obtain a LinkedHashMultimap.
<K,V2 extends V> java.util.stream.Collector<Tuple2<K,V2>,java.util.ArrayList<Tuple2<K,V2>>,Multimap<K,V2>>	LinkedHashMultimap.Builder.collector()	Returns a Collector which may be used in conjunction with Stream.collect(Collector) to obtain a LinkedHashMultimap.
static <K extends java.lang.Comparable<? super K>,V> java.util.stream.Collector<Tuple2<K,V>,java.util.ArrayList<Tuple2<K,V>>,TreeMap<K,V>>	TreeMap.collector()	Returns a Collector which may be used in conjunction with Stream.collect(Collector) to obtain a TreeMap.
static <K extends java.lang.Comparable<? super K>,V> java.util.stream.Collector<Tuple2<K,V>,java.util.ArrayList<Tuple2<K,V>>,TreeMap<K,V>>	TreeMap.collector()	Returns a Collector which may be used in conjunction with Stream.collect(Collector) to obtain a TreeMap.
static <K,V> java.util.stream.Collector<Tuple2<K,V>,java.util.ArrayList<Tuple2<K,V>>,TreeMap<K,V>>	TreeMap.collector(@NonNull java.util.Comparator<? super K> keyComparator)	Returns a Collector which may be used in conjunction with Stream.collect(Collector) to obtain a TreeMap.
static <K,V> java.util.stream.Collector<Tuple2<K,V>,java.util.ArrayList<Tuple2<K,V>>,TreeMap<K,V>>	TreeMap.collector(@NonNull java.util.Comparator<? super K> keyComparator)	Returns a Collector which may be used in conjunction with Stream.collect(Collector) to obtain a TreeMap.
<K extends java.lang.Comparable<? super K>,V2 extends V> java.util.stream.Collector<Tuple2<K,V2>,java.util.ArrayList<Tuple2<K,V2>>,TreeMultimap<K,V2>>	TreeMultimap.Builder.collector()	Returns a Collector which may be used in conjunction with Stream.collect(Collector) to obtain a TreeMultimap.
<K extends java.lang.Comparable<? super K>,V2 extends V> java.util.stream.Collector<Tuple2<K,V2>,java.util.ArrayList<Tuple2<K,V2>>,TreeMultimap<K,V2>>	TreeMultimap.Builder.collector()	Returns a Collector which may be used in conjunction with Stream.collect(Collector) to obtain a TreeMultimap.
<K,V2 extends V> java.util.stream.Collector<Tuple2<K,V2>,java.util.ArrayList<Tuple2<K,V2>>,TreeMultimap<K,V2>>	TreeMultimap.Builder.collector(@NonNull java.util.Comparator<? super K> keyComparator)	Returns a Collector which may be used in conjunction with Stream.collect(Collector) to obtain a TreeMultimap.
<K,V2 extends V> java.util.stream.Collector<Tuple2<K,V2>,java.util.ArrayList<Tuple2<K,V2>>,TreeMultimap<K,V2>>	TreeMultimap.Builder.collector(@NonNull java.util.Comparator<? super K> keyComparator)	Returns a Collector which may be used in conjunction with Stream.collect(Collector) to obtain a TreeMultimap.
private static <K,V> java.util.stream.Collector<Tuple2<K,V>,java.util.ArrayList<Tuple2<K,V>>,TreeMap<K,V>>	TreeMap.createCollector(@NonNull TreeMap.EntryComparator<K,V> entryComparator)
private static <K,V> java.util.stream.Collector<Tuple2<K,V>,java.util.ArrayList<Tuple2<K,V>>,TreeMap<K,V>>	TreeMap.createCollector(@NonNull TreeMap.EntryComparator<K,V> entryComparator)
default Iterator<Tuple2<T,T>>	Seq.crossProduct()	Computes the Cartesian product of this sequence with itself, producing all pairs of elements (this × this).
default <U> Iterator<Tuple2<T,U>>	Seq.crossProduct(@NonNull java.lang.Iterable<? extends U> that)	Computes the Cartesian product of this sequence with another iterable, producing pairs of elements (this × that).
Option<Tuple2<T,Q>>	AbstractQueue.dequeueOption()	Removes an element from this Queue.
@NonNull Iterator<Tuple2<K,V>>	AbstractMultimap.iterator()
Iterator<Tuple2<K,V>>	HashArrayMappedTrie.iterator()
Iterator<Tuple2<K,V>>	HashArrayMappedTrieModule.AbstractNode.iterator()
@NonNull Iterator<Tuple2<K,V>>	HashMap.iterator()
@NonNull Iterator<Tuple2<K,V>>	LinkedHashMap.iterator()
@NonNull Iterator<Tuple2<K,V>>	Map.iterator()
@NonNull Iterator<Tuple2<K,V>>	Multimap.iterator()
@NonNull Iterator<Tuple2<K,V>>	TreeMap.iterator()
default Option<Tuple2<T,List<T>>>	List.pop2Option()	Removes the head element from this List.
<U> Array<Tuple2<T,U>>	Array.zip(@NonNull java.lang.Iterable<? extends U> that)
default <U> TreeSet<Tuple2<T,U>>	BitSet.zip(@NonNull java.lang.Iterable<? extends U> that)
<U> IndexedSeq<Tuple2<java.lang.Character,U>>	CharSeq.zip(@NonNull java.lang.Iterable<? extends U> that)
<U> HashSet<Tuple2<T,U>>	HashSet.zip(@NonNull java.lang.Iterable<? extends U> that)
<U> IndexedSeq<Tuple2<T,U>>	IndexedSeq.zip(@NonNull java.lang.Iterable<? extends U> that)
default <U> Iterator<Tuple2<T,U>>	Iterator.zip(@NonNull java.lang.Iterable<? extends U> that)
<U> LinearSeq<Tuple2<T,U>>	LinearSeq.zip(@NonNull java.lang.Iterable<? extends U> that)
<U> LinkedHashSet<Tuple2<T,U>>	LinkedHashSet.zip(@NonNull java.lang.Iterable<? extends U> that)
default <U> List<Tuple2<T,U>>	List.zip(@NonNull java.lang.Iterable<? extends U> that)
default <U> Seq<Tuple2<Tuple2<K,V>,U>>	Map.zip(@NonNull java.lang.Iterable<? extends U> that)
default <U> Seq<Tuple2<Tuple2<K,V>,U>>	Map.zip(@NonNull java.lang.Iterable<? extends U> that)
default <U> Seq<Tuple2<Tuple2<K,V>,U>>	Multimap.zip(@NonNull java.lang.Iterable<? extends U> that)
default <U> Seq<Tuple2<Tuple2<K,V>,U>>	Multimap.zip(@NonNull java.lang.Iterable<? extends U> that)
<U> PriorityQueue<Tuple2<T,U>>	PriorityQueue.zip(@NonNull java.lang.Iterable<? extends U> that)
<U> Queue<Tuple2<T,U>>	Queue.zip(@NonNull java.lang.Iterable<? extends U> that)
<U> Seq<Tuple2<T,U>>	Seq.zip(@NonNull java.lang.Iterable<? extends U> that)
<U> Set<Tuple2<T,U>>	Set.zip(@NonNull java.lang.Iterable<? extends U> that)
<U> SortedSet<Tuple2<T,U>>	SortedSet.zip(@NonNull java.lang.Iterable<? extends U> that)
default <U> Stream<Tuple2<T,U>>	Stream.zip(@NonNull java.lang.Iterable<? extends U> that)
<U> Traversable<Tuple2<T,U>>	Traversable.zip(@NonNull java.lang.Iterable<? extends U> that)	Returns a Traversable formed by pairing elements of this Traversable with elements of another Iterable.
default <U> Tree<Tuple2<T,U>>	Tree.zip(@NonNull java.lang.Iterable<? extends U> that)
<U> TreeSet<Tuple2<T,U>>	TreeSet.zip(@NonNull java.lang.Iterable<? extends U> that)
<U> Vector<Tuple2<T,U>>	Vector.zip(@NonNull java.lang.Iterable<? extends U> that)
<U> Array<Tuple2<T,U>>	Array.zipAll(@NonNull java.lang.Iterable<? extends U> that, T thisElem, U thatElem)
default <U> TreeSet<Tuple2<T,U>>	BitSet.zipAll(@NonNull java.lang.Iterable<? extends U> that, T thisElem, U thatElem)
<U> IndexedSeq<Tuple2<java.lang.Character,U>>	CharSeq.zipAll(@NonNull java.lang.Iterable<? extends U> that, java.lang.Character thisElem, U thatElem)
<U> HashSet<Tuple2<T,U>>	HashSet.zipAll(@NonNull java.lang.Iterable<? extends U> that, T thisElem, U thatElem)
<U> IndexedSeq<Tuple2<T,U>>	IndexedSeq.zipAll(@NonNull java.lang.Iterable<? extends U> that, T thisElem, U thatElem)
default <U> Iterator<Tuple2<T,U>>	Iterator.zipAll(@NonNull java.lang.Iterable<? extends U> that, T thisElem, U thatElem)
<U> LinearSeq<Tuple2<T,U>>	LinearSeq.zipAll(@NonNull java.lang.Iterable<? extends U> that, T thisElem, U thatElem)
<U> LinkedHashSet<Tuple2<T,U>>	LinkedHashSet.zipAll(@NonNull java.lang.Iterable<? extends U> that, T thisElem, U thatElem)
default <U> List<Tuple2<T,U>>	List.zipAll(@NonNull java.lang.Iterable<? extends U> that, T thisElem, U thatElem)
default <U> Seq<Tuple2<Tuple2<K,V>,U>>	Map.zipAll(@NonNull java.lang.Iterable<? extends U> that, Tuple2<K,V> thisElem, U thatElem)
default <U> Seq<Tuple2<Tuple2<K,V>,U>>	Map.zipAll(@NonNull java.lang.Iterable<? extends U> that, Tuple2<K,V> thisElem, U thatElem)
default <U> Seq<Tuple2<Tuple2<K,V>,U>>	Multimap.zipAll(@NonNull java.lang.Iterable<? extends U> that, Tuple2<K,V> thisElem, U thatElem)
default <U> Seq<Tuple2<Tuple2<K,V>,U>>	Multimap.zipAll(@NonNull java.lang.Iterable<? extends U> that, Tuple2<K,V> thisElem, U thatElem)
<U> PriorityQueue<Tuple2<T,U>>	PriorityQueue.zipAll(@NonNull java.lang.Iterable<? extends U> that, T thisElem, U thatElem)
<U> Queue<Tuple2<T,U>>	Queue.zipAll(@NonNull java.lang.Iterable<? extends U> that, T thisElem, U thatElem)
<U> Seq<Tuple2<T,U>>	Seq.zipAll(@NonNull java.lang.Iterable<? extends U> that, T thisElem, U thatElem)
<U> Set<Tuple2<T,U>>	Set.zipAll(@NonNull java.lang.Iterable<? extends U> that, T thisElem, U thatElem)
<U> SortedSet<Tuple2<T,U>>	SortedSet.zipAll(@NonNull java.lang.Iterable<? extends U> that, T thisElem, U thatElem)
default <U> Stream<Tuple2<T,U>>	Stream.zipAll(@NonNull java.lang.Iterable<? extends U> iterable, T thisElem, U thatElem)
<U> Traversable<Tuple2<T,U>>	Traversable.zipAll(@NonNull java.lang.Iterable<? extends U> that, T thisElem, U thatElem)	Returns a Traversable formed by pairing elements of this Traversable with elements of another Iterable, filling in placeholder elements when one collection is shorter than the other.
default <U> Tree<Tuple2<T,U>>	Tree.zipAll(@NonNull java.lang.Iterable<? extends U> that, T thisElem, U thatElem)
static <T,U> Tree<Tuple2<T,U>>	TreeModule.zipAll(@NonNull Tree.Node<T> node, @NonNull java.util.Iterator<? extends U> that, U thatElem)
<U> TreeSet<Tuple2<T,U>>	TreeSet.zipAll(@NonNull java.lang.Iterable<? extends U> that, T thisElem, U thatElem)
<U> Vector<Tuple2<T,U>>	Vector.zipAll(@NonNull java.lang.Iterable<? extends U> that, T thisElem, U thatElem)
Array<Tuple2<T,java.lang.Integer>>	Array.zipWithIndex()
default TreeSet<Tuple2<T,java.lang.Integer>>	BitSet.zipWithIndex()
IndexedSeq<Tuple2<java.lang.Character,java.lang.Integer>>	CharSeq.zipWithIndex()
HashSet<Tuple2<T,java.lang.Integer>>	HashSet.zipWithIndex()
IndexedSeq<Tuple2<T,java.lang.Integer>>	IndexedSeq.zipWithIndex()
default Iterator<Tuple2<T,java.lang.Integer>>	Iterator.zipWithIndex()
LinearSeq<Tuple2<T,java.lang.Integer>>	LinearSeq.zipWithIndex()
LinkedHashSet<Tuple2<T,java.lang.Integer>>	LinkedHashSet.zipWithIndex()
default List<Tuple2<T,java.lang.Integer>>	List.zipWithIndex()
default Seq<Tuple2<Tuple2<K,V>,java.lang.Integer>>	Map.zipWithIndex()
default Seq<Tuple2<Tuple2<K,V>,java.lang.Integer>>	Map.zipWithIndex()
default Seq<Tuple2<Tuple2<K,V>,java.lang.Integer>>	Multimap.zipWithIndex()
default Seq<Tuple2<Tuple2<K,V>,java.lang.Integer>>	Multimap.zipWithIndex()
PriorityQueue<Tuple2<T,java.lang.Integer>>	PriorityQueue.zipWithIndex()
Queue<Tuple2<T,java.lang.Integer>>	Queue.zipWithIndex()
Seq<Tuple2<T,java.lang.Integer>>	Seq.zipWithIndex()
Set<Tuple2<T,java.lang.Integer>>	Set.zipWithIndex()
SortedSet<Tuple2<T,java.lang.Integer>>	SortedSet.zipWithIndex()
default Stream<Tuple2<T,java.lang.Integer>>	Stream.zipWithIndex()
Traversable<Tuple2<T,java.lang.Integer>>	Traversable.zipWithIndex()	Zips this Traversable with its indices, starting at 0.
default Tree<Tuple2<T,java.lang.Integer>>	Tree.zipWithIndex()
TreeSet<Tuple2<T,java.lang.Integer>>	TreeSet.zipWithIndex()
Vector<Tuple2<T,java.lang.Integer>>	Vector.zipWithIndex()

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

Modifier and Type	Method	Description
int	TreeMap.EntryComparator.Natural.compare(Tuple2<K,V> e1, Tuple2<K,V> e2)
int	TreeMap.EntryComparator.Specific.compare(Tuple2<K,V> e1, Tuple2<K,V> e2)
default boolean	Map.contains(@NonNull Tuple2<K,V> element)
default boolean	Multimap.contains(@NonNull Tuple2<K,V> element)
private static <K,V> TreeMap<K,V>	TreeMap.createFromTuple(@NonNull TreeMap.EntryComparator<K,V> entryComparator, @NonNull Tuple2<? extends K,? extends V> entry)
private static <K,V> TreeMap<K,V>	TreeMap.createFromTuples(@NonNull TreeMap.EntryComparator<K,V> entryComparator, @NonNull Tuple2<? extends K,? extends V> @NonNull ... entries)
<K,V2 extends V> HashMultimap<K,V2>	HashMultimap.Builder.fill(int n, @NonNull Tuple2<? extends K,? extends V2> element)	Returns a HashMultimap containing n times the given element
<K,V2 extends V> LinkedHashMultimap<K,V2>	LinkedHashMultimap.Builder.fill(int n, @NonNull Tuple2<? extends K,? extends V2> element)	Returns a LinkedHashMultimap containing n times the given element
<K extends java.lang.Comparable<? super K>,V2 extends V> TreeMultimap<K,V2>	TreeMultimap.Builder.fill(int n, @NonNull Tuple2<? extends K,? extends V2> element)	Returns a TreeMultimap containing n times the given element The underlying key comparator is the natural comparator of K.
<K,V2 extends V> TreeMultimap<K,V2>	TreeMultimap.Builder.fill(java.util.Comparator<? super K> keyComparator, int n, @NonNull Tuple2<? extends K,? extends V2> element)	Returns a TreeMultimap containing n times the given element
static <K,V> HashMap<K,V>	HashMap.of(@NonNull Tuple2<? extends K,? extends V> entry)	Returns a singleton HashMap, i.e.
<K,V2 extends V> HashMultimap<K,V2>	HashMultimap.Builder.of(@NonNull Tuple2<? extends K,? extends V2> entry)	Creates a HashMultimap of the given key-value pair.
static <K,V> LinkedHashMap<K,V>	LinkedHashMap.of(@NonNull Tuple2<? extends K,? extends V> entry)	Returns a singleton LinkedHashMap, i.e.
<K,V2 extends V> LinkedHashMultimap<K,V2>	LinkedHashMultimap.Builder.of(Tuple2<? extends K,? extends V2> entry)	Creates a LinkedHashMultimap of the given key-value pair.
static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	TreeMap.of(@NonNull Tuple2<? extends K,? extends V> entry)	Returns a singleton TreeMap, i.e.
static <K,V> TreeMap<K,V>	TreeMap.of(@NonNull java.util.Comparator<? super K> keyComparator, @NonNull Tuple2<? extends K,? extends V> entry)	Returns a singleton TreeMap, i.e.
<K extends java.lang.Comparable<? super K>,V2 extends V> TreeMultimap<K,V2>	TreeMultimap.Builder.of(@NonNull Tuple2<? extends K,? extends V2> entry)	Creates a TreeMultimap of the given list of key-value pairs.
<K,V2 extends V> TreeMultimap<K,V2>	TreeMultimap.Builder.of(@NonNull java.util.Comparator<? super K> keyComparator, Tuple2<? extends K,? extends V2> entry)	Returns a singleton TreeMultimap, i.e.
static <K,V> HashMap<K,V>	HashMap.ofEntries(@NonNull Tuple2<? extends K,? extends V> @NonNull ... entries)	Creates a HashMap of the given entries.
<K,V2 extends V> HashMultimap<K,V2>	HashMultimap.Builder.ofEntries(@NonNull Tuple2<? extends K,? extends V2> @NonNull ... entries)	Creates a HashMultimap of the given entries.
static <K,V> LinkedHashMap<K,V>	LinkedHashMap.ofEntries(@NonNull Tuple2<? extends K,? extends V> @NonNull ... entries)	Creates a LinkedHashMap of the given entries.
<K,V2 extends V> LinkedHashMultimap<K,V2>	LinkedHashMultimap.Builder.ofEntries(@NonNull Tuple2<? extends K,? extends V2> @NonNull ... entries)	Creates a LinkedHashMultimap of the given entries.
static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	TreeMap.ofEntries(@NonNull Tuple2<? extends K,? extends V> @NonNull ... entries)	Creates a TreeMap of the given entries using the natural key comparator.
static <K,V> TreeMap<K,V>	TreeMap.ofEntries(@NonNull java.util.Comparator<? super K> keyComparator, @NonNull Tuple2<? extends K,? extends V> @NonNull ... entries)	Creates a TreeMap of the given entries using the given key comparator.
<K extends java.lang.Comparable<? super K>,V2 extends V> TreeMultimap<K,V2>	TreeMultimap.Builder.ofEntries(@NonNull Tuple2<? extends K,? extends V2> @NonNull ... entries)	Creates a TreeMultimap of the given entries.
<K,V2 extends V> TreeMultimap<K,V2>	TreeMultimap.Builder.ofEntries(@NonNull java.util.Comparator<? super K> keyComparator, Tuple2<? extends K,? extends V2> @NonNull ... entries)	Creates a TreeMultimap of the given entries.
M	AbstractMultimap.put(@NonNull Tuple2<? extends K,? extends V> entry)
HashMap<K,V>	HashMap.put(@NonNull Tuple2<? extends K,? extends V> entry)
<U extends V> HashMap<K,V>	HashMap.put(@NonNull Tuple2<? extends K,U> entry, @NonNull java.util.function.BiFunction<? super V,? super U,? extends V> merge)
LinkedHashMap<K,V>	LinkedHashMap.put(@NonNull Tuple2<? extends K,? extends V> entry)
<U extends V> LinkedHashMap<K,V>	LinkedHashMap.put(@NonNull Tuple2<? extends K,U> entry, @NonNull java.util.function.BiFunction<? super V,? super U,? extends V> merge)
Map<K,V>	Map.put(@NonNull Tuple2<? extends K,? extends V> entry)	Convenience method for put(entry._1, entry._2).
<U extends V> Map<K,V>	Map.put(@NonNull Tuple2<? extends K,U> entry, @NonNull java.util.function.BiFunction<? super V,? super U,? extends V> merge)	Convenience method for put(entry._1, entry._2, merge).
(package private) static <K,V,M extends Map<K,V>> M	Maps.put(M map, Tuple2<? extends K,? extends V> entry)
(package private) static <K,V,U extends V,M extends Map<K,V>> M	Maps.put(M map, Tuple2<? extends K,U> entry, java.util.function.BiFunction<? super V,? super U,? extends V> merge)
Multimap<K,V>	Multimap.put(@NonNull Tuple2<? extends K,? extends V> entry)	Convenience method for put(entry._1, entry._2).
SortedMap<K,V>	SortedMap.put(@NonNull Tuple2<? extends K,? extends V> entry)
<U extends V> SortedMap<K,V>	SortedMap.put(@NonNull Tuple2<? extends K,U> entry, @NonNull java.util.function.BiFunction<? super V,? super U,? extends V> merge)
SortedMultimap<K,V>	SortedMultimap.put(@NonNull Tuple2<? extends K,? extends V> entry)
TreeMap<K,V>	TreeMap.put(@NonNull Tuple2<? extends K,? extends V> entry)
<U extends V> TreeMap<K,V>	TreeMap.put(@NonNull Tuple2<? extends K,U> entry, @NonNull java.util.function.BiFunction<? super V,? super U,? extends V> merge)
M	AbstractMultimap.replace(@NonNull Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
HashMap<K,V>	HashMap.replace(@NonNull Tuple2<K,V> currentElement, @NonNull Tuple2<K,V> newElement)
LinkedHashMap<K,V>	LinkedHashMap.replace(@NonNull Tuple2<K,V> currentElement, @NonNull Tuple2<K,V> newElement)
Map<K,V>	Map.replace(@NonNull Tuple2<K,V> currentElement, @NonNull Tuple2<K,V> newElement)
(package private) static <K,V,M extends Map<K,V>> M	Maps.replace(M map, Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
Multimap<K,V>	Multimap.replace(Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
SortedMap<K,V>	SortedMap.replace(@NonNull Tuple2<K,V> currentElement, @NonNull Tuple2<K,V> newElement)
SortedMultimap<K,V>	SortedMultimap.replace(@NonNull Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
TreeMap<K,V>	TreeMap.replace(@NonNull Tuple2<K,V> currentElement, @NonNull Tuple2<K,V> newElement)
M	AbstractMultimap.replaceAll(@NonNull Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
HashMap<K,V>	HashMap.replaceAll(@NonNull Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
LinkedHashMap<K,V>	LinkedHashMap.replaceAll(@NonNull Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
Map<K,V>	Map.replaceAll(@NonNull Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
(package private) static <K,V,M extends Map<K,V>> M	Maps.replaceAll(M map, Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
Multimap<K,V>	Multimap.replaceAll(Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
SortedMap<K,V>	SortedMap.replaceAll(@NonNull Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
SortedMultimap<K,V>	SortedMultimap.replaceAll(@NonNull Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
TreeMap<K,V>	TreeMap.replaceAll(@NonNull Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
M	AbstractMultimap.scan(Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
HashMap<K,V>	HashMap.scan(@NonNull Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
LinkedHashMap<K,V>	LinkedHashMap.scan(@NonNull Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
Map<K,V>	Map.scan(@NonNull Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
(package private) static <K,V,M extends Map<K,V>> M	Maps.scan(M map, Tuple2<K,V> zero, java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation, java.util.function.Function<Iterator<Tuple2<K,V>>,Traversable<Tuple2<K,V>>> finisher)
Multimap<K,V>	Multimap.scan(Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
SortedMap<K,V>	SortedMap.scan(@NonNull Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
SortedMultimap<K,V>	SortedMultimap.scan(Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
TreeMap<K,V>	TreeMap.scan(@NonNull Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
default <U> Seq<Tuple2<Tuple2<K,V>,U>>	Map.zipAll(@NonNull java.lang.Iterable<? extends U> that, Tuple2<K,V> thisElem, U thatElem)
default <U> Seq<Tuple2<Tuple2<K,V>,U>>	Multimap.zipAll(@NonNull java.lang.Iterable<? extends U> that, Tuple2<K,V> thisElem, U thatElem)

Method parameters in io.vavr.collection with type arguments of type Tuple2

Modifier and Type	Method	Description
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)
private <K2,V2> Multimap<K2,V2>	AbstractMultimap.createFromEntries(java.lang.Iterable<? extends Tuple2<? extends K2,? extends V2>> entries)	Creates a new Multimap from the given entries by grouping values by their keys.
private HashMap<K,V>	HashMap.createFromEntries(java.lang.Iterable<Tuple2<K,V>> tuples)
private LinkedHashMap<K,V>	LinkedHashMap.createFromEntries(java.lang.Iterable<Tuple2<K,V>> tuples)
private TreeMap<K,V>	TreeMap.createFromEntries(@NonNull java.lang.Iterable<Tuple2<K,V>> tuples)
private static <K,V> TreeMap<K,V>	TreeMap.createTreeMap(@NonNull TreeMap.EntryComparator<K,V> entryComparator, @NonNull java.lang.Iterable<? extends Tuple2<? extends K,? extends V>> entries)
private static <K,K2,V,V2> TreeMap<K2,V2>	TreeMap.createTreeMap(@NonNull TreeMap.EntryComparator<K2,V2> entryComparator, @NonNull java.lang.Iterable<Tuple2<K,V>> entries, java.util.function.Function<Tuple2<K,V>,Tuple2<K2,V2>> entryMapper)
private static <K,K2,V,V2> TreeMap<K2,V2>	TreeMap.createTreeMap(@NonNull TreeMap.EntryComparator<K2,V2> entryComparator, @NonNull java.lang.Iterable<Tuple2<K,V>> entries, java.util.function.Function<Tuple2<K,V>,Tuple2<K2,V2>> entryMapper)
private static <K,K2,V,V2> TreeMap<K2,V2>	TreeMap.createTreeMap(@NonNull TreeMap.EntryComparator<K2,V2> entryComparator, @NonNull java.lang.Iterable<Tuple2<K,V>> entries, java.util.function.Function<Tuple2<K,V>,Tuple2<K2,V2>> entryMapper)
M	AbstractMultimap.distinctBy(@NonNull java.util.Comparator<? super Tuple2<K,V>> comparator)
<U> M	AbstractMultimap.distinctBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends U> keyExtractor)
HashMap<K,V>	HashMap.distinctBy(@NonNull java.util.Comparator<? super Tuple2<K,V>> comparator)
<U> HashMap<K,V>	HashMap.distinctBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends U> keyExtractor)
LinkedHashMap<K,V>	LinkedHashMap.distinctBy(@NonNull java.util.Comparator<? super Tuple2<K,V>> comparator)
<U> LinkedHashMap<K,V>	LinkedHashMap.distinctBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends U> keyExtractor)
Map<K,V>	Map.distinctBy(@NonNull java.util.Comparator<? super Tuple2<K,V>> comparator)
<U> Map<K,V>	Map.distinctBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends U> keyExtractor)
(package private) static <K,V,M extends Map<K,V>> M	Maps.distinctBy(M map, Maps.OfEntries<K,V,M> ofEntries, java.util.Comparator<? super Tuple2<K,V>> comparator)
(package private) static <K,V,U,M extends Map<K,V>> M	Maps.distinctBy(M map, Maps.OfEntries<K,V,M> ofEntries, java.util.function.Function<? super Tuple2<K,V>,? extends U> keyExtractor)
Multimap<K,V>	Multimap.distinctBy(@NonNull java.util.Comparator<? super Tuple2<K,V>> comparator)
<U> Multimap<K,V>	Multimap.distinctBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends U> keyExtractor)
SortedMap<K,V>	SortedMap.distinctBy(@NonNull java.util.Comparator<? super Tuple2<K,V>> comparator)
<U> SortedMap<K,V>	SortedMap.distinctBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends U> keyExtractor)
SortedMultimap<K,V>	SortedMultimap.distinctBy(@NonNull java.util.Comparator<? super Tuple2<K,V>> comparator)
<U> SortedMultimap<K,V>	SortedMultimap.distinctBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends U> keyExtractor)
TreeMap<K,V>	TreeMap.distinctBy(@NonNull java.util.Comparator<? super Tuple2<K,V>> comparator)
<U> TreeMap<K,V>	TreeMap.distinctBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends U> keyExtractor)
M	AbstractMultimap.dropUntil(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
HashMap<K,V>	HashMap.dropUntil(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
LinkedHashMap<K,V>	LinkedHashMap.dropUntil(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Map<K,V>	Map.dropUntil(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
(package private) static <K,V,M extends Map<K,V>> M	Maps.dropUntil(M map, Maps.OfEntries<K,V,M> ofEntries, java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Multimap<K,V>	Multimap.dropUntil(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
SortedMap<K,V>	SortedMap.dropUntil(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
SortedMultimap<K,V>	SortedMultimap.dropUntil(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
TreeMap<K,V>	TreeMap.dropUntil(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
M	AbstractMultimap.dropWhile(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
HashMap<K,V>	HashMap.dropWhile(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
LinkedHashMap<K,V>	LinkedHashMap.dropWhile(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Map<K,V>	Map.dropWhile(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
(package private) static <K,V,M extends Map<K,V>> M	Maps.dropWhile(M map, Maps.OfEntries<K,V,M> ofEntries, java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Multimap<K,V>	Multimap.dropWhile(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
SortedMap<K,V>	SortedMap.dropWhile(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
SortedMultimap<K,V>	SortedMultimap.dropWhile(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
TreeMap<K,V>	TreeMap.dropWhile(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
static <K,V> HashMap<K,V>	HashMap.fill(int n, @NonNull java.util.function.Supplier<? extends Tuple2<? extends K,? extends V>> s)	Returns a HashMap containing tuples returned by n calls to a given Supplier s.
<K,V2 extends V> HashMultimap<K,V2>	HashMultimap.Builder.fill(int n, @NonNull java.util.function.Supplier<? extends Tuple2<? extends K,? extends V2>> s)	Returns a HashMultimap containing n values supplied by a given Supplier s.
static <K,V> LinkedHashMap<K,V>	LinkedHashMap.fill(int n, @NonNull java.util.function.Supplier<? extends Tuple2<? extends K,? extends V>> s)	Returns a LinkedHashMap containing tuples returned by n calls to a given Supplier s.
<K,V2 extends V> LinkedHashMultimap<K,V2>	LinkedHashMultimap.Builder.fill(int n, @NonNull java.util.function.Supplier<? extends Tuple2<? extends K,? extends V2>> s)	Returns a LinkedHashMultimap containing n values supplied by a given Supplier s.
static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	TreeMap.fill(int n, @NonNull java.util.function.Supplier<? extends Tuple2<? extends K,? extends V>> s)	Returns a TreeMap containing tuples returned by n calls to a given Supplier s.
static <K,V> TreeMap<K,V>	TreeMap.fill(@NonNull java.util.Comparator<? super K> keyComparator, int n, @NonNull java.util.function.Supplier<? extends Tuple2<? extends K,? extends V>> s)	Returns a TreeMap containing tuples returned by n calls to a given Supplier s.
<K extends java.lang.Comparable<? super K>,V2 extends V> TreeMultimap<K,V2>	TreeMultimap.Builder.fill(int n, @NonNull java.util.function.Supplier<? extends Tuple2<? extends K,? extends V2>> s)	Returns a TreeMultimap containing n values supplied by a given Supplier s.
<K,V2 extends V> TreeMultimap<K,V2>	TreeMultimap.Builder.fill(java.util.Comparator<? super K> keyComparator, int n, @NonNull java.util.function.Supplier<? extends Tuple2<? extends K,? extends V2>> s)	Returns a TreeMultimap containing n values supplied by a given Supplier s.
M	AbstractMultimap.filter(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
HashMap<K,V>	HashMap.filter(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
LinkedHashMap<K,V>	LinkedHashMap.filter(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Map<K,V>	Map.filter(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
(package private) static <K,V,M extends Map<K,V>> M	Maps.filter(M map, Maps.OfEntries<K,V,M> ofEntries, java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Multimap<K,V>	Multimap.filter(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
SortedMap<K,V>	SortedMap.filter(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
SortedMultimap<K,V>	SortedMultimap.filter(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
TreeMap<K,V>	TreeMap.filter(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
<K2,V2> Multimap<K2,V2>	AbstractMultimap.flatMap(@NonNull java.util.function.BiFunction<? super K,? super V,? extends java.lang.Iterable<Tuple2<K2,V2>>> mapper)
<K2,V2> HashMap<K2,V2>	HashMap.flatMap(@NonNull java.util.function.BiFunction<? super K,? super V,? extends java.lang.Iterable<Tuple2<K2,V2>>> mapper)
<K2,V2> LinkedHashMap<K2,V2>	LinkedHashMap.flatMap(@NonNull java.util.function.BiFunction<? super K,? super V,? extends java.lang.Iterable<Tuple2<K2,V2>>> mapper)
<K2,V2> Map<K2,V2>	Map.flatMap(@NonNull java.util.function.BiFunction<? super K,? super V,? extends java.lang.Iterable<Tuple2<K2,V2>>> mapper)	FlatMaps this Map to a new Map with different component type.
default <U> Seq<U>	Map.flatMap(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends java.lang.Iterable<? extends U>> mapper)	Flat-maps this entries to a sequence of values.
<K2,V2> Multimap<K2,V2>	Multimap.flatMap(@NonNull java.util.function.BiFunction<? super K,? super V,? extends java.lang.Iterable<Tuple2<K2,V2>>> mapper)	FlatMaps this Multimap to a new Multimap with different component type.
default <U> Seq<U>	Multimap.flatMap(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends java.lang.Iterable<? extends U>> mapper)	Flat-maps this entries to a sequence of values.
<K2,V2> SortedMap<K2,V2>	SortedMap.flatMap(@NonNull java.util.Comparator<? super K2> keyComparator, @NonNull java.util.function.BiFunction<? super K,? super V,? extends java.lang.Iterable<Tuple2<K2,V2>>> mapper)	Same as SortedMap.flatMap(BiFunction) but using a specific comparator for values of the codomain of the given mapper.
<K2,V2> SortedMap<K2,V2>	SortedMap.flatMap(@NonNull java.util.function.BiFunction<? super K,? super V,? extends java.lang.Iterable<Tuple2<K2,V2>>> mapper)
private static <K,V,K2,V2> TreeMap<K2,V2>	TreeMap.flatMap(@NonNull TreeMap<K,V> map, @NonNull TreeMap.EntryComparator<K2,V2> entryComparator, java.util.function.BiFunction<? super K,? super V,? extends java.lang.Iterable<Tuple2<K2,V2>>> mapper)
<K2,V2> TreeMap<K2,V2>	TreeMap.flatMap(@NonNull java.util.Comparator<? super K2> keyComparator, @NonNull java.util.function.BiFunction<? super K,? super V,? extends java.lang.Iterable<Tuple2<K2,V2>>> mapper)
<K2,V2> TreeMap<K2,V2>	TreeMap.flatMap(@NonNull java.util.function.BiFunction<? super K,? super V,? extends java.lang.Iterable<Tuple2<K2,V2>>> mapper)
default <U> U	Map.foldRight(U zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super U,? extends U> f)
default <U> U	Multimap.foldRight(U zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super U,? extends U> f)
<C> Map<C,M>	AbstractMultimap.groupBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends C> classifier)
<C> Map<C,HashMap<K,V>>	HashMap.groupBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends C> classifier)
<C> Map<C,LinkedHashMap<K,V>>	LinkedHashMap.groupBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends C> classifier)
<C> Map<C,? extends Map<K,V>>	Map.groupBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends C> classifier)
(package private) static <K,V,C,M extends Map<K,V>> Map<C,M>	Maps.groupBy(M map, Maps.OfEntries<K,V,M> ofEntries, java.util.function.Function<? super Tuple2<K,V>,? extends C> classifier)
<C> Map<C,? extends Multimap<K,V>>	Multimap.groupBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends C> classifier)
<C> Map<C,? extends SortedMap<K,V>>	SortedMap.groupBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends C> classifier)
<C> Map<C,? extends SortedMultimap<K,V>>	SortedMultimap.groupBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends C> classifier)
<C> Map<C,TreeMap<K,V>>	TreeMap.groupBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends C> classifier)
<K2,V2> Multimap<K2,V2>	AbstractMultimap.map(@NonNull java.util.function.BiFunction<? super K,? super V,Tuple2<K2,V2>> mapper)
<K2,V2> HashMap<K2,V2>	HashMap.map(@NonNull java.util.function.BiFunction<? super K,? super V,Tuple2<K2,V2>> mapper)
<K2,V2> LinkedHashMap<K2,V2>	LinkedHashMap.map(@NonNull java.util.function.BiFunction<? super K,? super V,Tuple2<K2,V2>> mapper)
<K2,V2> Map<K2,V2>	Map.map(@NonNull java.util.function.BiFunction<? super K,? super V,Tuple2<K2,V2>> mapper)	Maps the entries of this Map to form a new Map.
default <U> Seq<U>	Map.map(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends U> mapper)	Maps the Map entries to a sequence of values.
<K2,V2> Multimap<K2,V2>	Multimap.map(@NonNull java.util.function.BiFunction<? super K,? super V,Tuple2<K2,V2>> mapper)	Maps the entries of this Multimap to form a new Multimap.
default <U> Seq<U>	Multimap.map(@NonNull java.util.function.Function<? super Tuple2<K,V>,? extends U> mapper)	Maps the Multimap entries to a sequence of values.
<K2,V2> SortedMap<K2,V2>	SortedMap.map(@NonNull java.util.Comparator<? super K2> keyComparator, @NonNull java.util.function.BiFunction<? super K,? super V,Tuple2<K2,V2>> mapper)	Same as SortedMap.map(BiFunction), using a specific comparator for keys of the codomain of the given mapper.
<K2,V2> SortedMap<K2,V2>	SortedMap.map(@NonNull java.util.function.BiFunction<? super K,? super V,Tuple2<K2,V2>> mapper)
private static <K,K2,V,V2> TreeMap<K2,V2>	TreeMap.map(@NonNull TreeMap<K,V> map, @NonNull TreeMap.EntryComparator<K2,V2> entryComparator, java.util.function.BiFunction<? super K,? super V,Tuple2<K2,V2>> mapper)
<K2,V2> TreeMap<K2,V2>	TreeMap.map(@NonNull java.util.Comparator<? super K2> keyComparator, @NonNull java.util.function.BiFunction<? super K,? super V,Tuple2<K2,V2>> mapper)
<K2,V2> TreeMap<K2,V2>	TreeMap.map(@NonNull java.util.function.BiFunction<? super K,? super V,Tuple2<K2,V2>> mapper)
static <T,K,V> HashMap<K,V>	HashMap.ofAll(@NonNull java.util.stream.Stream<? extends T> stream, @NonNull java.util.function.Function<? super T,Tuple2<? extends K,? extends V>> entryMapper)	Returns a HashMap, from entries mapped from stream.
<T,K,V2 extends V> HashMultimap<K,V2>	HashMultimap.Builder.ofAll(@NonNull java.util.stream.Stream<? extends T> stream, @NonNull java.util.function.Function<? super T,Tuple2<? extends K,? extends V2>> entryMapper)	Returns a HashMultimap, from entries mapped from stream.
static <T,K,V> LinkedHashMap<K,V>	LinkedHashMap.ofAll(@NonNull java.util.stream.Stream<? extends T> stream, java.util.function.Function<? super T,Tuple2<? extends K,? extends V>> entryMapper)	Returns a LinkedHashMap, from entries mapped from stream.
<T,K,V2 extends V> LinkedHashMultimap<K,V2>	LinkedHashMultimap.Builder.ofAll(@NonNull java.util.stream.Stream<? extends T> stream, @NonNull java.util.function.Function<? super T,Tuple2<? extends K,? extends V2>> entryMapper)	Returns a LinkedHashMultimap, from entries mapped from stream.
static <T,K,V> TreeMap<K,V>	TreeMap.ofAll(@NonNull java.util.Comparator<? super K> keyComparator, @NonNull java.util.stream.Stream<? extends T> stream, @NonNull java.util.function.Function<? super T,Tuple2<? extends K,? extends V>> entryMapper)	Returns a TreeMap, from entries mapped from stream.
static <T,K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	TreeMap.ofAll(@NonNull java.util.stream.Stream<? extends T> stream, @NonNull java.util.function.Function<? super T,Tuple2<? extends K,? extends V>> entryMapper)	Returns a TreeMap, from entries mapped from stream.
<T,K,V2 extends V> TreeMultimap<K,V2>	TreeMultimap.Builder.ofAll(@NonNull java.util.Comparator<? super K> keyComparator, @NonNull java.util.stream.Stream<? extends T> stream, @NonNull java.util.function.Function<? super T,Tuple2<? extends K,? extends V2>> entryMapper)	Returns a TreeMultimap, from entries mapped from stream.
<T,K extends java.lang.Comparable<? super K>,V2 extends V> TreeMultimap<K,V2>	TreeMultimap.Builder.ofAll(@NonNull java.util.stream.Stream<? extends T> stream, @NonNull java.util.function.Function<? super T,Tuple2<? extends K,? extends V2>> entryMapper)	Returns a TreeMultimap, from entries mapped from stream.
static <K,V> HashMap<K,V>	HashMap.ofEntries(@NonNull java.lang.Iterable<? extends Tuple2<? extends K,? extends V>> entries)	Creates a HashMap of the given entries.
<K,V2 extends V> HashMultimap<K,V2>	HashMultimap.Builder.ofEntries(@NonNull java.lang.Iterable<? extends Tuple2<? extends K,? extends V2>> entries)	Creates a HashMultimap of the given entries.
static <K,V> LinkedHashMap<K,V>	LinkedHashMap.ofEntries(@NonNull java.lang.Iterable<? extends Tuple2<? extends K,? extends V>> entries)	Creates a LinkedHashMap of the given entries.
<K,V2 extends V> LinkedHashMultimap<K,V2>	LinkedHashMultimap.Builder.ofEntries(@NonNull java.lang.Iterable<? extends Tuple2<? extends K,? extends V2>> entries)	Creates a LinkedHashMultimap of the given entries.
static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	TreeMap.ofEntries(@NonNull java.lang.Iterable<? extends Tuple2<? extends K,? extends V>> entries)	Creates a TreeMap of the given entries.
static <K,V> TreeMap<K,V>	TreeMap.ofEntries(@NonNull java.util.Comparator<? super K> keyComparator, @NonNull java.lang.Iterable<? extends Tuple2<? extends K,? extends V>> entries)	Creates a TreeMap of the given entries.
<K extends java.lang.Comparable<? super K>,V2 extends V> TreeMultimap<K,V2>	TreeMultimap.Builder.ofEntries(@NonNull java.lang.Iterable<? extends Tuple2<? extends K,? extends V2>> entries)	Creates a TreeMultimap of the given entries.
<K,V2 extends V> TreeMultimap<K,V2>	TreeMultimap.Builder.ofEntries(@NonNull java.util.Comparator<? super K> keyComparator, java.lang.Iterable<? extends Tuple2<? extends K,? extends V2>> entries)	Creates a TreeMultimap of the given entries.
(package private) static <T,K,V,M extends Map<K,V>> M	Maps.ofStream(M map, java.util.stream.Stream<? extends T> stream, java.util.function.Function<? super T,Tuple2<? extends K,? extends V>> entryMapper)
(package private) static <T,K,V,M extends Multimap<K,V>> M	Multimaps.ofStream(M source, java.util.stream.Stream<? extends T> stream, java.util.function.Function<? super T,Tuple2<? extends K,? extends V>> entryMapper)
M	AbstractMultimap.orElse(@NonNull java.util.function.Supplier<? extends java.lang.Iterable<? extends Tuple2<K,V>>> supplier)	Returns this Multimap if it is nonempty, otherwise Multimap created from result of evaluating supplier, using existing multimap properties.
M	AbstractMultimap.orElse(java.lang.Iterable<? extends Tuple2<K,V>> other)	Returns this Multimap if it is nonempty, otherwise Multimap created from iterable, using existing multimap properties.
HashMap<K,V>	HashMap.orElse(@NonNull java.lang.Iterable<? extends Tuple2<K,V>> other)
HashMap<K,V>	HashMap.orElse(@NonNull java.util.function.Supplier<? extends java.lang.Iterable<? extends Tuple2<K,V>>> supplier)
LinkedHashMap<K,V>	LinkedHashMap.orElse(@NonNull java.util.function.Supplier<? extends java.lang.Iterable<? extends Tuple2<K,V>>> supplier)
LinkedHashMap<K,V>	LinkedHashMap.orElse(java.lang.Iterable<? extends Tuple2<K,V>> other)
Map<K,V>	Map.orElse(@NonNull java.util.function.Supplier<? extends java.lang.Iterable<? extends Tuple2<K,V>>> supplier)
Map<K,V>	Map.orElse(java.lang.Iterable<? extends Tuple2<K,V>> other)
Multimap<K,V>	Multimap.orElse(@NonNull java.util.function.Supplier<? extends java.lang.Iterable<? extends Tuple2<K,V>>> supplier)
Multimap<K,V>	Multimap.orElse(java.lang.Iterable<? extends Tuple2<K,V>> other)
SortedMap<K,V>	SortedMap.orElse(@NonNull java.util.function.Supplier<? extends java.lang.Iterable<? extends Tuple2<K,V>>> supplier)
SortedMap<K,V>	SortedMap.orElse(java.lang.Iterable<? extends Tuple2<K,V>> other)
SortedMultimap<K,V>	SortedMultimap.orElse(@NonNull java.util.function.Supplier<? extends java.lang.Iterable<? extends Tuple2<K,V>>> supplier)
SortedMultimap<K,V>	SortedMultimap.orElse(java.lang.Iterable<? extends Tuple2<K,V>> other)
TreeMap<K,V>	TreeMap.orElse(@NonNull java.lang.Iterable<? extends Tuple2<K,V>> other)	Returns this TreeMap if it is nonempty, otherwise TreeMap created from iterable, using existing comparator.
TreeMap<K,V>	TreeMap.orElse(@NonNull java.util.function.Supplier<? extends java.lang.Iterable<? extends Tuple2<K,V>>> supplier)	Returns this TreeMap if it is nonempty, otherwise TreeMap created from result of evaluating supplier, using existing comparator.
Tuple2<M,M>	AbstractMultimap.partition(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<HashMap<K,V>,HashMap<K,V>>	HashMap.partition(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<LinkedHashMap<K,V>,LinkedHashMap<K,V>>	LinkedHashMap.partition(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends Map<K,V>,? extends Map<K,V>>	Map.partition(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
(package private) static <K,V,M extends Map<K,V>> Tuple2<M,M>	Maps.partition(M map, Maps.OfEntries<K,V,M> ofEntries, java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends Multimap<K,V>,? extends Multimap<K,V>>	Multimap.partition(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends SortedMap<K,V>,? extends SortedMap<K,V>>	SortedMap.partition(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends SortedMultimap<K,V>,? extends SortedMultimap<K,V>>	SortedMultimap.partition(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<TreeMap<K,V>,TreeMap<K,V>>	TreeMap.partition(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
M	AbstractMultimap.peek(@NonNull java.util.function.Consumer<? super Tuple2<K,V>> action)
HashMap<K,V>	HashMap.peek(@NonNull java.util.function.Consumer<? super Tuple2<K,V>> action)
LinkedHashMap<K,V>	LinkedHashMap.peek(@NonNull java.util.function.Consumer<? super Tuple2<K,V>> action)
Map<K,V>	Map.peek(@NonNull java.util.function.Consumer<? super Tuple2<K,V>> action)
(package private) static <K,V,M extends Map<K,V>> M	Maps.peek(M map, java.util.function.Consumer<? super Tuple2<K,V>> action)
Multimap<K,V>	Multimap.peek(@NonNull java.util.function.Consumer<? super Tuple2<K,V>> action)
SortedMap<K,V>	SortedMap.peek(@NonNull java.util.function.Consumer<? super Tuple2<K,V>> action)
SortedMultimap<K,V>	SortedMultimap.peek(@NonNull java.util.function.Consumer<? super Tuple2<K,V>> action)
TreeMap<K,V>	TreeMap.peek(@NonNull java.util.function.Consumer<? super Tuple2<K,V>> action)
M	AbstractMultimap.reject(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
HashMap<K,V>	HashMap.reject(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
LinkedHashMap<K,V>	LinkedHashMap.reject(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Map<K,V>	Map.reject(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
(package private) static <K,V,M extends Map<K,V>> M	Maps.reject(M map, Maps.OfEntries<K,V,M> ofEntries, java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Multimap<K,V>	Multimap.reject(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
SortedMap<K,V>	SortedMap.reject(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
SortedMultimap<K,V>	SortedMultimap.reject(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
TreeMap<K,V>	TreeMap.reject(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
M	AbstractMultimap.retainAll(@NonNull java.lang.Iterable<? extends Tuple2<K,V>> elements)
HashMap<K,V>	HashMap.retainAll(@NonNull java.lang.Iterable<? extends Tuple2<K,V>> elements)
LinkedHashMap<K,V>	LinkedHashMap.retainAll(@NonNull java.lang.Iterable<? extends Tuple2<K,V>> elements)
Map<K,V>	Map.retainAll(@NonNull java.lang.Iterable<? extends Tuple2<K,V>> elements)
Multimap<K,V>	Multimap.retainAll(@NonNull java.lang.Iterable<? extends Tuple2<K,V>> elements)
SortedMap<K,V>	SortedMap.retainAll(@NonNull java.lang.Iterable<? extends Tuple2<K,V>> elements)
SortedMultimap<K,V>	SortedMultimap.retainAll(@NonNull java.lang.Iterable<? extends Tuple2<K,V>> elements)
TreeMap<K,V>	TreeMap.retainAll(@NonNull java.lang.Iterable<? extends Tuple2<K,V>> elements)
M	AbstractMultimap.scan(Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
M	AbstractMultimap.scan(Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
M	AbstractMultimap.scan(Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
HashMap<K,V>	HashMap.scan(@NonNull Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
HashMap<K,V>	HashMap.scan(@NonNull Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
HashMap<K,V>	HashMap.scan(@NonNull Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
LinkedHashMap<K,V>	LinkedHashMap.scan(@NonNull Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
LinkedHashMap<K,V>	LinkedHashMap.scan(@NonNull Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
LinkedHashMap<K,V>	LinkedHashMap.scan(@NonNull Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
Map<K,V>	Map.scan(@NonNull Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
Map<K,V>	Map.scan(@NonNull Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
Map<K,V>	Map.scan(@NonNull Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
(package private) static <K,V,M extends Map<K,V>> M	Maps.scan(M map, Tuple2<K,V> zero, java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation, java.util.function.Function<Iterator<Tuple2<K,V>>,Traversable<Tuple2<K,V>>> finisher)
(package private) static <K,V,M extends Map<K,V>> M	Maps.scan(M map, Tuple2<K,V> zero, java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation, java.util.function.Function<Iterator<Tuple2<K,V>>,Traversable<Tuple2<K,V>>> finisher)
(package private) static <K,V,M extends Map<K,V>> M	Maps.scan(M map, Tuple2<K,V> zero, java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation, java.util.function.Function<Iterator<Tuple2<K,V>>,Traversable<Tuple2<K,V>>> finisher)
(package private) static <K,V,M extends Map<K,V>> M	Maps.scan(M map, Tuple2<K,V> zero, java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation, java.util.function.Function<Iterator<Tuple2<K,V>>,Traversable<Tuple2<K,V>>> finisher)
(package private) static <K,V,M extends Map<K,V>> M	Maps.scan(M map, Tuple2<K,V> zero, java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation, java.util.function.Function<Iterator<Tuple2<K,V>>,Traversable<Tuple2<K,V>>> finisher)
Multimap<K,V>	Multimap.scan(Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
Multimap<K,V>	Multimap.scan(Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
Multimap<K,V>	Multimap.scan(Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
SortedMap<K,V>	SortedMap.scan(@NonNull Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
SortedMap<K,V>	SortedMap.scan(@NonNull Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
SortedMap<K,V>	SortedMap.scan(@NonNull Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
SortedMultimap<K,V>	SortedMultimap.scan(Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
SortedMultimap<K,V>	SortedMultimap.scan(Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
SortedMultimap<K,V>	SortedMultimap.scan(Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
TreeMap<K,V>	TreeMap.scan(@NonNull Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
TreeMap<K,V>	TreeMap.scan(@NonNull Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
TreeMap<K,V>	TreeMap.scan(@NonNull Tuple2<K,V> zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super Tuple2<K,V>,? extends Tuple2<K,V>> operation)
default <U> Seq<U>	Map.scanLeft(U zero, @NonNull java.util.function.BiFunction<? super U,? super Tuple2<K,V>,? extends U> operation)
default <U> Seq<U>	Multimap.scanLeft(U zero, @NonNull java.util.function.BiFunction<? super U,? super Tuple2<K,V>,? extends U> operation)
default <U> Seq<U>	Map.scanRight(U zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super U,? extends U> operation)
default <U> Seq<U>	Multimap.scanRight(U zero, @NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super U,? extends U> operation)
Iterator<M>	AbstractMultimap.slideBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,?> classifier)
Iterator<HashMap<K,V>>	HashMap.slideBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,?> classifier)
Iterator<LinkedHashMap<K,V>>	LinkedHashMap.slideBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,?> classifier)
Iterator<? extends Map<K,V>>	Map.slideBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,?> classifier)
(package private) static <K,V,M extends Map<K,V>> Iterator<M>	Maps.slideBy(M map, Maps.OfEntries<K,V,M> ofEntries, java.util.function.Function<? super Tuple2<K,V>,?> classifier)
Iterator<? extends Multimap<K,V>>	Multimap.slideBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,?> classifier)
Iterator<? extends SortedMap<K,V>>	SortedMap.slideBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,?> classifier)
Iterator<? extends SortedMultimap<K,V>>	SortedMultimap.slideBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,?> classifier)
Iterator<TreeMap<K,V>>	TreeMap.slideBy(@NonNull java.util.function.Function<? super Tuple2<K,V>,?> classifier)
Tuple2<M,M>	AbstractMultimap.span(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<HashMap<K,V>,HashMap<K,V>>	HashMap.span(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<LinkedHashMap<K,V>,LinkedHashMap<K,V>>	LinkedHashMap.span(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends Map<K,V>,? extends Map<K,V>>	Map.span(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
(package private) static <K,V,M extends Map<K,V>> Tuple2<M,M>	Maps.span(M map, Maps.OfEntries<K,V,M> ofEntries, java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends Multimap<K,V>,? extends Multimap<K,V>>	Multimap.span(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends SortedMap<K,V>,? extends SortedMap<K,V>>	SortedMap.span(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends SortedMultimap<K,V>,? extends SortedMultimap<K,V>>	SortedMultimap.span(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Tuple2<TreeMap<K,V>,TreeMap<K,V>>	TreeMap.span(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
static <K,V> HashMap<K,V>	HashMap.tabulate(int n, @NonNull java.util.function.Function<? super java.lang.Integer,? extends Tuple2<? extends K,? extends V>> f)	Returns an HashMap containing n values of a given Function f over a range of integer values from 0 to n - 1.
<K,V2 extends V> HashMultimap<K,V2>	HashMultimap.Builder.tabulate(int n, @NonNull java.util.function.Function<? super java.lang.Integer,? extends Tuple2<? extends K,? extends V2>> f)	Returns a HashMultimap containing n values of a given Function f over a range of integer values from 0 to n - 1.
static <K,V> LinkedHashMap<K,V>	LinkedHashMap.tabulate(int n, @NonNull java.util.function.Function<? super java.lang.Integer,? extends Tuple2<? extends K,? extends V>> f)	Returns a LinkedHashMap containing n values of a given Function f over a range of integer values from 0 to n - 1.
<K,V2 extends V> LinkedHashMultimap<K,V2>	LinkedHashMultimap.Builder.tabulate(int n, @NonNull java.util.function.Function<? super java.lang.Integer,? extends Tuple2<? extends K,? extends V2>> f)	Returns a LinkedHashMultimap containing n values of a given Function f over a range of integer values from 0 to n - 1.
static <K extends java.lang.Comparable<? super K>,V> TreeMap<K,V>	TreeMap.tabulate(int n, @NonNull java.util.function.Function<? super java.lang.Integer,? extends Tuple2<? extends K,? extends V>> f)	Returns a TreeMap containing n values of a given Function f over a range of integer values from 0 to n - 1.
static <K,V> TreeMap<K,V>	TreeMap.tabulate(java.util.Comparator<? super K> keyComparator, int n, @NonNull java.util.function.Function<? super java.lang.Integer,? extends Tuple2<? extends K,? extends V>> f)	Returns a TreeMap containing n values of a given Function f over a range of integer values from 0 to n - 1.
<K extends java.lang.Comparable<? super K>,V2 extends V> TreeMultimap<K,V2>	TreeMultimap.Builder.tabulate(int n, @NonNull java.util.function.Function<? super java.lang.Integer,? extends Tuple2<? extends K,? extends V2>> f)	Returns a TreeMultimap containing n values of a given Function f over a range of integer values from 0 to n - 1.
<K,V2 extends V> TreeMultimap<K,V2>	TreeMultimap.Builder.tabulate(@NonNull java.util.Comparator<? super K> keyComparator, int n, @NonNull java.util.function.Function<? super java.lang.Integer,? extends Tuple2<? extends K,? extends V2>> f)	Returns a TreeMultimap containing n values of a given Function f over a range of integer values from 0 to n - 1.
M	AbstractMultimap.takeUntil(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
HashMap<K,V>	HashMap.takeUntil(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
LinkedHashMap<K,V>	LinkedHashMap.takeUntil(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Map<K,V>	Map.takeUntil(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
(package private) static <K,V,M extends Map<K,V>> M	Maps.takeUntil(M map, Maps.OfEntries<K,V,M> ofEntries, java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Multimap<K,V>	Multimap.takeUntil(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
SortedMap<K,V>	SortedMap.takeUntil(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
SortedMultimap<K,V>	SortedMultimap.takeUntil(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
TreeMap<K,V>	TreeMap.takeUntil(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
M	AbstractMultimap.takeWhile(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
HashMap<K,V>	HashMap.takeWhile(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
LinkedHashMap<K,V>	LinkedHashMap.takeWhile(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Map<K,V>	Map.takeWhile(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
(package private) static <K,V,M extends Map<K,V>> M	Maps.takeWhile(M map, Maps.OfEntries<K,V,M> ofEntries, java.util.function.Predicate<? super Tuple2<K,V>> predicate)
Multimap<K,V>	Multimap.takeWhile(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
SortedMap<K,V>	SortedMap.takeWhile(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
SortedMultimap<K,V>	SortedMultimap.takeWhile(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
TreeMap<K,V>	TreeMap.takeWhile(@NonNull java.util.function.Predicate<? super Tuple2<K,V>> predicate)
static <T> Array<T>	Array.unfold(T seed, java.util.function.Function<? super T,Option<Tuple2<? extends T,? extends T>>> f)	Creates an Array from a seed value and a function.
static CharSeq	CharSeq.unfold(java.lang.Character seed, java.util.function.Function<? super java.lang.Character,Option<Tuple2<? extends java.lang.Character,? extends java.lang.Character>>> f)	Creates a CharSeq from a seed value and a function.
static <T> Iterator<T>	Iterator.unfold(T seed, java.util.function.Function<? super T,Option<Tuple2<? extends T,? extends T>>> f)	Creates an Iterator by repeatedly applying a function to a seed value.
static <T> List<T>	List.unfold(T seed, @NonNull java.util.function.Function<? super T,Option<Tuple2<? extends T,? extends T>>> f)	Creates a list from a seed value and a function.
static <T> Queue<T>	Queue.unfold(T seed, @NonNull java.util.function.Function<? super T,Option<Tuple2<? extends T,? extends T>>> f)	Creates a Queue from a seed value and a function.
static <T> Stream<T>	Stream.unfold(T seed, @NonNull java.util.function.Function<? super T,Option<Tuple2<? extends T,? extends T>>> f)	Creates a Stream from a seed value and a function.
static <T> Vector<T>	Vector.unfold(T seed, @NonNull java.util.function.Function<? super T,Option<Tuple2<? extends T,? extends T>>> f)	Creates a Vector from a seed value and a function.
static <T,U> Array<U>	Array.unfoldLeft(T seed, java.util.function.Function<? super T,Option<Tuple2<? extends T,? extends U>>> f)	Creates an Array from a seed value and a function.
static <T> CharSeq	CharSeq.unfoldLeft(T seed, java.util.function.Function<? super T,Option<Tuple2<? extends T,? extends java.lang.Character>>> f)	Creates a CharSeq from a seed value and a function.
static <T,U> Iterator<U>	Iterator.unfoldLeft(T seed, java.util.function.Function<? super T,Option<Tuple2<? extends T,? extends U>>> f)	Creates an Iterator by repeatedly applying a function to a seed value, generating elements in a left-to-right order.
static <T,U> List<U>	List.unfoldLeft(T seed, @NonNull java.util.function.Function<? super T,Option<Tuple2<? extends T,? extends U>>> f)	Creates a list from a seed value and a function.
static <T,U> Queue<U>	Queue.unfoldLeft(T seed, @NonNull java.util.function.Function<? super T,Option<Tuple2<? extends T,? extends U>>> f)	Creates a Queue from a seed value and a function.
static <T,U> Stream<U>	Stream.unfoldLeft(T seed, @NonNull java.util.function.Function<? super T,Option<Tuple2<? extends T,? extends U>>> f)	Creates a Stream from a seed value and a function.
static <T,U> Vector<U>	Vector.unfoldLeft(T seed, @NonNull java.util.function.Function<? super T,Option<Tuple2<? extends T,? extends U>>> f)	Creates a Vector from a seed value and a function.
static <T,U> Array<U>	Array.unfoldRight(T seed, java.util.function.Function<? super T,Option<Tuple2<? extends U,? extends T>>> f)	Creates an Array from a seed value and a function.
static <T> CharSeq	CharSeq.unfoldRight(T seed, java.util.function.Function<? super T,Option<Tuple2<? extends java.lang.Character,? extends T>>> f)	Creates a CharSeq from a seed value and a function.
static <T,U> Iterator<U>	Iterator.unfoldRight(T seed, java.util.function.Function<? super T,Option<Tuple2<? extends U,? extends T>>> f)	Creates an Iterator by repeatedly applying a function to a seed value, generating elements in a right-to-left order.
static <T,U> List<U>	List.unfoldRight(T seed, @NonNull java.util.function.Function<? super T,@NonNull Option<Tuple2<? extends U,? extends T>>> f)	Creates a list from a seed value and a function.
static <T,U> Queue<U>	Queue.unfoldRight(T seed, @NonNull java.util.function.Function<? super T,Option<Tuple2<? extends U,? extends T>>> f)	Creates a Queue from a seed value and a function.
static <T,U> Stream<U>	Stream.unfoldRight(T seed, @NonNull java.util.function.Function<? super T,Option<Tuple2<? extends U,? extends T>>> f)	Creates a Stream from a seed value and a function.
static <T,U> Vector<U>	Vector.unfoldRight(T seed, @NonNull java.util.function.Function<? super T,Option<Tuple2<? extends U,? extends T>>> f)	Creates a Vector from a seed value and a function.
<T1,T2> Tuple2<Array<T1>,Array<T2>>	Array.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2> Tuple2<TreeSet<T1>,TreeSet<T2>>	BitSet.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<IndexedSeq<T1>,IndexedSeq<T2>>	CharSeq.unzip(@NonNull java.util.function.Function<? super java.lang.Character,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<HashSet<T1>,HashSet<T2>>	HashSet.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<? extends IndexedSeq<T1>,? extends IndexedSeq<T2>>	IndexedSeq.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2> Tuple2<Iterator<T1>,Iterator<T2>>	Iterator.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<? extends LinearSeq<T1>,? extends LinearSeq<T2>>	LinearSeq.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<LinkedHashSet<T1>,LinkedHashSet<T2>>	LinkedHashSet.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2> Tuple2<List<T1>,List<T2>>	List.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Map.unzip(@NonNull java.util.function.BiFunction<? super K,? super V,Tuple2<? extends T1,? extends T2>> unzipper)	Unzips the entries of this Map by mapping each key-value pair to a tuple.
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Map.unzip(@NonNull java.util.function.Function<? super Tuple2<K,V>,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Map.unzip(@NonNull java.util.function.Function<? super Tuple2<K,V>,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Multimap.unzip(@NonNull java.util.function.BiFunction<? super K,? super V,Tuple2<? extends T1,? extends T2>> unzipper)	Unzips the entries of this Multimap by mapping each key-value pair to a pair and splitting them into two separate Seq collections.
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Multimap.unzip(@NonNull java.util.function.Function<? super Tuple2<K,V>,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Multimap.unzip(@NonNull java.util.function.Function<? super Tuple2<K,V>,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<? extends PriorityQueue<T1>,? extends PriorityQueue<T2>>	PriorityQueue.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<Queue<T1>,Queue<T2>>	Queue.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<? extends Seq<T1>,? extends Seq<T2>>	Seq.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<? extends Set<T1>,? extends Set<T2>>	Set.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<? extends SortedSet<T1>,? extends SortedSet<T2>>	SortedSet.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2> Tuple2<Stream<T1>,Stream<T2>>	Stream.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<? extends Traversable<T1>,? extends Traversable<T2>>	Traversable.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)	Unzips the elements of this Traversable by mapping each element to a pair and splitting them into two separate Traversable collections.
default <T1,T2> Tuple2<Tree<T1>,Tree<T2>>	Tree.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
static <T,T1,T2> Tuple2<Tree.Node<T1>,Tree.Node<T2>>	TreeModule.unzip(@NonNull Tree.Node<T> node, @NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<TreeSet<T1>,TreeSet<T2>>	TreeSet.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
<T1,T2> Tuple2<Vector<T1>,Vector<T2>>	Vector.unzip(@NonNull java.util.function.Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Map.unzip3(@NonNull java.util.function.Function<? super Tuple2<K,V>,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Multimap.unzip3(@NonNull java.util.function.Function<? super Tuple2<K,V>,Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)
private static <K,V> LinkedHashMap<K,V>	LinkedHashMap.wrap(@NonNull Queue<Tuple2<K,V>> list, HashMap<K,V> map)	Construct Map with given values and key order.
private static <K,V> LinkedHashMap<K,V>	LinkedHashMap.wrapNonUnique(@NonNull Queue<Tuple2<K,V>> list, HashMap<K,V> map)	Construct Map with given values and key order.
default <U,R> Seq<R>	Map.zipWith(@NonNull java.lang.Iterable<? extends U> that, java.util.function.BiFunction<? super Tuple2<K,V>,? super U,? extends R> mapper)
default <U,R> Seq<R>	Multimap.zipWith(@NonNull java.lang.Iterable<? extends U> that, java.util.function.BiFunction<? super Tuple2<K,V>,? super U,? extends R> mapper)
default <U> Seq<U>	Map.zipWithIndex(@NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super java.lang.Integer,? extends U> mapper)
default <U> Seq<U>	Multimap.zipWithIndex(@NonNull java.util.function.BiFunction<? super Tuple2<K,V>,? super java.lang.Integer,? extends U> mapper)

Constructor parameters in io.vavr.collection with type arguments of type Tuple2

Constructor	Description
LinkedHashMap(Queue<Tuple2<K,V>> list, HashMap<K,V> map)
TreeMap(RedBlackTree<Tuple2<K,V>> entries)

Uses of Tuple2 in io.vavr.concurrent

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

Modifier and Type	Method	Description
default <U> Future<Tuple2<T,U>>	Future.zip(@NonNull Future<? extends U> that)	Combines this Future with another Future, returning a Future of a tuple of both results.