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.
io.vavr.test	A property check framework built around Property which integrates well with unit test frameworks like junit.

Uses of Tuple2 in io.vavr

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

Modifier and Type	Class	Description
static class	API.Match.Pattern2<T,T1,T2>
final class	Tuple2<T1,T2>	A tuple of two elements which can be seen as cartesian product of two components.

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(Tuple2<T1,T2> tuple)	Concat a tuple's values to this tuple.
<T2> Tuple2<T1,T2>	Tuple1.concat(Tuple1<T2> tuple)	Concat a tuple's values to this tuple.
static <T1,T2> Tuple2<T1,T2>	Tuple.fromEntry(Map.Entry<? extends T1, ? extends T2> entry)	Creates a Tuple2 from a Map.Entry.
<U1,U2> Tuple2<U1,U2>	Tuple2.map(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(Function<? super T1, ? extends U1> f1, 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(Function<? super T1, ? extends U> mapper)	Maps the 1st component of this tuple to a new value.
<U> Tuple2<T1,U>	Tuple2.map2(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(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.
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> Comparator<Tuple2<T1,T2>>	Tuple2.comparator(Comparator<? super T1> t1Comp, 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
int	Tuple2.compareTo(Tuple2<T1,T2> that)
<T1,T2> Tuple2<T1,T2>	Tuple0.concat(Tuple2<T1,T2> tuple)	Concat a tuple's values to this tuple.
<T2,T3> Tuple3<T1,T2,T3>	Tuple1.concat(Tuple2<T2,T3> tuple)	Concat a tuple's values to this tuple.
<T3,T4> Tuple4<T1,T2,T3,T4>	Tuple2.concat(Tuple2<T3,T4> tuple)	Concat a tuple's values to this tuple.
<T4,T5> Tuple5<T1,T2,T3,T4,T5>	Tuple3.concat(Tuple2<T4,T5> tuple)	Concat a tuple's values to this tuple.
<T5,T6> Tuple6<T1,T2,T3,T4,T5,T6>	Tuple4.concat(Tuple2<T5,T6> tuple)	Concat a tuple's values to this tuple.
<T6,T7> Tuple7<T1,T2,T3,T4,T5,T6,T7>	Tuple5.concat(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(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>... entries)	Deprecated. Will be removed in a future version.
static <K,V> Map<K,V>	API.Map(Tuple2<? extends K, ? extends V>... 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 extends Comparable<? super K>, V> SortedMap<K,V>	API.SortedMap(Tuple2<? extends K, ? extends V>... entries)	Deprecated. Will be removed in a future version.
static <K,V> SortedMap<K,V>	API.SortedMap(Comparator<? super K> keyComparator, Tuple2<? extends K, ? extends V>... entries)	Deprecated. Will be removed in a future version.

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

Modifier and Type	Method	Description
<U1,U2> Tuple2<U1,U2>	Tuple2.map(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(Class<? super T> type, API.Match.Pattern<T1,?> p1, API.Match.Pattern<T2,?> p2, Function<T, Tuple2<U1,U2>> unapply)
static <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Tuple.sequence2(Iterable<? extends Tuple2<? extends T1, ? extends T2>> tuples)	Turns a sequence of Tuple2 into a Tuple2 of Seqs.
default <K,V> Map<K,V>	Value.toJavaMap(Function<? super T, ? extends Tuple2<? extends K, ? extends V>> f)	Converts this to a mutable Map.
default <K, V, MAP extends Map<K,V>> MAP	Value.toJavaMap(Supplier<MAP> factory, 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(Function<? super T, ? extends Tuple2<? extends K, ? extends V>> f)	Converts this to a Map.
default <K,V> Map<K,V>	Value.toMap(Function<? super T, ? extends Tuple2<? extends K, ? extends V>> f)	Converts this to a Map.
default <K,V> SortedMap<K,V>	Value.toSortedMap(Comparator<? super K> comparator, Function<? super T, ? extends Tuple2<? extends K, ? extends V>> f)	Converts this to a Map.
default <K extends Comparable<? super K>, V> SortedMap<K,V>	Value.toSortedMap(Function<? super T, ? extends Tuple2<? extends K, ? extends V>> f)	Converts this to a Map.

Uses of Tuple2 in io.vavr.collection

Subinterfaces with type arguments of type Tuple2 in io.vavr.collection

Modifier and Type	Interface	Description
interface	Map<K,V>	An immutable Map interface.
interface	Multimap<K,V>	An immutable Multimap interface.

Methods in io.vavr.collection that return Tuple2

Modifier and Type	Method	Description
Tuple2<V, HashMap<K,V>>	HashMap.computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)
Tuple2<V, LinkedHashMap<K,V>>	LinkedHashMap.computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)
Tuple2<V, ? extends Map<K,V>>	Map.computeIfAbsent(K key, 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.
Tuple2<V, ? extends SortedMap<K,V>>	SortedMap.computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)
Tuple2<V, TreeMap<K,V>>	TreeMap.computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)
Tuple2<Option<V>, HashMap<K,V>>	HashMap.computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction)
Tuple2<Option<V>, LinkedHashMap<K,V>>	LinkedHashMap.computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction)
Tuple2<Option<V>, ? extends Map<K,V>>	Map.computeIfPresent(K key, 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.
Tuple2<Option<V>, ? extends SortedMap<K,V>>	SortedMap.computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction)
Tuple2<Option<V>, TreeMap<K,V>>	TreeMap.computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction)
Tuple2<T, PriorityQueue<T>>	PriorityQueue.dequeue()
static <K,V> Tuple2<K,V>	Map.entry(K key, V value)	Convenience factory method to create a key/value pair.
Tuple2<K,V>	HashMap.head()
Tuple2<K,V>	LinkedHashMap.head()
Tuple2<K,V>	TreeMap.head()
Tuple2<K,V>	HashMap.last()
Tuple2<K,V>	LinkedHashMap.last()
default Tuple2<K,V>	SortedMap.last()
Tuple2<K,V>	TreeMap.last()
Tuple2<Array<T>,Array<T>>	Array.partition(Predicate<? super T> predicate)
Tuple2<BitSet<T>, BitSet<T>>	BitSet.partition(Predicate<? super T> predicate)
Tuple2<CharSeq,CharSeq>	CharSeq.partition(Predicate<? super Character> predicate)
Tuple2<HashMap<K,V>, HashMap<K,V>>	HashMap.partition(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<HashSet<T>, HashSet<T>>	HashSet.partition(Predicate<? super T> predicate)
Tuple2<? extends IndexedSeq<T>, ? extends IndexedSeq<T>>	IndexedSeq.partition(Predicate<? super T> predicate)
default Tuple2<Iterator<T>, Iterator<T>>	Iterator.partition(Predicate<? super T> predicate)
Tuple2<? extends LinearSeq<T>, ? extends LinearSeq<T>>	LinearSeq.partition(Predicate<? super T> predicate)
Tuple2<LinkedHashMap<K,V>, LinkedHashMap<K,V>>	LinkedHashMap.partition(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<LinkedHashSet<T>, LinkedHashSet<T>>	LinkedHashSet.partition(Predicate<? super T> predicate)
default Tuple2<List<T>,List<T>>	List.partition(Predicate<? super T> predicate)
Tuple2<? extends Map<K,V>, ? extends Map<K,V>>	Map.partition(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends Multimap<K,V>, ? extends Multimap<K,V>>	Multimap.partition(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends PriorityQueue<T>, ? extends PriorityQueue<T>>	PriorityQueue.partition(Predicate<? super T> predicate)
Tuple2<Queue<T>,Queue<T>>	Queue.partition(Predicate<? super T> predicate)
Tuple2<? extends Seq<T>, ? extends Seq<T>>	Seq.partition(Predicate<? super T> predicate)
Tuple2<? extends Set<T>, ? extends Set<T>>	Set.partition(Predicate<? super T> predicate)
Tuple2<? extends SortedMap<K,V>, ? extends SortedMap<K,V>>	SortedMap.partition(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends SortedMultimap<K,V>, ? extends SortedMultimap<K,V>>	SortedMultimap.partition(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends SortedSet<T>, ? extends SortedSet<T>>	SortedSet.partition(Predicate<? super T> predicate)
default Tuple2<Stream<T>, Stream<T>>	Stream.partition(Predicate<? super T> predicate)
Tuple2<? extends Traversable<T>, ? extends Traversable<T>>	Traversable.partition(Predicate<? super T> predicate)	Creates a partition of this Traversable by splitting this elements in two in distinct traversables according to a predicate.
default Tuple2<Seq<T>,Seq<T>>	Tree.partition(Predicate<? super T> predicate)
Tuple2<TreeMap<K,V>, TreeMap<K,V>>	TreeMap.partition(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<TreeSet<T>, TreeSet<T>>	TreeSet.partition(Predicate<? super T> predicate)
Tuple2<Vector<T>, Vector<T>>	Vector.partition(Predicate<? super T> predicate)
default Tuple2<T,List<T>>	List.pop2()	Removes the head element from this List.
Tuple2<Array<T>,Array<T>>	Array.span(Predicate<? super T> predicate)
Tuple2<BitSet<T>, BitSet<T>>	BitSet.span(Predicate<? super T> predicate)
Tuple2<CharSeq,CharSeq>	CharSeq.span(Predicate<? super Character> predicate)
Tuple2<HashMap<K,V>, HashMap<K,V>>	HashMap.span(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<HashSet<T>, HashSet<T>>	HashSet.span(Predicate<? super T> predicate)
Tuple2<? extends IndexedSeq<T>, ? extends IndexedSeq<T>>	IndexedSeq.span(Predicate<? super T> predicate)
default Tuple2<Iterator<T>, Iterator<T>>	Iterator.span(Predicate<? super T> predicate)
Tuple2<? extends LinearSeq<T>, ? extends LinearSeq<T>>	LinearSeq.span(Predicate<? super T> predicate)
Tuple2<LinkedHashMap<K,V>, LinkedHashMap<K,V>>	LinkedHashMap.span(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<LinkedHashSet<T>, LinkedHashSet<T>>	LinkedHashSet.span(Predicate<? super T> predicate)
default Tuple2<List<T>,List<T>>	List.span(Predicate<? super T> predicate)
Tuple2<? extends Map<K,V>, ? extends Map<K,V>>	Map.span(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends Multimap<K,V>, ? extends Multimap<K,V>>	Multimap.span(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends PriorityQueue<T>, ? extends PriorityQueue<T>>	PriorityQueue.span(Predicate<? super T> predicate)
Tuple2<Queue<T>,Queue<T>>	Queue.span(Predicate<? super T> predicate)
Tuple2<? extends Seq<T>, ? extends Seq<T>>	Seq.span(Predicate<? super T> predicate)
Tuple2<? extends Set<T>, ? extends Set<T>>	Set.span(Predicate<? super T> predicate)
Tuple2<? extends SortedMap<K,V>, ? extends SortedMap<K,V>>	SortedMap.span(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends SortedMultimap<K,V>, ? extends SortedMultimap<K,V>>	SortedMultimap.span(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends SortedSet<T>, ? extends SortedSet<T>>	SortedSet.span(Predicate<? super T> predicate)
default Tuple2<Stream<T>, Stream<T>>	Stream.span(Predicate<? super T> predicate)
Tuple2<? extends Traversable<T>, ? extends Traversable<T>>	Traversable.span(Predicate<? super T> predicate)	Returns a tuple where the first element is the longest prefix of elements that satisfy the given predicate and the second element is the remainder.
default Tuple2<Seq<T>,Seq<T>>	Tree.span(Predicate<? super T> predicate)
Tuple2<TreeMap<K,V>, TreeMap<K,V>>	TreeMap.span(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<TreeSet<T>, TreeSet<T>>	TreeSet.span(Predicate<? super T> predicate)
Tuple2<Vector<T>, Vector<T>>	Vector.span(Predicate<? super T> predicate)
Tuple2<Array<T>,Array<T>>	Array.splitAt(int n)
Tuple2<Array<T>,Array<T>>	Array.splitAt(Predicate<? super T> predicate)
Tuple2<CharSeq,CharSeq>	CharSeq.splitAt(int n)
Tuple2<CharSeq,CharSeq>	CharSeq.splitAt(Predicate<? super Character> predicate)
default Tuple2<List<T>,List<T>>	List.splitAt(int n)
default Tuple2<List<T>,List<T>>	List.splitAt(Predicate<? super T> predicate)
Tuple2<Queue<T>,Queue<T>>	Queue.splitAt(int n)
Tuple2<Queue<T>,Queue<T>>	Queue.splitAt(Predicate<? super T> predicate)
Tuple2<? extends Seq<T>, ? extends Seq<T>>	Seq.splitAt(int n)	Splits a Seq at the specified index.
Tuple2<? extends Seq<T>, ? extends Seq<T>>	Seq.splitAt(Predicate<? super T> predicate)	Splits a sequence at the first element which satisfies the Predicate, e.g.
default Tuple2<Stream<T>, Stream<T>>	Stream.splitAt(int n)
default Tuple2<Stream<T>, Stream<T>>	Stream.splitAt(Predicate<? super T> predicate)
Tuple2<Vector<T>, Vector<T>>	Vector.splitAt(int n)
Tuple2<Vector<T>, Vector<T>>	Vector.splitAt(Predicate<? super T> predicate)
Tuple2<Array<T>,Array<T>>	Array.splitAtInclusive(Predicate<? super T> predicate)
Tuple2<CharSeq,CharSeq>	CharSeq.splitAtInclusive(Predicate<? super Character> predicate)
default Tuple2<List<T>,List<T>>	List.splitAtInclusive(Predicate<? super T> predicate)
Tuple2<Queue<T>,Queue<T>>	Queue.splitAtInclusive(Predicate<? super T> predicate)
Tuple2<? extends Seq<T>, ? extends Seq<T>>	Seq.splitAtInclusive(Predicate<? super T> predicate)	Splits a sequence at the first element which satisfies the Predicate, e.g.
default Tuple2<Stream<T>, Stream<T>>	Stream.splitAtInclusive(Predicate<? super T> predicate)
Tuple2<Vector<T>, Vector<T>>	Vector.splitAtInclusive(Predicate<? super T> predicate)
<T1,T2> Tuple2<Array<T1>, Array<T2>>	Array.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
default <T1,T2> Tuple2<TreeSet<T1>, TreeSet<T2>>	BitSet.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<IndexedSeq<T1>, IndexedSeq<T2>>	CharSeq.unzip(Function<? super Character, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<HashSet<T1>, HashSet<T2>>	HashSet.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<? extends IndexedSeq<T1>, ? extends IndexedSeq<T2>>	IndexedSeq.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
default <T1,T2> Tuple2<Iterator<T1>, Iterator<T2>>	Iterator.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<? extends LinearSeq<T1>, ? extends LinearSeq<T2>>	LinearSeq.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<LinkedHashSet<T1>, LinkedHashSet<T2>>	LinkedHashSet.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
default <T1,T2> Tuple2<List<T1>,List<T2>>	List.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
default Tuple2<Seq<K>,Seq<V>>	Map.unzip()
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Map.unzip(BiFunction<? super K, ? super V, Tuple2<? extends T1, ? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Map.unzip(Function<? super Tuple2<K,V>, Tuple2<? extends T1, ? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Multimap.unzip(BiFunction<? super K, ? super V, Tuple2<? extends T1, ? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Multimap.unzip(Function<? super Tuple2<K,V>, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<? extends PriorityQueue<T1>, ? extends PriorityQueue<T2>>	PriorityQueue.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<Queue<T1>, Queue<T2>>	Queue.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<? extends Seq<T1>, ? extends Seq<T2>>	Seq.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<? extends Set<T1>, ? extends Set<T2>>	Set.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<? extends SortedSet<T1>, ? extends SortedSet<T2>>	SortedSet.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
default <T1,T2> Tuple2<Stream<T1>, Stream<T2>>	Stream.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<? extends Traversable<T1>, ? extends Traversable<T2>>	Traversable.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)	Unzips this elements by mapping this elements to pairs which are subsequently split into two distinct sets.
default <T1,T2> Tuple2<Tree<T1>,Tree<T2>>	Tree.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<TreeSet<T1>, TreeSet<T2>>	TreeSet.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<Vector<T1>, Vector<T2>>	Vector.unzip(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> Collector<Tuple2<K,V>, 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> Collector<Tuple2<K,V>, 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> Collector<Tuple2<K,V2>, 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> Collector<Tuple2<K,V2>, 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> Collector<Tuple2<K,V>, 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> Collector<Tuple2<K,V>, 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> Collector<Tuple2<K,V2>, 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> Collector<Tuple2<K,V2>, 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 Comparable<? super K>, V> Collector<Tuple2<K,V>, 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 Comparable<? super K>, V> Collector<Tuple2<K,V>, 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> Collector<Tuple2<K,V>, ArrayList<Tuple2<K,V>>, TreeMap<K,V>>	TreeMap.collector(Comparator<? super K> keyComparator)	Returns a Collector which may be used in conjunction with Stream.collect(Collector) to obtain a TreeMap.
static <K,V> Collector<Tuple2<K,V>, ArrayList<Tuple2<K,V>>, TreeMap<K,V>>	TreeMap.collector(Comparator<? super K> keyComparator)	Returns a Collector which may be used in conjunction with Stream.collect(Collector) to obtain a TreeMap.
<K extends Comparable<? super K>, V2 extends V> Collector<Tuple2<K,V2>, 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 Comparable<? super K>, V2 extends V> Collector<Tuple2<K,V2>, 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> Collector<Tuple2<K,V2>, ArrayList<Tuple2<K,V2>>, TreeMultimap<K,V2>>	TreeMultimap.Builder.collector(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> Collector<Tuple2<K,V2>, ArrayList<Tuple2<K,V2>>, TreeMultimap<K,V2>>	TreeMultimap.Builder.collector(Comparator<? super K> keyComparator)	Returns a Collector which may be used in conjunction with Stream.collect(Collector) to obtain a TreeMultimap.
default Iterator<Tuple2<T,T>>	Seq.crossProduct()	Calculates the cross product (, i.e. square) of this x this.
default <U> Iterator<Tuple2<T,U>>	Seq.crossProduct(Iterable<? extends U> that)	Calculates the cross product this x that.
Iterator<Tuple2<K,V>>	HashMap.iterator()
Iterator<Tuple2<K,V>>	LinkedHashMap.iterator()
Iterator<Tuple2<K,V>>	Map.iterator()
Iterator<Tuple2<K,V>>	Multimap.iterator()
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(Iterable<? extends U> that)
default <U> TreeSet<Tuple2<T,U>>	BitSet.zip(Iterable<? extends U> that)
<U> IndexedSeq<Tuple2<Character, U>>	CharSeq.zip(Iterable<? extends U> that)
<U> HashSet<Tuple2<T,U>>	HashSet.zip(Iterable<? extends U> that)
<U> IndexedSeq<Tuple2<T,U>>	IndexedSeq.zip(Iterable<? extends U> that)
default <U> Iterator<Tuple2<T,U>>	Iterator.zip(Iterable<? extends U> that)
<U> LinearSeq<Tuple2<T,U>>	LinearSeq.zip(Iterable<? extends U> that)
<U> LinkedHashSet<Tuple2<T,U>>	LinkedHashSet.zip(Iterable<? extends U> that)
default <U> List<Tuple2<T,U>>	List.zip(Iterable<? extends U> that)
default <U> Seq<Tuple2<Tuple2<K,V>, U>>	Map.zip(Iterable<? extends U> that)
default <U> Seq<Tuple2<Tuple2<K,V>, U>>	Map.zip(Iterable<? extends U> that)
default <U> Seq<Tuple2<Tuple2<K,V>, U>>	Multimap.zip(Iterable<? extends U> that)
default <U> Seq<Tuple2<Tuple2<K,V>, U>>	Multimap.zip(Iterable<? extends U> that)
<U> PriorityQueue<Tuple2<T,U>>	PriorityQueue.zip(Iterable<? extends U> that)
<U> Queue<Tuple2<T,U>>	Queue.zip(Iterable<? extends U> that)
<U> Seq<Tuple2<T,U>>	Seq.zip(Iterable<? extends U> that)
<U> Set<Tuple2<T,U>>	Set.zip(Iterable<? extends U> that)
<U> SortedSet<Tuple2<T,U>>	SortedSet.zip(Iterable<? extends U> that)
default <U> Stream<Tuple2<T,U>>	Stream.zip(Iterable<? extends U> that)
<U> Traversable<Tuple2<T,U>>	Traversable.zip(Iterable<? extends U> that)	Returns a traversable formed from this traversable and another Iterable collection by combining corresponding elements in pairs.
default <U> Tree<Tuple2<T,U>>	Tree.zip(Iterable<? extends U> that)
<U> TreeSet<Tuple2<T,U>>	TreeSet.zip(Iterable<? extends U> that)
<U> Vector<Tuple2<T,U>>	Vector.zip(Iterable<? extends U> that)
<U> Array<Tuple2<T,U>>	Array.zipAll(Iterable<? extends U> that, T thisElem, U thatElem)
default <U> TreeSet<Tuple2<T,U>>	BitSet.zipAll(Iterable<? extends U> that, T thisElem, U thatElem)
<U> IndexedSeq<Tuple2<Character, U>>	CharSeq.zipAll(Iterable<? extends U> that, Character thisElem, U thatElem)
<U> HashSet<Tuple2<T,U>>	HashSet.zipAll(Iterable<? extends U> that, T thisElem, U thatElem)
<U> IndexedSeq<Tuple2<T,U>>	IndexedSeq.zipAll(Iterable<? extends U> that, T thisElem, U thatElem)
default <U> Iterator<Tuple2<T,U>>	Iterator.zipAll(Iterable<? extends U> that, T thisElem, U thatElem)
<U> LinearSeq<Tuple2<T,U>>	LinearSeq.zipAll(Iterable<? extends U> that, T thisElem, U thatElem)
<U> LinkedHashSet<Tuple2<T,U>>	LinkedHashSet.zipAll(Iterable<? extends U> that, T thisElem, U thatElem)
default <U> List<Tuple2<T,U>>	List.zipAll(Iterable<? extends U> that, T thisElem, U thatElem)
default <U> Seq<Tuple2<Tuple2<K,V>, U>>	Map.zipAll(Iterable<? extends U> that, Tuple2<K,V> thisElem, U thatElem)
default <U> Seq<Tuple2<Tuple2<K,V>, U>>	Map.zipAll(Iterable<? extends U> that, Tuple2<K,V> thisElem, U thatElem)
default <U> Seq<Tuple2<Tuple2<K,V>, U>>	Multimap.zipAll(Iterable<? extends U> that, Tuple2<K,V> thisElem, U thatElem)
default <U> Seq<Tuple2<Tuple2<K,V>, U>>	Multimap.zipAll(Iterable<? extends U> that, Tuple2<K,V> thisElem, U thatElem)
<U> PriorityQueue<Tuple2<T,U>>	PriorityQueue.zipAll(Iterable<? extends U> that, T thisElem, U thatElem)
<U> Queue<Tuple2<T,U>>	Queue.zipAll(Iterable<? extends U> that, T thisElem, U thatElem)
<U> Seq<Tuple2<T,U>>	Seq.zipAll(Iterable<? extends U> that, T thisElem, U thatElem)
<U> Set<Tuple2<T,U>>	Set.zipAll(Iterable<? extends U> that, T thisElem, U thatElem)
<U> SortedSet<Tuple2<T,U>>	SortedSet.zipAll(Iterable<? extends U> that, T thisElem, U thatElem)
default <U> Stream<Tuple2<T,U>>	Stream.zipAll(Iterable<? extends U> iterable, T thisElem, U thatElem)
<U> Traversable<Tuple2<T,U>>	Traversable.zipAll(Iterable<? extends U> that, T thisElem, U thatElem)	Returns a traversable formed from this traversable and another Iterable by combining corresponding elements in pairs.
default <U> Tree<Tuple2<T,U>>	Tree.zipAll(Iterable<? extends U> that, T thisElem, U thatElem)
<U> TreeSet<Tuple2<T,U>>	TreeSet.zipAll(Iterable<? extends U> that, T thisElem, U thatElem)
<U> Vector<Tuple2<T,U>>	Vector.zipAll(Iterable<? extends U> that, T thisElem, U thatElem)
Array<Tuple2<T,Integer>>	Array.zipWithIndex()
default TreeSet<Tuple2<T,Integer>>	BitSet.zipWithIndex()
IndexedSeq<Tuple2<Character, Integer>>	CharSeq.zipWithIndex()
HashSet<Tuple2<T,Integer>>	HashSet.zipWithIndex()
IndexedSeq<Tuple2<T,Integer>>	IndexedSeq.zipWithIndex()
default Iterator<Tuple2<T,Integer>>	Iterator.zipWithIndex()
LinearSeq<Tuple2<T,Integer>>	LinearSeq.zipWithIndex()
LinkedHashSet<Tuple2<T,Integer>>	LinkedHashSet.zipWithIndex()
default List<Tuple2<T,Integer>>	List.zipWithIndex()
default Seq<Tuple2<Tuple2<K,V>, Integer>>	Map.zipWithIndex()
default Seq<Tuple2<Tuple2<K,V>, Integer>>	Map.zipWithIndex()
default Seq<Tuple2<Tuple2<K,V>, Integer>>	Multimap.zipWithIndex()
default Seq<Tuple2<Tuple2<K,V>, Integer>>	Multimap.zipWithIndex()
PriorityQueue<Tuple2<T,Integer>>	PriorityQueue.zipWithIndex()
Queue<Tuple2<T,Integer>>	Queue.zipWithIndex()
Seq<Tuple2<T,Integer>>	Seq.zipWithIndex()
Set<Tuple2<T,Integer>>	Set.zipWithIndex()
SortedSet<Tuple2<T,Integer>>	SortedSet.zipWithIndex()
default Stream<Tuple2<T,Integer>>	Stream.zipWithIndex()
Traversable<Tuple2<T,Integer>>	Traversable.zipWithIndex()	Zips this traversable with its indices.
default Tree<Tuple2<T,Integer>>	Tree.zipWithIndex()
TreeSet<Tuple2<T,Integer>>	TreeSet.zipWithIndex()
Vector<Tuple2<T,Integer>>	Vector.zipWithIndex()

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

Modifier and Type	Method	Description
default boolean	Map.contains(Tuple2<K,V> element)
default boolean	Multimap.contains(Tuple2<K,V> element)
<K, V2 extends V> HashMultimap<K,V2>	HashMultimap.Builder.fill(int n, 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, Tuple2<? extends K, ? extends V2> element)	Returns a LinkedHashMultimap containing n times the given element
<K extends Comparable<? super K>, V2 extends V> TreeMultimap<K,V2>	TreeMultimap.Builder.fill(int n, 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(Comparator<? super K> keyComparator, int n, Tuple2<? extends K, ? extends V2> element)	Returns a TreeMultimap containing n times the given element
static <K,V> HashMap<K,V>	HashMap.of(Tuple2<? extends K, ? extends V> entry)	Returns a singleton HashMap, i.e. a HashMap of one element.
<K, V2 extends V> HashMultimap<K,V2>	HashMultimap.Builder.of(Tuple2<? extends K, ? extends V2> entry)	Creates a HashMultimap of the given key-value pair.
static <K,V> LinkedHashMap<K,V>	LinkedHashMap.of(Tuple2<? extends K, ? extends V> entry)	Returns a singleton LinkedHashMap, i.e. a LinkedHashMap of one element.
<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 Comparable<? super K>, V> TreeMap<K,V>	TreeMap.of(Tuple2<? extends K, ? extends V> entry)	Returns a singleton TreeMap, i.e. a TreeMap of one entry.
static <K,V> TreeMap<K,V>	TreeMap.of(Comparator<? super K> keyComparator, Tuple2<? extends K, ? extends V> entry)	Returns a singleton TreeMap, i.e. a TreeMap of one entry using a specific key comparator.
<K extends Comparable<? super K>, V2 extends V> TreeMultimap<K,V2>	TreeMultimap.Builder.of(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(Comparator<? super K> keyComparator, Tuple2<? extends K, ? extends V2> entry)	Returns a singleton TreeMultimap, i.e. a TreeMultimap of one entry using a specific key comparator.
static <K,V> HashMap<K,V>	HashMap.ofEntries(Tuple2<? extends K, ? extends V>... entries)	Creates a HashMap of the given entries.
final <K, V2 extends V> HashMultimap<K,V2>	HashMultimap.Builder.ofEntries(Tuple2<? extends K, ? extends V2>... entries)	Creates a HashMultimap of the given entries.
static <K,V> LinkedHashMap<K,V>	LinkedHashMap.ofEntries(Tuple2<? extends K, ? extends V>... entries)	Creates a LinkedHashMap of the given entries.
final <K, V2 extends V> LinkedHashMultimap<K,V2>	LinkedHashMultimap.Builder.ofEntries(Tuple2<? extends K, ? extends V2>... entries)	Creates a LinkedHashMultimap of the given entries.
static <K extends Comparable<? super K>, V> TreeMap<K,V>	TreeMap.ofEntries(Tuple2<? extends K, ? extends V>... entries)	Creates a TreeMap of the given entries using the natural key comparator.
static <K,V> TreeMap<K,V>	TreeMap.ofEntries(Comparator<? super K> keyComparator, Tuple2<? extends K, ? extends V>... entries)	Creates a TreeMap of the given entries using the given key comparator.
final <K extends Comparable<? super K>, V2 extends V> TreeMultimap<K,V2>	TreeMultimap.Builder.ofEntries(Tuple2<? extends K, ? extends V2>... entries)	Creates a TreeMultimap of the given entries.
final <K, V2 extends V> TreeMultimap<K,V2>	TreeMultimap.Builder.ofEntries(Comparator<? super K> keyComparator, Tuple2<? extends K, ? extends V2>... entries)	Creates a TreeMultimap of the given entries.
HashMap<K,V>	HashMap.put(Tuple2<? extends K, ? extends V> entry)
<U extends V> HashMap<K,V>	HashMap.put(Tuple2<? extends K, U> entry, BiFunction<? super V, ? super U, ? extends V> merge)
LinkedHashMap<K,V>	LinkedHashMap.put(Tuple2<? extends K, ? extends V> entry)
<U extends V> LinkedHashMap<K,V>	LinkedHashMap.put(Tuple2<? extends K, U> entry, BiFunction<? super V, ? super U, ? extends V> merge)
Map<K,V>	Map.put(Tuple2<? extends K, ? extends V> entry)	Convenience method for put(entry._1, entry._2).
<U extends V> Map<K,V>	Map.put(Tuple2<? extends K, U> entry, BiFunction<? super V, ? super U, ? extends V> merge)	Convenience method for put(entry._1, entry._2, merge).
Multimap<K,V>	Multimap.put(Tuple2<? extends K, ? extends V> entry)	Convenience method for put(entry._1, entry._2).
SortedMap<K,V>	SortedMap.put(Tuple2<? extends K, ? extends V> entry)
<U extends V> SortedMap<K,V>	SortedMap.put(Tuple2<? extends K, U> entry, BiFunction<? super V, ? super U, ? extends V> merge)
SortedMultimap<K,V>	SortedMultimap.put(Tuple2<? extends K, ? extends V> entry)
TreeMap<K,V>	TreeMap.put(Tuple2<? extends K, ? extends V> entry)
<U extends V> TreeMap<K,V>	TreeMap.put(Tuple2<? extends K, U> entry, BiFunction<? super V, ? super U, ? extends V> merge)
HashMap<K,V>	HashMap.replace(Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
LinkedHashMap<K,V>	LinkedHashMap.replace(Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
Map<K,V>	Map.replace(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(Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
SortedMultimap<K,V>	SortedMultimap.replace(Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
TreeMap<K,V>	TreeMap.replace(Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
HashMap<K,V>	HashMap.replaceAll(Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
LinkedHashMap<K,V>	LinkedHashMap.replaceAll(Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
Map<K,V>	Map.replaceAll(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(Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
SortedMultimap<K,V>	SortedMultimap.replaceAll(Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
TreeMap<K,V>	TreeMap.replaceAll(Tuple2<K,V> currentElement, Tuple2<K,V> newElement)
HashMap<K,V>	HashMap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
LinkedHashMap<K,V>	LinkedHashMap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
Map<K,V>	Map.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
Multimap<K,V>	Multimap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
SortedMap<K,V>	SortedMap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
SortedMultimap<K,V>	SortedMultimap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
TreeMap<K,V>	TreeMap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
default <U> Seq<Tuple2<Tuple2<K,V>, U>>	Map.zipAll(Iterable<? extends U> that, Tuple2<K,V> thisElem, U thatElem)
default <U> Seq<Tuple2<Tuple2<K,V>, U>>	Multimap.zipAll(Iterable<? extends U> that, Tuple2<K,V> thisElem, U thatElem)

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

Modifier and Type	Method	Description
default <R> Seq<R>	Map.collect(PartialFunction<? super Tuple2<K,V>, ? extends R> partialFunction)
default <R> Seq<R>	Multimap.collect(PartialFunction<? super Tuple2<K,V>, ? extends R> partialFunction)
HashMap<K,V>	HashMap.distinctBy(Comparator<? super Tuple2<K,V>> comparator)
<U> HashMap<K,V>	HashMap.distinctBy(Function<? super Tuple2<K,V>, ? extends U> keyExtractor)
LinkedHashMap<K,V>	LinkedHashMap.distinctBy(Comparator<? super Tuple2<K,V>> comparator)
<U> LinkedHashMap<K,V>	LinkedHashMap.distinctBy(Function<? super Tuple2<K,V>, ? extends U> keyExtractor)
Map<K,V>	Map.distinctBy(Comparator<? super Tuple2<K,V>> comparator)
<U> Map<K,V>	Map.distinctBy(Function<? super Tuple2<K,V>, ? extends U> keyExtractor)
Multimap<K,V>	Multimap.distinctBy(Comparator<? super Tuple2<K,V>> comparator)
<U> Multimap<K,V>	Multimap.distinctBy(Function<? super Tuple2<K,V>, ? extends U> keyExtractor)
SortedMap<K,V>	SortedMap.distinctBy(Comparator<? super Tuple2<K,V>> comparator)
<U> SortedMap<K,V>	SortedMap.distinctBy(Function<? super Tuple2<K,V>, ? extends U> keyExtractor)
SortedMultimap<K,V>	SortedMultimap.distinctBy(Comparator<? super Tuple2<K,V>> comparator)
<U> SortedMultimap<K,V>	SortedMultimap.distinctBy(Function<? super Tuple2<K,V>, ? extends U> keyExtractor)
TreeMap<K,V>	TreeMap.distinctBy(Comparator<? super Tuple2<K,V>> comparator)
<U> TreeMap<K,V>	TreeMap.distinctBy(Function<? super Tuple2<K,V>, ? extends U> keyExtractor)
HashMap<K,V>	HashMap.dropUntil(Predicate<? super Tuple2<K,V>> predicate)
LinkedHashMap<K,V>	LinkedHashMap.dropUntil(Predicate<? super Tuple2<K,V>> predicate)
Map<K,V>	Map.dropUntil(Predicate<? super Tuple2<K,V>> predicate)
Multimap<K,V>	Multimap.dropUntil(Predicate<? super Tuple2<K,V>> predicate)
SortedMap<K,V>	SortedMap.dropUntil(Predicate<? super Tuple2<K,V>> predicate)
SortedMultimap<K,V>	SortedMultimap.dropUntil(Predicate<? super Tuple2<K,V>> predicate)
TreeMap<K,V>	TreeMap.dropUntil(Predicate<? super Tuple2<K,V>> predicate)
HashMap<K,V>	HashMap.dropWhile(Predicate<? super Tuple2<K,V>> predicate)
LinkedHashMap<K,V>	LinkedHashMap.dropWhile(Predicate<? super Tuple2<K,V>> predicate)
Map<K,V>	Map.dropWhile(Predicate<? super Tuple2<K,V>> predicate)
Multimap<K,V>	Multimap.dropWhile(Predicate<? super Tuple2<K,V>> predicate)
SortedMap<K,V>	SortedMap.dropWhile(Predicate<? super Tuple2<K,V>> predicate)
SortedMultimap<K,V>	SortedMultimap.dropWhile(Predicate<? super Tuple2<K,V>> predicate)
TreeMap<K,V>	TreeMap.dropWhile(Predicate<? super Tuple2<K,V>> predicate)
static <K,V> HashMap<K,V>	HashMap.fill(int n, 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, 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, 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, Supplier<? extends Tuple2<? extends K, ? extends V2>> s)	Returns a LinkedHashMultimap containing n values supplied by a given Supplier s.
static <K extends Comparable<? super K>, V> TreeMap<K,V>	TreeMap.fill(int n, 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(Comparator<? super K> keyComparator, int n, Supplier<? extends Tuple2<? extends K, ? extends V>> s)	Returns a TreeMap containing tuples returned by n calls to a given Supplier s.
<K extends Comparable<? super K>, V2 extends V> TreeMultimap<K,V2>	TreeMultimap.Builder.fill(int n, 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(Comparator<? super K> keyComparator, int n, Supplier<? extends Tuple2<? extends K, ? extends V2>> s)	Returns a TreeMultimap containing n values supplied by a given Supplier s.
HashMap<K,V>	HashMap.filter(Predicate<? super Tuple2<K,V>> predicate)
LinkedHashMap<K,V>	LinkedHashMap.filter(Predicate<? super Tuple2<K,V>> predicate)
Map<K,V>	Map.filter(Predicate<? super Tuple2<K,V>> predicate)
Multimap<K,V>	Multimap.filter(Predicate<? super Tuple2<K,V>> predicate)
SortedMap<K,V>	SortedMap.filter(Predicate<? super Tuple2<K,V>> predicate)
SortedMultimap<K,V>	SortedMultimap.filter(Predicate<? super Tuple2<K,V>> predicate)
TreeMap<K,V>	TreeMap.filter(Predicate<? super Tuple2<K,V>> predicate)
<K2,V2> HashMap<K2,V2>	HashMap.flatMap(BiFunction<? super K, ? super V, ? extends Iterable<Tuple2<K2,V2>>> mapper)
<K2,V2> LinkedHashMap<K2,V2>	LinkedHashMap.flatMap(BiFunction<? super K, ? super V, ? extends Iterable<Tuple2<K2,V2>>> mapper)
<K2,V2> Map<K2,V2>	Map.flatMap(BiFunction<? super K, ? super V, ? extends Iterable<Tuple2<K2,V2>>> mapper)	FlatMaps this Map to a new Map with different component type.
default <U> Seq<U>	Map.flatMap(Function<? super Tuple2<K,V>, ? extends Iterable<? extends U>> mapper)	Flat-maps this entries to a sequence of values.
<K2,V2> Multimap<K2,V2>	Multimap.flatMap(BiFunction<? super K, ? super V, ? extends Iterable<Tuple2<K2,V2>>> mapper)	FlatMaps this Multimap to a new Multimap with different component type.
default <U> Seq<U>	Multimap.flatMap(Function<? super Tuple2<K,V>, ? extends Iterable<? extends U>> mapper)	Flat-maps this entries to a sequence of values.
<K2,V2> SortedMap<K2,V2>	SortedMap.flatMap(Comparator<? super K2> keyComparator, BiFunction<? super K, ? super V, ? extends 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(BiFunction<? super K, ? super V, ? extends Iterable<Tuple2<K2,V2>>> mapper)
<K2,V2> TreeMap<K2,V2>	TreeMap.flatMap(Comparator<? super K2> keyComparator, BiFunction<? super K, ? super V, ? extends Iterable<Tuple2<K2,V2>>> mapper)
<K2,V2> TreeMap<K2,V2>	TreeMap.flatMap(BiFunction<? super K, ? super V, ? extends Iterable<Tuple2<K2,V2>>> mapper)
default <U> U	Map.foldRight(U zero, BiFunction<? super Tuple2<K,V>, ? super U, ? extends U> f)
default <U> U	Multimap.foldRight(U zero, BiFunction<? super Tuple2<K,V>, ? super U, ? extends U> f)
<C> Map<C, HashMap<K,V>>	HashMap.groupBy(Function<? super Tuple2<K,V>, ? extends C> classifier)
<C> Map<C, LinkedHashMap<K,V>>	LinkedHashMap.groupBy(Function<? super Tuple2<K,V>, ? extends C> classifier)
<C> Map<C, ? extends Map<K,V>>	Map.groupBy(Function<? super Tuple2<K,V>, ? extends C> classifier)
<C> Map<C, ? extends Multimap<K,V>>	Multimap.groupBy(Function<? super Tuple2<K,V>, ? extends C> classifier)
<C> Map<C, ? extends SortedMap<K,V>>	SortedMap.groupBy(Function<? super Tuple2<K,V>, ? extends C> classifier)
<C> Map<C, ? extends SortedMultimap<K,V>>	SortedMultimap.groupBy(Function<? super Tuple2<K,V>, ? extends C> classifier)
<C> Map<C, TreeMap<K,V>>	TreeMap.groupBy(Function<? super Tuple2<K,V>, ? extends C> classifier)
<K2,V2> HashMap<K2,V2>	HashMap.map(BiFunction<? super K, ? super V, Tuple2<K2,V2>> mapper)
<K2,V2> LinkedHashMap<K2,V2>	LinkedHashMap.map(BiFunction<? super K, ? super V, Tuple2<K2,V2>> mapper)
<K2,V2> Map<K2,V2>	Map.map(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(Function<? super Tuple2<K,V>, ? extends U> mapper)	Maps the Map entries to a sequence of values.
<K2,V2> Multimap<K2,V2>	Multimap.map(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(Function<? super Tuple2<K,V>, ? extends U> mapper)	Maps the Multimap entries to a sequence of values.
<K2,V2> SortedMap<K2,V2>	SortedMap.map(Comparator<? super K2> keyComparator, 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(BiFunction<? super K, ? super V, Tuple2<K2,V2>> mapper)
<K2,V2> TreeMap<K2,V2>	TreeMap.map(Comparator<? super K2> keyComparator, BiFunction<? super K, ? super V, Tuple2<K2,V2>> mapper)
<K2,V2> TreeMap<K2,V2>	TreeMap.map(BiFunction<? super K, ? super V, Tuple2<K2,V2>> mapper)
static <T,K,V> HashMap<K,V>	HashMap.ofAll(Stream<? extends T> stream, 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(Stream<? extends T> stream, 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(Stream<? extends T> stream, 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(Stream<? extends T> stream, 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(Comparator<? super K> keyComparator, Stream<? extends T> stream, Function<? super T, Tuple2<? extends K, ? extends V>> entryMapper)	Returns a TreeMap, from entries mapped from stream.
static <T, K extends Comparable<? super K>, V> TreeMap<K,V>	TreeMap.ofAll(Stream<? extends T> stream, 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(Comparator<? super K> keyComparator, Stream<? extends T> stream, Function<? super T, Tuple2<? extends K, ? extends V2>> entryMapper)	Returns a TreeMultimap, from entries mapped from stream.
<T, K extends Comparable<? super K>, V2 extends V> TreeMultimap<K,V2>	TreeMultimap.Builder.ofAll(Stream<? extends T> stream, 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(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(Iterable<? extends Tuple2<? extends K, ? extends V2>> entries)	Creates a HashMultimap of the given entries.
static <K,V> LinkedHashMap<K,V>	LinkedHashMap.ofEntries(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(Iterable<? extends Tuple2<? extends K, ? extends V2>> entries)	Creates a LinkedHashMultimap of the given entries.
static <K extends Comparable<? super K>, V> TreeMap<K,V>	TreeMap.ofEntries(Iterable<? extends Tuple2<? extends K, ? extends V>> entries)	Creates a TreeMap of the given entries.
static <K,V> TreeMap<K,V>	TreeMap.ofEntries(Comparator<? super K> keyComparator, Iterable<? extends Tuple2<? extends K, ? extends V>> entries)	Creates a TreeMap of the given entries.
<K extends Comparable<? super K>, V2 extends V> TreeMultimap<K,V2>	TreeMultimap.Builder.ofEntries(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(Comparator<? super K> keyComparator, Iterable<? extends Tuple2<? extends K, ? extends V2>> entries)	Creates a TreeMultimap of the given entries.
HashMap<K,V>	HashMap.orElse(Iterable<? extends Tuple2<K,V>> other)
HashMap<K,V>	HashMap.orElse(Supplier<? extends Iterable<? extends Tuple2<K,V>>> supplier)
LinkedHashMap<K,V>	LinkedHashMap.orElse(Iterable<? extends Tuple2<K,V>> other)
LinkedHashMap<K,V>	LinkedHashMap.orElse(Supplier<? extends Iterable<? extends Tuple2<K,V>>> supplier)
Map<K,V>	Map.orElse(Iterable<? extends Tuple2<K,V>> other)
Map<K,V>	Map.orElse(Supplier<? extends Iterable<? extends Tuple2<K,V>>> supplier)
Multimap<K,V>	Multimap.orElse(Iterable<? extends Tuple2<K,V>> other)
Multimap<K,V>	Multimap.orElse(Supplier<? extends Iterable<? extends Tuple2<K,V>>> supplier)
SortedMap<K,V>	SortedMap.orElse(Iterable<? extends Tuple2<K,V>> other)
SortedMap<K,V>	SortedMap.orElse(Supplier<? extends Iterable<? extends Tuple2<K,V>>> supplier)
SortedMultimap<K,V>	SortedMultimap.orElse(Iterable<? extends Tuple2<K,V>> other)
SortedMultimap<K,V>	SortedMultimap.orElse(Supplier<? extends Iterable<? extends Tuple2<K,V>>> supplier)
TreeMap<K,V>	TreeMap.orElse(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(Supplier<? extends 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<HashMap<K,V>, HashMap<K,V>>	HashMap.partition(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<LinkedHashMap<K,V>, LinkedHashMap<K,V>>	LinkedHashMap.partition(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends Map<K,V>, ? extends Map<K,V>>	Map.partition(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends Multimap<K,V>, ? extends Multimap<K,V>>	Multimap.partition(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends SortedMap<K,V>, ? extends SortedMap<K,V>>	SortedMap.partition(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends SortedMultimap<K,V>, ? extends SortedMultimap<K,V>>	SortedMultimap.partition(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<TreeMap<K,V>, TreeMap<K,V>>	TreeMap.partition(Predicate<? super Tuple2<K,V>> predicate)
HashMap<K,V>	HashMap.peek(Consumer<? super Tuple2<K,V>> action)
LinkedHashMap<K,V>	LinkedHashMap.peek(Consumer<? super Tuple2<K,V>> action)
Map<K,V>	Map.peek(Consumer<? super Tuple2<K,V>> action)
Multimap<K,V>	Multimap.peek(Consumer<? super Tuple2<K,V>> action)
SortedMap<K,V>	SortedMap.peek(Consumer<? super Tuple2<K,V>> action)
SortedMultimap<K,V>	SortedMultimap.peek(Consumer<? super Tuple2<K,V>> action)
TreeMap<K,V>	TreeMap.peek(Consumer<? super Tuple2<K,V>> action)
HashMap<K,V>	HashMap.reject(Predicate<? super Tuple2<K,V>> predicate)
LinkedHashMap<K,V>	LinkedHashMap.reject(Predicate<? super Tuple2<K,V>> predicate)
Map<K,V>	Map.reject(Predicate<? super Tuple2<K,V>> predicate)
Multimap<K,V>	Multimap.reject(Predicate<? super Tuple2<K,V>> predicate)
SortedMap<K,V>	SortedMap.reject(Predicate<? super Tuple2<K,V>> predicate)
SortedMultimap<K,V>	SortedMultimap.reject(Predicate<? super Tuple2<K,V>> predicate)
TreeMap<K,V>	TreeMap.reject(Predicate<? super Tuple2<K,V>> predicate)
HashMap<K,V>	HashMap.retainAll(Iterable<? extends Tuple2<K,V>> elements)
LinkedHashMap<K,V>	LinkedHashMap.retainAll(Iterable<? extends Tuple2<K,V>> elements)
Map<K,V>	Map.retainAll(Iterable<? extends Tuple2<K,V>> elements)
Multimap<K,V>	Multimap.retainAll(Iterable<? extends Tuple2<K,V>> elements)
SortedMap<K,V>	SortedMap.retainAll(Iterable<? extends Tuple2<K,V>> elements)
SortedMultimap<K,V>	SortedMultimap.retainAll(Iterable<? extends Tuple2<K,V>> elements)
TreeMap<K,V>	TreeMap.retainAll(Iterable<? extends Tuple2<K,V>> elements)
HashMap<K,V>	HashMap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
HashMap<K,V>	HashMap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
HashMap<K,V>	HashMap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
LinkedHashMap<K,V>	LinkedHashMap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
LinkedHashMap<K,V>	LinkedHashMap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
LinkedHashMap<K,V>	LinkedHashMap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
Map<K,V>	Map.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
Map<K,V>	Map.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
Map<K,V>	Map.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
Multimap<K,V>	Multimap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
Multimap<K,V>	Multimap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
Multimap<K,V>	Multimap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
SortedMap<K,V>	SortedMap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
SortedMap<K,V>	SortedMap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
SortedMap<K,V>	SortedMap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
SortedMultimap<K,V>	SortedMultimap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
SortedMultimap<K,V>	SortedMultimap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
SortedMultimap<K,V>	SortedMultimap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
TreeMap<K,V>	TreeMap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
TreeMap<K,V>	TreeMap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
TreeMap<K,V>	TreeMap.scan(Tuple2<K,V> zero, BiFunction<? super Tuple2<K,V>, ? super Tuple2<K,V>, ? extends Tuple2<K,V>> operation)
default <U> Seq<U>	Map.scanLeft(U zero, BiFunction<? super U, ? super Tuple2<K,V>, ? extends U> operation)
default <U> Seq<U>	Multimap.scanLeft(U zero, BiFunction<? super U, ? super Tuple2<K,V>, ? extends U> operation)
default <U> Seq<U>	Map.scanRight(U zero, BiFunction<? super Tuple2<K,V>, ? super U, ? extends U> operation)
default <U> Seq<U>	Multimap.scanRight(U zero, BiFunction<? super Tuple2<K,V>, ? super U, ? extends U> operation)
Iterator<HashMap<K,V>>	HashMap.slideBy(Function<? super Tuple2<K,V>, ?> classifier)
Iterator<LinkedHashMap<K,V>>	LinkedHashMap.slideBy(Function<? super Tuple2<K,V>, ?> classifier)
Iterator<? extends Map<K,V>>	Map.slideBy(Function<? super Tuple2<K,V>, ?> classifier)
Iterator<? extends Multimap<K,V>>	Multimap.slideBy(Function<? super Tuple2<K,V>, ?> classifier)
Iterator<? extends SortedMap<K,V>>	SortedMap.slideBy(Function<? super Tuple2<K,V>, ?> classifier)
Iterator<? extends SortedMultimap<K,V>>	SortedMultimap.slideBy(Function<? super Tuple2<K,V>, ?> classifier)
Iterator<TreeMap<K,V>>	TreeMap.slideBy(Function<? super Tuple2<K,V>, ?> classifier)
Tuple2<HashMap<K,V>, HashMap<K,V>>	HashMap.span(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<LinkedHashMap<K,V>, LinkedHashMap<K,V>>	LinkedHashMap.span(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends Map<K,V>, ? extends Map<K,V>>	Map.span(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends Multimap<K,V>, ? extends Multimap<K,V>>	Multimap.span(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends SortedMap<K,V>, ? extends SortedMap<K,V>>	SortedMap.span(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<? extends SortedMultimap<K,V>, ? extends SortedMultimap<K,V>>	SortedMultimap.span(Predicate<? super Tuple2<K,V>> predicate)
Tuple2<TreeMap<K,V>, TreeMap<K,V>>	TreeMap.span(Predicate<? super Tuple2<K,V>> predicate)
static <K,V> HashMap<K,V>	HashMap.tabulate(int n, Function<? super 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, Function<? super 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, Function<? super 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, Function<? super 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 Comparable<? super K>, V> TreeMap<K,V>	TreeMap.tabulate(int n, Function<? super 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(Comparator<? super K> keyComparator, int n, Function<? super 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 Comparable<? super K>, V2 extends V> TreeMultimap<K,V2>	TreeMultimap.Builder.tabulate(int n, Function<? super 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(Comparator<? super K> keyComparator, int n, Function<? super 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.
HashMap<K,V>	HashMap.takeUntil(Predicate<? super Tuple2<K,V>> predicate)
LinkedHashMap<K,V>	LinkedHashMap.takeUntil(Predicate<? super Tuple2<K,V>> predicate)
Map<K,V>	Map.takeUntil(Predicate<? super Tuple2<K,V>> predicate)
Multimap<K,V>	Multimap.takeUntil(Predicate<? super Tuple2<K,V>> predicate)
SortedMap<K,V>	SortedMap.takeUntil(Predicate<? super Tuple2<K,V>> predicate)
SortedMultimap<K,V>	SortedMultimap.takeUntil(Predicate<? super Tuple2<K,V>> predicate)
TreeMap<K,V>	TreeMap.takeUntil(Predicate<? super Tuple2<K,V>> predicate)
HashMap<K,V>	HashMap.takeWhile(Predicate<? super Tuple2<K,V>> predicate)
LinkedHashMap<K,V>	LinkedHashMap.takeWhile(Predicate<? super Tuple2<K,V>> predicate)
Map<K,V>	Map.takeWhile(Predicate<? super Tuple2<K,V>> predicate)
Multimap<K,V>	Multimap.takeWhile(Predicate<? super Tuple2<K,V>> predicate)
SortedMap<K,V>	SortedMap.takeWhile(Predicate<? super Tuple2<K,V>> predicate)
SortedMultimap<K,V>	SortedMultimap.takeWhile(Predicate<? super Tuple2<K,V>> predicate)
TreeMap<K,V>	TreeMap.takeWhile(Predicate<? super Tuple2<K,V>> predicate)
static <T> Array<T>	Array.unfold(T seed, Function<? super T, Option<Tuple2<? extends T, ? extends T>>> f)	Creates an Array from a seed value and a function.
static CharSeq	CharSeq.unfold(Character seed, Function<? super Character, Option<Tuple2<? extends Character, ? extends Character>>> f)	Creates a CharSeq from a seed value and a function.
static <T> Iterator<T>	Iterator.unfold(T seed, Function<? super T, Option<Tuple2<? extends T, ? extends T>>> f)	Creates an iterator from a seed value and a function.
static <T> List<T>	List.unfold(T seed, 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, 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, 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, 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, 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, Function<? super T, Option<Tuple2<? extends T, ? extends Character>>> f)	Creates a CharSeq from a seed value and a function.
static <T,U> Iterator<U>	Iterator.unfoldLeft(T seed, Function<? super T, Option<Tuple2<? extends T, ? extends U>>> f)	Creates an iterator from a seed value and a function.
static <T,U> List<U>	List.unfoldLeft(T seed, 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, 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, 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, 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, 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, Function<? super T, Option<Tuple2<? extends Character, ? extends T>>> f)	Creates a CharSeq from a seed value and a function.
static <T,U> Iterator<U>	Iterator.unfoldRight(T seed, Function<? super T, Option<Tuple2<? extends U, ? extends T>>> f)	Creates an iterator from a seed value and a function.
static <T,U> List<U>	List.unfoldRight(T seed, Function<? super T, 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, 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, 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, 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(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
default <T1,T2> Tuple2<TreeSet<T1>, TreeSet<T2>>	BitSet.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<IndexedSeq<T1>, IndexedSeq<T2>>	CharSeq.unzip(Function<? super Character, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<HashSet<T1>, HashSet<T2>>	HashSet.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<? extends IndexedSeq<T1>, ? extends IndexedSeq<T2>>	IndexedSeq.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
default <T1,T2> Tuple2<Iterator<T1>, Iterator<T2>>	Iterator.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<? extends LinearSeq<T1>, ? extends LinearSeq<T2>>	LinearSeq.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<LinkedHashSet<T1>, LinkedHashSet<T2>>	LinkedHashSet.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
default <T1,T2> Tuple2<List<T1>,List<T2>>	List.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Map.unzip(BiFunction<? super K, ? super V, Tuple2<? extends T1, ? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Map.unzip(Function<? super Tuple2<K,V>, Tuple2<? extends T1, ? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Map.unzip(Function<? super Tuple2<K,V>, Tuple2<? extends T1, ? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Multimap.unzip(BiFunction<? super K, ? super V, Tuple2<? extends T1, ? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Multimap.unzip(Function<? super Tuple2<K,V>, Tuple2<? extends T1, ? extends T2>> unzipper)
default <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	Multimap.unzip(Function<? super Tuple2<K,V>, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<? extends PriorityQueue<T1>, ? extends PriorityQueue<T2>>	PriorityQueue.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<Queue<T1>, Queue<T2>>	Queue.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<? extends Seq<T1>, ? extends Seq<T2>>	Seq.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<? extends Set<T1>, ? extends Set<T2>>	Set.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<? extends SortedSet<T1>, ? extends SortedSet<T2>>	SortedSet.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
default <T1,T2> Tuple2<Stream<T1>, Stream<T2>>	Stream.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<? extends Traversable<T1>, ? extends Traversable<T2>>	Traversable.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)	Unzips this elements by mapping this elements to pairs which are subsequently split into two distinct sets.
default <T1,T2> Tuple2<Tree<T1>,Tree<T2>>	Tree.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<TreeSet<T1>, TreeSet<T2>>	TreeSet.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
<T1,T2> Tuple2<Vector<T1>, Vector<T2>>	Vector.unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Map.unzip3(Function<? super Tuple2<K,V>, Tuple3<? extends T1, ? extends T2, ? extends T3>> unzipper)
default <T1,T2,T3> Tuple3<Seq<T1>,Seq<T2>,Seq<T3>>	Multimap.unzip3(Function<? super Tuple2<K,V>, Tuple3<? extends T1, ? extends T2, ? extends T3>> unzipper)
default <U,R> Seq<R>	Map.zipWith(Iterable<? extends U> that, BiFunction<? super Tuple2<K,V>, ? super U, ? extends R> mapper)
default <U,R> Seq<R>	Multimap.zipWith(Iterable<? extends U> that, BiFunction<? super Tuple2<K,V>, ? super U, ? extends R> mapper)
default <U> Seq<U>	Map.zipWithIndex(BiFunction<? super Tuple2<K,V>, ? super Integer, ? extends U> mapper)
default <U> Seq<U>	Multimap.zipWithIndex(BiFunction<? super Tuple2<K,V>, ? super Integer, ? extends U> mapper)

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(Future<? extends U> that)	Returns a tuple of this and that Future result.

Uses of Tuple2 in io.vavr.test

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

Modifier and Type	Method	Description
static <T> Gen<T>	Gen.frequency(Tuple2<Integer,Gen<T>>... generators)	Chooses one of the given generators according to their frequency.

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

Modifier and Type	Method	Description
static <T> Gen<T>	Gen.frequency(Iterable<Tuple2<Integer,Gen<T>>> generators)	Chooses one of the given generators according to their frequency.