Iter

type Iter<T> = { next : () -> ?T }

An iterator that produces values of type T. Calling next returns null when iteration is finished.

Iterators are inherently stateful. Calling next "consumes" a value from the Iterator that cannot be put back, so keep that in mind when sharing iterators between consumers.

An iterater i can be iterated over using

for (x in i) {
  …do something with x…
}

public func empty<T>() : Iter<T>

public func singleton<T>(value : T) : Iter<T>

public func forEach<T>(xs : Iter<T>, f : (T) -> ())

Calls a function f on every value produced by an iterator and discards the results. If you're looking to keep these results use map instead.

import Iter "mo:base/Iter";
var sum = 0;
Iter.forEach<Nat>(Iter.range(1, 3), func(x) {
  sum += x;
});
assert(6 == sum)

public func enumerate<T>(xs : Iter<T>) : Iter<(Nat, T)>

Takes an iterator and returns a new iterator that pairs each element with its index. The index starts at 0 and increments by 1 for each element.

import Iter "mo:base/Iter";
let iter = Iter.fromArray(["A", "B", "C"]);
let enumerated = Iter.enumerate(iter);
assert(?(0, "A") == enumerated.next());
assert(?(1, "B") == enumerated.next());
assert(?(2, "C") == enumerated.next());
assert(null == enumerated.next());

public func size<T>(xs : Iter<T>) : Nat

Consumes an iterator and counts how many elements were produced (discarding them in the process).

public func map<T, R>(xs : Iter<T>, f : T -> R) : Iter<R>

Takes a function and an iterator and returns a new iterator that lazily applies the function to every element produced by the argument iterator.

import Iter "mo:base/Iter";
let iter = Iter.range(1, 3);
let mappedIter = Iter.map(iter, func (x : Nat) : Nat { x * 2 });
assert(?2 == mappedIter.next());
assert(?4 == mappedIter.next());
assert(?6 == mappedIter.next());
assert(null == mappedIter.next());

public func filter<T>(xs : Iter<T>, f : T -> Bool) : Iter<T>

Takes a function and an iterator and returns a new iterator that produces elements from the original iterator if and only if the predicate is true.

import Iter "mo:base/Iter";
let iter = Iter.range(1, 3);
let mappedIter = Iter.filter(iter, func (x : Nat) : Bool { x % 2 == 1 });
assert(?1 == mappedIter.next());
assert(?3 == mappedIter.next());
assert(null == mappedIter.next());

public func infinite<T>(item : T) : Iter<T>

Creates an iterator that produces an infinite sequence of x.

import Iter "mo:base/Iter";
let iter = Iter.make(10);
assert(?10 == iter.next());
assert(?10 == iter.next());
assert(?10 == iter.next());
// ...

public func concat<T>(a : Iter<T>, b : Iter<T>) : Iter<T>

Takes two iterators and returns a new iterator that produces elements from the original iterators sequentally.

import Iter "mo:base/Iter";
let iter1 = Iter.range(1, 2);
let iter2 = Iter.range(5, 6);
let concatenatedIter = Iter.concat(iter1, iter2);
assert(?1 == concatenatedIter.next());
assert(?2 == concatenatedIter.next());
assert(?5 == concatenatedIter.next());
assert(?6 == concatenatedIter.next());
assert(null == concatenatedIter.next());

public func fromArray<T>(xs : [T]) : Iter<T>

Creates an iterator that produces the elements of an Array in ascending index order.

import Iter "mo:base/Iter";
let iter = Iter.fromArray([1, 2, 3]);
assert(?1 == iter.next());
assert(?2 == iter.next());
assert(?3 == iter.next());
assert(null == iter.next());

public func fromVarArray<T>(xs : [var T]) : Iter<T>

Like fromArray but for Arrays with mutable elements. Captures the elements of the Array at the time the iterator is created, so further modifications won't be reflected in the iterator.

public func toArray<T>(iter : Iter<T>) : [T]

Consumes an iterator and collects its produced elements in an Array.

import Iter "mo:base/Iter";
let iter = Iter.range(1, 3);
assert([1, 2, 3] == Iter.toArray(iter));

public func toVarArray<T>(xs : Iter<T>) : [var T]

Like toArray but for Arrays with mutable elements.

public func sort<T>(xs : Iter<T>, compare : (T, T) -> Order.Order) : Iter<T>

Sorted iterator. Will iterate over all elements to sort them, necessarily.