ic-mops 0.8.5 → 0.8.7

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

@@ -1,29 +0,0 @@
-/// Certified data.
-///
-/// The Internet Computer allows canister smart contracts to store a small amount of data during
-/// update method processing so that during query call processing, the canister can obtain
-/// a certificate about that data.
-///
-/// This module provides a _low-level_ interface to this API, aimed at advanced
-/// users and library implementors. See the Internet Computer Functional
-/// Specification and corresponding documentation for how to use this to make query
-/// calls to your canister tamperproof.
-
-import Prim "mo:⛔";
-
-module {
-
-  /// Set the certified data.
-  ///
-  /// Must be called from an update method, else traps.
-  /// Must be passed a blob of at most 32 bytes, else traps.
-  public let set : (data : Blob) -> () = Prim.setCertifiedData;
-
-  /// Gets a certificate
-  ///
-  /// Returns `null` if no certificate is available, e.g. when processing an
-  /// update call or inter-canister call. This returns a non-`null` value only
-  /// when processing a query call.
-  public let getCertificate : () -> ?Blob = Prim.getCertificate;
-
-}

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

@@ -1,67 +0,0 @@
-/// Characters
-import Prim "mo:⛔";
-module {
-
-  /// Characters represented as Unicode code points.
-  public type Char = Prim.Types.Char;
-
-  /// Convert character `c` to a word containing its Unicode scalar value.
-  public let toNat32 : (c : Char) -> Nat32 = Prim.charToNat32;
-
-  /// Convert `w` to a character.
-  /// Traps if `w` is not a valid Unicode scalar value.
-  /// Value `w` is valid if, and only if, `w < 0xD800 or (0xE000 <= w and w <= 0x10FFFF)`.
-  public let fromNat32 : (w : Nat32) -> Char = Prim.nat32ToChar;
-
-  /// Convert character `c` to single character text.
-  public let toText : (c : Char) -> Text = Prim.charToText;
-
-  // Not exposed pending multi-char implementation.
-  private let toUpper : (c : Char) -> Char = Prim.charToUpper;
-
-  // Not exposed pending multi-char implementation.
-  private let toLower : (c : Char) -> Char = Prim.charToLower;
-
-  /// Returns `true` when `c` is a decimal digit between `0` and `9`, otherwise `false`.
-  public func isDigit(c : Char) : Bool {
-    Prim.charToNat32(c) -% Prim.charToNat32('0') <= (9 : Nat32)
-  };
-
-  /// Returns the Unicode _White_Space_ property of `c`.
-  public let isWhitespace : (c : Char) -> Bool = Prim.charIsWhitespace;
-
-  /// Returns the Unicode _Lowercase_ property of `c`.
-  public let isLowercase : (c : Char) -> Bool = Prim.charIsLowercase;
-
-  /// Returns the Unicode _Uppercase_ property of `c`.
-  public let isUppercase : (c : Char) -> Bool = Prim.charIsUppercase;
-
-  /// Returns the Unicode _Alphabetic_ property of `c`.
-  public let isAlphabetic : (c : Char) -> Bool = Prim.charIsAlphabetic;
-
-  /// Returns `x == y`.
-  public func equal(x : Char, y : Char) : Bool { x == y };
-
-  /// Returns `x != y`.
-  public func notEqual(x : Char, y : Char) : Bool { x != y };
-
-  /// Returns `x < y`.
-  public func less(x : Char, y : Char) : Bool { x < y };
-
-  /// Returns `x <= y`.
-  public func lessOrEqual(x : Char, y : Char) : Bool { x <= y };
-
-  /// Returns `x > y`.
-  public func greater(x : Char, y : Char) : Bool { x > y };
-
-  /// Returns `x >= y`.
-  public func greaterOrEqual(x : Char, y : Char) : Bool { x >= y };
-
-  /// Returns the order of `x` and `y`.
-  public func compare(x : Char, y : Char) : { #less; #equal; #greater } {
-    if (x < y) { #less }
-    else if (x == y) { #equal }
-    else { #greater }
-  };
-
-}

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

@@ -1,15 +0,0 @@
-/// Debugging aids
-
-import Prim "mo:⛔";
-module {
-
-  /// `print(t)` emits text `t` to the debug output stream.
-  /// How this stream is stored or displayed depends on the
-  /// execution environment.
-  public let print : Text -> () = Prim.debugPrint;
-
-  /// `trap(t)` traps execution with a user-provided message.
-  public let trap : Text -> None = Prim.trap;
-
-
-}

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

@@ -1,75 +0,0 @@
-/// Functions for persistent, double-ended queues.
-
-import List "List";
-import P "Prelude";
-
-module {
-  type List<T> = List.List<T>;
-
-  /// Double-ended queue
-  public type Deque<T> = (List<T>, List<T>);
-
-  /// Empty queue
-  public func empty<T> () : Deque<T> { (List.nil(), List.nil()); };
-
-  /// True when the queue is empty
-  public func isEmpty<T>(q : Deque<T>) : Bool {
-    switch q {
-      case (f, r) { List.isNil(f) and List.isNil(r) };
-    }
-  };
-
-  func check<T>(q : Deque<T>) : Deque<T> {
-    switch q {
-      case (null, r) { let (a,b) = List.split(List.size(r) / 2, r); (List.reverse(b), a) };
-      case (f, null) { let (a,b) = List.split(List.size(f) / 2, f); (a, List.reverse(b)) };
-      case q { q };
-    }
-  };
-
-  /// Insert a new element on the front end of the queue
-  public func pushFront<T>(q : Deque<T>, x : T) : Deque<T> {
-    check (List.push(x, q.0), q.1);
-  };
-
-  /// Inspect the (optional) first element on the front end of the queue
-  public func peekFront<T>(q : Deque<T>) : ?T {
-    switch q {
-      case (?(x, f), r) { ?x };
-      case (null, ?(x, r)) { ?x };
-      case _ { null };
-    };
-  };
-
-  /// Remove the first element on the front end of the queue; Returns null when empty.
-  public func popFront<T>(q : Deque<T>) : ?(T, Deque<T>) {
-    switch q {
-      case (?(x, f), r) { ?(x, check(f, r)) };
-      case (null, ?(x, r)) { ?(x, check(null, r)) };
-      case _ { null };
-    };
-  };
-
-  /// Insert a new element on the back end of the queue
-  public func pushBack<T>(q : Deque<T>, x : T) : Deque<T> {
-    check (q.0, List.push(x, q.1));
-  };
-
-  /// Inspect the (optional) first element on the back end of the queue
-  public func peekBack<T>(q : Deque<T>) : ?T {
-    switch q {
-      case (f, ?(x, r)) { ?x };
-      case (?(x, r), null) { ?x };
-      case _ { null };
-    };
-  };
-
-  /// Remove the first element on the back end of the queue; Returns null when empty.
-  public func popBack<T>(q : Deque<T>) : ?(Deque<T>, T) {
-    switch q {
-      case (f, ?(x, r)) { ?(check(f, r), x) };
-      case (?(x, f), null) { ?(check(f, null), x) };
-      case _ { null };
-    };
-  };
-};

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

@@ -1,41 +0,0 @@
-/// Error values and inspection.
-///
-/// The `Error` type is the argument to `throw`, parameter of `catch`.
-/// The `Error` type is opaque.
-
-import Prim "mo:⛔";
-
-module {
-
-  /// Error values resulting from  `async` computations
-  public type Error = Prim.Types.Error;
-
-  /// Error codes (user and system), where module `Prim` defines:
-  /// ```motoko
-  /// type ErrorCode = {
-  ///   // Fatal error.
-  ///   #system_fatal;
-  ///   // Transient error.
-  ///   #system_transient;
-  ///   // Destination invalid.
-  ///   #destination_invalid;
-  ///   // Explicit reject by canister code.
-  ///   #canister_reject;
-  ///   // Canister trapped.
-  ///   #canister_error;
-  ///   // Future error code (with unrecognized numeric code)
-  ///   #future : Nat32;
-  /// };
-  /// ```
-  public type ErrorCode = Prim.ErrorCode;
-
-  /// Create an error from message `m` with code #canister_reject.
-  public let reject : (m : Text) -> Error = Prim.error;
-
-  /// Returns the code of an error `e`.
-  public let code : (e : Error) -> ErrorCode = Prim.errorCode;
-
-  /// Returns the message of an error `e`.
-  public let message : (e : Error) -> Text = Prim.errorMessage;
-
-}

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

@@ -1,51 +0,0 @@
-/// Managing cycles
-///
-/// Usage of the Internet Computer is measured, and paid for, in _cycles_.
-/// This library provides imperative operations for observing cycles, transferring cycles and
-/// observing refunds of cycles.
-///
-/// **WARNING:** This low-level API is **experimental** and likely to change or even disappear.
-/// Dedicated syntactic support for manipulating cycles may be added to the language in future, obsoleting this library.
-///
-/// **NOTE:** Since cycles measure computational resources, the value of
-/// `balance()` can change from one call to the next.
-
-import Prim "mo:⛔";
-module {
-
-  /// Returns the actor's current balance of cycles as `amount`.
-  public let balance : () -> (amount : Nat) = Prim.cyclesBalance;
-
-  /// Returns the currently available `amount` of cycles.
-  /// The amount available is the amount received in the current call,
-  /// minus the cumulative amount `accept`ed by this call.
-  /// On exit from the current shared function or async expression via `return` or `throw`
-  /// any remaining available amount is automatically
-  /// refunded to the caller/context.
-  public let available : () -> (amount : Nat) = Prim.cyclesAvailable;
-
-  /// Transfers up to `amount` from `available()` to `balance()`.
-  /// Returns the amount actually transferred, which may be less than
-  /// requested, for example, if less is available, or if canister balance limits are reached.
-  public let accept : (amount : Nat) -> (accepted : Nat) = Prim.cyclesAccept;
-
-  /// Indicates additional `amount` of cycles to be transferred in
-  /// the next call, that is, evaluation of a shared function call or
-  /// async expression.
-  /// Traps if the current total would exceed 2^128 cycles.
-  /// Upon the call, but not before, the total amount of cycles ``add``ed since
-  /// the last call is deducted from `balance()`.
-  /// If this total exceeds `balance()`, the caller traps, aborting the call.
-  ///
-  /// **Note**: the implicit register of added amounts is reset to zero on entry to
-  /// a shared function and after each shared function call or resume from an await.
-  public let add : (amount : Nat) -> () = Prim.cyclesAdd;
-
-  /// Reports `amount` of cycles refunded in the last `await` of the current
-  /// context, or zero if no await has occurred yet.
-  /// Calling `refunded()` is solely informational and does not affect `balance()`.
-  /// Instead, refunds are automatically added to the current balance,
-  /// whether or not `refunded` is used to observe them.
-  public let refunded : () -> (amount : Nat) = Prim.cyclesRefunded;
-
-}

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

@@ -1,36 +0,0 @@
-/// Low-level interface to the Internet Computer.
-///
-/// **WARNING:** This low-level API is **experimental** and likely to change or even disappear.
-
-import Prim "mo:⛔";
-
-module {
-
-  /// Calls ``canister``'s update or query function, `name`, with the binary contents of `data` as IC argument.
-  /// Returns the response to the call, an IC _reply_ or _reject_, as a Motoko future:
-  ///
-  /// * The message data of an IC reply determines the binary contents of `reply`.
-  /// * The error code and textual message data of an IC reject determines the future's `Error` value.
-  ///
-  /// Note: `call` is an asynchronous function and can only be applied in an asynchronous context.
-  public let call : (canister : Principal, name : Text, data : Blob) ->
-     async (reply : Blob) = Prim.call_raw;
-
-  /// Given computation, `comp`, counts the number of actual and (for IC system calls) notional WebAssembly
-  /// instructions performed during the execution of `comp()`.
-  ///
-  /// More precisely, returns the difference between the state of the IC instruction counter (_performance counter_ `0`) before and after executing `comp()`
-  /// (see [Performance Counter](https://internetcomputer.org/docs/current/references/ic-interface-spec#system-api-performance-counter)).
-  ///
-  /// NB: `countInstructions(comp)` will _not_ account for any deferred garbage collection costs incurred by `comp()`.
-  public func countInstructions(comp : () -> ()) : Nat64 {
-    let init = Prim.performanceCounter(0);
-    let pre = Prim.performanceCounter(0);
-    comp();
-    let post = Prim.performanceCounter(0);
-    // performance_counter costs around 200 extra instructions, we perform an empty measurement to decide the overhead
-    let overhead = pre - init;
-    post - pre - overhead
-  }
-
-}

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

@@ -1,121 +0,0 @@
-/// Byte-level access to (virtual) _stable memory_.
-///
-/// **WARNING**: As its name suggests, this library is **experimental**, subject to change
-/// and may be replaced by safer alternatives in later versions of Motoko.
-/// Use at your own risk and discretion.
-///
-/// This is a lightweight abstraction over IC _stable memory_ and supports persisting
-/// raw binary data across Motoko upgrades.
-/// Use of this module is fully compatible with Motoko's use of
-/// _stable variables_, whose persistence mechanism also uses (real) IC stable memory internally, but does not interfere with this API.
-///
-/// Memory is allocated, using `grow(pages)`, sequentially and on demand, in units of 64KiB pages, starting with 0 allocated pages.
-/// New pages are zero initialized.
-/// Growth is capped by a soft limit on page count controlled by compile-time flag
-/// `--max-stable-pages <n>` (the default is 65536, or 4GiB).
-///
-/// Each `load` operation loads from byte address `offset` in little-endian
-/// format using the natural bit-width of the type in question.
-/// The operation traps if attempting to read beyond the current stable memory size.
-///
-/// Each `store` operation stores to byte address `offset` in little-endian format using the natural bit-width of the type in question.
-/// The operation traps if attempting to write beyond the current stable memory size.
-///
-/// Text values can be handled by using `Text.decodeUtf8` and `Text.encodeUtf8`, in conjunction with `loadBlob` and `storeBlob`.
-///
-/// The current page allocation and page contents is preserved across upgrades.
-///
-/// NB: The IC's actual stable memory size (`ic0.stable_size`) may exceed the
-/// page size reported by Motoko function `size()`.
-/// This (and the cap on growth) are to accommodate Motoko's stable variables.
-/// Applications that plan to use Motoko stable variables sparingly or not at all can
-/// increase `--max-stable-pages` as desired, approaching the IC maximum (currently 8GiB).
-/// All applications should reserve at least one page for stable variable data, even when no stable variables are used.
-
-import Prim "mo:⛔";
-
-module {
-
-  /// Current size of the stable memory, in pages.
-  /// Each page is 64KiB (65536 bytes).
-  /// Initially `0`.
-  /// Preserved across upgrades, together with contents of allocated
-  /// stable memory.
-  public let size : () -> (pages : Nat64) =
-    Prim.stableMemorySize;
-
-  /// Grow current `size` of stable memory by `pagecount` pages.
-  /// Each page is 64KiB (65536 bytes).
-  /// Returns previous `size` when able to grow.
-  /// Returns `0xFFFF_FFFF_FFFF_FFFF` if remaining pages insufficient.
-  /// Every new page is zero-initialized, containing byte 0 at every offset.
-  /// Function `grow` is capped by a soft limit on `size` controlled by compile-time flag
-  ///  `--max-stable-pages <n>` (the default is 65536, or 4GiB).
-  public let grow : (new_pages : Nat64) -> (oldpages : Nat64) =
-    Prim.stableMemoryGrow;
-
-  /// Returns a query that, when called, returns the number of bytes of (real) IC stable memory that would be
-  /// occupied by persisting its current stable variables before an upgrade.
-  /// This function may be used to monitor or limit real stable memory usage.
-  /// The query computes the estimate by running the first half of an upgrade, including any `preupgrade` system method.
-  /// Like any other query, its state changes are discarded so no actual upgrade (or other state change) takes place.
-  /// The query can only be called by the enclosing actor and will trap for other callers.
-  public let stableVarQuery : () -> (shared query () -> async {size : Nat64}) =
-    Prim.stableVarQuery;
-
-  public let loadNat32 : (offset : Nat64) -> Nat32 =
-    Prim.stableMemoryLoadNat32;
-  public let storeNat32 : (offset : Nat64, value: Nat32) -> () =
-    Prim.stableMemoryStoreNat32;
-
-  public let loadNat8 : (offset : Nat64) -> Nat8 =
-    Prim.stableMemoryLoadNat8;
-  public let storeNat8 : (offset : Nat64, value : Nat8) -> () =
-    Prim.stableMemoryStoreNat8;
-
-  public let loadNat16 : (offset : Nat64) -> Nat16 =
-    Prim.stableMemoryLoadNat16;
-  public let storeNat16 : (offset : Nat64, value : Nat16) -> () =
-    Prim.stableMemoryStoreNat16;
-
-  public let loadNat64 : (offset : Nat64) -> Nat64 =
-    Prim.stableMemoryLoadNat64;
-  public let storeNat64 : (offset : Nat64, value : Nat64) -> () =
-    Prim.stableMemoryStoreNat64;
-
-  public let loadInt32 : (offset : Nat64) -> Int32 =
-    Prim.stableMemoryLoadInt32;
-  public let storeInt32 : (offset : Nat64, value : Int32) -> () =
-    Prim.stableMemoryStoreInt32;
-
-  public let loadInt8 : (offset : Nat64) -> Int8 =
-    Prim.stableMemoryLoadInt8;
-  public let storeInt8 : (offset : Nat64, value : Int8) -> () =
-    Prim.stableMemoryStoreInt8;
-
-  public let loadInt16 : (offset : Nat64) -> Int16 =
-    Prim.stableMemoryLoadInt16;
-  public let storeInt16 : (offset : Nat64, value : Int16) -> () =
-    Prim.stableMemoryStoreInt16;
-
-  public let loadInt64 : (offset : Nat64) -> Int64 =
-    Prim.stableMemoryLoadInt64;
-  public let storeInt64 : (offset : Nat64, value : Int64) -> () =
-    Prim.stableMemoryStoreInt64;
-
-  public let loadFloat : (offset : Nat64) -> Float =
-    Prim.stableMemoryLoadFloat;
-  public let storeFloat : (offset : Nat64, value : Float) -> () =
-    Prim.stableMemoryStoreFloat;
-
-  /// Load `size` bytes starting from `offset` as a `Blob`.
-  /// Traps on out-of-bounds access.
-  public let loadBlob : (offset : Nat64, size : Nat) -> Blob =
-    Prim.stableMemoryLoadBlob;
-
-  /// Write bytes of `blob` beginning at `offset`.
-  /// Traps on out-of-bounds access.
-  public let storeBlob : (offset : Nat64, value : Blob) -> () =
-    Prim.stableMemoryStoreBlob;
-
-}

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

@@ -1,150 +0,0 @@
-/// 64-bit Floating-point numbers
-
-import Prim "mo:⛔";
-import Int "Int";
-
-module {
-
-  /// 64-bit floating point numbers.
-  public type Float = Prim.Types.Float;
-
-  /// Ratio of the circumference of a circle to its diameter.
-  public let pi : Float = 3.14159265358979323846; // taken from musl math.h
-
-  /// Base of the natural logarithm.
-  public let e : Float  = 2.7182818284590452354;  // taken from musl math.h
-
-  /// Returns the absolute value of `x`.
-  public let abs : (x : Float) -> Float = Prim.floatAbs;
-
-  /// Returns the square root of `x`.
-  public let sqrt : (x : Float) -> Float = Prim.floatSqrt;
-
-  /// Returns the smallest integral float greater than or equal to `x`.
-  public let ceil : (x : Float) -> Float = Prim.floatCeil;
-
-  /// Returns the largest integral float less than or equal to `x`.
-  public let floor : (x : Float) -> Float = Prim.floatFloor;
-
-  /// Returns the nearest integral float not greater in magnitude than `x`.
-  public let trunc : (x : Float) -> Float = Prim.floatTrunc;
-
-  /// Returns the nearest integral float to `x`.
-  public let nearest : (x : Float) -> Float = Prim.floatNearest;
-
-  /// Returns `x` if `x` and `y` have same sign, otherwise `x` with negated sign.
-  public let copySign : (x : Float, y : Float) -> Float = Prim.floatCopySign;
-
-  /// Returns the smaller value of `x` and `y`.
-  public let min : (x : Float, y :  Float) -> Float = Prim.floatMin;
-
-  /// Returns the larger value of `x` and `y`.
-  public let max : (x : Float, y : Float) -> Float = Prim.floatMax;
-
-  /// Returns the sine of the radian angle `x`.
-  public let sin : (x : Float) -> Float = Prim.sin;
-
-  /// Returns the cosine of the radian angle `x`.
-  public let cos : (x : Float) -> Float = Prim.cos;
-
-  /// Returns the tangent of the radian angle `x`.
-  public let tan : (x : Float) -> Float = Prim.tan;
-
-  /// Returns the arc sine of `x` in radians.
-  public let arcsin: (x : Float) -> Float = Prim.arcsin;
-
-  /// Returns the arc cosine of `x` in radians.
-  public let arccos : (x : Float) -> Float = Prim.arccos;
-
-  /// Returns the arc tangent of `x` in radians.
-  public let arctan : (x : Float) -> Float = Prim.arctan;
-
-  /// Given `(y,x)`, returns the arc tangent in radians of `y/x` based on the signs of both values to determine the correct quadrant.
-  public let arctan2 : (y : Float, x : Float) -> Float = Prim.arctan2;
-
-  /// Returns the value of `e` raised to the `x`-th power.
-  public let exp : (x : Float) -> Float = Prim.exp;
-
-  /// Returns the natural logarithm (base-`e`) of `x`.
-  public let log : (x : Float) -> Float = Prim.log;
-
-  /// Formatting. `format(fmt, x)` formats `x` to `Text` according to the
-  /// formatting directive `fmt`, which can take one of the following forms:
-  ///
-  /// * `#fix prec` as fixed-point format with `prec` digits
-  /// * `#exp prec` as exponential format with `prec` digits
-  /// * `#gen prec` as generic format with `prec` digits
-  /// * `#hex prec` as hexadecimal format with `prec` digits
-  /// * `#exact` as exact format that can be decoded without loss.
-  public func format
-    (fmt : { #fix : Nat8; #exp : Nat8; #gen : Nat8; #hex : Nat8; #exact }, x : Float) : Text =
-    switch fmt {
-      case (#fix(prec)) { Prim.floatToFormattedText(x, prec, 0) };
-      case (#exp(prec)) { Prim.floatToFormattedText(x, prec, 1) };
-      case (#gen(prec)) { Prim.floatToFormattedText(x, prec, 2) };
-      case (#hex(prec)) { Prim.floatToFormattedText(x, prec, 3) };
-      case (#exact) { Prim.floatToFormattedText(x, 17, 2) };
-    };
-
-  /// Conversion to Text. Use `format(fmt, x)` for more detailed control.
-  public let toText : Float -> Text = Prim.floatToText;
-
-  /// Conversion to Int64 by truncating Float, equivalent to `toInt64(trunc(f))`
-  public let toInt64 : Float -> Int64 = Prim.floatToInt64;
-
-  /// Conversion from Int64.
-  public let fromInt64 : Int64 -> Float = Prim.int64ToFloat;
-
-  /// Conversion to Int.
-  public let toInt : Float -> Int = Prim.floatToInt;
-
-  /// Conversion from Int. May result in `Inf`.
-  public let fromInt : Int -> Float = Prim.intToFloat;
-
-  /// Returns `x == y`.
-  public func equal(x : Float, y : Float) : Bool { x == y };
-
-  /// Returns `x != y`.
-  public func notEqual(x : Float, y : Float) : Bool { x != y };
-
-  /// Returns `x < y`.
-  public func less(x : Float, y : Float) : Bool { x < y };
-
-  /// Returns `x <= y`.
-  public func lessOrEqual(x : Float, y : Float) : Bool { x <= y };
-
-  /// Returns `x > y`.
-  public func greater(x : Float, y : Float) : Bool { x > y };
-
-  /// Returns `x >= y`.
-  public func greaterOrEqual(x : Float, y : Float) : Bool { x >= y };
-
-  /// Returns the order of `x` and `y`.
-  public func compare(x : Float, y : Float) : { #less; #equal; #greater} {
-    if (x < y) { #less }
-    else if (x == y) { #equal }
-    else { #greater }
-  };
-
-  /// Returns the negation of `x`, `-x` .
-  public func neq(x : Float) : Float { -x; };
-
-  /// Returns the sum of `x` and `y`, `x + y`.
-  public func add(x : Float, y : Float) : Float { x + y };
-
-  /// Returns the difference of `x` and `y`, `x - y`.
-  public func sub(x : Float, y : Float) : Float { x - y };
-
-  /// Returns the product of `x` and `y`, `x * y`.
-  public func mul(x : Float, y : Float) : Float { x * y };
-
-  /// Returns the division of `x` by `y`, `x / y`.
-  public func div(x : Float, y : Float) : Float { x / y };
-
-  /// Returns the remainder of `x` divided by `y`, `x % y`.
-  public func rem(x : Float, y : Float) : Float { x % y };
-
-  /// Returns `x` to the power of `y`, `x ** y`.
-  public func pow(x : Float, y : Float) : Float { x ** y };
-
-};

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

@@ -1,38 +0,0 @@
-/// Functions on functions
-///
-/// (Most commonly used when programming in functional style using higher-order
-/// functions.)
-
-module {
-
-  /// The composition of two functions `f` and `g` is a function that applies `g` and then `f`.
-  ///
-  /// ```
-  /// compose(f, g)(x) = f(g(x))
-  /// ```
-  public func compose<A, B, C>(f : B -> C, g : A -> B) : A -> C {
-    func (x : A) : C {
-      f(g(x));
-    };
-  };
-
-  /// The `identity` function returns its argument.
-  /// ```motoko
-  /// import Func "mo:base/Func";
-  /// assert(Func.identity(10) == 10);
-  /// assert(Func.identity(true) == true);
-  /// ```
-  public func identity<A>(x : A) : A = x;
-
-  /// The const function is a _curried_ function that accepts an argument `x`,
-  /// and then returns a function that discards its argument and always returns
-  /// the `x`.
-  ///
-  /// ```motoko
-  /// import Func "mo:base/Func";
-  /// assert(Func.const<Nat, Text>(10)("hello") == 10);
-  /// assert(Func.const<Bool, Nat>(true)(20) == true);
-  /// ```
-  public func const<A, B>(x : A) : B -> A =
-    func (_) = x;
-}