Why can't I use `by` delegation for an interface with two different type parameters? Is there some k...

# getting-started

[dave08]

Why can't I use by delegation for an interface with two different type parameters? Is there some kind of workaround to this?

interface Foo<T> { ... }

class Bar(val foo1: Foo<Baz>, val Foo<Baz2>): Foo<Baz> by foo1, Foo<Baz2> by foo2

[Gleb Minaev]

Because you can't inherit the same interface several times with different (precisely, "inconsistent") type arguments. For example, the following won't be compiled as well.

interface Foo<T>

interface Baz
interface Baz2

class Bar: Foo<Baz>, Foo<Baz2>

[dave08]

Oh... it's funny that Kotlin's type inference wouldn't know the difference... the implementations are totally different...

[Vampire]

That's called type erasure. At runtime it would be just class Bar: Foo<*>, Foo<*> and where you used T, Any.

[Vampire]

https://kotlinlang.org/docs/generics.html#type-erasure

[dave08]

I thought that was when retrieving from, say, a collection, since the type in the collection is the base type, and the elements could be any type derived from them... but foo1 and foo2 are:

class Foo1 : Foo<Baz> { override fun Baz.build(...): Baz ... }
class Foo2 : Foo<Baz2> { override fun Baz2.build(...): Baz2 ... }

[dave08]

Maybe I need some in or out there?

[asdf asdf]

class Bar(val foo1: Foo1, val foo2: Foo2) : Foo<Baz1> by foo1, Foo<Baz2> by foo2

fun test(foo: Foo<*>) {
    foo.baz()
}

val thing: Bar = createBar()
test(thing)

How would test choose between calling baz on foo1 or foo2?