Use Self for std.cmp.Equal and std.cmp.Compare

Similar to std.clone.Clone, this makes implementing these traits less
awkward and better captures their intent (= comparisons against values
of the same type).

Changelog: changed

Author: yorickpeterse

std/src/std/array.inko

@@ -730,7 +730,7 @@ impl Drop for Array {
   }
 }
 
-impl Contains[T] for Array if T: Equal[ref T] {
+impl Contains[T] for Array if T: Equal {
   # Returns `true` if `self` contains the given value.
   #
   # # Examples
@@ -757,7 +757,7 @@ impl Clone for Array if T: Clone {
   }
 }
 
-impl Equal[ref Array[T]] for Array if T: Equal[ref T] {
+impl Equal for Array if T: Equal {
   # Returns `true` if `self` and the given `Array` are identical.
   #
   # # Examples

std/src/std/base64.inko

@@ -741,7 +741,7 @@ impl Format for DecodeError {
   }
 }
 
-impl Equal[ref DecodeError] for DecodeError {
+impl Equal for DecodeError {
   fn pub ==(other: ref DecodeError) -> Bool {
     match (self, other) {
       case (InvalidSize, InvalidSize) -> true

std/src/std/bool.inko

@@ -64,13 +64,13 @@ impl Clone for Bool {
   }
 }
 
-impl Equal[ref Bool] for Bool {
+impl Equal for Bool {
   fn pub inline ==(other: ref Bool) -> Bool {
     _INKO.bool_eq(self, other)
   }
 }
 
-impl Compare[Bool] for Bool {
+impl Compare for Bool {
   fn pub inline cmp(other: ref Bool) -> Ordering {
     to_int.cmp(other.to_int)
   }

std/src/std/byte_array.inko

@@ -690,7 +690,7 @@ impl IntoString for ByteArray {
   }
 }
 
-impl Equal[ref ByteArray] for ByteArray {
+impl Equal for ByteArray {
   # Returns `true` if two `ByteArray` objects are equal to each other.
   #
   # Two `ByteArray` objects are considered equal if they have the exact same

std/src/std/cmp.inko

@@ -9,7 +9,7 @@ type pub copy enum Ordering {
   case Greater
 }
 
-impl Equal[ref Ordering] for Ordering {
+impl Equal for Ordering {
   fn pub inline ==(other: ref Ordering) -> Bool {
     match (self, other) {
       case (Less, Less) -> true
@@ -33,42 +33,42 @@ impl Format for Ordering {
 }
 
 # A type that can be compared to another type for a sort-order.
-trait pub Compare[T] {
+trait pub Compare {
   # Returns the ordering between `self` and the given argument.
   #
   # The returned value should be as follows:
   #
   # - `a == b`: `Ordering.Equal`
   # - `a > b`: `Ordering.Greater`
   # - `a < b`: `Ordering.Less`
-  fn pub cmp(other: ref T) -> Ordering
+  fn pub cmp(other: ref Self) -> Ordering
 
   # Returns `true` if `self` is lower than the given argument.
-  fn pub <(other: ref T) -> Bool {
+  fn pub <(other: ref Self) -> Bool {
     match cmp(other) {
       case Less -> true
       case _ -> false
     }
   }
 
   # Returns `true` if `self` is lower than or equal to the given argument.
-  fn pub <=(other: ref T) -> Bool {
+  fn pub <=(other: ref Self) -> Bool {
     match cmp(other) {
       case Less or Equal -> true
       case _ -> false
     }
   }
 
   # Returns `true` if `self` is greater than the given argument.
-  fn pub >(other: ref T) -> Bool {
+  fn pub >(other: ref Self) -> Bool {
     match cmp(other) {
       case Greater -> true
       case _ -> false
     }
   }
 
   # Returns `true` if `self` is equal to or greater than the given argument.
-  fn pub >=(other: ref T) -> Bool {
+  fn pub >=(other: ref Self) -> Bool {
     match cmp(other) {
       case Greater or Equal -> true
       case _ -> false
@@ -77,18 +77,18 @@ trait pub Compare[T] {
 }
 
 # A type that can be compared for equality.
-trait pub Equal[T] {
+trait pub Equal {
   # Returns `true` if `self` and the given object are equal to each other.
   #
   # This operator is used to perform structural equality. This means two objects
   # residing in different memory locations may be considered equal, provided
   # their structure is equal. For example, two different arrays may be
   # considered to have structural equality if they contain the exact same
   # values.
-  fn pub ==(other: T) -> Bool
+  fn pub ==(other: ref Self) -> Bool
 
   # Returns `true` if `self` and the given object are not equal to each other.
-  fn pub !=(other: T) -> Bool {
+  fn pub !=(other: ref Self) -> Bool {
     (self == other).false?
   }
 }
@@ -108,7 +108,7 @@ trait pub Contains[T] {
 #
 # min(10, 5) # => 5
 # ```
-fn pub inline min[T: Compare[T]](a: T, b: T) -> T {
+fn pub inline min[T: Compare](a: T, b: T) -> T {
   if a <= b { a } else { b }
 }
 
@@ -121,6 +121,6 @@ fn pub inline min[T: Compare[T]](a: T, b: T) -> T {
 #
 # max(10, 5) # => 10
 # ```
-fn pub inline max[T: Compare[T]](a: T, b: T) -> T {
+fn pub inline max[T: Compare](a: T, b: T) -> T {
   if a >= b { a } else { b }
 }

std/src/std/crypto/hash.inko

@@ -145,7 +145,7 @@ impl ToString for Hash {
   }
 }
 
-impl Equal[ref Hash] for Hash {
+impl Equal for Hash {
   fn pub ==(other: ref Hash) -> Bool {
     @bytes == other.bytes
   }

std/src/std/crypto/pem.inko

@@ -93,7 +93,7 @@ impl Format for Item {
   }
 }
 
-impl Equal[ref Item] for Item {
+impl Equal for Item {
   fn pub ==(other: ref Item) -> Bool {
     match (self, other) {
       case (Certificate(a), Certificate(b)) -> a == b
@@ -135,7 +135,7 @@ impl Format for ParseError {
   }
 }
 
-impl Equal[ref ParseError] for ParseError {
+impl Equal for ParseError {
   fn pub ==(other: ref ParseError) -> Bool {
     match (self, other) {
       case (Read(a), Read(b)) -> a == b

std/src/std/crypto/x509.inko

@@ -20,7 +20,7 @@ impl Format for Certificate {
   }
 }
 
-impl Equal[ref Certificate] for Certificate {
+impl Equal for Certificate {
   fn pub ==(other: ref Certificate) -> Bool {
     @bytes == other.bytes
   }
@@ -44,7 +44,7 @@ impl Format for PrivateKey {
   }
 }
 
-impl Equal[ref PrivateKey] for PrivateKey {
+impl Equal for PrivateKey {
   fn pub ==(other: ref PrivateKey) -> Bool {
     @bytes == other.bytes
   }

std/src/std/csv.inko

@@ -94,7 +94,7 @@ impl Format for Error {
   }
 }
 
-impl Equal[ref Error] for Error {
+impl Equal for Error {
   fn pub ==(other: ref Error) -> Bool {
     @kind == other.kind and @offset == other.offset
   }
@@ -128,7 +128,7 @@ impl Format for ErrorKind {
   }
 }
 
-impl Equal[ref ErrorKind] for ErrorKind {
+impl Equal for ErrorKind {
   fn pub ==(other: ref ErrorKind) -> Bool {
     match (self, other) {
       case (Read(a), Read(b)) -> a == b

std/src/std/float.inko

@@ -318,7 +318,7 @@ impl Power[Int, Float] for Float {
   }
 }
 
-impl Compare[Float] for Float {
+impl Compare for Float {
   # Return the ordering between `self` and `other`.
   #
   # This method implements total ordering of floats as per the IEEE 754
@@ -363,7 +363,7 @@ impl Compare[Float] for Float {
   }
 }
 
-impl Equal[ref Float] for Float {
+impl Equal for Float {
   # Returns `true` if `self` and `other` are equal to each other.
   #
   # This method uses "Units in the Last Place" or ULPs to perform an approximate

std/src/std/fs.inko

@@ -43,7 +43,7 @@ type pub copy enum FileType {
   }
 }
 
-impl Equal[ref FileType] for FileType {
+impl Equal for FileType {
   fn pub ==(other: ref FileType) -> Bool {
     match (self, other) {
       case (File, File) -> true
@@ -80,7 +80,7 @@ type pub inline DirectoryEntry {
   let pub @type: FileType
 }
 
-impl Equal[ref DirectoryEntry] for DirectoryEntry {
+impl Equal for DirectoryEntry {
   fn pub ==(other: ref DirectoryEntry) -> Bool {
     @path == other.path and @type == other.type
   }

std/src/std/fs/path.inko

@@ -885,7 +885,7 @@ type pub inline Path {
   }
 }
 
-impl Equal[ref Path] for Path {
+impl Equal for Path {
   # Returns `true` if `self` is equal to the given `Path`.
   #
   # # Examples

std/src/std/int.inko

@@ -648,7 +648,7 @@ impl ToFloat for Int {
   }
 }
 
-impl Compare[Int] for Int {
+impl Compare for Int {
   fn pub inline cmp(other: ref Int) -> Ordering {
     if self > other {
       Ordering.Greater
@@ -676,7 +676,7 @@ impl Compare[Int] for Int {
   }
 }
 
-impl Equal[ref Int] for Int {
+impl Equal for Int {
   fn pub inline ==(other: ref Int) -> Bool {
     _INKO.int_eq(self, other)
   }

std/src/std/io.inko

@@ -374,7 +374,7 @@ impl Format for Error {
   }
 }
 
-impl Equal[ref Error] for Error {
+impl Equal for Error {
   fn pub ==(other: ref Error) -> Bool {
     match (self, other) {
       case (AddressInUse, AddressInUse) -> true

std/src/std/json.inko

@@ -160,7 +160,7 @@ type pub inline enum ErrorKind {
   case Read(IoError)
 }
 
-impl Equal[ref ErrorKind] for ErrorKind {
+impl Equal for ErrorKind {
   fn pub ==(other: ref ErrorKind) -> Bool {
     match (self, other) {
       case (RecursionLimitExceeded(a), RecursionLimitExceeded(b)) -> a == b
@@ -222,7 +222,7 @@ type pub inline Error {
   }
 }
 
-impl Equal[ref Error] for Error {
+impl Equal for Error {
   fn pub ==(other: ref Error) -> Bool {
     @kind == other.kind and @offset == other.offset
   }
@@ -534,7 +534,7 @@ impl FormatTrait for Json {
   }
 }
 
-impl Equal[ref Json] for Json {
+impl Equal for Json {
   fn pub ==(other: ref Json) -> Bool {
     match (self, other) {
       case (Int(a), Int(b)) -> a == b
@@ -555,7 +555,7 @@ type pub copy enum Number {
   case Float(Float)
 }
 
-impl Equal[ref Number] for Number {
+impl Equal for Number {
   fn pub ==(other: ref Number) -> Bool {
     match (self, other) {
       case (Int(a), Int(b)) -> a == b
@@ -585,7 +585,7 @@ type pub copy enum Type {
   case String
 }
 
-impl Equal[ref Type] for Type {
+impl Equal for Type {
   fn pub ==(other: ref Type) -> Bool {
     match (self, other) {
       case (Array, Array) -> true

std/src/std/map.inko

@@ -17,7 +17,7 @@ let EMPTY = -1
 let DEFAULT_CAPACITY = 4
 
 # An entry stored in a Map.
-type pub Entry[K: Equal[ref K] + Hash, V] {
+type pub Entry[K: Equal + Hash, V] {
   # The key that was hashed.
   let @key: K
 
@@ -89,7 +89,7 @@ impl Clone for Entry if K: Clone, V: Clone {
 # - <http://codecapsule.com/2013/11/11/robin-hood-hashing/>
 # - <http://codecapsule.com/2013/11/17/robin-hood-hashing-backward-shift-deletion/>
 # - <https://www.sebastiansylvan.com/post/robin-hood-hashing-should-be-your-default-hash-table-implementation/>
-type pub Map[K: Equal[ref K] + Hash, V] {
+type pub Map[K: Equal + Hash, V] {
   # The slots we can hash into.
   #
   # An index of `-1` indicates the slot isn't used. A value of `0` or more
@@ -647,7 +647,7 @@ impl Map if V: mut {
   }
 }
 
-impl Equal[ref Map[K, V]] for Map if V: Equal[ref V] {
+impl Equal for Map if V: Equal {
   # Returns `true` if `self` and the given `Map` are identical to each
   # other.
   #

std/src/std/net/dns.inko

@@ -46,7 +46,7 @@ impl Format for Error {
   }
 }
 
-impl Equal[ref Error] for Error {
+impl Equal for Error {
   fn pub ==(other: ref Error) -> Bool {
     match (self, other) {
       case (InvalidHost, InvalidHost) -> true

std/src/std/net/ip.inko

@@ -168,7 +168,7 @@ type pub copy enum IpAddress {
   }
 }
 
-impl Equal[ref IpAddress] for IpAddress {
+impl Equal for IpAddress {
   fn pub inline ==(other: ref IpAddress) -> Bool {
     match self {
       case V4(a) -> {
@@ -500,7 +500,7 @@ impl FormatTrait for Ipv6Address {
   }
 }
 
-impl Equal[ref Ipv6Address] for Ipv6Address {
+impl Equal for Ipv6Address {
   # Returns `true` if `self` and the given IP address are the same.
   #
   # # Examples
@@ -891,7 +891,7 @@ impl FormatTrait for Ipv4Address {
   }
 }
 
-impl Equal[ref Ipv4Address] for Ipv4Address {
+impl Equal for Ipv4Address {
   # Returns `true` if `self` and the given IP address are the same.
   #
   # # Examples