I'm a newcomer to Kotlin/JVM so I'm definitely doi...

# announcements

[Karlo Lozovina]

I'm a newcomer to Kotlin/JVM so I'm definitely doing something non-idiomatic ... I'm used to structural equality from functional languages and I've had a few bugs because my classes weren't data classes...

[spand]

This is obviously way overkill and I deserve to be shot for this but:

open class Base {
    init {
        check(this::class.isData)
    }
}

[dany]

you may also add fun equals(other: MyType) in your interrface

[Karlo Lozovina]

cool trick, thanks, didn't think of something like that... I'm not used to that kind of "reflection" / runtime checking style...

[Casey Brooks]

Most likely, you’re not strictly wanting a data class, but a class that properly implements equals and hashCode. You can put those functions in your interface, which will require implementing classes to define them (and not just use the default ones from Any)

interface StructuralEquality {
    override fun equals(other: Any?): Boolean
    override fun hashCode(): Int
}

// does not compile
class ClassThatDoesNotImplementEqualsAndHashcode(val a: String) : StructuralEquality {

}

// compiles
class ClassThatImplementsEqualsAndHashcode(val a: String) : StructuralEquality {
    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (javaClass != other?.javaClass) return false

        other as ClassThatImplementsEqualsAndHashcode

        if (a != other.a) return false

        return true
    }

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

// compiles
data class DataClassThatImplementsEqualsAndHashcode(val a: String) : StructuralEquality

[Karlo Lozovina]

oh, this one looks even better...

[Karlo Lozovina]

didn't know you could put "override" modifier in interfaces...

[Karlo Lozovina]

maybe I should go read a book cover to cover, instead of just winging it 😄

[Matteo Mirk]

Yeah, compile-time checking is the best option! Other than the above solution I was about to suggest writing a Kotlin compiler plugin for your use case, since it’s extendable, but it’s an advanced topic.

[Karlo Lozovina]

yeah, I'm gonna leave compiler plugins for another day 🙂

[Jakub Pi]

In this case, override is required since equals and hashCode are already present on the supertype (Any)

[Karlo Lozovina]

ironically, i think I'm better of implementing this as reference equality and using singleton object everywhere (a pattern that's not used a lot in FP)

[Karlo Lozovina]

For example, https://kotlinlang.org/docs/reference/interfaces.html doesn't mention you can put override on interface methods (in this way)

[Karlo Lozovina]

it's a quite a nifty trick...

[Matteo Mirk]

yes, very cool!

[ilya.gorbunov]

You can put those functions in your interface, which will require implementing classes to define them

This is rather questionable behavior of the compiler and we may change it later. See https://youtrack.jetbrains.com/issue/KT-24971

[Karlo Lozovina]

oh-oh 🙂

[Sam Garfinkel]

You can get something similar to what you are looking for with sealed classes, but those can only be implemented by classes in the same library. Remember a data class is really just an ordinary class that is final with some synthesized boilerplate. There’s nothing special about them otherwise. The trick with KClass<*>.isData is based on Kotlin-specific metadata and is a pretty big antipattern.