Is there a way to accept an argument that is either of type A or B in Kotlin?

Question

Assuming I have A and B:

data class A(val a: String, val common: String)
data class B(val b: String, val common: String)

Can I have a method that accepts either one and use common in it? something like:

fun accept(val param: A|B) {
    println(param.common)
}

To spell out one point: the reason you can't just use `common` is that `A`'s `common` is unrelated to `B`'s `common`. The two properties may be _spelled_ the same, but that's not significant; in Kotlin, they're completely different, because there's no inheritance relationship between them. That relationship is what all the answers are providing, in various ways. — gidds, Nov 03 '20 at 11:29

David Soroko · Accepted Answer · 2020-11-03T12:39:48.763

4

Sealed classes do pretty much that:

sealed class AorB (val common : String)
class A(val a: String, common: String) : AorB(common)
class B(val b: String, common: String) : AorB(common)

fun accept(param: AorB) {
    println(param.common)
    when(param) {
        is A -> println(param.a)
        is B -> println(param.b)
    }
}

fun main() {
    accept(A("a value", "common value")) 
    accept(B("b value", "common value")) 
}

edited Nov 03 '20 at 12:39

answered Nov 03 '20 at 10:57

David Soroko

8,521
2
39
51

Not with data classes, though. – Adam Millerchip Nov 03 '20 at 10:59
1

Ah, actually you can do it with data classes if you make the property `open`: `sealed class AorB (open val common : String)`. +1 for sealed classes. – Adam Millerchip Nov 03 '20 at 11:02
is there a way to do this without making them both inherit the class? – orirab Nov 03 '20 at 11:27
If I understand your question correctly - no. Inheritance either via interfaces as Adam suggested or sealed classes is what makes `A|B` work – David Soroko Nov 03 '20 at 11:30
@orirab You could use function overloading to do it differently, avoiding the inheritance. Updated my answer. – Adam Millerchip Nov 03 '20 at 11:57
thing is, I have multiple fields which are similar, seems like inheritance is the better route for my use-case... – orirab Nov 03 '20 at 12:03

Adam Millerchip · Answer 2 · 2020-11-03T11:54:52.883

You can do it if you have them both implement a common interface, and use the interface as the type of parameter:

interface HasCommon {
    val common: String
}

data class A(val a: String, override val common: String) : HasCommon
data class B(val b: String, override val common: String) : HasCommon

fun accept(param: HasCommon) {
    println(param.common)
}

fun main() {
    accept(A("a", "a"))
    accept(B("b", "b"))
}

Output:

a
b

Alternatively, you could do it in a more functional way by defining multiple versions of accept for each type, and abstracting out the common functionality:

data class A(val a: String, val common: String)
data class B(val b: String, val common: String)

fun accept(a: A) = printCommon(a.common)
fun accept(b: B) = printCommon(b.common)

fun printCommon(common: String) = println(common)

fun main() {
    accept(A("a", "a"))
    accept(B("b", "b"))
}

This works, but having the parameter be called `common` is purely cosmetic. They have no more in common then `a`or `b` — David Soroko, Nov 03 '20 at 12:05
Assuming you're talking about the 2nd example. The first one is enforced by the interface. Although I think I prefer the 2nd one now. You could enforce it by making them extension functions: `fun A.printCommon() = printCommon(common)`. — Adam Millerchip, Nov 03 '20 at 12:11

score 1 · Answer 3 · answered Nov 03 '20 at 10:26

Inheritance is supposed to fix this problem

After all, accepting either would mean you can't call any specific methods on them unless you cast them.

That would be the same thing as accepting "Any" in Kotlin.

A workaround would be to define 2 methods where one method could call the other one after casting it.

Or you make the classes inherit but you are using data classes so I assume you already know that that isn't easily possible with them.

A workaround for inheritance with data classes is this

Is there a way to accept an argument that is either of type A or B in Kotlin?

3 Answers3