Uses of Interface
io.vavr.collection.Foldable

Packages that use Foldable

Package	Description
io.vavr.collection	Purely functional collections based on Traversable.

Uses of Foldable in io.vavr.collection

Subinterfaces of Foldable in io.vavr.collection

Modifier and Type	Interface	Description
interface	BitSet<T>	An immutable BitSet implementation.
interface	IndexedSeq<T>	Interface for immutable, indexed sequences.
interface	Iterator<T>	io.vavr.collection.Iterator is a compositional replacement for java.util.Iterator whose purpose is to iterate once over a sequence of elements.
interface	LinearSeq<T>	Interface for immutable, linear sequences.
interface	List<T>	An immutable List is an eager sequence of elements.
interface	Map<K,V>	An immutable Map interface.
interface	Multimap<K,V>	An immutable Multimap interface.
interface	Seq<T>	Interface for immutable sequential data structures.
interface	Set<T>	An immutable Set interface.
interface	SortedMap<K,V>	An immutable SortedMap interface.
interface	SortedMultimap<K,V>	An immutable SortedMultimap interface.
interface	SortedSet<T>	An immutable SortedSet interface.
interface	Stream<T>	An immutable Stream is lazy sequence of elements which may be infinitely long.
interface	Traversable<T>	An interface for inherently recursive, multi-valued data structures.
interface	Tree<T>	A general Tree interface.

Classes in io.vavr.collection that implement Foldable

Modifier and Type	Class	Description
(package private) class	AbstractIterator<T>	Provides a common Object.toString() implementation.
(package private) class	AbstractMultimap<K, V, M extends Multimap<K,V>>	An Multimap implementation (not intended to be public).
(package private) class	AbstractQueue<T, Q extends AbstractQueue<T,Q>>
final class	Array<T>	Array is a Traversable wrapper for Object[] containing elements of type T.
static class	BitSetModule.AbstractBitSet<T>
static class	BitSetModule.BitSet1<T>
static class	BitSetModule.BitSet2<T>
static class	BitSetModule.BitSetIterator<T>
static class	BitSetModule.BitSetN<T>
final class	CharSeq	The CharSeq (read: character sequence) collection essentially is a rich String wrapper having all operations we know from the functional Vavr collections.
static class	HashArrayMappedTrieModule.LeafNodeIterator<K,V>
final class	HashMap<K,V>	An immutable HashMap implementation based on a Hash array mapped trie (HAMT).
final class	HashMultimap<K,V>	A HashMap-based implementation of Multimap
final class	HashSet<T>	An immutable HashSet implementation.
static final class	IteratorModule.CachedIterator<T>
static final class	IteratorModule.ConcatIterator<T>
static final class	IteratorModule.DistinctIterator<T,U>
static final class	IteratorModule.EmptyIterator
static final class	IteratorModule.GroupedIterator<T>
final class	LinkedHashMap<K,V>	An immutable LinkedHashMap implementation that has predictable (insertion-order) iteration.
final class	LinkedHashMultimap<K,V>	A LinkedHashMap-based implementation of Multimap
final class	LinkedHashSet<T>	An immutable HashSet implementation that has predictable (insertion-order) iteration.
static final class	List.Cons<T>	Non-empty List, consisting of a head and a tail.
static final class	List.Nil<T>	Representation of the singleton empty List.
final class	PriorityQueue<T>	A PriorityQueue.
final class	Queue<T>	An immutable Queue stores elements allowing a first-in-first-out (FIFO) retrieval.
static class	Stream.Cons<T>	Non-empty Stream, consisting of a head, and tail.
static final class	Stream.Empty<T>	The empty Stream.
static final class	StreamModule.AppendElements<T>
static final class	StreamModule.ConsImpl<T>
static final class	StreamModule.FlatMapIterator<T,U>
static final class	StreamModule.StreamIterator<T>
static final class	Tree.Empty<T>	The empty tree.
static final class	Tree.Node<T>	Represents a tree node.
final class	TreeMap<K,V>	SortedMap implementation, backed by a Red/Black Tree.
final class	TreeMultimap<K,V>	A TreeMap-based implementation of Multimap
final class	TreeSet<T>	SortedSet implementation, backed by a Red/Black Tree.
final class	Vector<T>	Vector is the default Seq implementation that provides effectively constant time access to any element.