Index of modules

• RevIter

  Reversible Iterator

  This type of iterator allows for both forward and backward iteration Reversible Iterators are useful for iterating over data structures in reverse without allocating extra space for the reverse iteration.

  The RevIter type is an extension of the Iter type built in Motoko so it is compatible with all the function defined for the Iter type.

  The RevIter is intended to be used with functions for the Iter type to avoid rewriting similar functions for both types.

  • An example reversing a list of integers and breaking them into chunks of size n:

  
    import Itertools "mo:itertools/Iter";
    import RevIter "mo:itertools/RevIter";
  
    let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  
    // create a Reversible Iterator from an array
    let iter = RevIter.fromArray(arr);
  
    // reverse iterator
    let rev_iter = iter.rev();
  
    // Reversible Iterator gets typecasted to an Iter type
    let chunks = Itertools.chunks(revRevIter, 3);
  
    assert chunks.next() == ?[10, 9, 8];
    assert chunks.next() == ?[7, 6, 5];
    assert chunks.next() == ?[4, 3, 2];
    assert chunks.next() == ?[1];
    assert chunks.next() == null;
  
  

• Iter

  Main module with utility functions for working efficiently with iterators.

  See the Iter module from the base lib for more information on the Iter type.

  Getting started

  To get started, you'll need to import the Iter module from both the base library and this one.

      import Iter "mo:base/Iter";
      import Itertools "mo:itertools/Iter";

  Converting data types to iterators is the next step.

  • Array
    • [1, 2, 3, 4, 5].vals()
    • Iter.fromArray([1, 2, 3, 4, 5])
  • List
    • Iter.fromList(list)
  • Text
    • "Hello, world!".chars()
    • Text.split("a,b,c", #char ',')
  • Buffer
    • Buffer.toArray(buffer).vals()
  • HashMap
    • map.entries()

  For conversion of other data types to iterators, you can look in the base library for the specific data type's documentation.

  Here are some examples of using the functions in this library to create simple and efficient iterators for solving different problems:

  • An example, using range and sum to find the sum of values from 1 to 25:

      let range = Itertools.range(1, 25 + 1);
      let sum = Itertools.sum(range, Nat.add);
  
      assert sum == ?325;

  • An example, using multiple functions to retrieve the indices of all even numbers in an array:

      let vals = [1, 2, 3, 4, 5, 6].vals();
      let iterWithIndices = Itertools.enumerate(vals);
  
      let isEven = func ( x : (Int, Int)) : Bool { x.1 % 2 == 0 };
      let mapIndex = func (x : (Int, Int)) : Int { x.0 };
      let evenIndices = Itertools.mapFilter(iterWithIndices, isEven, mapIndex);
  
      assert Iter.toArray(evenIndices) == [1, 3, 5];

  • An example to find the difference between consecutive elements in an array:

      let vals = [5, 3, 3, 7, 8, 10].vals();
  
      let tuples = Itertools.slidingTuples(vals);
      // Iter.toArray(tuples) == [(5, 3), (3, 3), (3, 7), (7, 8), (8, 10)]
  
      let diff = func (x : (Int, Int)) : Int { x.1 - x.0 };
      let iter = Iter.map(tuples, diff);
  
      assert Iter.toArray(iter) == [-2, 0, 4, 1, 2];

• PeekableIter

  Peekable Iterator

  An iterator equipped with a peek method that returns the next value without advancing the iterator.

  The PeekableIter type is an extension of the Iter type built in Motoko so it is compatible with all the function defined for the Iter type.

• Utils/ArrayMut
• Utils/Deque
• Utils/Nat
• Utils/TrieMap