ic-mops 0.8.5 → 0.8.7

package/.mops/base@0.7.4/src/Hash.mo

@@ -1,83 +0,0 @@
-/// Hash values
-
-import Prim "mo:⛔";
-import Iter "Iter";
-
-module {
-
-  /// Hash values represent a string of _hash bits_, packed into a `Nat32`.
-  public type Hash = Nat32;
-
-  /// The hash length, always 31.
-  public let length : Nat = 31; // Why not 32?
-
-  /// Project a given bit from the bit vector.
-  public func bit(h : Hash, pos : Nat) : Bool {
-    assert (pos <= length);
-    (h & (Prim.natToNat32(1) << Prim.natToNat32(pos))) != Prim.natToNat32(0)
-  };
-
-  /// Test if two hashes are equal
-  public func equal(ha : Hash, hb : Hash) : Bool {
-    ha == hb
-  };
-
-  /// Computes a hash from the least significant 32-bits of `n`, ignoring other bits.
-  /// @deprecated For large `Nat` values consider using a bespoke hash function that considers all of the argument's bits.
-  public func hash(n : Nat) : Hash {
-    let j = Prim.intToNat32Wrap(n);
-    hashNat8(
-      [j & (255 << 0),
-       j & (255 << 8),
-       j & (255 << 16),
-       j & (255 << 24)
-      ]);
-  };
-
-  /// @deprecated This function will be removed in future.
-  public func debugPrintBits(bits : Hash) {
-    for (j in Iter.range(0, length - 1)) {
-      if (bit(bits, j)) {
-        Prim.debugPrint("1")
-      } else {
-        Prim.debugPrint("0")
-      }
-    }
-  };
-
-  /// @deprecated This function will be removed in future.
-  public func debugPrintBitsRev(bits : Hash) {
-    for (j in Iter.revRange(length - 1, 0)) {
-      if (bit(bits, Prim.abs(j))) {
-        Prim.debugPrint("1")
-      } else {
-        Prim.debugPrint("0")
-      }
-    }
-  };
-
-
-  /// Jenkin's one at a time:
-  ///
-  /// https://en.wikipedia.org/wiki/Jenkins_hash_function#one_at_a_time
-  ///
-  /// The input type should actually be `[Nat8]`.
-  /// Note: Be sure to explode each `Nat8` of a `Nat32` into its own `Nat32`, and to shift into lower 8 bits.
-
-  // should this really be public?
-  // NB: Int.mo contains a local copy of hashNat8 (redefined to suppress the deprecation warning).
-  /// @deprecated This function may be removed or changed in future.
-  public func hashNat8(key : [Hash]) : Hash {
-    var hash : Nat32 = 0;
-    for (natOfKey in key.vals()) {
-      hash := hash +% natOfKey;
-      hash := hash +% hash << 10;
-      hash := hash ^ (hash >> 6);
-    };
-    hash := hash +% hash << 3;
-    hash := hash ^ (hash >> 11);
-    hash := hash +% hash << 15;
-    return hash;
-  };
-
-}

package/.mops/base@0.7.4/src/HashMap.mo

@@ -1,229 +0,0 @@
-/// Mutable hash map (aka Hashtable)
-///
-/// This module defines an imperative hash map (hash table), with a general key and value type.
-///
-/// It has a minimal object-oriented interface: `get`, `set`, `delete`, `count` and `entries`.
-///
-/// The class is parameterized by the key's equality and hash functions,
-/// and an initial capacity.  However, as with the `Buffer` class, no array allocation
-/// happens until the first `set`.
-///
-/// Internally, table growth policy is very simple, for now:
-///  Double the current capacity when the expected bucket list size grows beyond a certain constant.
-
-import Prim "mo:⛔";
-import P "Prelude";
-import A "Array";
-import Hash "Hash";
-import Iter "Iter";
-import AssocList "AssocList";
-import Nat32 "Nat32";
-
-module {
-
-
-  // hash field avoids re-hashing the key when the array grows.
-  type Key<K> = (Hash.Hash, K);
-
-  // key-val list type
-  type KVs<K, V> = AssocList.AssocList<Key<K>, V>;
-
-  /// An imperative HashMap with a minimal object-oriented interface.
-  /// Maps keys of type `K` to values of type `V`.
-  public class HashMap<K, V>(
-    initCapacity : Nat,
-    keyEq : (K, K) -> Bool,
-    keyHash : K -> Hash.Hash) {
-
-    var table : [var KVs<K, V>] = [var];
-    var _count : Nat = 0;
-
-    /// Returns the number of entries in this HashMap.
-    public func size() : Nat = _count;
-
-    /// Deletes the entry with the key `k`. Doesn't do anything if the key doesn't
-    /// exist.
-    public func delete(k : K) = ignore remove(k);
-
-    func keyHash_(k : K) : Key<K> = (keyHash(k), k);
-
-    func keyHashEq(k1 : Key<K>, k2 : Key<K>) : Bool { k1.0 == k2.0 and keyEq(k1.1, k2.1) };
-
-    /// Removes the entry with the key `k` and returns the associated value if it
-    /// existed or `null` otherwise.
-    public func remove(k : K) : ?V {
-      let m = table.size();
-      if (m > 0) {
-        let h = Prim.nat32ToNat(keyHash(k));
-        let pos = h % m;
-        let (kvs2, ov) = AssocList.replace<Key<K>, V>(table[pos], keyHash_(k), keyHashEq, null);
-        table[pos] := kvs2;
-        switch(ov){
-          case null { };
-          case _ { _count -= 1; }
-        };
-        ov
-      } else {
-        null
-      };
-    };
-
-    /// Gets the entry with the key `k` and returns its associated value if it
-    /// existed or `null` otherwise.
-    public func get(k : K) : ?V {
-      let h = Prim.nat32ToNat(keyHash(k));
-      let m = table.size();
-      let v = if (m > 0) {
-        AssocList.find<Key<K>, V>(table[h % m], keyHash_(k), keyHashEq)
-      } else {
-        null
-      };
-    };
-
-    /// Insert the value `v` at key `k`. Overwrites an existing entry with key `k`
-    public func put(k : K, v : V) = ignore replace(k, v);
-
-    /// Insert the value `v` at key `k` and returns the previous value stored at
-    /// `k` or `null` if it didn't exist.
-    public func replace(k : K, v : V) : ?V {
-      if (_count >= table.size()) {
-        let size =
-          if (_count == 0) {
-            if (initCapacity > 0) {
-              initCapacity
-            } else {
-              1
-            }
-          } else {
-            table.size() * 2;
-          };
-        let table2 = A.init<KVs<K, V>>(size, null);
-        for (i in table.keys()) {
-          var kvs = table[i];
-          label moveKeyVals : ()
-          loop {
-            switch kvs {
-              case null { break moveKeyVals };
-              case (?((k, v), kvsTail)) {
-                let pos2 = Nat32.toNat(k.0) % table2.size(); // critical: uses saved hash. no re-hash.
-                table2[pos2] := ?((k,v), table2[pos2]);
-                kvs := kvsTail;
-              };
-            }
-          };
-        };
-        table := table2;
-      };
-      let h = Prim.nat32ToNat(keyHash(k));
-      let pos = h % table.size();
-      let (kvs2, ov) = AssocList.replace<Key<K>, V>(table[pos], keyHash_(k), keyHashEq, ?v);
-      table[pos] := kvs2;
-      switch(ov){
-        case null { _count += 1 };
-        case _ {}
-      };
-      ov
-    };
-
-    /// An `Iter` over the keys.
-    public func keys() : Iter.Iter<K>
-    { Iter.map(entries(), func (kv : (K, V)) : K { kv.0 }) };
-
-    /// An `Iter` over the values.
-    public func vals() : Iter.Iter<V>
-    { Iter.map(entries(), func (kv : (K, V)) : V { kv.1 }) };
-
-    /// Returns an iterator over the key value pairs in this
-    /// `HashMap`. Does _not_ modify the `HashMap`.
-    public func entries() : Iter.Iter<(K, V)> {
-      if (table.size() == 0) {
-        object { public func next() : ?(K, V) { null } }
-      }
-      else {
-        object {
-          var kvs = table[0];
-          var nextTablePos = 1;
-          public func next () : ?(K, V) {
-            switch kvs {
-              case (?(kv, kvs2)) {
-                kvs := kvs2;
-                ?(kv.0.1, kv.1)
-              };
-              case null {
-                if (nextTablePos < table.size()) {
-                  kvs := table[nextTablePos];
-                  nextTablePos += 1;
-                  next()
-                } else {
-                  null
-                }
-              }
-            }
-          }
-        }
-      }
-    };
-
-  };
-
-  /// clone cannot be an efficient object method,
-  /// ...but is still useful in tests, and beyond.
-  public func clone<K, V> (
-    h : HashMap<K, V>,
-    keyEq : (K, K) -> Bool,
-    keyHash : K -> Hash.Hash
-  ) : HashMap<K, V> {
-    let h2 = HashMap<K, V>(h.size(), keyEq, keyHash);
-    for ((k,v) in h.entries()) {
-      h2.put(k,v);
-    };
-    h2
-  };
-
-  /// Clone from any iterator of key-value pairs
-  public func fromIter<K, V>(
-    iter : Iter.Iter<(K, V)>,
-    initCapacity : Nat,
-    keyEq : (K, K) -> Bool,
-    keyHash : K -> Hash.Hash
-  ) : HashMap<K, V> {
-    let h = HashMap<K, V>(initCapacity, keyEq, keyHash);
-    for ((k, v) in iter) {
-      h.put(k, v);
-    };
-    h
-  };
-
-  public func map<K, V1, V2>(
-    h : HashMap<K, V1>,
-    keyEq : (K, K) -> Bool,
-    keyHash : K -> Hash.Hash,
-    mapFn : (K, V1) -> V2,
-  ) : HashMap<K, V2> {
-    let h2 = HashMap<K, V2>(h.size(), keyEq, keyHash);
-    for ((k, v1) in h.entries()) {
-      let v2 = mapFn(k, v1);
-      h2.put(k, v2);
-    };
-    h2
-  };
-
-  public func mapFilter<K, V1, V2>(
-    h : HashMap<K, V1>,
-    keyEq : (K, K) -> Bool,
-    keyHash : K -> Hash.Hash,
-    mapFn : (K, V1) -> ?V2,
-  ) : HashMap<K, V2> {
-    let h2 = HashMap<K, V2>(h.size(), keyEq, keyHash);
-    for ((k, v1) in h.entries()) {
-      switch (mapFn(k, v1)) {
-        case null { };
-        case (?v2) {
-          h2.put(k, v2);
-        };
-      }
-    };
-    h2
-  };
-
-}

package/.mops/base@0.7.4/src/Heap.mo

@@ -1,113 +0,0 @@
-/// Priority Queue
-///
-/// This module provides purely-functional priority queue based on leftist heap
-
-import O "Order";
-import P "Prelude";
-import L "List";
-import I "Iter";
-
-module {
-
-  public type Tree<T> = ?(Int, T, Tree<T>, Tree<T>);
-
-  public class Heap<T>(ord : (T, T) -> O.Order) {
-    var heap : Tree<T> = null;
-
-    /// Get purely-functional representation
-    public func share() : Tree<T> {
-      heap
-    };
-
-    /// Put purely-functional representation into class. Need to make sure the tree is constructed with the same compare function
-    public func unsafeUnshare(t : Tree<T>) {
-      heap := t;
-    };
-
-    /// Insert an element to the heap
-    public func put(x : T) {
-      heap := merge(heap, ?(1, x, null, null), ord);
-    };
-
-    /// Return the minimal element
-    public func peekMin() : ?T {
-      switch heap {
-        case (null) { null };
-        case (?(_, x, _, _)) { ?x };
-      }
-    };
-
-    /// Delete the minimal element
-    public func deleteMin() {
-      switch heap {
-        case null {};
-        case (?(_, _, a, b)) { heap := merge(a, b, ord) };
-      }
-    };
-
-    /// Remove the minimal element and return its value
-    public func removeMin() : ?T {
-      switch heap {
-        case null { null };
-        case (?(_, x, a, b)) {
-          heap := merge(a, b, ord);
-          ?x
-        };
-      }
-    };
-  };
-
-  func rank<T>(heap : Tree<T>) : Int {
-    switch heap {
-      case null { 0 };
-      case (?(r, _, _, _)) { r };
-    }
-  };
-
-  func makeT<T>(x : T, a : Tree<T>, b : Tree<T>) : Tree<T> {
-    if (rank(a) >= rank(b)) {
-        ?(rank(b) + 1, x, a, b)
-    } else {
-        ?(rank(a) + 1, x, b, a)
-    };
-  };
-
-  func merge<T>(h1 : Tree<T>, h2 : Tree<T>, ord : (T, T) -> O.Order) : Tree<T> {
-    switch (h1, h2) {
-      case (null, h) { h };
-      case (h, null) { h };
-      case (?(_, x, a, b), ?(_, y, c, d)) {
-        switch (ord(x,y)) {
-          case (#less) { makeT(x, a, merge(b, h2, ord)) };
-          case _ { makeT(y, c, merge(d, h1, ord)) };
-        };
-      };
-    };
-  };
-
-  /// Convert iterator into a heap in O(N) time.
-  public func fromIter<T>(iter : I.Iter<T>, ord : (T, T) -> O.Order) : Heap<T> {
-    let heap = Heap<T>(ord);
-    func build(xs : L.List<Tree<T>>) : Tree<T> {
-      func join(xs : L.List<Tree<T>>) : L.List<Tree<T>> {
-        switch(xs) {
-          case (null) { null };
-          case (?(hd, null)) { ?(hd, null) };
-          case (?(h1, ?(h2, tl))) { ?(merge(h1, h2, ord), join(tl)) };
-        }
-      };
-      switch(xs) {
-        case null { P.unreachable() };
-        case (?(hd, null)) { hd };
-        case _ { build(join(xs)) };
-      };
-    };
-    let list = I.toList(I.map(iter, func (x : T) : Tree<T> { ?(1, x, null, null) } ));
-    if (not L.isNil(list)) {
-      let t = build(list);
-      heap.unsafeUnshare(t);
-    };
-    heap
-  };
-
-};

package/.mops/base@0.7.4/src/Int.mo

@@ -1,150 +0,0 @@
-/// Integer numbers
-///
-/// Most operations on integers (e.g. addition) are available as built-in operators (e.g. `1 + 1`).
-/// This module provides equivalent functions and `Text` conversion.
-
-import Prim "mo:⛔";
-import Prelude "Prelude";
-import Hash "Hash";
-
-module {
-
-  /// Infinite precision signed integers.
-  public type Int = Prim.Types.Int;
-
-  /// Returns the absolute value of the number
-  public let abs : Int -> Nat = Prim.abs;
-
-  /// Conversion.
-  public let toText : Int -> Text = func(x) {
-    if (x == 0) {
-      return "0";
-    };
-
-    let isNegative = x < 0;
-    var int = if isNegative { -x } else { x };
-
-    var text = "";
-    let base = 10;
-
-    while (int > 0) {
-      let rem = int % base;
-      text := (switch (rem) {
-        case 0 { "0" };
-        case 1 { "1" };
-        case 2 { "2" };
-        case 3 { "3" };
-        case 4 { "4" };
-        case 5 { "5" };
-        case 6 { "6" };
-        case 7 { "7" };
-        case 8 { "8" };
-        case 9 { "9" };
-        case _ { Prelude.unreachable() };
-      }) # text;
-      int := int / base;
-    };
-
-    return if isNegative { "-" # text } else { text };
-  };
-
-  /// Returns the minimum of `x` and `y`.
-  public func min(x : Int, y : Int) : Int {
-    if (x < y) { x } else { y };
-  };
-
-  /// Returns the maximum of `x` and `y`.
-  public func max(x : Int, y : Int) : Int {
-    if (x < y) { y } else { x };
-  };
-
-  // this is a local copy of deprecated Hash.hashNat8 (redefined to suppress the warning)
-  private func hashNat8(key : [Nat32]) : Hash.Hash {
-    var hash : Nat32 = 0;
-    for (natOfKey in key.vals()) {
-      hash := hash +% natOfKey;
-      hash := hash +% hash << 10;
-      hash := hash ^ (hash >> 6);
-    };
-    hash := hash +% hash << 3;
-    hash := hash ^ (hash >> 11);
-    hash := hash +% hash << 15;
-    return hash;
-  };
-
-  /// Computes a hash from the least significant 32-bits of `i`, ignoring other bits.
-  /// @deprecated For large `Int` values consider using a bespoke hash function that considers all of the argument's bits.
-  public func hash(i : Int) : Hash.Hash {
-    // CAUTION: This removes the high bits!
-    let j = Prim.int32ToNat32(Prim.intToInt32Wrap(i));
-    hashNat8(
-      [j & (255 << 0),
-       j & (255 << 8),
-       j & (255 << 16),
-       j & (255 << 24)
-      ]);
-  };
-
-  /// @deprecated This function will be removed in future.
-  public func hashAcc(h1 : Hash.Hash, i : Int) : Hash.Hash {
-    // CAUTION: This removes the high bits!
-    let j = Prim.int32ToNat32(Prim.intToInt32Wrap(i));
-    hashNat8(
-      [h1,
-       j & (255 << 0),
-       j & (255 << 8),
-       j & (255 << 16),
-       j & (255 << 24)
-      ]);
-  };
-
-  /// Returns `x == y`.
-  public func equal(x : Int, y : Int) : Bool { x == y };
-
-  /// Returns `x != y`.
-  public func notEqual(x : Int, y : Int) : Bool { x != y };
-
-  /// Returns `x < y`.
-  public func less(x : Int, y : Int) : Bool { x < y };
-
-  /// Returns `x <= y`.
-  public func lessOrEqual(x : Int, y : Int) : Bool { x <= y };
-
-  /// Returns `x > y`.
-  public func greater(x : Int, y : Int) : Bool { x > y };
-
-  /// Returns `x >= y`.
-  public func greaterOrEqual(x : Int, y : Int) : Bool { x >= y };
-
-  /// Returns the order of `x` and `y`.
-  public func compare(x : Int, y : Int) : { #less; #equal; #greater } {
-    if (x < y) { #less }
-    else if (x == y) { #equal }
-    else { #greater }
-  };
-
-  /// Returns the negation of `x`, `-x` .
-  public func neq(x : Int) : Int { -x; };
-
-  /// Returns the sum of `x` and `y`, `x + y`.
-  public func add(x : Int, y : Int) : Int { x + y };
-
-  /// Returns the difference of `x` and `y`, `x - y`.
-  public func sub(x : Int, y : Int) : Int { x - y };
-
-  /// Returns the product of `x` and `y`, `x * y`.
-  public func mul(x : Int, y : Int) : Int { x * y };
-
-  /// Returns the division of `x` by `y`,  `x / y`.
-  /// Traps when `y` is zero.
-  public func div(x : Int, y : Int) : Int { x / y };
-
-  /// Returns the remainder of `x` divided by `y`, `x % y`.
-  /// Traps when `y` is zero.
-  public func rem(x : Int, y : Int) : Int { x % y };
-
-  /// Returns `x` to the power of `y`, `x ** y`.
-  public func pow(x : Int, y : Int) : Int { x ** y };
-
-}
-