ic-mops 0.8.5 → 0.8.7

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

@@ -1,144 +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) : 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.8.3/src/Nat8.mo

@@ -1,144 +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) : 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.8.3/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) {}
-  }
-}

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

@@ -1,154 +0,0 @@
-/// Typesafe nulls
-///
-/// Optional values can be seen as a typesafe `null`. A value of type `?Int` can
-/// be constructed with either `null` or `?42`. The simplest way to get at the
-/// contents of an optional is to use pattern matching:
-///
-/// ```motoko
-/// let optionalInt1 : ?Int = ?42;
-/// let optionalInt2 : ?Int = null;
-///
-/// let int1orZero : Int = switch optionalInt1 {
-///   case null 0;
-///   case (?int) int;
-/// };
-/// assert int1orZero == 42;
-///
-/// let int2orZero : Int = switch optionalInt2 {
-///   case null 0;
-///   case (?int) int;
-/// };
-/// assert int2orZero == 0;
-/// ```
-///
-/// The functions in this module capture some common operations when working
-/// with optionals that can be more succinct than using pattern matching.
-
-import P "Prelude";
-
-module {
-
-  /// Unwraps an optional value, with a default value, i.e. `get(?x, d) = x` and
-  /// `get(null, d) = d`.
-  public func get<T>(x : ?T, default : T) : T = switch x {
-    case null { default };
-    case (?x_) { x_ }
-  };
-
-  /// Unwraps an optional value using a function, or returns the default, i.e.
-  /// `option(?x, f, d) = f x` and `option(null, f, d) = d`.
-  public func getMapped<A, B>(x : ?A, f : A -> B, default : B) : B = switch x {
-    case null { default };
-    case (?x_) { f(x_) }
-  };
-
-  /// Applies a function to the wrapped value. `null`'s are left untouched.
-  /// ```motoko
-  /// import Option "mo:base/Option";
-  /// assert Option.map<Nat, Nat>(?42, func x = x + 1) == ?43;
-  /// assert Option.map<Nat, Nat>(null, func x = x + 1) == null;
-  /// ```
-  public func map<A, B>(x : ?A, f : A -> B) : ?B = switch x {
-    case null { null };
-    case (?x_) { ?f(x_) }
-  };
-
-  /// Applies a function to the wrapped value, but discards the result. Use
-  /// `iterate` if you're only interested in the side effect `f` produces.
-  ///
-  /// ```motoko
-  /// import Option "mo:base/Option";
-  /// var counter : Nat = 0;
-  /// Option.iterate(?5, func (x : Nat) { counter += x });
-  /// assert counter == 5;
-  /// Option.iterate(null, func (x : Nat) { counter += x });
-  /// assert counter == 5;
-  /// ```
-  public func iterate<A>(x : ?A, f : A -> ()) = switch x {
-    case null {};
-    case (?x_) { f(x_) }
-  };
-
-  /// Applies an optional function to an optional value. Returns `null` if at
-  /// least one of the arguments is `null`.
-  public func apply<A, B>(x : ?A, f : ?(A -> B)) : ?B {
-    switch (f, x) {
-      case (?f_, ?x_) {
-        ?f_(x_)
-      };
-      case (_, _) {
-        null
-      }
-    }
-  };
-
-  /// Applies a function to an optional value. Returns `null` if the argument is
-  /// `null`, or the function returns `null`.
-  public func chain<A, B>(x : ?A, f : A -> ?B) : ?B {
-    switch (x) {
-      case (?x_) {
-        f(x_)
-      };
-      case (null) {
-        null
-      }
-    }
-  };
-
-  /// Given an optional optional value, removes one layer of optionality.
-  /// ```motoko
-  /// import Option "mo:base/Option";
-  /// assert Option.flatten(?(?(42))) == ?42;
-  /// assert Option.flatten(?(null)) == null;
-  /// assert Option.flatten(null) == null;
-  /// ```
-  public func flatten<A>(x : ??A) : ?A {
-    chain<?A, A>(
-      x,
-      func(x_ : ?A) : ?A {
-        x_
-      }
-    )
-  };
-
-  /// Creates an optional value from a definite value.
-  /// ```motoko
-  /// import Option "mo:base/Option";
-  /// assert Option.make(42) == ?42;
-  /// ```
-  public func make<A>(x : A) : ?A = ?x;
-
-  /// Returns true if the argument is not `null`, otherwise returns false.
-  public func isSome(x : ?Any) : Bool = switch x {
-    case null { false };
-    case _ { true }
-  };
-
-  /// Returns true if the argument is `null`, otherwise returns false.
-  public func isNull(x : ?Any) : Bool = switch x {
-    case null { true };
-    case _ { false }
-  };
-
-  /// Asserts that the value is not `null`; fails otherwise.
-  /// @deprecated Option.assertSome will be removed soon; use an assert expression instead
-  public func assertSome(x : ?Any) = switch x {
-    case null { P.unreachable() };
-    case _ {}
-  };
-
-  /// Asserts that the value _is_ `null`; fails otherwise.
-  /// @deprecated Option.assertNull will be removed soon; use an assert expression instead
-  public func assertNull(x : ?Any) = switch x {
-    case null {};
-    case _ { P.unreachable() }
-  };
-
-  /// Unwraps an optional value, i.e. `unwrap(?x) = x`.
-  ///
-  /// @deprecated Option.unwrap is unsafe and fails if the argument is null; it will be removed soon; use a `switch` or `do?` expression instead
-  public func unwrap<T>(x : ?T) : T = switch x {
-    case null { P.unreachable() };
-    case (?x_) { x_ }
-  }
-}

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

@@ -1,46 +0,0 @@
-/// Order
-
-module {
-
-  /// A type to represent an order.
-  public type Order = {
-    #less;
-    #equal;
-    #greater
-  };
-
-  /// Check if an order is #less.
-  public func isLess(order : Order) : Bool {
-    switch order {
-      case (#less) { true };
-      case _ { false }
-    }
-  };
-
-  /// Check if an order is #equal.
-  public func isEqual(order : Order) : Bool {
-    switch order {
-      case (#equal) { true };
-      case _ { false }
-    }
-  };
-
-  /// Check if an order is #greater.
-  public func isGreater(order : Order) : Bool {
-    switch order {
-      case (#greater) { true };
-      case _ { false }
-    }
-  };
-
-  /// Returns true if only if  `o1` and `o2` are the same ordering.
-  public func equal(o1 : Order, o2 : Order) : Bool {
-    switch (o1, o2) {
-      case (#less, #less) { true };
-      case (#equal, #equal) { true };
-      case (#greater, #greater) { true };
-      case _ { false }
-    }
-  };
-
-}

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

@@ -1,33 +0,0 @@
-/// General utilities
-///
-/// This prelude file proposes standard library features that _may_
-/// belong in the _language_ (compiler-internal) prelude sometime, after
-/// some further experience and discussion.  Until then, they live here.
-
-import Debug "Debug";
-
-module {
-
-  /// Not yet implemented
-  ///
-  /// Mark incomplete code with the `nyi` and `xxx` functions.
-  ///
-  /// Each have calls are well-typed in all typing contexts, which
-  /// trap in all execution contexts.
-  public func nyi() : None {
-    Debug.trap("Prelude.nyi()")
-  };
-
-  public func xxx() : None {
-    Debug.trap("Prelude.xxx()")
-  };
-
-  /// Mark unreachable code with the `unreachable` function.
-  ///
-  /// Calls are well-typed in all typing contexts, and they
-  /// trap in all execution contexts.
-  public func unreachable() : None {
-    Debug.trap("Prelude.unreachable()")
-  };
-
-}