experiment: contextual dot + implicits

Changelog.md

@@ -5,6 +5,7 @@
 * Add `PriorityQueue` (#392).
 * Add support for Weak references (#388).
 * Clarify difference between `List` and `pure/List` in doc comments (#386).
+* **Breaking:** Rename `sort` to `sortInPlace`, add `sort` (#405).
 
 ## 1.0.0
 

mops.toml

@@ -20,8 +20,8 @@ matchers = "2.1.0"
 base-0-14-13 = "https://github.com/dfinity/motoko-base#moc-0.14.13@794174a307975c225cfb26b57f73e38a841c0415"
 
 [requirements]
-moc = "0.16.1"
+moc = "0.16.3-implicits-6"
 
 [toolchain]
-moc = "0.16.1"
+moc = "0.16.3-implicits-6"
 wasmtime = "35.0.0"

src/Array.mo

@@ -21,6 +21,8 @@ import Prim "mo:⛔";
 
 module {
 
+  public type Self<T> = [T];
+
   /// Creates an empty array (equivalent to `[]`).
   ///
   /// ```motoko include=import
@@ -120,7 +122,7 @@ module {
   /// Space: O(1)
   ///
   /// *Runtime and space assumes that `equal` runs in O(1) time and space.
-  public func equal<T>(array1 : [T], array2 : [T], equal : (T, T) -> Bool) : Bool {
+  public func equal<T>(array1 : [T], array2 : [T], equal : (implicit : (T, T) -> Bool)) : Bool {
     let size1 = array1.size();
     let size2 = array2.size();
     if (size1 != size2) {
@@ -221,7 +223,7 @@ module {
   ///
   /// Space: O(size)
   /// *Runtime and space assumes that `compare` runs in O(1) time and space.
-  public func sort<T>(array : [T], compare : (T, T) -> Order.Order) : [T] {
+  public func sort<T>(array : [T], compare : (implicit : (T, T) -> Order.Order)) : [T] {
     let varArray : [var T] = toVarArray(array);
     VarArray.sortInPlace(varArray, compare);
     fromVarArray(varArray)
@@ -800,7 +802,7 @@ module {
   /// Runtime: O(array.size())
   ///
   /// Space: O(1)
-  public func indexOf<T>(array : [T], equal : (T, T) -> Bool, element : T) : ?Nat = nextIndexOf<T>(array, equal, element, 0);
+  public func indexOf<T>(array : [T], equal : (implicit : (T, T) -> Bool), element : T) : ?Nat = nextIndexOf<T>(array, equal, element, 0);
 
   /// Returns the index of the next occurence of `element` in the `array` starting from the `from` index (inclusive).
   ///
@@ -817,7 +819,7 @@ module {
   /// Runtime: O(array.size())
   ///
   /// Space: O(1)
-  public func nextIndexOf<T>(array : [T], equal : (T, T) -> Bool, element : T, fromInclusive : Nat) : ?Nat {
+  public func nextIndexOf<T>(array : [T], equal : (implicit : (T, T) -> Bool), element : T, fromInclusive : Nat) : ?Nat {
     var index = fromInclusive;
     let size = array.size();
     while (index < size) {
@@ -844,7 +846,7 @@ module {
   /// Runtime: O(array.size())
   ///
   /// Space: O(1)
-  public func lastIndexOf<T>(array : [T], equal : (T, T) -> Bool, element : T) : ?Nat = prevIndexOf<T>(array, equal, element, array.size());
+  public func lastIndexOf<T>(array : [T], equal : (implicit : (T, T) -> Bool), element : T) : ?Nat = prevIndexOf<T>(array, equal, element, array.size());
 
   /// Returns the index of the previous occurence of `element` in the `array` starting from the `from` index (exclusive).
   ///
@@ -864,7 +866,7 @@ module {
   ///
   /// Runtime: O(array.size());
   /// Space: O(1);
-  public func prevIndexOf<T>(array : [T], equal : (T, T) -> Bool, element : T, fromExclusive : Nat) : ?Nat {
+  public func prevIndexOf<T>(array : [T], equal : (implicit : (T, T) -> Bool), element : T, fromExclusive : Nat) : ?Nat {
     var i = fromExclusive;
     while (i > 0) {
       i -= 1;
@@ -1030,7 +1032,7 @@ module {
   /// Space: O(size)
   ///
   /// *Runtime and space assumes that `f` runs in O(1) time and space.
-  public func toText<T>(array : [T], f : T -> Text) : Text {
+  public func toText<T>(array : [T], f : (implicit : (toText : T -> Text))) : Text {
     let size = array.size();
     if (size == 0) { return "[]" };
     var text = "[";
@@ -1074,7 +1076,7 @@ module {
   /// Space: O(1)
   ///
   /// *Runtime and space assumes that `compare` runs in O(1) time and space.
-  public func compare<T>(array1 : [T], array2 : [T], compare : (T, T) -> Order.Order) : Order.Order {
+  public func compare<T>(array1 : [T], array2 : [T], compare : (implicit : (T, T) -> Order.Order)) : Order.Order {
     let size1 = array1.size();
     let size2 = array2.size();
     var i = 0;
@@ -1112,7 +1114,7 @@ module {
   /// Space: O(1)
   ///
   /// *Runtime and space assumes that `compare` runs in O(1) time and space.
-  public func binarySearch<T>(array : [T], compare : (T, T) -> Order.Order, element : T) : {
+  public func binarySearch<T>(array : [T], compare : (implicit : (T, T) -> Order.Order), element : T) : {
     #found : Nat;
     #insertionIndex : Nat
   } {

src/Blob.mo

@@ -38,6 +38,7 @@ import Order "Order";
 module {
 
   public type Blob = Prim.Types.Blob;
+  public type Self = Blob;
 
   /// Returns an empty `Blob` (equivalent to `""`).
   ///

src/Bool.mo

@@ -31,6 +31,8 @@ module {
   /// Booleans with constants `true` and `false`.
   public type Bool = Prim.Types.Bool;
 
+  public type Self = Bool;
+
   /// Returns `a and b`.
   ///
   /// Example:

src/Char.mo

@@ -31,6 +31,8 @@ module {
   /// Characters represented as Unicode code points.
   public type Char = Prim.Types.Char;
 
+  public type Self = Char;
+
   /// Convert character `char` to a word containing its Unicode scalar value.
   ///
   /// Example:

src/Error.mo

@@ -9,6 +9,7 @@ module {
 
   /// Error value resulting from  `async` computations
   public type Error = Prim.Types.Error;
+  public type Self = Error;
 
   /// Error code to classify different kinds of user and system errors:
   /// ```motoko

src/Float.mo

@@ -54,6 +54,7 @@ module {
 
   /// 64-bit floating point number type.
   public type Float = Prim.Types.Float;
+  public type Self = Float;
 
   /// Ratio of the circumference of a circle to its diameter.
   /// Note: Limited precision.

src/Int.mo

@@ -18,6 +18,7 @@ module {
 
   /// Infinite precision signed integers.
   public type Int = Prim.Types.Int;
+  public type Self = Int;
 
   /// Returns the absolute value of `x`.
   ///

src/Int16.mo

@@ -16,6 +16,7 @@ module {
 
   /// 16-bit signed integers.
   public type Int16 = Prim.Types.Int16;
+  public type Self = Int16;
 
   /// Minimum 16-bit integer value, `-2 ** 15`.
   ///

src/Int32.mo

@@ -15,6 +15,7 @@ module {
 
   /// 32-bit signed integers.
   public type Int32 = Prim.Types.Int32;
+  public type Self = Int32;
 
   /// Minimum 32-bit integer value, `-2 ** 31`.
   ///

src/Int64.mo

@@ -16,6 +16,7 @@ module {
 
   /// 64-bit signed integers.
   public type Int64 = Prim.Types.Int64;
+  public type Self = Int64;
 
   /// Minimum 64-bit integer value, `-2 ** 63`.
   ///

src/Int8.mo

@@ -15,6 +15,7 @@ module {
 
   /// 8-bit signed integers.
   public type Int8 = Prim.Types.Int8;
+  public type Self = Int8;
 
   /// Minimum 8-bit integer value, `-2 ** 7`.
   ///

src/Iter.mo

@@ -54,6 +54,7 @@ module {
   /// }
   /// ```
   public type Iter<T> = Types.Iter<T>;
+  public type Self<T> = Iter<T>;
 
   /// Creates an empty iterator.
   ///
@@ -531,7 +532,7 @@ module {
   /// let iter = [1, 2, 3, 4].values();
   /// assert Iter.contains<Nat>(iter, Nat.equal, 2);
   /// ```
-  public func contains<T>(iter : Iter<T>, equal : (T, T) -> Bool, value : T) : Bool {
+  public func contains<T>(iter : Iter<T>, equal : (implicit : (T, T) -> Bool), value : T) : Bool {
     for (x in iter) {
       if (equal(x, value)) return true
     };
@@ -661,7 +662,7 @@ module {
   /// let iter = [1, 2, 3].values();
   /// assert ?3 == Iter.max<Nat>(iter, Nat.compare);
   /// ```
-  public func max<T>(iter : Iter<T>, compare : (T, T) -> Order.Order) : ?T {
+  public func max<T>(iter : Iter<T>, compare : (implicit : (T, T) -> Order.Order)) : ?T {
     reduce<T>(
       iter,
       func(a, b) {
@@ -682,7 +683,7 @@ module {
   /// let iter = [1, 2, 3].values();
   /// assert ?1 == Iter.min<Nat>(iter, Nat.compare);
   /// ```
-  public func min<T>(iter : Iter<T>, compare : (T, T) -> Order.Order) : ?T {
+  public func min<T>(iter : Iter<T>, compare : (implicit : (T, T) -> Order.Order)) : ?T {
     reduce<T>(
       iter,
       func(a, b) {
@@ -803,7 +804,7 @@ module {
   };
 
   /// Sorted iterator.  Will iterate over *all* elements to sort them, necessarily.
-  public func sort<T>(iter : Iter<T>, compare : (T, T) -> Order.Order) : Iter<T> {
+  public func sort<T>(iter : Iter<T>, compare : (implicit : (T, T) -> Order.Order)) : Iter<T> {
     let array = toVarArray<T>(iter);
     VarArray.sortInPlace<T>(array, compare);
     fromVarArray<T>(array)

src/List.mo

@@ -32,6 +32,7 @@ module {
   ///
   /// The maximum number of elements in a `List` is 2^32.
   public type List<T> = Types.List<T>;
+  public type Self<T> = List<T>;
 
   let INTERNAL_ERROR = "List: internal error";
 
@@ -587,15 +588,15 @@ module {
   /// List.add(list, 3);
   /// List.add(list, 1);
   /// List.add(list, 2);
-  /// List.sort(list, Nat.compare);
+  /// List.sortInPlace(list, Nat.compare);
   /// assert List.toArray(list) == [1, 2, 3];
   /// ```
   ///
   /// Runtime: O(size * log(size))
   ///
   /// Space: O(size)
   /// *Runtime and space assumes that `compare` runs in O(1) time and space.
-  public func sort<T>(list : List<T>, compare : (T, T) -> Order.Order) {
+  public func sortInPlace<T>(list : List<T>, compare : (implicit : (T, T) -> Order.Order)) {
     if (size(list) < 2) return;
     let arr = toVarArray(list);
     VarArray.sortInPlace(arr, compare);
@@ -604,6 +605,31 @@ module {
     }
   };
 
+  /// Sorts the elements in the list according to `compare`.
+  /// Sort is deterministic, stable, and in-place.
+  ///
+  /// Example:
+  /// ```motoko include=import
+  /// import Nat "mo:core/Nat";
+  ///
+  /// let list = List.empty<Nat>();
+  /// List.add(list, 3);
+  /// List.add(list, 1);
+  /// List.add(list, 2);
+  /// let sorted = List.sort(list, Nat.compare);
+  /// assert List.toArray(sorted) == [1, 2, 3];
+  /// ```
+  ///
+  /// Runtime: O(size * log(size))
+  ///
+  /// Space: O(size)
+  /// *Runtime and space assumes that `compare` runs in O(1) time and space.
+  public func sort<T>(list : List<T>, compare : (implicit : (T, T) -> Types.Order)) : List<T> {
+    let array = toVarArray(list);
+    VarArray.sortInPlace(array, compare);
+    fromVarArray(array)
+  };
+
   /// Finds the first index of `element` in `list` using equality of elements defined
   /// by `equal`. Returns `null` if `element` is not found.
   ///
@@ -624,7 +650,7 @@ module {
   /// Runtime: `O(size)`
   ///
   /// *Runtime and space assumes that `equal` runs in `O(1)` time and space.
-  public func indexOf<T>(list : List<T>, equal : (T, T) -> Bool, element : T) : ?Nat {
+  public func indexOf<T>(list : List<T>, equal : (implicit : (T, T) -> Bool), element : T) : ?Nat {
     // inlining would save 10 instructions per entry
     findIndex<T>(list, func(x) = equal(element, x))
   };
@@ -645,7 +671,7 @@ module {
   /// Runtime: `O(size)`
   ///
   /// *Runtime and space assumes that `equal` runs in `O(1)` time and space.
-  public func lastIndexOf<T>(list : List<T>, equal : (T, T) -> Bool, element : T) : ?Nat {
+  public func lastIndexOf<T>(list : List<T>, equal : (implicit : (T, T) -> Bool), element : T) : ?Nat {
     // inlining would save 10 instructions per entry
     findLastIndex<T>(list, func(x) = equal(element, x))
   };
@@ -784,7 +810,7 @@ module {
   /// Space: `O(1)`
   ///
   /// *Runtime and space assumes that `compare` runs in `O(1)` time and space.
-  public func binarySearch<T>(list : List<T>, compare : (T, T) -> Order.Order, element : T) : {
+  public func binarySearch<T>(list : List<T>, compare : (implicit : (T, T) -> Order.Order), element : T) : {
     #found : Nat;
     #insertionIndex : Nat
   } {
@@ -1547,7 +1573,7 @@ module {
   /// Space: `O(1)`
   ///
   /// *Runtime and space assumes that `equal` runs in O(1) time and space.
-  public func contains<T>(list : List<T>, equal : (T, T) -> Bool, element : T) : Bool {
+  public func contains<T>(list : List<T>, equal : (implicit : (T, T) -> Bool), element : T) : Bool {
     Option.isSome(indexOf(list, equal, element))
   };
 
@@ -1571,7 +1597,7 @@ module {
   /// Space: `O(1)`
   ///
   /// *Runtime and space assumes that `compare` runs in O(1) time and space.
-  public func max<T>(list : List<T>, compare : (T, T) -> Order.Order) : ?T {
+  public func max<T>(list : List<T>, compare : (implicit : (T, T) -> Order.Order)) : ?T {
     if (isEmpty(list)) return null;
 
     var maxSoFar = at(list, 0);
@@ -1606,7 +1632,7 @@ module {
   /// Space: `O(1)`
   ///
   /// *Runtime and space assumes that `compare` runs in O(1) time and space.
-  public func min<T>(list : List<T>, compare : (T, T) -> Order.Order) : ?T {
+  public func min<T>(list : List<T>, compare : (implicit : (T, T) -> Order.Order)) : ?T {
     if (isEmpty(list)) return null;
 
     var minSoFar = at(list, 0);
@@ -1642,7 +1668,7 @@ module {
   /// Space: `O(1)`
   ///
   /// *Runtime and space assumes that `equal` runs in O(1) time and space.
-  public func equal<T>(list1 : List<T>, list2 : List<T>, equal : (T, T) -> Bool) : Bool {
+  public func equal<T>(list1 : List<T>, list2 : List<T>, equal : (implicit : (T, T) -> Bool)) : Bool {
     let size1 = size(list1);
 
     if (size1 != size(list2)) return false;
@@ -1680,7 +1706,7 @@ module {
   /// Space: `O(1)`
   ///
   /// *Runtime and space assumes that `compare` runs in O(1) time and space.
-  public func compare<T>(list1 : List<T>, list2 : List<T>, compare : (T, T) -> Order.Order) : Order.Order {
+  public func compare<T>(list1 : List<T>, list2 : List<T>, compare : (implicit : (T, T) -> Order.Order)) : Order.Order {
     let size1 = size(list1);
     let size2 = size(list2);
     let minSize = if (size1 < size2) { size1 } else { size2 };
@@ -1716,7 +1742,7 @@ module {
   /// Space: `O(size)`
   ///
   /// *Runtime and space assumes that `toText` runs in O(1) time and space.
-  public func toText<T>(list : List<T>, f : T -> Text) : Text {
+  public func toText<T>(list : List<T>, f : (implicit : (toText : T -> Text))) : Text {
     let vsize : Int = size(list);
     let next = values_(list).unsafe_next;
     var i = 0;