eq -> equal, cmp -> compare

Author: cknitt

src/Core__List.mjs

@@ -969,7 +969,7 @@ function every2(l1, l2, p) {
   };
 }
 
-function cmpByLength(_l1, _l2) {
+function compareLength(_l1, _l2) {
   while(true) {
     var l2 = _l2;
     var l1 = _l1;
@@ -989,7 +989,7 @@ function cmpByLength(_l1, _l2) {
   };
 }
 
-function cmp(l1, l2, f) {
+function compare(l1, l2, f) {
   var _l1 = l1;
   var _l2 = l2;
   var p = Curry.__2(f);
@@ -1016,7 +1016,7 @@ function cmp(l1, l2, f) {
   };
 }
 
-function eq(l1, l2, f) {
+function equal(l1, l2, f) {
   var _l1 = l1;
   var _l2 = l2;
   var p = Curry.__2(f);
@@ -1386,9 +1386,9 @@ export {
   some ,
   every2 ,
   some2 ,
-  cmpByLength ,
-  cmp ,
-  eq ,
+  compareLength ,
+  compare ,
+  equal ,
   has ,
   getBy ,
   filter ,

src/Core__List.res

@@ -680,43 +680,43 @@ let rec every2U = (l1, l2, p) =>
 
 let every2 = (l1, l2, p) => every2U(l1, l2, (. a, b) => p(a, b))
 
-let rec cmpByLength = (l1, l2) =>
+let rec compareLength = (l1, l2) =>
   switch (l1, l2) {
   | (list{}, list{}) => 0
   | (_, list{}) => 1
   | (list{}, _) => -1
-  | (list{_, ...l1s}, list{_, ...l2s}) => cmpByLength(l1s, l2s)
+  | (list{_, ...l1s}, list{_, ...l2s}) => compareLength(l1s, l2s)
   }
 
-let rec cmpU = (l1, l2, p) =>
+let rec compareU = (l1, l2, p) =>
   switch (l1, l2) {
   | (list{}, list{}) => 0
   | (_, list{}) => 1
   | (list{}, _) => -1
   | (list{a1, ...l1}, list{a2, ...l2}) =>
     let c = p(. a1, a2)
     if c == 0 {
-      cmpU(l1, l2, p)
+      compareU(l1, l2, p)
     } else {
       c
     }
   }
 
-let cmp = (l1, l2, f) => cmpU(l1, l2, (. x, y) => f(x, y))
+let compare = (l1, l2, f) => compareU(l1, l2, (. x, y) => f(x, y))
 
-let rec eqU = (l1, l2, p) =>
+let rec equalU = (l1, l2, p) =>
   switch (l1, l2) {
   | (list{}, list{}) => true
   | (_, list{})
   | (list{}, _) => false
   | (list{a1, ...l1}, list{a2, ...l2}) =>
     if p(. a1, a2) {
-      eqU(l1, l2, p)
+      equalU(l1, l2, p)
     } else {
       false
     }
   }
-let eq = (l1, l2, f) => eqU(l1, l2, (. x, y) => f(x, y))
+let equal = (l1, l2, f) => equalU(l1, l2, (. x, y) => f(x, y))
 
 let rec some2U = (l1, l2, p) =>
   switch (l1, l2) {

src/Core__List.resi

@@ -615,24 +615,24 @@ List.some2(list{0, 1}, list{5, 0}, (a, b) => a > b) // true
 let some2: (t<'a>, t<'b>, ('a, 'b) => bool) => bool
 
 /**
-`cmpByLength(list1, list2)` compare two lists solely by length. Returns `-1` if
+`compareLength(list1, list2)` compare two lists solely by length. Returns `-1` if
 `length(list1)` is less than `length(list2)`, `0` if `length(list1)` equals
 `length(list2)`, and `1` if `length(list1)` is greater than `length(list2)`.
 
 ## Examples
 
 ```rescript
-List.cmpByLength(list{1, 2}, list{3, 4, 5, 6}) // -1
+List.compareLength(list{1, 2}, list{3, 4, 5, 6}) // -1
 
-List.cmpByLength(list{1, 2, 3}, list{4, 5, 6}) // 0
+List.compareLength(list{1, 2, 3}, list{4, 5, 6}) // 0
 
-List.cmpByLength(list{1, 2, 3, 4}, list{5, 6}) // 1
+List.compareLength(list{1, 2, 3, 4}, list{5, 6}) // 1
 ```
 */
-let cmpByLength: (t<'a>, t<'a>) => int
+let compareLength: (t<'a>, t<'a>) => int
 
 /**
-`cmp(list1, list2, f)` compare elements one by one `f`. `f` returns a negative
+`compare(list1, list2, f)` compare elements one by one `f`. `f` returns a negative
 number if `list1` is "less than" `list2`, zero if `list1` is "equal to" `list2`,
 a positive number if `list1` is "greater than" `list2`.
 
@@ -645,40 +645,40 @@ zero for all `list1` and `list2`.
 ## Examples
 
 ```rescript
-List.cmp(list{3}, list{3, 7}, (a, b) => compare(a, b)) /* (-1) */
+List.compare(list{3}, list{3, 7}, (a, b) => compare(a, b)) /* (-1) */
 
-List.cmp(list{5, 3}, list{5}, (a, b) => compare(a, b)) /* 1 */
+List.compare(list{5, 3}, list{5}, (a, b) => compare(a, b)) /* 1 */
 
-List.cmp(list{1, 3, 5}, list{1, 4, 2}, (a, b) => compare(a, b)) /* (-1) */
+List.compare(list{1, 3, 5}, list{1, 4, 2}, (a, b) => compare(a, b)) /* (-1) */
 
-List.cmp(list{1, 3, 5}, list{1, 2, 3}, (a, b) => compare(a, b)) /* 1 */
+List.compare(list{1, 3, 5}, list{1, 2, 3}, (a, b) => compare(a, b)) /* 1 */
 
-List.cmp(list{1, 3, 5}, list{1, 3, 5}, (a, b) => compare(a, b)) /* 0 */
+List.compare(list{1, 3, 5}, list{1, 3, 5}, (a, b) => compare(a, b)) /* 0 */
 ```
 
 **Please note:** The total ordering of List is different from Array,
 for Array, we compare the length first and, only if the lengths are equal, elements one by one.
 For lists, we just compare elements one by one.
 */
-let cmp: (t<'a>, t<'a>, ('a, 'a) => int) => int
+let compare: (t<'a>, t<'a>, ('a, 'a) => int) => int
 
 /**
-`eq(list1, list2, f)` check equality of `list2` and `list2` using `f` for
+`equal(list1, list2, f)` check equality of `list2` and `list2` using `f` for
 equality on elements, where `f` is a function that returns `true` if items `x` and
-`y` meet some criterion for equality, `false` otherwise. eq `false` if length
+`y` meet some criterion for equality, `false` otherwise. equal `false` if length
 of `list1` and `list2` are not the same.
 
 ## Examples
 
 ```rescript
-List.eq(list{1, 2, 3}, list{1, 2}, (a, b) => a == b) // false
+List.equal(list{1, 2, 3}, list{1, 2}, (a, b) => a == b) // false
 
-List.eq(list{1, 2}, list{1, 2}, (a, b) => a == b) // true
+List.equal(list{1, 2}, list{1, 2}, (a, b) => a == b) // true
 
-List.eq(list{1, 2, 3}, list{(-1), (-2), (-3)}, (a, b) => abs(a) == abs(b)) // true
+List.equal(list{1, 2, 3}, list{(-1), (-2), (-3)}, (a, b) => abs(a) == abs(b)) // true
 ```
 */
-let eq: (t<'a>, t<'a>, ('a, 'a) => bool) => bool
+let equal: (t<'a>, t<'a>, ('a, 'a) => bool) => bool
 
 /**
 `has(list, element, f)` returns `true` if the list contains at least one

src/Core__Option.mjs

@@ -78,7 +78,7 @@ function isNone(x) {
   return x === undefined;
 }
 
-function eq(a, b, f) {
+function equal(a, b, f) {
   var f$1 = Curry.__2(f);
   if (a !== undefined) {
     if (b !== undefined) {
@@ -91,7 +91,7 @@ function eq(a, b, f) {
   }
 }
 
-function cmp(a, b, f) {
+function compare(a, b, f) {
   var f$1 = Curry.__2(f);
   if (a !== undefined) {
     if (b !== undefined) {
@@ -117,7 +117,7 @@ export {
   orElse ,
   isSome ,
   isNone ,
-  eq ,
-  cmp ,
+  equal ,
+  compare ,
 }
 /* No side effect */

src/Core__Option.res

@@ -90,7 +90,7 @@ let isSome = x =>
 
 let isNone = x => x == None
 
-let eqU = (a, b, f) =>
+let equalU = (a, b, f) =>
   switch a {
   | Some(a) =>
     switch b {
@@ -100,14 +100,14 @@ let eqU = (a, b, f) =>
   | None => b == None
   }
 
-let eq = (a, b, f) => eqU(a, b, (. x, y) => f(x, y))
+let equal = (a, b, f) => equalU(a, b, (. x, y) => f(x, y))
 
-let cmpU = (a, b, f) =>
+let compareU = (a, b, f) =>
   switch (a, b) {
   | (Some(a), Some(b)) => f(. a, b)
   | (None, Some(_)) => -1
   | (Some(_), None) => 1
   | (None, None) => 0
   }
 
-let cmp = (a, b, f) => cmpU(a, b, (. x, y) => f(x, y))
+let compare = (a, b, f) => compareU(a, b, (. x, y) => f(x, y))

src/Core__Option.resi

@@ -198,7 +198,7 @@ Option.isNone(Some(1)) // false
 let isNone: option<'a> => bool
 
 /**
-`eq(opt1, opt2, f)` evaluates two optional values for equality with respect to a predicate function `f`. If both `opt1` and `opt2` are `None`, returns `true`.
+`equal(opt1, opt2, f)` evaluates two optional values for equality with respect to a predicate function `f`. If both `opt1` and `opt2` are `None`, returns `true`.
 If one of the arguments is `Some(value)` and the other is `None`, returns
 `false`.
 If arguments are `Some(value1)` and `Some(value2)`, returns the result of
@@ -211,16 +211,16 @@ let clockEqual = (a, b) => mod(a, 12) == mod(b, 12)
 
 open Option
 
-eq(Some(3), Some(15), clockEqual) // true
-eq(Some(3), None, clockEqual) // false
-eq(None, Some(3), clockEqual) // false
-eq(None, None, clockEqual) // true
+equal(Some(3), Some(15), clockEqual) // true
+equal(Some(3), None, clockEqual) // false
+equal(None, Some(3), clockEqual) // false
+equal(None, None, clockEqual) // true
 ```
 */
-let eq: (option<'a>, option<'b>, ('a, 'b) => bool) => bool
+let equal: (option<'a>, option<'b>, ('a, 'b) => bool) => bool
 
 /**
-`cmp(opt1, opt2, f)` compares two optional values with respect to given `f`.
+`compare(opt1, opt2, f)` compares two optional values with respect to given `f`.
 
 If both `opt1` and `opt2` are `None`, it returns `0`. If the first argument is `Some(value1)` and the second is `None`, returns `1` (something is greater than nothing).
 
@@ -239,12 +239,12 @@ let clockCompare = (a, b) => compare(mod(a, 12), mod(b, 12))
 
 open Option
 
-cmp(Some(3), Some(15), clockCompare) // 0
-cmp(Some(3), Some(14), clockCompare) // 1
-cmp(Some(2), Some(15), clockCompare) // (-1)
-cmp(None, Some(15), clockCompare) // (-1)
-cmp(Some(14), None, clockCompare) // 1
-cmp(None, None, clockCompare) // 0
+compare(Some(3), Some(15), clockCompare) // 0
+compare(Some(3), Some(14), clockCompare) // 1
+compare(Some(2), Some(15), clockCompare) // (-1)
+compare(None, Some(15), clockCompare) // (-1)
+compare(Some(14), None, clockCompare) // 1
+compare(None, None, clockCompare) // 0
 ```
 */
-let cmp: (option<'a>, option<'b>, ('a, 'b) => int) => int
+let compare: (option<'a>, option<'b>, ('a, 'b) => int) => int

src/Core__Result.mjs

@@ -72,7 +72,7 @@ function isError(x) {
   }
 }
 
-function eq(a, b, f) {
+function equal(a, b, f) {
   var f$1 = Curry.__2(f);
   if (a.TAG === /* Ok */0) {
     if (b.TAG === /* Ok */0) {
@@ -87,7 +87,7 @@ function eq(a, b, f) {
   }
 }
 
-function cmp(a, b, f) {
+function compare(a, b, f) {
   var f$1 = Curry.__2(f);
   if (a.TAG === /* Ok */0) {
     if (b.TAG === /* Ok */0) {
@@ -117,8 +117,8 @@ export {
   getWithDefault ,
   isOk ,
   isError ,
-  eq ,
-  cmp ,
+  equal ,
+  compare ,
   forEach ,
 }
 /* No side effect */

src/Core__Result.res

@@ -72,25 +72,25 @@ let isError = x =>
   | Error(_) => true
   }
 
-let eqU = (a, b, f) =>
+let equalU = (a, b, f) =>
   switch (a, b) {
   | (Ok(a), Ok(b)) => f(. a, b)
   | (Error(_), Ok(_))
   | (Ok(_), Error(_)) => false
   | (Error(_), Error(_)) => true
   }
 
-let eq = (a, b, f) => eqU(a, b, (. x, y) => f(x, y))
+let equal = (a, b, f) => equalU(a, b, (. x, y) => f(x, y))
 
-let cmpU = (a, b, f) =>
+let compareU = (a, b, f) =>
   switch (a, b) {
   | (Ok(a), Ok(b)) => f(. a, b)
   | (Error(_), Ok(_)) => -1
   | (Ok(_), Error(_)) => 1
   | (Error(_), Error(_)) => 0
   }
 
-let cmp = (a, b, f) => cmpU(a, b, (. x, y) => f(x, y))
+let compare = (a, b, f) => compareU(a, b, (. x, y) => f(x, y))
 
 let forEach = (r, f) =>
   switch r {