Equals overloading

Kotlin's Equals OPERATOR overloading simply doesn't work (Operator '!=' cannot be applied to 'SettingString' and 'String'):

class SettingString(var selected) {
    override infix fun equals(other: Any?) = other is String && selected == other
}

fun arbitraryFunction() {
    val mode = SettingString("Boost")
    mode != "Boost" // error
}

That's by design:

> Kotlin checks the applicability of value equality operators at compile-time and may reject certain combinations of types for A and B. Specifically, it uses the following basic principle.
>
>>If type of A and type of B are definitely distinct and not related by subtyping, A == B is an invalid expression and should result in a compile-time error.
>
>>Informally: this principle means “no two objects unrelated by subtyping can ever be considered equal by ==”.

Because SettingString and String are completely separate, unrelated types, the compiler won't even try to compare them. The implication is if you're trying to implicitly compare two completely different objects like this, it's an error.

You can always can equals() explicitly, or maybe write your own infix operator using a different keyword. Or use a type alias if it's for readability. A value/inline class will probably run into the same problem, since it compiles to a new type (that might change in future though?)

There's a bit of compiler magic around the equality operators — which makes good sense as long as implementations of equals() behave as they should.

First, note that you can call equals() by name in this case, and it will use your override method as expected.

However, although it compiles, it doesn't behave correctly: your equals() method doesn't fulfil its contract.

For one thing, it's not reflexive: a.equals(a) should always return true, but your method always returns false.

And for another, it's not symmetric: a.equals(b) should always give the same result as b.equals(a), but in your example, mode.equals("Boost") returns true, whereas "Boost".equals(mode) returns false. (After all, the system String class knows nothing about your code. How can it?)

Failure to follow the equals() contract can cause all sorts of bizarre problems and unexpected behaviour. (For example, you could get duplicate values in a set or map, or their elements could seem to disappear and reappear at random, or iterators might never finish.) Such bugs can be very hard to track down.

In general, there's no safe way to allow objects of different classes to compare as equal. (It can sometimes be done if you control both classes and all their common superclasses, but it's very difficult to get right; see this excellent article for all the gory details.)

So while your equals() method compiles, I'm afraid it's fatally flawed.

Because unrelated classes will never compare as equal if they're well-behaved, the Kotlin compiler makes the equality operators == and != more restrictive than the equals() method itself: if the compiler can tell that the two objects can't be related, it prevents you from even trying to compare them. After all, they're never going to compare as equal (assuming they're well-behaved), so why even try?

Trying to do so is likely to be a bug in the code — and since Kotlin works hard to spot as many bugs as possible at compile time, it makes this a compile error for safety. (You can always call equals() explicitly if you really need to — it's more verbose, but that should be a reminder that something may not be right!)

As cactustictacs' answer points out, this is detailed in the language spec.

(BTW, it shouldn't be a surprise that the compiler treats those operators specially, because it has to do so to allow null arguments; null == something is valid even though null.equals(something) isn't.)

Comparison with an object not being a SettingString too needs a cast with 'as Any':

class SettingString(private var selected: String) {

  override infix fun equals(other: Any?): Boolean {
    if (other is SettingString) {
      return other == selected
    }
    return other is String && selected == other
  }

  override fun hashCode(): Int {
    return selected.hashCode()
  }

}

val mode = SettingString("Boost")

val other = SettingString("Boost")
mode != other   // This obviously works

val other2 = "Boost"
mode != other2           // Doesn't work
mode != other2 as Any    // This does work
!(mode equals "Boost")   // This does work also

See the discussion here: https://discuss.kotlinlang.org/t/overloading-with-different-types-of-operands/4059/17