ic-mops 0.8.5 → 0.8.7

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

@@ -1,75 +0,0 @@
-/// Natural numbers
-///
-/// Most operations on natural numbers (e.g. addition) are available as built-in operators (e.g. `1 + 1`).
-/// This module provides equivalent functions and `Text` conversion.
-
-import Int "Int";
-import Order "Order";
-import Prim "mo:⛔";
-
-module {
-
-
-  /// Infinite precision natural numbers.
-  public type Nat = Prim.Types.Nat;
-
-  /// Conversion.
-  public let toText : Nat -> Text = Int.toText;
-
-  /// Returns the minimum of `x` and `y`.
-  public func min(x : Nat, y : Nat) : Nat {
-    if (x < y) { x } else { y }
-  };
-
-  /// Returns the maximum of `x` and `y`.
-  public func max( x : Nat, y : Nat) : Nat {
-    if (x < y) { y } else { x }
-  };
-
-  /// Returns `x == y`.
-  public func equal(x : Nat, y : Nat) : Bool { x == y };
-
-  /// Returns `x != y`.
-  public func notEqual(x : Nat, y : Nat) : Bool { x != y };
-
-  /// Returns `x < y`.
-  public func less(x : Nat, y : Nat) : Bool { x < y };
-
-  /// Returns `x <= y`.
-  public func lessOrEqual(x : Nat, y : Nat) : Bool { x <= y };
-
-  /// Returns `x > y`.
-  public func greater(x : Nat, y : Nat) : Bool { x > y };
-
-  /// Returns `x >= y`.
-  public func greaterOrEqual(x : Nat, y : Nat) : Bool { x >= y };
-
-  /// Returns the order of `x` and `y`.
-  public func compare(x : Nat, y : Nat) : { #less; #equal; #greater } {
-    if (x < y) { #less }
-    else if (x == y) { #equal }
-    else { #greater }
-  };
-
-  /// Returns the sum of `x` and `y`, `x + y`.
-  public func add(x : Nat, y : Nat) : Nat { x + y };
-
-  /// Returns the difference of `x` and `y`, `x - y`.
-  /// Traps on underflow.
-  public func sub(x : Nat, y : Nat) : Nat { x - y };
-
-  /// Returns the product of `x` and `y`, `x * y`.
-  public func mul(x : Nat, y : Nat) : Nat { x * y };
-
-  /// Returns the division of `x` by `y`, `x / y`.
-  /// Traps when `y` is zero.
-  public func div(x : Nat, y : Nat) : Nat { x / y };
-
-  /// Returns the remainder of `x` divided by `y`, `x % y`.
-  /// Traps when `y` is zero.
-  public func rem(x : Nat, y : Nat) : Nat { x % y };
-
-  /// Returns `x` to the power of `y`, `x ** y`.
-  public func pow(x : Nat, y : Nat) : Nat { x ** y };
-
-}

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

@@ -1,146 +0,0 @@
-/// 16-bit unsigned integers with checked arithmetic
-///
-/// Most operations are available as built-in operators (e.g. `1 + 1`).
-import Nat "Nat";
-import Prim "mo:⛔";
-
-module {
-
-  /// 16-bit natural numbers.
-  public type Nat16 = Prim.Types.Nat16;
-
-  /// Conversion.
-  public let toNat : Nat16 -> Nat = Prim.nat16ToNat;
-
-  /// Conversion. Traps on overflow/underflow.
-  public let fromNat : Nat -> Nat16  = Prim.natToNat16;
-
-  /// Conversion. Wraps on overflow/underflow.
-  public let fromIntWrap : Int -> Nat16  = Prim.intToNat16Wrap;
-
-  /// Returns the Text representation of `x`.
-  public func toText(x : Nat16) : Text {
-    Nat.toText(toNat(x))
-  };
-
-  /// Returns the minimum of `x` and `y`.
-  public func min(x : Nat16, y : Nat16) : Nat16 {
-    if (x < y) { x } else { y }
-  };
-
-  /// Returns the maximum of `x` and `y`.
-  public func max( x : Nat16, y : Nat16) : Nat16 {
-    if (x < y) { y } else { x }
-  };
-
-  /// Returns `x == y`.
-  public func equal(x : Nat16, y : Nat16) : Bool { x == y };
-
-  /// Returns `x != y`.
-  public func notEqual(x : Nat16, y : Nat16) : Bool { x != y };
-
-  /// Returns `x < y`.
-  public func less(x : Nat16, y : Nat16) : Bool { x < y };
-
-  /// Returns `x <= y`.
-  public func lessOrEqual(x : Nat16, y : Nat16) : Bool { x <= y };
-
-  /// Returns `x > y`.
-  public func greater(x : Nat16, y : Nat16) : Bool { x > y };
-
-  /// Returns `x >= y`.
-  public func greaterOrEqual(x : Nat16, y : Nat16) : Bool { x >= y };
-
-  /// Returns the order of `x` and `y`.
-  public func compare(x : Nat16, y : Nat16) : { #less; #equal; #greater } {
-    if (x < y) { #less }
-    else if (x == y) { #equal }
-    else { #greater }
-  };
-
-  /// Returns the sum of `x` and `y`, `x + y`. Traps on overflow.
-  public func add(x : Nat16, y : Nat16) : Nat16 { x + y };
-
-  /// Returns the difference of `x` and `y`, `x - y`. Traps on underflow.
-  public func sub(x : Nat16, y : Nat16) : Nat16 { x - y };
-
-  /// Returns the product of `x` and `y`, `x * y`. Traps on overflow.
-  public func mul(x : Nat16, y : Nat16) : Nat16 { x * y };
-
-  /// Returns the division of `x by y`, `x / y`.
-  /// Traps when `y` is zero.
-  public func div(x : Nat16, y : Nat16) : Nat16 { x / y };
-
-  /// Returns the remainder of `x` divided by `y`, `x % y`.
-  /// Traps when `y` is zero.
-  public func rem(x : Nat16, y : Nat16) : Nat16 { x % y };
-
-  /// Returns `x` to the power of `y`, `x ** y`. Traps on overflow.
-  public func pow(x : Nat16, y : Nat16) : Nat16 { x ** y };
-
-  /// Returns the bitwise negation of `x`, `^x`.
-  public func bitnot(x : Nat16, y : Nat16) : Nat16 { ^x };
-
-  /// Returns the bitwise and of `x` and `y`, `x & y`.
-  public func bitand(x : Nat16, y : Nat16) : Nat16 { x & y };
-
-  /// Returns the bitwise or of `x` and `y`, `x \| y`.
-  public func bitor(x : Nat16, y : Nat16) : Nat16 { x | y };
-
-  /// Returns the bitwise exclusive or of `x` and `y`, `x ^ y`.
-  public func bitxor(x : Nat16, y : Nat16) : Nat16 { x ^ y };
-
-  /// Returns the bitwise shift left of `x` by `y`, `x << y`.
-  public func bitshiftLeft(x : Nat16, y : Nat16) : Nat16 { x << y };
-
-  /// Returns the bitwise shift right of `x` by `y`, `x >> y`.
-  public func bitshiftRight(x : Nat16, y : Nat16) : Nat16 { x >> y };
-
-  /// Returns the bitwise rotate left of `x` by `y`, `x <<> y`.
-  public func bitrotLeft(x : Nat16, y : Nat16) : Nat16 { x <<> y };
-
-  /// Returns the bitwise rotate right of `x` by `y`, `x <>> y`.
-  public func bitrotRight(x : Nat16, y : Nat16) : Nat16 { x <>> y };
-
-  /// Returns the value of bit `p mod 16` in `x`, `(x & 2^(p mod 16)) == 2^(p mod 16)`.
-  public func bittest(x : Nat16, p : Nat) : Bool {
-    Prim.btstNat16(x, Prim.natToNat16(p));
-  };
-
-  /// Returns the value of setting bit `p mod 16` in `x` to `1`.
-  public func bitset(x : Nat16, p : Nat) : Nat16 {
-    x | (1 << Prim.natToNat16(p));
-  };
-
-  /// Returns the value of clearing bit `p mod 16` in `x` to `0`.
-  public func bitclear(x : Nat16, p : Nat) : Nat16 {
-    x & ^(1 << Prim.natToNat16(p));
-  };
-
-  /// Returns the value of flipping bit `p mod 16` in `x`.
-  public func bitflip(x : Nat16, p : Nat) : Nat16 {
-    x ^ (1 << Prim.natToNat16(p));
-  };
-
-  /// Returns the count of non-zero bits in `x`.
-  public let bitcountNonZero : (x : Nat16) -> Nat16 = Prim.popcntNat16;
-
-  /// Returns the count of leading zero bits in `x`.
-  public let bitcountLeadingZero : (x : Nat16) -> Nat16 = Prim.clzNat16;
-
-  /// Returns the count of trailing zero bits in `x`.
-  public let bitcountTrailingZero : (x : Nat16) -> Nat16 = Prim.ctzNat16;
-
-  /// Returns the sum of `x` and `y`, `x +% y`. Wraps on overflow.
-  public func addWrap(x : Nat16, y : Nat16) : Nat16 { x +% y };
-
-  /// Returns the difference of `x` and `y`, `x -% y`. Wraps on underflow.
-  public func subWrap(x : Nat16, y : Nat16) : Nat16 { x -% y };
-
-  /// Returns the product of `x` and `y`, `x *% y`. Wraps on overflow.
-  public func mulWrap(x : Nat16, y : Nat16) : Nat16 { x *% y };
-
-  /// Returns `x` to the power of `y`, `x **% y`. Wraps on overflow.
-  public func powWrap(x : Nat16, y : Nat16) : Nat16 { x **% y };
-
-}

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

@@ -1,146 +0,0 @@
-/// 32-bit unsigned integers with checked arithmetic
-///
-/// Most operations are available as built-in operators (e.g. `1 + 1`).
-import Nat "Nat";
-import Prim "mo:⛔";
-
-module {
-
-  /// 32-bit natural numbers.
-  public type Nat32 = Prim.Types.Nat32;
-
-  /// Conversion.
-  public let toNat : Nat32 -> Nat = Prim.nat32ToNat;
-
-  /// Conversion. Traps on overflow/underflow.
-  public let fromNat : Nat -> Nat32  = Prim.natToNat32;
-
-  /// Conversion. Wraps on overflow/underflow.
-  public let fromIntWrap : Int -> Nat32  = Prim.intToNat32Wrap;
-
-  /// Returns the Text representation of `x`.
-  public func toText(x : Nat32) : Text {
-    Nat.toText(toNat(x))
-  };
-
-  /// Returns the minimum of `x` and `y`.
-  public func min(x : Nat32, y : Nat32) : Nat32 {
-    if (x < y) { x } else { y }
-  };
-
-  /// Returns the maximum of `x` and `y`.
-  public func max( x : Nat32, y : Nat32) : Nat32 {
-    if (x < y) { y } else { x }
-  };
-
-  /// Returns `x == y`.
-  public func equal(x : Nat32, y : Nat32) : Bool { x == y };
-
-  /// Returns `x != y`.
-  public func notEqual(x : Nat32, y : Nat32) : Bool { x != y };
-
-  /// Returns `x < y`.
-  public func less(x : Nat32, y : Nat32) : Bool { x < y };
-
-  /// Returns `x <= y`.
-  public func lessOrEqual(x : Nat32, y : Nat32) : Bool { x <= y };
-
-  /// Returns `x > y`.
-  public func greater(x : Nat32, y : Nat32) : Bool { x > y };
-
-  /// Returns `x >= y`.
-  public func greaterOrEqual(x : Nat32, y : Nat32) : Bool { x >= y };
-
-  /// Returns the order of `x` and `y`.
-  public func compare(x : Nat32, y : Nat32) : { #less; #equal; #greater } {
-    if (x < y) { #less }
-    else if (x == y) { #equal }
-    else { #greater }
-  };
-
-  /// Returns the sum of `x` and `y`, `x + y`. Traps on overflow.
-  public func add(x : Nat32, y : Nat32) : Nat32 { x + y };
-
-  /// Returns the difference of `x` and `y`, `x - y`. Traps on underflow.
-  public func sub(x : Nat32, y : Nat32) : Nat32 { x - y };
-
-  /// Returns the product of `x` and `y`, `x * y`. Traps on overflow.
-  public func mul(x : Nat32, y : Nat32) : Nat32 { x * y };
-
-  /// Returns the division of `x by y`, `x / y`.
-  /// Traps when `y` is zero.
-  public func div(x : Nat32, y : Nat32) : Nat32 { x / y };
-
-  /// Returns the remainder of `x` divided by `y`, `x % y`.
-  /// Traps when `y` is zero.
-  public func rem(x : Nat32, y : Nat32) : Nat32 { x % y };
-
-  /// Returns `x` to the power of `y`, `x ** y`. Traps on overflow.
-  public func pow(x : Nat32, y : Nat32) : Nat32 { x ** y };
-
-  /// Returns the bitwise negation of `x`, `^x`.
-  public func bitnot(x : Nat32, y : Nat32) : Nat32 { ^x };
-
-  /// Returns the bitwise and of `x` and `y`, `x & y`.
-  public func bitand(x : Nat32, y : Nat32) : Nat32 { x & y };
-
-  /// Returns the bitwise or of `x` and `y`, `x \| y`.
-  public func bitor(x : Nat32, y : Nat32) : Nat32 { x | y };
-
-  /// Returns the bitwise exclusive or of `x` and `y`, `x ^ y`.
-  public func bitxor(x : Nat32, y : Nat32) : Nat32 { x ^ y };
-
-  /// Returns the bitwise shift left of `x` by `y`, `x << y`.
-  public func bitshiftLeft(x : Nat32, y : Nat32) : Nat32 { x << y };
-
-  /// Returns the bitwise shift right of `x` by `y`, `x >> y`.
-  public func bitshiftRight(x : Nat32, y : Nat32) : Nat32 { x >> y };
-
-  /// Returns the bitwise rotate left of `x` by `y`, `x <<> y`.
-  public func bitrotLeft(x : Nat32, y : Nat32) : Nat32 { x <<> y };
-
-  /// Returns the bitwise rotate right of `x` by `y`, `x <>> y`.
-  public func bitrotRight(x : Nat32, y : Nat32) : Nat32 { x <>> y };
-
-  /// Returns the value of bit `p mod 32` in `x`, `(x & 2^(p mod 32)) == 2^(p mod 32)`.
-  public func bittest(x : Nat32, p : Nat) : Bool {
-    Prim.btstNat32(x, Prim.natToNat32(p));
-  };
-
-  /// Returns the value of setting bit `p mod 32` in `x` to `1`.
-  public func bitset(x : Nat32, p : Nat) : Nat32 {
-    x | (1 << Prim.natToNat32(p));
-  };
-
-  /// Returns the value of clearing bit `p mod 32` in `x` to `0`.
-  public func bitclear(x : Nat32, p : Nat) : Nat32 {
-    x & ^(1 << Prim.natToNat32(p));
-  };
-
-  /// Returns the value of flipping bit `p mod 32` in `x`.
-  public func bitflip(x : Nat32, p : Nat) : Nat32 {
-    x ^ (1 << Prim.natToNat32(p));
-  };
-
-  /// Returns the count of non-zero bits in `x`.
-  public let bitcountNonZero : (x : Nat32) -> Nat32 = Prim.popcntNat32;
-
-  /// Returns the count of leading zero bits in `x`.
-  public let bitcountLeadingZero : (x : Nat32) -> Nat32 = Prim.clzNat32;
-
-  /// Returns the count of trailing zero bits in `x`.
-  public let bitcountTrailingZero : (x : Nat32) -> Nat32 = Prim.ctzNat32;
-
-  /// Returns the sum of `x` and `y`, `x +% y`. Wraps on overflow.
-  public func addWrap(x : Nat32, y : Nat32) : Nat32 { x +% y };
-
-  /// Returns the difference of `x` and `y`, `x -% y`. Wraps on underflow.
-  public func subWrap(x : Nat32, y : Nat32) : Nat32 { x -% y };
-
-  /// Returns the product of `x` and `y`, `x *% y`. Wraps on overflow.
-  public func mulWrap(x : Nat32, y : Nat32) : Nat32 { x *% y };
-
-  /// Returns `x` to the power of `y`, `x **% y`. Wraps on overflow.
-  public func powWrap(x : Nat32, y : Nat32) : Nat32 { x **% y };
-
-}

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

@@ -1,146 +0,0 @@
-/// 64-bit unsigned integers with checked arithmetic
-///
-/// Most operations are available as built-in operators (e.g. `1 + 1`).
-import Nat "Nat";
-import Prim "mo:⛔";
-
-module {
-
-  /// 64-bit natural numbers.
-  public type Nat64 = Prim.Types.Nat64;
-
-  /// Conversion.
-  public let toNat : Nat64 -> Nat = Prim.nat64ToNat;
-
-  /// Conversion. Traps on overflow/underflow.
-  public let fromNat : Nat -> Nat64  = Prim.natToNat64;
-
-  /// Conversion. Wraps on overflow/underflow.
-  public let fromIntWrap : Int -> Nat64  = Prim.intToNat64Wrap;
-
-  /// Returns the Text representation of `x`.
-  public func toText(x : Nat64) : Text {
-    Nat.toText(toNat(x))
-  };
-
-  /// Returns the minimum of `x` and `y`.
-  public func min(x : Nat64, y : Nat64) : Nat64 {
-    if (x < y) { x } else { y }
-  };
-
-  /// Returns the maximum of `x` and `y`.
-  public func max( x : Nat64, y : Nat64) : Nat64 {
-    if (x < y) { y } else { x }
-  };
-
-  /// Returns `x == y`.
-  public func equal(x : Nat64, y : Nat64) : Bool { x == y };
-
-  /// Returns `x != y`.
-  public func notEqual(x : Nat64, y : Nat64) : Bool { x != y };
-
-  /// Returns `x < y`.
-  public func less(x : Nat64, y : Nat64) : Bool { x < y };
-
-  /// Returns `x <= y`.
-  public func lessOrEqual(x : Nat64, y : Nat64) : Bool { x <= y };
-
-  /// Returns `x > y`.
-  public func greater(x : Nat64, y : Nat64) : Bool { x > y };
-
-  /// Returns `x >= y`.
-  public func greaterOrEqual(x : Nat64, y : Nat64) : Bool { x >= y };
-
-  /// Returns the order of `x` and `y`.
-  public func compare(x : Nat64, y : Nat64) : { #less; #equal; #greater } {
-    if (x < y) { #less }
-    else if (x == y) { #equal }
-    else { #greater }
-  };
-
-  /// Returns the sum of `x` and `y`, `x + y`. Traps on overflow.
-  public func add(x : Nat64, y : Nat64) : Nat64 { x + y };
-
-  /// Returns the difference of `x` and `y`, `x - y`. Traps on underflow.
-  public func sub(x : Nat64, y : Nat64) : Nat64 { x - y };
-
-  /// Returns the product of `x` and `y`, `x * y`. Traps on overflow.
-  public func mul(x : Nat64, y : Nat64) : Nat64 { x * y };
-
-  /// Returns the division of `x by y`, `x / y`.
-  /// Traps when `y` is zero.
-  public func div(x : Nat64, y : Nat64) : Nat64 { x / y };
-
-  /// Returns the remainder of `x` divided by `y`, `x % y`.
-  /// Traps when `y` is zero.
-  public func rem(x : Nat64, y : Nat64) : Nat64 { x % y };
-
-  /// Returns `x` to the power of `y`, `x ** y`. Traps on overflow.
-  public func pow(x : Nat64, y : Nat64) : Nat64 { x ** y };
-
-  /// Returns the bitwise negation of `x`, `^x`.
-  public func bitnot(x : Nat64, y : Nat64) : Nat64 { ^x };
-
-  /// Returns the bitwise and of `x` and `y`, `x & y`.
-  public func bitand(x : Nat64, y : Nat64) : Nat64 { x & y };
-
-  /// Returns the bitwise or of `x` and `y`, `x \| y`.
-  public func bitor(x : Nat64, y : Nat64) : Nat64 { x | y };
-
-  /// Returns the bitwise exclusive or of `x` and `y`, `x ^ y`.
-  public func bitxor(x : Nat64, y : Nat64) : Nat64 { x ^ y };
-
-  /// Returns the bitwise shift left of `x` by `y`, `x << y`.
-  public func bitshiftLeft(x : Nat64, y : Nat64) : Nat64 { x << y };
-
-  /// Returns the bitwise shift right of `x` by `y`, `x >> y`.
-  public func bitshiftRight(x : Nat64, y : Nat64) : Nat64 { x >> y };
-
-  /// Returns the bitwise rotate left of `x` by `y`, `x <<> y`.
-  public func bitrotLeft(x : Nat64, y : Nat64) : Nat64 { x <<> y };
-
-  /// Returns the bitwise rotate right of `x` by `y`, `x <>> y`.
-  public func bitrotRight(x : Nat64, y : Nat64) : Nat64 { x <>> y };
-
-  /// Returns the value of bit `p mod 64` in `x`, `(x & 2^(p mod 64)) == 2^(p mod 64)`.
-  public func bittest(x : Nat64, p : Nat) : Bool {
-    Prim.btstNat64(x, Prim.natToNat64(p));
-  };
-
-  /// Returns the value of setting bit `p mod 64` in `x` to `1`.
-  public func bitset(x : Nat64, p : Nat) : Nat64 {
-    x | (1 << Prim.natToNat64(p));
-  };
-
-  /// Returns the value of clearing bit `p mod 64` in `x` to `0`.
-  public func bitclear(x : Nat64, p : Nat) : Nat64 {
-    x & ^(1 << Prim.natToNat64(p));
-  };
-
-  /// Returns the value of flipping bit `p mod 64` in `x`.
-  public func bitflip(x : Nat64, p : Nat) : Nat64 {
-    x ^ (1 << Prim.natToNat64(p));
-  };
-
-  /// Returns the count of non-zero bits in `x`.
-  public let bitcountNonZero : (x : Nat64) -> Nat64 = Prim.popcntNat64;
-
-  /// Returns the count of leading zero bits in `x`.
-  public let bitcountLeadingZero : (x : Nat64) -> Nat64 = Prim.clzNat64;
-
-  /// Returns the count of trailing zero bits in `x`.
-  public let bitcountTrailingZero : (x : Nat64) -> Nat64 = Prim.ctzNat64;
-
-  /// Returns the sum of `x` and `y`, `x +% y`. Wraps on overflow.
-  public func addWrap(x : Nat64, y : Nat64) : Nat64 { x +% y };
-
-  /// Returns the difference of `x` and `y`, `x -% y`. Wraps on underflow.
-  public func subWrap(x : Nat64, y : Nat64) : Nat64 { x -% y };
-
-  /// Returns the product of `x` and `y`, `x *% y`. Wraps on overflow.
-  public func mulWrap(x : Nat64, y : Nat64) : Nat64 { x *% y };
-
-  /// Returns `x` to the power of `y`, `x **% y`. Wraps on overflow.
-  public func powWrap(x : Nat64, y : Nat64) : Nat64 { x **% y };
-
-}

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

@@ -1,146 +0,0 @@
-/// 8-bit unsigned integers with checked arithmetic
-///
-/// Most operations are available as built-in operators (e.g. `1 + 1`).
-import Nat "Nat";
-import Prim "mo:⛔";
-
-module {
-
-  /// 8-bit natural numbers.
-  public type Nat8 = Prim.Types.Nat8;
-
-  /// Conversion.
-  public let toNat : Nat8 -> Nat = Prim.nat8ToNat;
-
-  /// Conversion. Traps on overflow/underflow.
-  public let fromNat : Nat -> Nat8  = Prim.natToNat8;
-
-  /// Conversion. Wraps on overflow/underflow.
-  public let fromIntWrap : Int -> Nat8  = Prim.intToNat8Wrap;
-
-  /// Returns the Text representation of `x`.
-  public func toText(x : Nat8) : Text {
-    Nat.toText(toNat(x))
-  };
-
-  /// Returns the minimum of `x` and `y`.
-  public func min(x : Nat8, y : Nat8) : Nat8 {
-    if (x < y) { x } else { y }
-  };
-
-  /// Returns the maximum of `x` and `y`.
-  public func max( x : Nat8, y : Nat8) : Nat8 {
-    if (x < y) { y } else { x }
-  };
-
-  /// Returns `x == y`.
-  public func equal(x : Nat8, y : Nat8) : Bool { x == y };
-
-  /// Returns `x != y`.
-  public func notEqual(x : Nat8, y : Nat8) : Bool { x != y };
-
-  /// Returns `x < y`.
-  public func less(x : Nat8, y : Nat8) : Bool { x < y };
-
-  /// Returns `x <= y`.
-  public func lessOrEqual(x : Nat8, y : Nat8) : Bool { x <= y };
-
-  /// Returns `x > y`.
-  public func greater(x : Nat8, y : Nat8) : Bool { x > y };
-
-  /// Returns `x >= y`.
-  public func greaterOrEqual(x : Nat8, y : Nat8) : Bool { x >= y };
-
-  /// Returns the order of `x` and `y`.
-  public func compare(x : Nat8, y : Nat8) : { #less; #equal; #greater } {
-    if (x < y) { #less }
-    else if (x == y) { #equal }
-    else { #greater }
-  };
-
-  /// Returns the sum of `x` and `y`, `x + y`. Traps on overflow.
-  public func add(x : Nat8, y : Nat8) : Nat8 { x + y };
-
-  /// Returns the difference of `x` and `y`, `x - y`. Traps on underflow.
-  public func sub(x : Nat8, y : Nat8) : Nat8 { x - y };
-
-  /// Returns the product of `x` and `y`, `x * y`. Traps on overflow.
-  public func mul(x : Nat8, y : Nat8) : Nat8 { x * y };
-
-  /// Returns the division of `x by y`, `x / y`.
-  /// Traps when `y` is zero.
-  public func div(x : Nat8, y : Nat8) : Nat8 { x / y };
-
-  /// Returns the remainder of `x` divided by `y`, `x % y`.
-  /// Traps when `y` is zero.
-  public func rem(x : Nat8, y : Nat8) : Nat8 { x % y };
-
-  /// Returns `x` to the power of `y`, `x ** y`. Traps on overflow.
-  public func pow(x : Nat8, y : Nat8) : Nat8 { x ** y };
-
-  /// Returns the bitwise negation of `x`, `^x`.
-  public func bitnot(x : Nat8, y : Nat8) : Nat8 { ^x };
-
-  /// Returns the bitwise and of `x` and `y`, `x & y`.
-  public func bitand(x : Nat8, y : Nat8) : Nat8 { x & y };
-
-  /// Returns the bitwise or of `x` and `y`, `x \| y`.
-  public func bitor(x : Nat8, y : Nat8) : Nat8 { x | y };
-
-  /// Returns the bitwise exclusive or of `x` and `y`, `x ^ y`.
-  public func bitxor(x : Nat8, y : Nat8) : Nat8 { x ^ y };
-
-  /// Returns the bitwise shift left of `x` by `y`, `x << y`.
-  public func bitshiftLeft(x : Nat8, y : Nat8) : Nat8 { x << y };
-
-  /// Returns the bitwise shift right of `x` by `y`, `x >> y`.
-  public func bitshiftRight(x : Nat8, y : Nat8) : Nat8 { x >> y };
-
-  /// Returns the bitwise rotate left of `x` by `y`, `x <<> y`.
-  public func bitrotLeft(x : Nat8, y : Nat8) : Nat8 { x <<> y };
-
-  /// Returns the bitwise rotate right of `x` by `y`, `x <>> y`.
-  public func bitrotRight(x : Nat8, y : Nat8) : Nat8 { x <>> y };
-
-  /// Returns the value of bit `p mod 8` in `x`, `(x & 2^(p mod 8)) == 2^(p mod 8)`.
-  public func bittest(x : Nat8, p : Nat) : Bool {
-    Prim.btstNat8(x, Prim.natToNat8(p));
-  };
-
-  /// Returns the value of setting bit `p mod 8` in `x` to `1`.
-  public func bitset(x : Nat8, p : Nat) : Nat8 {
-    x | (1 << Prim.natToNat8(p));
-  };
-
-  /// Returns the value of clearing bit `p mod 8` in `x` to `0`.
-  public func bitclear(x : Nat8, p : Nat) : Nat8 {
-    x & ^(1 << Prim.natToNat8(p));
-  };
-
-  /// Returns the value of flipping bit `p mod 8` in `x`.
-  public func bitflip(x : Nat8, p : Nat) : Nat8 {
-    x ^ (1 << Prim.natToNat8(p));
-  };
-
-  /// Returns the count of non-zero bits in `x`.
-  public let bitcountNonZero : (x : Nat8) -> Nat8 = Prim.popcntNat8;
-
-  /// Returns the count of leading zero bits in `x`.
-  public let bitcountLeadingZero : (x : Nat8) -> Nat8 = Prim.clzNat8;
-
-  /// Returns the count of trailing zero bits in `x`.
-  public let bitcountTrailingZero : (x : Nat8) -> Nat8 = Prim.ctzNat8;
-
-  /// Returns the sum of `x` and `y`, `x +% y`. Wraps on overflow.
-  public func addWrap(x : Nat8, y : Nat8) : Nat8 { x +% y };
-
-  /// Returns the difference of `x` and `y`, `x -% y`. Wraps on underflow.
-  public func subWrap(x : Nat8, y : Nat8) : Nat8 { x -% y };
-
-  /// Returns the product of `x` and `y`, `x *% y`. Wraps on overflow.
-  public func mulWrap(x : Nat8, y : Nat8) : Nat8 { x *% y };
-
-  /// Returns `x` to the power of `y`, `x **% y`. Wraps on overflow.
-  public func powWrap(x : Nat8, y : Nat8) : Nat8 { x **% y };
-
-}

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

@@ -1,19 +0,0 @@
-/// The absent value
-///
-/// The `None` type represents a type with _no_ value.
-///
-/// It is often used to type code that fails to return control (e.g. an infinite loop)
-/// or to designate impossible values (e.g. the type `?None` only contains `null`).
-
-import Prim "mo:⛔";
-
-module {
-
-  /// The empty type. A subtype of all types.
-  public type None = Prim.Types.None;
-
-  /// Turns an absurd value into an arbitrary type.
-  public let impossible : <A> None -> A = func<A>(x : None) : A {
-    switch (x) {};
-  };
-}