collection
library
Classes

BoolList

A spaceefficient list of boolean values.

CanonicalizedMap<C, K, V>

A map whose keys are converted to canonical values of type
C
.

CaseInsensitiveEquality

String equality that's insensitive to differences in ASCII case.

CombinedIterableView<T>

A view of several iterables combined sequentially into a single iterable.

CombinedListView<T>

A view of several lists combined into a single list.

CombinedMapView<K, V>

Returns a new map that represents maps flattened into a single map.

DeepCollectionEquality

Deep equality on collections.

DefaultEquality<E>

Equality of objects that compares only the natural equality of the objects.

DelegatingIterable<E>

An Iterable that delegates all operations to a base iterable.

DelegatingList<E>

A List that delegates all operations to a base list.

DelegatingMap<K, V>

A Map that delegates all operations to a base map.

DelegatingQueue<E>

A Queue that delegates all operations to a base queue.

DelegatingSet<E>

A Set that delegates all operations to a base set.

Equality<E>

A generic equality relation on objects.

EqualityBy<E, F>

Equality of objects based on derived values.

EqualityMap<K, V>

A Map whose key equality is determined by an Equality object.

EqualitySet<E>

A Set whose key equality is determined by an Equality object.

HeapPriorityQueue<E>

Heap based priority queue.

IdentityEquality<E>

Equality of objects that compares only the identity of the objects.

IterableEquality<E>

Equality on iterables.

IterableZip<T>

Iterable that iterates over lists of values from other iterables.

ListEquality<E>

Equality on lists.

ListSlice<E>

A list view of a range of another list.

MapEquality<K, V>

Equality on maps.

MapKeySet<E>

An unmodifiable Set view of the keys of a Map.

MapValueSet<K, V>

Creates a modifiable Set view of the values of a Map.

MultiEquality<E>

Combines several equalities into a single equality.

NonGrowableListMixin<E>

Mixin class that implements a throwing version of all list operations that
change the List's length.

NonGrowableListView<E>

A fixedlength list.

PriorityQueue<E>

A priority queue is a priority based worklist of elements.

QueueList<E>

A class that efficiently implements both Queue and List.

SetEquality<E>

Equality of sets.

UnionSet<E>

A single set that provides a view of the union over a set of sets.

UnionSetController<E>

A controller that exposes a view of the union of a collection of sets.

UnmodifiableListView<E>

An unmodifiable List view of another List.

UnmodifiableMapMixin<K, V>

Mixin class that implements a throwing version of all map operations that
change the Map.

UnmodifiableMapView<K, V>

View of a Map that disallow modifying the map.

UnmodifiableSetMixin<E>

Mixin class that implements a throwing version of all set operations that
change the Set.

UnmodifiableSetView<E>

An unmodifiable set.

UnorderedIterableEquality<E>

Equality of the elements of two iterables without considering order.
Functions

binarySearch<E>(List<E> sortedList, E value, {int compare(E, E)?})
→ int

Returns a position of the
value
in sortedList
, if it is there.

compareAsciiLowerCase(String a, String b)
→ int

Compares
a
and b
lexically, converting ASCII letters to lower case.

compareAsciiLowerCaseNatural(String a, String b)
→ int

Compares strings
a
and b
according to lowercase
natural sort ordering.

compareAsciiUpperCase(String a, String b)
→ int

Compares
a
and b
lexically, converting ASCII letters to upper case.

compareAsciiUpperCaseNatural(String a, String b)
→ int

Compares strings
a
and b
according to uppercase
natural sort ordering.

compareNatural(String a, String b)
→ int

Compares strings
a
and b
according to natural sort ordering.

equalsIgnoreAsciiCase(String a, String b)
→ bool

Checks if strings
a
and b
differ only on the case of ASCII letters.

groupBy<S, T>(Iterable<S> values, T key(S))
→ Map<T, List<S>>

Groups the elements in
values
by the value returned by key
.

hashIgnoreAsciiCase(String string)
→ int

Hash code for a string which is compatible with equalsIgnoreAsciiCase.

insertionSort<E>(List<E> elements, {int compare(E, E)?, int start = 0, int? end})
→ void

Sort a list between
start
(inclusive) and end
(exclusive) using
insertion sort.

lastBy<S, T>(Iterable<S> values, T key(S))
→ Map<T, S>

Associates the elements in
values
by the value returned by key
.

lowerBound<E>(List<E> sortedList, E value, {int compare(E, E)?})
→ int

Returns the first position in
sortedList
that does not compare less than
value
.

mapMap<K1, V1, K2, V2>(Map<K1, V1> map, {K2 key(K1, V1)?, V2 value(K1, V1)?})
→ Map<K2, V2>

Creates a new map from
map
with new keys and values.

maxBy<S, T>(Iterable<S> values, T orderBy(S), {int compare(T, T)?})
→ S?

Returns the element of
values
for which orderBy
returns the maximum
value.

mergeMaps<K, V>(Map<K, V> map1, Map<K, V> map2, {V value(V, V)?})
→ Map<K, V>

Returns a new map with all key/value pairs in both
map1
and map2
.

mergeSort<E>(List<E> elements, {int start = 0, int? end, int compare(E, E)?})
→ void

Sorts a list between
start
(inclusive) and end
(exclusive) using the
merge sort algorithm.

minBy<S, T>(Iterable<S> values, T orderBy(S), {int compare(T, T)?})
→ S?

Returns the element of
values
for which orderBy
returns the minimum
value.

reverse<E>(List<E> elements, [int start = 0, int? end])
→ void

Reverses a list, or a part of a list, inplace.

shuffle(List elements, [int start = 0, int? end, Random? random])
→ void

Shuffles a list randomly.

stronglyConnectedComponents<T>(Map<T, Iterable<T>> graph)
→ List<Set<T>>

Returns the strongly connected components of
graph
, in topological
order.

transitiveClosure<T>(Map<T, Iterable<T>> graph)
→ Map<T, Set<T>>

Returns the transitive closure of
graph
.