ic-mops 0.8.3 → 0.8.5

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

@@ -0,0 +1,404 @@
+/// Map implemented as a linked-list of key-value pairs ("Associations").
+///
+/// NOTE: This map implementation is mainly used as underlying buckets for other map
+/// structures. Thus, other map implementations are easier to use in most cases.
+
+import List "List";
+
+module {
+  /// Import from the base library to use this module.
+  ///
+  /// ```motoko name=import
+  /// import AssocList "mo:base/AssocList";
+  /// import List "mo:base/List";
+  /// import Nat "mo:base/Nat";
+  ///
+  /// type AssocList<K, V> = AssocList.AssocList<K, V>;
+  /// ```
+  ///
+  /// Initialize an empty map using an empty list.
+  /// ```motoko name=initialize include=import
+  /// var map : AssocList<Nat, Nat> = List.nil(); // Empty list as an empty map
+  /// map := null; // Alternative: null as empty list.
+  /// map
+  /// ```
+  public type AssocList<K, V> = List.List<(K, V)>;
+
+  /// Find the value associated with key `key`, or `null` if no such key exists.
+  /// Compares keys using the provided function `equal`.
+  ///
+  /// Example:
+  /// ```motoko include=import,initialize
+  /// // Create map = [(0, 10), (1, 11), (2, 12)]
+  /// map := AssocList.replace(map, 0, Nat.equal, ?10).0;
+  /// map := AssocList.replace(map, 1, Nat.equal, ?11).0;
+  /// map := AssocList.replace(map, 2, Nat.equal, ?12).0;
+  ///
+  /// // Find value associated with key 1
+  /// AssocList.find(map, 1, Nat.equal)
+  /// ```
+  /// Runtime: O(size)
+  ///
+  /// Space: O(1)
+  ///
+  /// *Runtime and space assumes that `equal` runs in O(1) time and space.
+  public func find<K, V>(
+    map : AssocList<K, V>,
+    key : K,
+    equal : (K, K) -> Bool
+  ) : ?V {
+    func rec(al : AssocList<K, V>) : ?V {
+      label profile_assocList_find_rec : (?V) switch (al) {
+        case (null) { label profile_assocList_find_end_fail : (?V) { null } };
+        case (?((hd_k, hd_v), tl)) {
+          if (equal(key, hd_k)) {
+            label profile_assocList_find_end_success : (?V) {
+              ?hd_v
+            }
+          } else {
+            rec(tl)
+          }
+        }
+      }
+    };
+    label profile_assocList_find_begin : (?V) {
+      rec(map)
+    }
+  };
+
+  /// Maps `key` to `value` in `map`, and overwrites the old entry if the key
+  /// was already present. Returns the old value in an option if it existed and
+  /// `null` otherwise, as well as the new map. Compares keys using the provided
+  /// function `equal`.
+  ///
+  /// Example:
+  /// ```motoko include=import,initialize
+  /// // Add three entries to the map
+  /// // map = [(0, 10), (1, 11), (2, 12)]
+  /// map := AssocList.replace(map, 0, Nat.equal, ?10).0;
+  /// map := AssocList.replace(map, 1, Nat.equal, ?11).0;
+  /// map := AssocList.replace(map, 2, Nat.equal, ?12).0;
+  /// // Override second entry
+  /// map := AssocList.replace(map, 1, Nat.equal, ?21).0;
+  ///
+  /// List.toArray(map)
+  /// ```
+  /// Runtime: O(size)
+  ///
+  /// Space: O(size)
+  ///
+  /// *Runtime and space assumes that `equal` runs in O(1) time and space.
+  public func replace<K, V>(
+    map : AssocList<K, V>,
+    key : K,
+    equal : (K, K) -> Bool,
+    value : ?V
+  ) : (AssocList<K, V>, ?V) {
+    func rec(al : AssocList<K, V>) : (AssocList<K, V>, ?V) {
+      switch (al) {
+        case (null) {
+          switch value {
+            case (null) { (null, null) };
+            case (?value) { (?((key, value), null), null) }
+          }
+        };
+        case (?((hd_k, hd_v), tl)) {
+          if (equal(key, hd_k)) {
+            // if value is null, remove the key; otherwise, replace key's old value
+            // return old value
+            switch value {
+              case (null) { (tl, ?hd_v) };
+              case (?value) { (?((hd_k, value), tl), ?hd_v) }
+            }
+          } else {
+            let (tl2, old_v) = rec(tl);
+            (?((hd_k, hd_v), tl2), old_v)
+          }
+        }
+      }
+    };
+    rec(map)
+  };
+
+  /// Produces a new map containing all entries from `map1` whose keys are not
+  /// contained in `map2`. The "extra" entries in `map2` are ignored. Compares
+  /// keys using the provided function `equal`.
+  ///
+  /// Example:
+  /// ```motoko include=import,initialize
+  /// // Create map1 = [(0, 10), (1, 11), (2, 12)]
+  /// var map1 : AssocList<Nat, Nat> = null;
+  /// map1 := AssocList.replace(map1, 0, Nat.equal, ?10).0;
+  /// map1 := AssocList.replace(map1, 1, Nat.equal, ?11).0;
+  /// map1 := AssocList.replace(map1, 2, Nat.equal, ?12).0;
+  ///
+  /// // Create map2 = [(2, 12), (3, 13)]
+  /// var map2 : AssocList<Nat, Nat> = null;
+  /// map2 := AssocList.replace(map2, 2, Nat.equal, ?12).0;
+  /// map2 := AssocList.replace(map2, 3, Nat.equal, ?13).0;
+  ///
+  /// // Take the difference
+  /// let newMap = AssocList.diff(map1, map2, Nat.equal);
+  /// List.toArray(newMap)
+  /// ```
+  /// Runtime: O(size1 * size2)
+  ///
+  /// Space: O(1)
+  ///
+  /// *Runtime and space assumes that `equal` runs in O(1) time and space.
+  public func diff<K, V, W>(
+    map1 : AssocList<K, V>,
+    map2 : AssocList<K, W>,
+    equal : (K, K) -> Bool
+  ) : AssocList<K, V> {
+    func rec(al1 : AssocList<K, V>) : AssocList<K, V> {
+      switch al1 {
+        case (null) { null };
+        case (?((k, v1), tl)) {
+          switch (find<K, W>(map2, k, equal)) {
+            case (null) { ?((k, v1), rec(tl)) };
+            case (?v2) { rec(tl) }
+          }
+        }
+      }
+    };
+    rec(map1)
+  };
+
+  /// @deprecated
+  public func mapAppend<K, V, W, X>(
+    map1 : AssocList<K, V>,
+    map2 : AssocList<K, W>,
+    f : (?V, ?W) -> X
+  ) : AssocList<K, X> = label profile_assocList_mapAppend : AssocList<K, X> {
+    func rec(al1 : AssocList<K, V>, al2 : AssocList<K, W>) : AssocList<K, X> = label profile_assocList_mapAppend_rec : AssocList<K, X> {
+      switch (al1, al2) {
+        case (null, null) { null };
+        case (?((k, v), al1_), _) { ?((k, f(?v, null)), rec(al1_, al2)) };
+        case (null, ?((k, v), al2_)) { ?((k, f(null, ?v)), rec(null, al2_)) }
+      }
+    };
+    rec(map1, map2)
+  };
+
+  /// Produces a new map by mapping entries in `map1` and `map2` using `f` and
+  /// concatenating the results. Assumes that there are no collisions between
+  /// keys in `map1` and `map2`.
+  ///
+  /// Example:
+  /// ```motoko include=import,initialize
+  /// import { trap } "mo:base/Debug";
+  ///
+  /// // Create map1 = [(0, 10), (1, 11), (2, 12)]
+  /// var map1 : AssocList<Nat, Nat> = null;
+  /// map1 := AssocList.replace(map1, 0, Nat.equal, ?10).0;
+  /// map1 := AssocList.replace(map1, 1, Nat.equal, ?11).0;
+  /// map1 := AssocList.replace(map1, 2, Nat.equal, ?12).0;
+  ///
+  /// // Create map2 = [(4, "14"), (3, "13")]
+  /// var map2 : AssocList<Nat, Text> = null;
+  /// map2 := AssocList.replace(map2, 4, Nat.equal, ?"14").0;
+  /// map2 := AssocList.replace(map2, 3, Nat.equal, ?"13").0;
+  ///
+  /// // Map and append the two AssocLists
+  /// let newMap =
+  ///   AssocList.disjDisjoint<Nat, Nat, Text, Text>(
+  ///     map1,
+  ///     map2,
+  ///     func((v1, v2) : (?Nat, ?Text)) {
+  ///       switch(v1, v2) {
+  ///         case(?v1, null) {
+  ///           debug_show(v1) // convert values from map1 to Text
+  ///         };
+  ///         case(null, ?v2) {
+  ///           v2 // keep values from map2 as Text
+  ///         };
+  ///         case _ {
+  ///           trap "These cases will never happen in mapAppend"
+  ///         }
+  ///       }
+  ///     }
+  ///   );
+  ///
+  /// List.toArray(newMap)
+  /// ```
+  /// Runtime: O(size1 + size2)
+  ///
+  /// Space: O(1)
+  ///
+  /// *Runtime and space assumes that `f` runs in O(1) time and space.
+  public func disjDisjoint<K, V, W, X>(
+    map1 : AssocList<K, V>,
+    map2 : AssocList<K, W>,
+    f : (?V, ?W) -> X
+  ) : AssocList<K, X> = label profile_assocList_disjDisjoint : AssocList<K, X> {
+    mapAppend<K, V, W, X>(map1, map2, f)
+  };
+
+  /// Creates a new map by merging entries from `map1` and `map2`, and mapping
+  /// them using `combine`. `combine` is also used to combine the values of colliding keys.
+  /// Keys are compared using the given `equal` function.
+  ///
+  /// NOTE: `combine` will never be applied to `(null, null)`.
+  ///
+  /// Example:
+  /// ```motoko include=import,initialize
+  /// import { trap } "mo:base/Debug";
+  ///
+  /// // Create map1 = [(0, 10), (1, 11), (2, 12)]
+  /// var map1 : AssocList<Nat, Nat> = null;
+  /// map1 := AssocList.replace(map1, 0, Nat.equal, ?10).0;
+  /// map1 := AssocList.replace(map1, 1, Nat.equal, ?11).0;
+  /// map1 := AssocList.replace(map1, 2, Nat.equal, ?12).0;
+  ///
+  /// // Create map2 = [(2, 12), (3, 13)]
+  /// var map2 : AssocList<Nat, Nat> = null;
+  /// map2 := AssocList.replace(map2, 2, Nat.equal, ?12).0;
+  /// map2 := AssocList.replace(map2, 3, Nat.equal, ?13).0;
+  ///
+  /// // Merge the two maps using `combine`
+  /// let newMap =
+  ///   AssocList.disj<Nat, Nat, Nat, Nat>(
+  ///     map1,
+  ///     map2,
+  ///     Nat.equal,
+  ///     func((v1, v2) : (?Nat, ?Nat)) : Nat {
+  ///       switch(v1, v2) {
+  ///         case(?v1, ?v2) {
+  ///           v1 + v2 // combine values of colliding keys by adding them
+  ///         };
+  ///         case(?v1, null) {
+  ///           v1 // when a key doesn't collide, keep the original value
+  ///         };
+  ///         case(null, ?v2) {
+  ///           v2
+  ///         };
+  ///         case _ {
+  ///           trap "This case will never happen in disj"
+  ///         }
+  ///       }
+  ///     }
+  ///   );
+  ///
+  /// List.toArray(newMap)
+  /// ```
+  /// Runtime: O(size1 * size2)
+  ///
+  /// Space: O(size1 + size2)
+  ///
+  /// *Runtime and space assumes that `equal` and `combine` runs in O(1) time and space.
+  public func disj<K, V, W, X>(
+    map1 : AssocList<K, V>,
+    map2 : AssocList<K, W>,
+    equal : (K, K) -> Bool,
+    combine : (?V, ?W) -> X
+  ) : AssocList<K, X> {
+    func rec1(al1Rec : AssocList<K, V>) : AssocList<K, X> {
+      switch al1Rec {
+        case (null) {
+          func rec2(al2 : AssocList<K, W>) : AssocList<K, X> {
+            switch al2 {
+              case (null) { null };
+              case (?((k, v2), tl)) {
+                switch (find<K, V>(map1, k, equal)) {
+                  case (null) { ?((k, combine(null, ?v2)), rec2(tl)) };
+                  case (?v1) { ?((k, combine(?v1, ?v2)), rec2(tl)) }
+                }
+              }
+            }
+          };
+          rec2(map2)
+        };
+        case (?((k, v1), tl)) {
+          switch (find<K, W>(map2, k, equal)) {
+            case (null) { ?((k, combine(?v1, null)), rec1(tl)) };
+            case (?v2) { /* handled above */ rec1(tl) }
+          }
+        }
+      }
+    };
+    rec1(map1)
+  };
+
+  /// Takes the intersection of `map1` and `map2`, only keeping colliding keys
+  /// and combining values using the `combine` function. Keys are compared using
+  /// the `equal` function.
+  ///
+  /// Example:
+  /// ```motoko include=import,initialize
+  /// // Create map1 = [(0, 10), (1, 11), (2, 12)]
+  /// var map1 : AssocList<Nat, Nat> = null;
+  /// map1 := AssocList.replace(map1, 0, Nat.equal, ?10).0;
+  /// map1 := AssocList.replace(map1, 1, Nat.equal, ?11).0;
+  /// map1 := AssocList.replace(map1, 2, Nat.equal, ?12).0;
+  ///
+  /// // Create map2 = [(2, 12), (3, 13)]
+  /// var map2 : AssocList<Nat, Nat> = null;
+  /// map2 := AssocList.replace(map2, 2, Nat.equal, ?12).0;
+  /// map2 := AssocList.replace(map2, 3, Nat.equal, ?13).0;
+  ///
+  /// // Take the intersection of the two maps, combining values by adding them
+  /// let newMap = AssocList.join<Nat, Nat, Nat, Nat>(map1, map2, Nat.equal, Nat.add);
+  ///
+  /// List.toArray(newMap)
+  /// ```
+  /// Runtime: O(size1 * size2)
+  ///
+  /// Space: O(size1 + size2)
+  ///
+  /// *Runtime and space assumes that `equal` and `combine` runs in O(1) time and space.
+  public func join<K, V, W, X>(
+    map1 : AssocList<K, V>,
+    map2 : AssocList<K, W>,
+    equal : (K, K) -> Bool,
+    combine : (V, W) -> X
+  ) : AssocList<K, X> {
+    func rec(al1 : AssocList<K, V>) : AssocList<K, X> {
+      switch al1 {
+        case (null) { null };
+        case (?((k, v1), tl)) {
+          switch (find<K, W>(map2, k, equal)) {
+            case (null) { rec(tl) };
+            case (?v2) { ?((k, combine(v1, v2)), rec(tl)) }
+          }
+        }
+      }
+    };
+    rec(map1)
+  };
+
+  /// Collapses the elements in `map` into a single value by starting with `base`
+  /// and progessively combining elements into `base` with `combine`. Iteration runs
+  /// left to right.
+  ///
+  /// Example:
+  /// ```motoko include=import,initialize
+  /// // Create map = [(0, 10), (1, 11), (2, 12)]
+  /// var map : AssocList<Nat, Nat> = null;
+  /// map := AssocList.replace(map, 0, Nat.equal, ?10).0;
+  /// map := AssocList.replace(map, 1, Nat.equal, ?11).0;
+  /// map := AssocList.replace(map, 2, Nat.equal, ?12).0;
+  ///
+  /// // (0 * 10) + (1 * 11) + (2 * 12)
+  /// AssocList.fold<Nat, Nat, Nat>(map, 0, func(k, v, sumSoFar) = (k * v) + sumSoFar)
+  /// ```
+  ///
+  /// Runtime: O(size)
+  ///
+  /// Space: O(size)
+  ///
+  /// *Runtime and space assumes that `combine` runs in O(1) time and space.
+  public func fold<K, V, X>(
+    map : AssocList<K, V>,
+    base : X,
+    combine : (K, V, X) -> X
+  ) : X {
+    func rec(al : AssocList<K, V>) : X {
+      switch al {
+        case null { base };
+        case (?((k, v), t)) { combine(k, v, rec(t)) }
+      }
+    };
+    rec(map)
+  }
+}

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

@@ -0,0 +1,212 @@
+/// Module for working with Blobs: immutable sequence of bytes.
+///
+/// Blobs represent sequences of bytes. They are immutable, iterable, but not indexable and can be empty.
+///
+/// Byte sequences are also often represented as `[Nat8]`, i.e. an array of bytes, but this representation is currently much less compact than `Blob`, taking 4 physical bytes to represent each logical byte in the sequence.
+/// If you would like to manipulate Blobs, it is recommended that you convert
+/// Blobs to `[var Nat8]` or `Buffer<Nat8>`, do the manipulation, then convert back.
+///
+/// Import from the base library to use this module.
+/// ```motoko name=import
+/// import Blob "mo:base/Blob";
+/// ```
+///
+/// Some built in features not listed in this module:
+///
+/// * You can create a `Blob` literal from a `Text` literal, provided the context expects an expression of type `Blob`.
+/// * `b.size() : Nat` returns the number of bytes in the blob `b`;
+/// * `b.vals() : Iter.Iter<Nat8>` returns an iterator to enumerate the bytes of the blob `b`.
+///
+///  For example:
+/// ```motoko include=import
+/// import Debug "mo:base/Debug";
+/// import Nat8 "mo:base/Nat8";
+///
+/// let blob = "\00\00\00\ff" : Blob; // blob literals, where each byte is delimited by a back-slash and represented in hex
+/// let blob2 = "charsもあり" : Blob; // you can also use characters in the literals
+/// let numBytes = blob.size(); // => 4 (returns the number of bytes in the Blob)
+/// for (byte : Nat8 in blob.vals()) { // iterator over the Blob
+///   Debug.print(Nat8.toText(byte))
+/// }
+/// ```
+import Prim "mo:⛔";
+module {
+  public type Blob = Prim.Types.Blob;
+  /// Creates a `Blob` from an array of bytes (`[Nat8]`), by copying each element.
+  ///
+  /// Example:
+  /// ```motoko include=import
+  /// let bytes : [Nat8] = [0, 255, 0];
+  /// let blob = Blob.fromArray(bytes); // => "\00\FF\00"
+  /// ```
+  public func fromArray(bytes : [Nat8]) : Blob = Prim.arrayToBlob bytes;
+
+  /// Creates a `Blob` from a mutable array of bytes (`[var Nat8]`), by copying each element.
+  ///
+  /// Example:
+  /// ```motoko include=import
+  /// let bytes : [var Nat8] = [var 0, 255, 0];
+  /// let blob = Blob.fromArrayMut(bytes); // => "\00\FF\00"
+  /// ```
+  public func fromArrayMut(bytes : [var Nat8]) : Blob = Prim.arrayMutToBlob bytes;
+
+  /// Converts a `Blob` to an array of bytes (`[Nat8]`), by copying each element.
+  ///
+  /// Example:
+  /// ```motoko include=import
+  /// let blob = "\00\FF\00" : Blob;
+  /// let bytes = Blob.toArray(blob); // => [0, 255, 0]
+  /// ```
+  public func toArray(blob : Blob) : [Nat8] = Prim.blobToArray blob;
+
+  /// Converts a `Blob` to a mutable array of bytes (`[var Nat8]`), by copying each element.
+  ///
+  /// Example:
+  /// ```motoko include=import
+  /// let blob = "\00\FF\00" : Blob;
+  /// let bytes = Blob.toArrayMut(blob); // => [var 0, 255, 0]
+  /// ```
+  public func toArrayMut(blob : Blob) : [var Nat8] = Prim.blobToArrayMut blob;
+
+  /// Returns the (non-cryptographic) hash of `blob`.
+  ///
+  /// Example:
+  /// ```motoko include=import
+  /// let blob = "\00\FF\00" : Blob;
+  /// Blob.hash(blob) // => 1_818_567_776
+  /// ```
+  public func hash(blob : Blob) : Nat32 = Prim.hashBlob blob;
+
+  /// General purpose comparison function for `Blob` by comparing the value of
+  /// the bytes. Returns the `Order` (either `#less`, `#equal`, or `#greater`)
+  /// by comparing `blob1` with `blob2`.
+  ///
+  /// Example:
+  /// ```motoko include=import
+  /// let blob1 = "\00\00\00" : Blob;
+  /// let blob2 = "\00\FF\00" : Blob;
+  /// Blob.compare(blob1, blob2) // => #less
+  /// ```
+  public func compare(blob1 : Blob, blob2 : Blob) : { #less; #equal; #greater } {
+    if (blob1 < blob2) {
+      #less
+    } else if (blob1 == blob2) {
+      #equal
+    } else {
+      #greater
+    }
+  };
+
+  /// Equality function for `Blob` types.
+  /// This is equivalent to `blob1 == blob2`.
+  ///
+  /// Example:
+  /// ```motoko include=import
+  /// let blob1 = "\00\FF\00" : Blob;
+  /// let blob2 = "\00\FF\00" : Blob;
+  /// ignore Blob.equal(blob1, blob2);
+  /// blob1 == blob2 // => true
+  /// ```
+  ///
+  /// Note: The reason why this function is defined in this library (in addition
+  /// to the existing `==` operator) is so that you can use it as a function value
+  /// to pass to a higher order function. It is not possible to use `==` as a
+  /// function value at the moment.
+  ///
+  /// Example:
+  /// ```motoko include=import
+  /// import Buffer "mo:base/Buffer";
+  ///
+  /// let buffer1 = Buffer.Buffer<Blob>(3);
+  /// let buffer2 = Buffer.Buffer<Blob>(3);
+  /// Buffer.equal(buffer1, buffer2, Blob.equal) // => true
+  /// ```
+  public func equal(blob1 : Blob, blob2 : Blob) : Bool { blob1 == blob2 };
+
+  /// Inequality function for `Blob` types.
+  /// This is equivalent to `blob1 != blob2`.
+  ///
+  /// Example:
+  /// ```motoko include=import
+  /// let blob1 = "\00\AA\AA" : Blob;
+  /// let blob2 = "\00\FF\00" : Blob;
+  /// ignore Blob.notEqual(blob1, blob2);
+  /// blob1 != blob2 // => true
+  /// ```
+  ///
+  /// Note: The reason why this function is defined in this library (in addition
+  /// to the existing `!=` operator) is so that you can use it as a function value
+  /// to pass to a higher order function. It is not possible to use `!=` as a
+  /// function value at the moment.
+  public func notEqual(blob1 : Blob, blob2 : Blob) : Bool { blob1 != blob2 };
+
+  /// "Less than" function for `Blob` types.
+  /// This is equivalent to `blob1 < blob2`.
+  ///
+  /// Example:
+  /// ```motoko include=import
+  /// let blob1 = "\00\AA\AA" : Blob;
+  /// let blob2 = "\00\FF\00" : Blob;
+  /// ignore Blob.less(blob1, blob2);
+  /// blob1 < blob2 // => true
+  /// ```
+  ///
+  /// Note: The reason why this function is defined in this library (in addition
+  /// to the existing `<` operator) is so that you can use it as a function value
+  /// to pass to a higher order function. It is not possible to use `<` as a
+  /// function value at the moment.
+  public func less(blob1 : Blob, blob2 : Blob) : Bool { blob1 < blob2 };
+
+  /// "Less than or equal to" function for `Blob` types.
+  /// This is equivalent to `blob1 <= blob2`.
+  ///
+  /// Example:
+  /// ```motoko include=import
+  /// let blob1 = "\00\AA\AA" : Blob;
+  /// let blob2 = "\00\FF\00" : Blob;
+  /// ignore Blob.lessOrEqual(blob1, blob2);
+  /// blob1 <= blob2 // => true
+  /// ```
+  ///
+  /// Note: The reason why this function is defined in this library (in addition
+  /// to the existing `<=` operator) is so that you can use it as a function value
+  /// to pass to a higher order function. It is not possible to use `<=` as a
+  /// function value at the moment.
+  public func lessOrEqual(blob1 : Blob, blob2 : Blob) : Bool { blob1 <= blob2 };
+
+  /// "Greater than" function for `Blob` types.
+  /// This is equivalent to `blob1 > blob2`.
+  ///
+  /// Example:
+  /// ```motoko include=import
+  /// let blob1 = "\BB\AA\AA" : Blob;
+  /// let blob2 = "\00\00\00" : Blob;
+  /// ignore Blob.greater(blob1, blob2);
+  /// blob1 > blob2 // => true
+  /// ```
+  ///
+  /// Note: The reason why this function is defined in this library (in addition
+  /// to the existing `>` operator) is so that you can use it as a function value
+  /// to pass to a higher order function. It is not possible to use `>` as a
+  /// function value at the moment.
+  public func greater(blob1 : Blob, blob2 : Blob) : Bool { blob1 > blob2 };
+
+  /// "Greater than or equal to" function for `Blob` types.
+  /// This is equivalent to `blob1 >= blob2`.
+  ///
+  /// Example:
+  /// ```motoko include=import
+  /// let blob1 = "\BB\AA\AA" : Blob;
+  /// let blob2 = "\00\00\00" : Blob;
+  /// ignore Blob.greaterOrEqual(blob1, blob2);
+  /// blob1 >= blob2 // => true
+  /// ```
+  ///
+  /// Note: The reason why this function is defined in this library (in addition
+  /// to the existing `>=` operator) is so that you can use it as a function value
+  /// to pass to a higher order function. It is not possible to use `>=` as a
+  /// function value at the moment.
+  public func greaterOrEqual(blob1 : Blob, blob2 : Blob) : Bool {
+    blob1 >= blob2
+  }
+}

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

@@ -0,0 +1,44 @@
+/// Boolean type and operations.
+///
+/// While boolean operators `_ and _` and `_ or _` are short-circuiting,
+/// avoiding computation of the right argument when possible, the functions
+/// `logand(_, _)` and `logor(_, _)` are *strict* and will always evaluate *both*
+/// of their arguments.
+
+import Prim "mo:⛔";
+module {
+
+  /// Booleans with constants `true` and `false`.
+  public type Bool = Prim.Types.Bool;
+
+  /// Conversion.
+  public func toText(x : Bool) : Text {
+    if x { "true" } else { "false" }
+  };
+
+  /// Returns `x and y`.
+  public func logand(x : Bool, y : Bool) : Bool { x and y };
+
+  /// Returns `x or y`.
+  public func logor(x : Bool, y : Bool) : Bool { x or y };
+
+  /// Returns exclusive or of `x` and `y`, `x != y`.
+  public func logxor(x : Bool, y : Bool) : Bool {
+    x != y
+  };
+
+  /// Returns `not x`.
+  public func lognot(x : Bool) : Bool { not x };
+
+  /// Returns `x == y`.
+  public func equal(x : Bool, y : Bool) : Bool { x == y };
+
+  /// Returns `x != y`.
+  public func notEqual(x : Bool, y : Bool) : Bool { x != y };
+
+  /// Returns the order of `x` and `y`, where `false < true`.
+  public func compare(x : Bool, y : Bool) : { #less; #equal; #greater } {
+    if (x == y) { #equal } else if (x) { #greater } else { #less }
+  };
+
+}