ic-mops 0.8.5 → 0.8.7

package/.mops/base@0.8.3/src/Iter.mo

@@ -1,227 +0,0 @@
-/// Iterators
-
-import Array "Array";
-import Buffer "Buffer";
-import List "List";
-import Order "Order";
-
-module {
-
-  /// 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 type Iter<T> = { next : () -> ?T };
-
-  /// Creates an iterator that produces all `Nat`s from `x` to `y` including
-  /// both of the bounds.
-  /// ```motoko
-  /// import Iter "mo:base/Iter";
-  /// let iter = Iter.range(1, 3);
-  /// assert(?1 == iter.next());
-  /// assert(?2 == iter.next());
-  /// assert(?3 == iter.next());
-  /// assert(null == iter.next());
-  /// ```
-  public class range(x : Nat, y : Int) {
-    var i = x;
-    public func next() : ?Nat {
-      if (i > y) { null } else { let j = i; i += 1; ?j }
-    }
-  };
-
-  /// Like `range` but produces the values in the opposite
-  /// order.
-  public class revRange(x : Int, y : Int) {
-    var i = x;
-    public func next() : ?Int {
-      if (i < y) { null } else { let j = i; i -= 1; ?j }
-    }
-  };
-
-  /// 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.
-  ///
-  /// ```motoko
-  /// import Iter "mo:base/Iter";
-  /// var sum = 0;
-  /// Iter.iterate<Nat>(Iter.range(1, 3), func(x, _index) {
-  ///   sum += x;
-  /// });
-  /// assert(6 == sum)
-  /// ```
-  public func iterate<A>(
-    xs : Iter<A>,
-    f : (A, Nat) -> ()
-  ) {
-    var i = 0;
-    label l loop {
-      switch (xs.next()) {
-        case (?next) {
-          f(next, i)
-        };
-        case (null) {
-          break l
-        }
-      };
-      i += 1;
-      continue l
-    }
-  };
-
-  /// Consumes an iterator and counts how many elements were produced
-  /// (discarding them in the process).
-  public func size<A>(xs : Iter<A>) : Nat {
-    var len = 0;
-    iterate<A>(xs, func(x, i) { len += 1 });
-    len
-  };
-
-  /// Takes a function and an iterator and returns a new iterator that lazily applies
-  /// the function to every element produced by the argument iterator.
-  /// ```motoko
-  /// 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 map<A, B>(xs : Iter<A>, f : A -> B) : Iter<B> = object {
-    public func next() : ?B {
-      switch (xs.next()) {
-        case (?next) {
-          ?f(next)
-        };
-        case (null) {
-          null
-        }
-      }
-    }
-  };
-
-  /// 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.
-  /// ```motoko
-  /// import Iter "o: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 filter<A>(xs : Iter<A>, f : A -> Bool) : Iter<A> = object {
-    public func next() : ?A {
-      loop {
-        switch (xs.next()) {
-          case (null) {
-            return null
-          };
-          case (?x) {
-            if (f(x)) {
-              return ?x
-            }
-          }
-        }
-      };
-      null
-    }
-  };
-
-  /// Creates an iterator that produces an infinite sequence of `x`.
-  /// ```motoko
-  /// import Iter "mo:base/Iter";
-  /// let iter = Iter.make(10);
-  /// assert(?10 == iter.next());
-  /// assert(?10 == iter.next());
-  /// assert(?10 == iter.next());
-  /// // ...
-  /// ```
-  public func make<A>(x : A) : Iter<A> = object {
-    public func next() : ?A {
-      ?x
-    }
-  };
-
-  /// Creates an iterator that produces the elements of an Array in ascending index order.
-  /// ```motoko
-  /// 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 fromArray<A>(xs : [A]) : Iter<A> {
-    var ix : Nat = 0;
-    let size = xs.size();
-    object {
-      public func next() : ?A {
-        if (ix >= size) {
-          return null
-        } else {
-          let res = ?(xs[ix]);
-          ix += 1;
-          return res
-        }
-      }
-    }
-  };
-
-  /// 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 fromArrayMut<A>(xs : [var A]) : Iter<A> {
-    fromArray<A>(Array.freeze<A>(xs))
-  };
-
-  /// Like `fromArray` but for Lists.
-  public let fromList = List.toIter;
-
-  /// Consumes an iterator and collects its produced elements in an Array.
-  /// ```motoko
-  /// import Iter "mo:base/Iter";
-  /// let iter = Iter.range(1, 3);
-  /// assert([1, 2, 3] == Iter.toArray(iter));
-  /// ```
-  public func toArray<A>(xs : Iter<A>) : [A] {
-    let buffer = Buffer.Buffer<A>(8);
-    iterate(xs, func(x : A, ix : Nat) { buffer.add(x) });
-    return Buffer.toArray(buffer)
-  };
-
-  /// Like `toArray` but for Arrays with mutable elements.
-  public func toArrayMut<A>(xs : Iter<A>) : [var A] {
-    Array.thaw<A>(toArray<A>(xs))
-  };
-
-  /// Like `toArray` but for Lists.
-  public func toList<A>(xs : Iter<A>) : List.List<A> {
-    var result = List.nil<A>();
-    iterate<A>(
-      xs,
-      func(x, _i) {
-        result := List.push<A>(x, result)
-      }
-    );
-    List.reverse<A>(result)
-  };
-
-  /// Sorted iterator.  Will iterate over *all* elements to sort them, necessarily.
-  public func sort<A>(xs : Iter<A>, compare : (A, A) -> Order.Order) : Iter<A> {
-    let a = toArrayMut<A>(xs);
-    Array.sortInPlace<A>(a, compare);
-    fromArrayMut<A>(a)
-  };
-
-}

package/.mops/base@0.8.3/src/IterType.mo

@@ -1,7 +0,0 @@
-/// The Iterator type
-
-// Just here to break cyclic module definitions
-
-module {
-  public type Iter<T> = { next : () -> ?T }
-}