Implicit pattern across entire core package (#398)

* First pass

* Another pass

* Fix stragglers

* Fix more stragglers

* Apply suggestions from code review

Co-authored-by: Christoph <christoph.hegemann@dfinity.org>
Co-authored-by: Claudio Russo <claudio@dfinity.org>

* Apply suggestions from code review

Co-authored-by: Claudio Russo <claudio@dfinity.org>

* Various fixes

* Apply suggestions from code review

Co-authored-by: Claudio Russo <claudio@dfinity.org>

* Fix

* Update API lockfile

---------

Co-authored-by: Christoph <christoph.hegemann@dfinity.org>
Co-authored-by: Claudio Russo <claudio@dfinity.org>

Author: 3 people

src/Array.mo

@@ -122,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) {
@@ -1032,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 = "[";

src/Iter.mo

@@ -662,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) {
@@ -683,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) {
@@ -804,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

@@ -596,7 +596,7 @@ module {
   ///
   /// 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 sort<T>(list : List<T>, compare : (implicit : (T, T) -> Order.Order)) {
     if (size(list) < 2) return;
     let arr = toVarArray(list);
     VarArray.sortInPlace(arr, compare);
@@ -785,7 +785,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
   } {
@@ -1572,7 +1572,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);
@@ -1607,7 +1607,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);
@@ -1681,7 +1681,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 };
@@ -1717,7 +1717,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;

src/Map.mo

@@ -1260,11 +1260,11 @@ module {
   /// assuming that `keyFormat` and `valueFormat` have runtime and space costs of `O(1)`.
   ///
   /// Note: Creates `O(log(n))` temporary objects that will be collected as garbage.
-  public func toText<K, V>(map : Map<K, V>, toText : (implicit : K -> Text), valueFormat : V -> Text) : Text {
+  public func toText<K, V>(map : Map<K, V>, keyFormat : (implicit : (toText : K -> Text)), valueFormat : (implicit : (toText : V -> Text))) : Text {
     var text = "Map{";
     var sep = "";
     for ((key, value) in entries(map)) {
-      text #= sep # "(" # toText(key) # ", " # valueFormat(value) # ")";
+      text #= sep # "(" # keyFormat(key) # ", " # valueFormat(value) # ")";
       sep := ", "
     };
     text # "}"
@@ -1311,7 +1311,7 @@ module {
   /// assuming that `compareKey` and `compareValue` have runtime and space costs of `O(1)`.
   ///
   /// Note: Creates `O(log(n))` temporary objects that will be collected as garbage.
-  public func compare<K, V>(map1 : Map<K, V>, map2 : Map<K, V>, compareKey : (K, K) -> Order.Order, compareValue : (V, V) -> Order.Order) : Order.Order {
+  public func compare<K, V>(map1 : Map<K, V>, map2 : Map<K, V>, compareKey : (implicit : (compare : (K, K) -> Order.Order)), compareValue : (implicit : (compare : (V, V) -> Order.Order))) : Order.Order {
     let iterator1 = entries(map1);
     let iterator2 = entries(map2);
     loop {
@@ -2314,7 +2314,7 @@ module {
     /// * compare - the comparator used to perform the search
     /// * searchKey - the key being compared against in the search
     /// * maxIndex - the right-most index (bound) from which to begin the search
-    public func binarySearchNode<K, V>(array : [var ?(K, V)], compare : (K, K) -> Order.Order, searchKey : K, maxIndex : Nat) : SearchResult {
+    public func binarySearchNode<K, V>(array : [var ?(K, V)], compare : (implicit : (K, K) -> Order.Order), searchKey : K, maxIndex : Nat) : SearchResult {
       // TODO: get rid of this check?
       // Trap if array is size 0 (should not happen)
       if (array.size() == 0) {

src/Option.mo

@@ -40,7 +40,7 @@ module {
 
   /// 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 {
+  public func getMapped<T, R>(x : ?T, f : T -> R, default : R) : R = switch x {
     case null { default };
     case (?x_) { f(x_) }
   };
@@ -51,7 +51,7 @@ module {
   /// 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 {
+  public func map<T, R>(x : ?T, f : T -> R) : ?R = switch x {
     case null { null };
     case (?x_) { ?f(x_) }
   };
@@ -67,14 +67,14 @@ module {
   /// Option.forEach(null, func (x : Nat) { counter += x });
   /// assert counter == 5;
   /// ```
-  public func forEach<A>(x : ?A, f : A -> ()) = switch x {
+  public func forEach<T>(x : ?T, f : T -> ()) = 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 {
+  public func apply<T, R>(x : ?T, f : ?(T -> R)) : ?R {
     switch (f, x) {
       case (?f_, ?x_) { ?f_(x_) };
       case (_, _) { null }
@@ -83,7 +83,7 @@ module {
 
   /// 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 {
+  public func chain<T, R>(x : ?T, f : T -> ?R) : ?R {
     switch (x) {
       case (?x_) { f(x_) };
       case (null) { null }
@@ -97,16 +97,16 @@ module {
   /// 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_)
+  public func flatten<T>(x : ??T) : ?T {
+    chain<?T, T>(x, func(x_ : ?T) : ?T = x_)
   };
 
   /// Creates an optional value from a definite value.
   /// ```motoko
   /// import Option "mo:core/Option";
   /// assert Option.some(42) == ?42;
   /// ```
-  public func some<A>(x : A) : ?A = ?x;
+  public func some<T>(x : T) : ?T = ?x;
 
   /// Returns true if the argument is not `null`, otherwise returns false.
   public func isSome(x : ?Any) : Bool {
@@ -119,7 +119,7 @@ module {
   };
 
   /// Returns true if the optional arguments are equal according to the equality function provided, otherwise returns false.
-  public func equal<A>(x : ?A, y : ?A, eq : (A, A) -> Bool) : Bool = switch (x, y) {
+  public func equal<T>(x : ?T, y : ?T, eq : (implicit : (equal : (T, T) -> Bool))) : Bool = switch (x, y) {
     case (null, null) { true };
     case (?x_, ?y_) { eq(x_, y_) };
     case (_, _) { false }
@@ -132,7 +132,7 @@ module {
   /// - `#less` if the first value is `null` and the second is not,
   /// - `#greater` if the first value is not `null` and the second is,
   /// - the result of the comparison function when both values are not `null`.
-  public func compare<A>(x : ?A, y : ?A, cmp : (A, A) -> Types.Order) : Types.Order = switch (x, y) {
+  public func compare<T>(x : ?T, y : ?T, cmp : (implicit : (compare : (T, T) -> Types.Order))) : Types.Order = switch (x, y) {
     case (null, null) #equal;
     case (null, _) #less;
     case (_, null) #greater;
@@ -148,7 +148,7 @@ module {
   };
 
   /// Returns the textural representation of an optional value for debugging purposes.
-  public func toText<A>(x : ?A, toText : A -> Text) : Text = switch x {
+  public func toText<T>(x : ?T, toText : (implicit : T -> Text)) : Text = switch x {
     case null { "null" };
     case (?x_) { "?" # toText(x_) }
   };

src/Queue.mo

@@ -736,7 +736,7 @@ module {
   /// Runtime: O(n)
   /// Space: O(n)
   /// `n` denotes the number of elements stored in the queue.
-  public func toText<T>(queue : Queue<T>, format : T -> Text) : Text {
+  public func toText<T>(queue : Queue<T>, format : (implicit : (toText : T -> Text))) : Text {
     var text = "Queue[";
     var sep = "";
     for (element in values(queue)) {
@@ -765,7 +765,7 @@ module {
   /// Runtime: O(n)
   /// Space: O(1)
   /// `n` denotes the number of elements stored in the queue.
-  public func compare<T>(queue1 : Queue<T>, queue2 : Queue<T>, compare : (T, T) -> Order.Order) : Order.Order {
+  public func compare<T>(queue1 : Queue<T>, queue2 : Queue<T>, compare : (implicit : (T, T) -> Order.Order)) : Order.Order {
     let iterator1 = values(queue1);
     let iterator2 = values(queue2);
     loop {

src/Result.mo

@@ -63,8 +63,8 @@ module {
   public func equal<Ok, Err>(
     result1 : Result<Ok, Err>,
     result2 : Result<Ok, Err>,
-    equalOk : (Ok, Ok) -> Bool,
-    equalErr : (Err, Err) -> Bool
+    equalOk : (implicit : (equal : Ok, Ok) -> Bool),
+    equalErr : (implicit : (equal : (Err, Err) -> Bool))
   ) : Bool {
     switch (result1, result2) {
       case (#ok(ok1), #ok(ok2)) {
@@ -96,8 +96,8 @@ module {
   public func compare<Ok, Err>(
     result1 : Result<Ok, Err>,
     result2 : Result<Ok, Err>,
-    compareOk : (Ok, Ok) -> Order.Order,
-    compareErr : (Err, Err) -> Order.Order
+    compareOk : (implicit : (compare : (Ok, Ok) -> Order.Order)),
+    compareErr : (implicit : (compare : (Err, Err) -> Order.Order))
   ) : Order.Order {
     switch (result1, result2) {
       case (#ok(ok1), #ok(ok2)) {

src/Stack.mo

@@ -741,7 +741,7 @@ module {
   /// Space: O(n)
   /// where `n` denotes the number of elements stored on the stack and
   /// assuming that `format` has O(1) costs.
-  public func toText<T>(stack : Stack<T>, format : T -> Text) : Text {
+  public func toText<T>(stack : Stack<T>, format : (implicit : (toText : T -> Text))) : Text {
     var text = "Stack[";
     var sep = "";
     for (element in values(stack)) {
@@ -770,7 +770,7 @@ module {
   /// Space: O(1)
   /// where `n` denotes the number of elements stored on the stack and
   /// assuming that `compare` has O(1) costs.
-  public func compare<T>(stack1 : Stack<T>, stack2 : Stack<T>, compare : (T, T) -> Order.Order) : Order.Order {
+  public func compare<T>(stack1 : Stack<T>, stack2 : Stack<T>, compare : (implicit : (T, T) -> Order.Order)) : Order.Order {
     let iterator1 = values(stack1);
     let iterator2 = values(stack2);
     loop {

src/Text.mo

@@ -903,7 +903,7 @@ module {
   public func compareWith(
     t1 : Text,
     t2 : Text,
-    cmp : (Char, Char) -> Order.Order
+    cmp : (implicit : (compare : (Char, Char) -> Order.Order))
   ) : Order.Order {
     let cs1 = t1.chars();
     let cs2 = t2.chars();

src/VarArray.mo

@@ -1170,7 +1170,7 @@ module {
   /// Space: O(size)
   ///
   /// *Runtime and space assumes that `f` runs in O(1) time and space.
-  public func toText<T>(array : [var T], f : T -> Text) : Text {
+  public func toText<T>(array : [var T], f : (implicit : (toText : T -> Text))) : Text {
     let size = array.size();
     if (size == 0) { return "[var]" };
     var text = "[var ";