Returns a new map identical to this except that the value it possibly binds to key has been adjusted by update.

{'a': 1, 'b': 2}.adjust('b', (x) => x + 1) == {'a', 1, 'b', 3}
{'a': 1}.adjust('b', (x) => x + 1) == {'a', 1}

bool any(bool f(E element)) {
 for (E element in this) {
   if (f(element)) return true;
 }
 return false;
}

Returns a new map identical to this except that it doesn't bind key anymore.

{'a': 1, 'b': 2}.delete('b') == {'a': 1}
{'a': 1}.delete('b') == {'a': 1}

E elementAt(int index) {
 if (index is! int || index < 0) throw new RangeError.value(index);
 int remaining = index;
 for (E element in this) {
   if (remaining == 0) return element;
   remaining--;
 }
 throw new RangeError.value(index);
}

bool every(bool f(E element)) {
 for (E element in this) {
   if (!f(element)) return false;
 }
 return true;
}

Iterable expand(Iterable f(E element)) =>
   new ExpandIterable<E, dynamic>(this, f);

dynamic firstWhere(bool test(E value), { Object orElse() }) {
 for (E element in this) {
   if (test(element)) return element;
 }
 if (orElse != null) return orElse();
 throw new StateError("No matching element");
}

iterable.fold(0, (prev, element) => prev + element);

dynamic fold(var initialValue,
            dynamic combine(var previousValue, E element)) {
 var value = initialValue;
 for (E element in this) value = combine(value, element);
 return value;
}

void forEach(void f(E element)) {
 for (E element in this) f(element);
}

Evaluates f(key, value) for each (key, value) pair in this.

Returns a new map identical to this except that it binds key to value.

If key was bound to some oldvalue in this, it is nevertheless bound to value in the new map. If key was bound to some oldvalue in this and if combine is provided then key it is bound to combine(oldvalue, value) in the new map.

{'a': 1}.insert('b', 2) == {'a': 1, 'b', 2}
{'a': 1, 'b': 2}.insert('b', 3) == {'a': 3, 'b', 3}
{'a': 1, 'b': 2}.insert('b', 3, (x,y) => x - y) == {'a': 3, 'b', -1}

Returns a new map whose (key, value) pairs are the intersection of those of this and other.

The intersection is right-biased: values from other are retained. If combine is provided, the retained value for a key present in both this and other is then combine(leftvalue, rightvalue) where leftvalue is the value bound to key in this and rightvalue is the one bound to key in other.

{'a': 1}.intersection({'b': 2}) == {}
{'a': 1}.intersection({'a': 3, 'b': 2}) == {'a': 3}
{'a': 1}.intersection({'a': 3, 'b': 2}, (x,y) => x + y) == {'a': 4}

Note that intersection is commutative if and only if combine is provided and if it is commutative.

String join([String separator = ""]) {
 Iterator<E> iterator = this.iterator;
 if (!iterator.moveNext()) return "";
 StringBuffer buffer = new StringBuffer();
 if (separator == null || separator == "") {
   do {
     buffer.write("${iterator.current}");
   } while (iterator.moveNext());
 } else {
   buffer.write("${iterator.current}");
   while (iterator.moveNext()) {
     buffer.write(separator);
     buffer.write("${iterator.current}");
   }
 }
 return buffer.toString();
}

dynamic lastWhere(bool test(E value), { Object orElse() }) {
 E result = null;
 bool foundMatching = false;
 for (E element in this) {
   if (test(element)) {
     result = element;
     foundMatching = true;
   }
 }
 if (foundMatching) return result;
 if (orElse != null) return orElse();
 throw new StateError("No matching element");
}

Looks up the value possibly bound to key in this. Returns Option.some(value) if it exists, Option.none() otherwise.

{'a': 1}.lookup('b') == Option.none()
{'a': 1, 'b': 2}.lookup('b') == Option.some(2)

Iterable map(f(E element)) => new MappedIterable<E, dynamic>(this, f);

Returns a new map identical to this where each value has been updated by f.

{'a': 1, 'b': 2}.mapValues((x) => x + 1) == {'a', 2, 'b', 3}
{}.mapValues((x) => x + 1) == {}

iterable.reduce((value, element) => value + element);

E reduce(E combine(E value, E element)) {
 Iterator<E> iterator = this.iterator;
 if (!iterator.moveNext()) {
   throw new StateError("No elements");
 }
 E value = iterator.current;
 while (iterator.moveNext()) {
   value = combine(value, iterator.current);
 }
 return value;
}

E singleWhere(bool test(E value)) {
 E result = null;
 bool foundMatching = false;
 for (E element in this) {
   if (test(element)) {
     if (foundMatching) {
       throw new StateError("More than one matching element");
     }
     result = element;
     foundMatching = true;
   }
 }
 if (foundMatching) return result;
 throw new StateError("No matching element");
}

Iterable<E> skip(int n) {
 return new SkipIterable<E>(this, n);
}

Iterable<E> skipWhile(bool test(E value)) {
 return new SkipWhileIterable<E>(this, test);
}

Iterable<E> take(int n) {
 return new TakeIterable<E>(this, n);
}

Iterable<E> takeWhile(bool test(E value)) {
 return new TakeWhileIterable<E>(this, test);
}

List<E> toList({ bool growable: true }) =>
   new List<E>.from(this, growable: growable);

Set<E> toSet() => new Set<E>.from(this);

Returns a new map whose (key, value) pairs are the union of those of this and other.

The union is right-biased: if a key is present in both this and other, the value from other is retained. If combine is provided, the retained value for a key present in both this and other is then combine(leftvalue, rightvalue) where leftvalue is the value bound to key in this and rightvalue is the one bound to key in other.

{'a': 1}.union({'b': 2}) == {'a': 1, 'b': 2}
{'a': 1}.union({'a': 3, 'b': 2}) == {'a': 3, 'b': 2}
{'a': 1}.union({'a': 3, 'b': 2}, (x,y) => x + y) == {'a': 4, 'b': 2}

Note that union is commutative if and only if combine is provided and if it is commutative.

Iterable<E> where(bool f(E element)) => new WhereIterable<E>(this, f);