ic-mops 0.8.3 → 0.8.5

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

@@ -0,0 +1,392 @@
+/// Class `TrieMap<K, V>` provides a map from keys of type `K` to values of type `V`.
+/// The class wraps and manipulates an underyling hash trie, found in the `Trie`
+/// module. The trie is a binary tree in which the position of elements in the
+/// tree are determined using the hash of the elements.
+///
+/// Note: The `class` `TrieMap` exposes the same interface as `HashMap`.
+///
+/// Creating a map:
+/// The equality function is used to compare keys, and the hash function is used
+/// to hash keys. See the example below.
+///
+/// ```motoko name=initialize
+/// import TrieMap "mo:base/TrieMap";
+/// import Nat "mo:base/Nat";
+/// import Hash "mo:base/Hash";
+/// import Iter "mo:base/Iter";
+///
+/// let map = TrieMap.TrieMap<Nat, Nat>(Nat.equal, Hash.hash)
+/// ```
+
+import T "Trie";
+import P "Prelude";
+import I "Iter";
+import Hash "Hash";
+import List "List";
+
+module {
+  public class TrieMap<K, V>(isEq : (K, K) -> Bool, hashOf : K -> Hash.Hash) {
+    var map = T.empty<K, V>();
+    var _size : Nat = 0;
+
+    /// Returns the number of entries in the map.
+    ///
+    /// Example:
+    /// ```motoko include=initialize
+    /// map.size()
+    /// ```
+    ///
+    /// Runtime: O(1)
+    /// Space: O(1)
+    public func size() : Nat { _size };
+
+    /// Maps `key` to `value`, and overwrites the old entry if the key
+    /// was already present.
+    ///
+    /// Example:
+    /// ```motoko include=initialize
+    /// map.put(0, 10);
+    /// map.put(2, 12);
+    /// Iter.toArray(map.entries())
+    /// ```
+    ///
+    /// Runtime: O(log(size))
+    /// Space: O(log(size))
+    ///
+    /// *Runtime and space assumes that the trie is reasonably balanced and the
+    /// map is using a constant time and space equality and hash function.
+    public func put(key : K, value : V) = ignore replace(key, value);
+
+    /// Maps `key` to `value`. Overwrites _and_ returns the old entry as an
+    /// option if the key was already present, and `null` otherwise.
+    ///
+    /// Example:
+    /// ```motoko include=initialize
+    /// map.put(0, 10);
+    /// map.replace(0, 20)
+    /// ```
+    ///
+    /// Runtime: O(log(size))
+    /// Space: O(log(size))
+    ///
+    /// *Runtime and space assumes that the trie is reasonably balanced and the
+    /// map is using a constant time and space equality and hash function.
+    public func replace(key : K, value : V) : ?V {
+      let keyObj = { key; hash = hashOf(key) };
+      let (map2, ov) = T.put<K, V>(map, keyObj, isEq, value);
+      map := map2;
+      switch (ov) {
+        case null { _size += 1 };
+        case _ {}
+      };
+      ov
+    };
+
+    /// Gets the value associated with the key `key` in an option, or `null` if it
+    /// doesn't exist.
+    ///
+    /// Example:
+    /// ```motoko include=initialize
+    /// map.put(0, 10);
+    /// map.get(0)
+    /// ```
+    ///
+    /// Runtime: O(log(size))
+    /// Space: O(log(size))
+    ///
+    /// *Runtime and space assumes that the trie is reasonably balanced and the
+    /// map is using a constant time and space equality and hash function.
+    public func get(key : K) : ?V {
+      let keyObj = { key; hash = hashOf(key) };
+      T.find<K, V>(map, keyObj, isEq)
+    };
+
+    /// Delete the entry associated with key `key`, if it exists. If the key is
+    /// absent, there is no effect.
+    ///
+    /// Example:
+    /// ```motoko include=initialize
+    /// map.put(0, 10);
+    /// map.delete(0);
+    /// map.get(0)
+    /// ```
+    ///
+    /// Runtime: O(log(size))
+    /// Space: O(log(size))
+    ///
+    /// *Runtime and space assumes that the trie is reasonably balanced and the
+    /// map is using a constant time and space equality and hash function.
+    public func delete(key : K) = ignore remove(key);
+
+    /// Delete the entry associated with key `key`. Return the deleted value
+    /// as an option if it exists, and `null` otherwise.
+    ///
+    /// Example:
+    /// ```motoko include=initialize
+    /// map.put(0, 10);
+    /// map.remove(0)
+    /// ```
+    ///
+    /// Runtime: O(log(size))
+    /// Space: O(log(size))
+    ///
+    /// *Runtime and space assumes that the trie is reasonably balanced and the
+    /// map is using a constant time and space equality and hash function.
+    public func remove(key : K) : ?V {
+      let keyObj = { key; hash = hashOf(key) };
+      let (t, ov) = T.remove<K, V>(map, keyObj, isEq);
+      map := t;
+      switch (ov) {
+        case null {};
+        case (?_) { _size -= 1 }
+      };
+      ov
+    };
+
+    /// Returns an iterator over the keys of the map.
+    ///
+    /// Each iterator gets a _snapshot view_ of the mapping, and is unaffected
+    /// by concurrent updates to the iterated map.
+    ///
+    /// Example:
+    /// ```motoko include=initialize
+    /// map.put(0, 10);
+    /// map.put(1, 11);
+    /// map.put(2, 12);
+    ///
+    /// // find the sum of all the keys
+    /// var sum = 0;
+    /// for (key in map.keys()) {
+    ///   sum += key;
+    /// };
+    /// // 0 + 1 + 2
+    /// sum
+    /// ```
+    ///
+    /// Runtime: O(1)
+    /// Space: O(1)
+    ///
+    /// *The above runtime and space are for the construction of the iterator.
+    /// The iteration itself takes linear time and logarithmic space to execute.
+    public func keys() : I.Iter<K> {
+      I.map(entries(), func(kv : (K, V)) : K { kv.0 })
+    };
+
+    /// Returns an iterator over the values in the map.
+    ///
+    /// Each iterator gets a _snapshot view_ of the mapping, and is unaffected
+    /// by concurrent updates to the iterated map.
+    ///
+    /// Example:
+    /// ```motoko include=initialize
+    /// map.put(0, 10);
+    /// map.put(1, 11);
+    /// map.put(2, 12);
+    ///
+    /// // find the sum of all the values
+    /// var sum = 0;
+    /// for (key in map.vals()) {
+    ///   sum += key;
+    /// };
+    /// // 10 + 11 + 12
+    /// sum
+    /// ```
+    ///
+    /// Runtime: O(1)
+    /// Space: O(1)
+    ///
+    /// *The above runtime and space are for the construction of the iterator.
+    /// The iteration itself takes linear time and logarithmic space to execute.
+    public func vals() : I.Iter<V> {
+      I.map(entries(), func(kv : (K, V)) : V { kv.1 })
+    };
+
+    /// Returns an iterator over the entries (key-value pairs) in the map.
+    ///
+    /// Each iterator gets a _snapshot view_ of the mapping, and is unaffected
+    /// by concurrent updates to the iterated map.
+    ///
+    /// Example:
+    /// ```motoko include=initialize
+    /// map.put(0, 10);
+    /// map.put(1, 11);
+    /// map.put(2, 12);
+    ///
+    /// // find the sum of all the products of key-value pairs
+    /// var sum = 0;
+    /// for ((key, value) in map.entries()) {
+    ///   sum += key * value;
+    /// };
+    /// // (0 * 10) + (1 * 11) + (2 * 12)
+    /// sum
+    /// ```
+    ///
+    /// Runtime: O(1)
+    /// Space: O(1)
+    ///
+    /// *The above runtime and space are for the construction of the iterator.
+    /// The iteration itself takes linear time and logarithmic space to execute.
+    public func entries() : I.Iter<(K, V)> {
+      object {
+        var stack = ?(map, null) : List.List<T.Trie<K, V>>;
+        public func next() : ?(K, V) {
+          switch stack {
+            case null { null };
+            case (?(trie, stack2)) {
+              switch trie {
+                case (#empty) {
+                  stack := stack2;
+                  next()
+                };
+                case (#leaf({ keyvals = null })) {
+                  stack := stack2;
+                  next()
+                };
+                case (#leaf({ size = c; keyvals = ?((k, v), kvs) })) {
+                  stack := ?(#leaf({ size = c -1; keyvals = kvs }), stack2);
+                  ?(k.key, v)
+                };
+                case (#branch(br)) {
+                  stack := ?(br.left, ?(br.right, stack2));
+                  next()
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+
+  /// Produce a copy of `map`, using `keyEq` to compare keys and `keyHash` to
+  /// hash keys.
+  ///
+  /// Example:
+  /// ```motoko include=initialize
+  /// map.put(0, 10);
+  /// map.put(1, 11);
+  /// map.put(2, 12);
+  /// // Clone using the same equality and hash functions used to initialize `map`
+  /// let mapCopy = TrieMap.clone(map, Nat.equal, Hash.hash);
+  /// Iter.toArray(mapCopy.entries())
+  /// ```
+  ///
+  /// Runtime: O(size * log(size))
+  /// Space: O(size)
+  ///
+  /// *Runtime and space assumes that the trie underlying `map` is reasonably
+  /// balanced and that `keyEq` and `keyHash` run in O(1) time and space.
+  public func clone<K, V>(
+    map : TrieMap<K, V>,
+    keyEq : (K, K) -> Bool,
+    keyHash : K -> Hash.Hash
+  ) : TrieMap<K, V> {
+    let h2 = TrieMap<K, V>(keyEq, keyHash);
+    for ((k, v) in map.entries()) {
+      h2.put(k, v)
+    };
+    h2
+  };
+
+  /// Create a new map from the entries in `entries`, using `keyEq` to compare
+  /// keys and `keyHash` to hash keys.
+  ///
+  /// Example:
+  /// ```motoko include=initialize
+  /// let entries = [(0, 10), (1, 11), (2, 12)];
+  /// let newMap = TrieMap.fromEntries<Nat, Nat>(entries.vals(), Nat.equal, Hash.hash);
+  /// newMap.get(2)
+  /// ```
+  ///
+  /// Runtime: O(size * log(size))
+  /// Space: O(size)
+  ///
+  /// *Runtime and space assumes that `entries` returns elements in O(1) time,
+  /// and `keyEq` and `keyHash` run in O(1) time and space.
+  public func fromEntries<K, V>(
+    entries : I.Iter<(K, V)>,
+    keyEq : (K, K) -> Bool,
+    keyHash : K -> Hash.Hash
+  ) : TrieMap<K, V> {
+    let h = TrieMap<K, V>(keyEq, keyHash);
+    for ((k, v) in entries) {
+      h.put(k, v)
+    };
+    h
+  };
+
+  /// Transform (map) the values in `map` using function `f`, retaining the keys.
+  /// Uses `keyEq` to compare keys and `keyHash` to hash keys.
+  ///
+  /// Example:
+  /// ```motoko include=initialize
+  /// map.put(0, 10);
+  /// map.put(1, 11);
+  /// map.put(2, 12);
+  /// // double all the values in map
+  /// let newMap = TrieMap.map<Nat, Nat, Nat>(map, Nat.equal, Hash.hash, func(key, value) = value * 2);
+  /// Iter.toArray(newMap.entries())
+  /// ```
+  ///
+  /// Runtime: O(size * log(size))
+  /// Space: O(size)
+  ///
+  /// *Runtime and space assumes that `f`, `keyEq`, and `keyHash` run in O(1)
+  /// time and space.
+  public func map<K, V1, V2>(
+    map : TrieMap<K, V1>,
+    keyEq : (K, K) -> Bool,
+    keyHash : K -> Hash.Hash,
+    f : (K, V1) -> V2
+  ) : TrieMap<K, V2> {
+    let h2 = TrieMap<K, V2>(keyEq, keyHash);
+    for ((k, v1) in map.entries()) {
+      let v2 = f(k, v1);
+      h2.put(k, v2)
+    };
+    h2
+  };
+
+  /// Transform (map) the values in `map` using function `f`, discarding entries
+  /// for which `f` evaluates to `null`. Uses `keyEq` to compare keys and
+  /// `keyHash` to hash keys.
+  ///
+  /// Example:
+  /// ```motoko include=initialize
+  /// map.put(0, 10);
+  /// map.put(1, 11);
+  /// map.put(2, 12);
+  /// // double all the values in map, only keeping entries that have an even key
+  /// let newMap =
+  ///   TrieMap.mapFilter<Nat, Nat, Nat>(
+  ///     map,
+  ///     Nat.equal,
+  ///     Hash.hash,
+  ///     func(key, value) = if (key % 2 == 0) { ?(value * 2) } else { null }
+  ///   );
+  /// Iter.toArray(newMap.entries())
+  /// ```
+  ///
+  /// Runtime: O(size * log(size))
+  /// Space: O(size)
+  ///
+  /// *Runtime and space assumes that `f`, `keyEq`, and `keyHash` run in O(1)
+  /// time and space.
+  public func mapFilter<K, V1, V2>(
+    map : TrieMap<K, V1>,
+    keyEq : (K, K) -> Bool,
+    keyHash : K -> Hash.Hash,
+    f : (K, V1) -> ?V2
+  ) : TrieMap<K, V2> {
+    let h2 = TrieMap<K, V2>(keyEq, keyHash);
+    for ((k, v1) in map.entries()) {
+      switch (f(k, v1)) {
+        case null {};
+        case (?v2) {
+          h2.put(k, v2)
+        }
+      }
+    };
+    h2
+  }
+}

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

@@ -0,0 +1,148 @@
+/// Functional set
+///
+/// Sets are partial maps from element type to unit type,
+/// i.e., the partial map represents the set with its domain.
+
+// TODO-Matthew:
+// ---------------
+//
+// - for now, we pass a hash value each time we pass an element value;
+//   in the future, we might avoid passing element hashes with each element in the API;
+//   related to: https://dfinity.atlassian.net/browse/AST-32
+//
+// - similarly, we pass an equality function when we do some operations.
+//   in the future, we might avoid this via https://dfinity.atlassian.net/browse/AST-32
+import Trie "Trie";
+import Hash "Hash";
+import List "List";
+import Iter "Iter";
+
+module {
+
+  public type Hash = Hash.Hash;
+  public type Set<T> = Trie.Trie<T, ()>;
+  type Key<K> = Trie.Key<K>;
+  type Trie<K, V> = Trie.Trie<K, V>;
+
+  // helper for defining equal and sub, avoiding Trie.diff.
+  // TODO: add to Trie.mo?
+  private func keys<K>(t : Trie<K, Any>) : Iter.Iter<Key<K>> {
+    object {
+      var stack = ?(t, null) : List.List<Trie<K, Any>>;
+      public func next() : ?Key<K> {
+        switch stack {
+          case null { null };
+          case (?(trie, stack2)) {
+            switch trie {
+              case (#empty) {
+                stack := stack2;
+                next()
+              };
+              case (#leaf({ keyvals = null })) {
+                stack := stack2;
+                next()
+              };
+              case (#leaf({ size = c; keyvals = ?((k, v), kvs) })) {
+                stack := ?(#leaf({ size = c - 1; keyvals = kvs }), stack2);
+                ?k
+              };
+              case (#branch(br)) {
+                stack := ?(br.left, ?(br.right, stack2));
+                next()
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+
+  /// Empty set.
+  public func empty<T>() : Set<T> { Trie.empty<T, ()>() };
+
+  /// Put an element into the set.
+  public func put<T>(s : Set<T>, x : T, xh : Hash, eq : (T, T) -> Bool) : Set<T> {
+    let (s2, _) = Trie.put<T, ()>(s, { key = x; hash = xh }, eq, ());
+    s2
+  };
+
+  /// Delete an element from the set.
+  public func delete<T>(s : Set<T>, x : T, xh : Hash, eq : (T, T) -> Bool) : Set<T> {
+    let (s2, _) = Trie.remove<T, ()>(s, { key = x; hash = xh }, eq);
+    s2
+  };
+
+  /// Test if two sets are equal.
+  public func equal<T>(s1 : Set<T>, s2 : Set<T>, eq : (T, T) -> Bool) : Bool {
+    if (Trie.size(s1) != Trie.size(s2)) return false;
+    for (k in keys(s1)) {
+      if (Trie.find<T,()>(s2, k, eq) == null) {
+        return false;
+      }
+    };
+    return true;
+  };
+
+  /// The number of set elements, set's cardinality.
+  public func size<T>(s : Set<T>) : Nat {
+    Trie.size(s);
+  };
+
+  /// Test if `s` is the empty set.
+  public func isEmpty<T>(s : Set<T>) : Bool {
+    Trie.size(s) == 0;
+  };
+
+  /// Test if `s1` is a subset of `s2`.
+  public func isSubset<T>(s1 : Set<T>, s2 : Set<T>, eq : (T, T) -> Bool) : Bool {
+    if (Trie.size(s1) > Trie.size(s2)) return false;
+    for (k in keys(s1)) {
+      if (Trie.find<T,()>(s2, k, eq) == null) {
+        return false;
+      }
+    };
+    return true;
+  };
+
+  /// Test if a set contains a given element.
+  public func mem<T>(s : Set<T>, x : T, xh : Hash, eq : (T, T) -> Bool) : Bool {
+    switch (Trie.find<T, ()>(s, { key = x; hash = xh }, eq)) {
+      case null { false };
+      case (?_) { true }
+    }
+  };
+
+  /// [Set union](https://en.wikipedia.org/wiki/Union_(set_theory)).
+  public func union<T>(s1 : Set<T>, s2 : Set<T>, eq : (T, T) -> Bool) : Set<T> {
+    let s3 = Trie.merge<T, ()>(s1, s2, eq);
+    s3
+  };
+
+  /// [Set difference](https://en.wikipedia.org/wiki/Difference_(set_theory)).
+  public func diff<T>(s1 : Set<T>, s2 : Set<T>, eq : (T, T) -> Bool) : Set<T> {
+    let s3 = Trie.diff<T, (), ()>(s1, s2, eq);
+    s3
+  };
+
+  /// [Set intersection](https://en.wikipedia.org/wiki/Intersection_(set_theory)).
+  public func intersect<T>(s1 : Set<T>, s2 : Set<T>, eq : (T, T) -> Bool) : Set<T> {
+    let noop : ((), ()) -> (()) = func(_ : (), _ : ()) : (()) = ();
+    let s3 = Trie.join<T, (), (), ()>(s1, s2, eq, noop);
+    s3
+  };
+
+  //// Construct a set from an array.
+  public func fromArray<T>(arr : [T], elemHash : T -> Hash, eq : (T, T) -> Bool) : Set<T> {
+    var s = empty<T>();
+    for (elem in arr.vals()) {
+      s := put<T>(s, elem, elemHash(elem), eq)
+    };
+    s
+  };
+
+  //// Returns the set as an array.
+  public func toArray<T>(s : Set<T>) : [T] {
+    Trie.toArray(s, func(t : T, _ : ()) : T { t })
+  }
+
+}

package/mops.js

@@ -40,7 +40,7 @@ export function getNetwork() {
 	else if (network === 'ic') {
 		return {
 			network,
-			host: 'https://mainnet.dfinity.network',
+			host: 'https://ic0.app',
 			canisterId: 'oknww-riaaa-aaaam-qaf6a-cai',
 		};
 	}

package/network.txt

@@ -0,0 +1 @@
+local

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ic-mops",
-	"version": "0.8.3",
+	"version": "0.8.5",
 	"type": "module",
 	"bin": {
 		"mops": "cli.js"
@@ -39,7 +39,7 @@
 		"log-update": "^5.0.1",
 		"minimatch": "^5.0.1",
 		"ncp": "^2.0.0",
-		"node-fetch": "^2.6.7",
+		"node-fetch": "^3.3.0",
 		"pem-file": "^1.0.1",
 		"prompts": "^2.4.2"
 	}