but I wonder if you could use overload

==

if you just defined another

operator fun equals

Doesn’t appear so

The type of equals is always

Any?

, because the compiler cannot enforce a

Value

being passed to your own

equals(...)

method:

val x: Any = Value(1)
val y: Any = Value(2)
println(x == y) // Both are "Any" here, so the compiler does not know about "Value.equals(Value)"

@Shawn commented on @bdawg.io’s file : ah, so it goes

Right, but that’s because you’re explicitly telling the compiler to use the super type. How would that be any different than the following in your example?

println(x + y)

Unresolved reference. None of the following candidates is applicable because of receiver type mismatch: (lists 53 potential 'plus' methods)

^ That’s the compilation result. But if they are not explicitly typed as

Any

the compiler finds

Value.plus(other: Value): Value

What would you expect the compiler to do? The compiler sees a type (

Any

) and an operator/function and tries to find that operator/function on the type it sees

The compiler can only use the type information of the variable that you use. It cannot know the actual type, so it cannot know which functions may aply

Kotlin and Java store a reference to a specific operator/function in the bytecode. There is no look-up at runtime to find the most suitable function for the actual types of the target and arguments

Again, we’re talking about 2 completely different problems

Right, in Java this would work because it does not use an operator for

equals(Any?)

. So if you do this, the compiler will pick

equals(Value)

because it is more specific:

val x = Value(1)
val y = Value(2)
println(x.equals(y))

But in Kotlin, the

==

operator is implemented using operator function

equals(Any?)

, so it will not look for other functions. You can still use the same syntax as in Java though, and then it will work

I guess the fact that it is an operator function, limits the signatures that can be supported to 1. I suppose this restriction could be lifted, but I don't know what the implications for the compiler are

I don’t think it’s wrong since I’m not really sure the reasoning behind it, but like I said, it just feels like a weird inconsistency that the

equals

operator specifically is limited to an exact method signature

I’m curious how the mapping for

+

works now, since it seems to override overload just fine (and is an operator fun)

one thing that might be of note is that

plus

isn’t defined on

Any

, so no override happening there

I guess

==

might be mapped specifically to

Any$equals

granted, this is just speculation from me 😅

Look at

plus

for

Int

, etc. There is no definition of

plus

on

Number

, so each number type defines it separately

For the

equals

convention to be consistent to

plus

, it would need to use the most qualified type and then follow the hierarchy thereafter until it finds a match

@bdawg.io commented on @bdawg.io’s file : Sorry I left the

open

on the

A.plus(other: A)

definition and the

B

class, I was playing with some other stuff and intended to strip them before the screenshot (since they are irrelevant to the example)

There must be a reason why you cannot do it for

equals

. Hopefully one of the JB people can tell you why

In a similar example, but matching the

(Any?) -> Boolean

signature with the

plus

convention

Thanks @jstuyts-squins for the input, it’s been an interesting discussion so far, same here on the JB feedback

But why don't you simply implement

equals(Any?)

? You will then also be able to compare to all other objects

I agree that comparing all other objects is handy, but the arithmetic conventions (

plus

,

minus

, etc. and even

compareTo

) provide a modular way to overload the operator instead of having to share this override hierarchy that can potentially quickly build up to a large call stack with a bunch of

super

handoffs

More of a discussion on the inconsistency rather than whether or not it is possible

equals

is Java legacy and important thing for compatibility with Java

Even in Java you can overload the

equals

method

With

Value

instead of

Object

for argument type? I’m pretty sure you cannot