Why Kotlin doesn't allow use-site variance with the interface

I want to create a source like this:

interface IA{}
interface IB{}
class A{}
abstract class C extends A implements IA {}
abstract class D extends C implements IB {}
class E extends D implements IA, IB {}

class B <T extends A & IA> {}

class Test {
	B<? extends IB> t = new B<E>();

but I can’t write this code.

var t: B<out IB> = B<E>()

I want to know why to this is not allowed.

First, I’m going to convert your question into Kotlin:

interface IA
interface IB
open class A
abstract class C : A(), IA
abstract class D : C(), IB

open class E : D(), IA, IB

class B<T> where T : A, T : IA

class Test {
    fun foo(): B<out IB> = B<E>()
    //     ERROR ^^^^^^

Now, let’s examine the error message on out IB:

Type argument is not within bounds.
Expected: A
Found: IB
Type argument is not within bounds.
Expected: IA
Found: IB

The problem is that this parameter is required to implement both A and IA, which is what you specified in the where clause (intersection type). But IB implements neither. If you say out E it’s fine and does not require the explicit cast to E:

    val t: B<out E> = B()

This was an interesting brain teaser that got me to learn about the where keyword - I didn’t even know that Kotlin had intersection types!

I want to add variance. because Test.t will set B with a type that doesn’t extend both C and D, extends another subtype of A, and implements IA and IB.
Now, In my code, we write subtype of B and add variance with where. But I think it is not good to read. So I want to know why to couldn’t add variance like Java or how to pass this problem.

It doesn’t (yet). Your example of where T : IA, T : A1 is an intersection type, isn’t it?

I think so. where T : IA, T : A1 is an intersection type.

this mean make an intersection type with where T : IA, T : A1, T : IB

@gidds and @anatawa12 - you’re both right - thank you! I’ve suggested that the documentation be expanded. I’ll edit my post so I don’t confuse someone else.

I think you can simplify your whole example to:

    interface IA{}
    interface IB{}

    class B <T extends IA> {}

    class Test {
        B<? extends IB> t = new B<>();

I’m still missing something between these two lines:

class B <T extends IA> {}
B<? extends IB>

The first line says that the generic type parameter to class B must extend/implement/be an IA. The second line arbitrarily redefines what types a B class can take says that B’s type parameter will be from a totally unrelated interface IB.

This looks like a contradiction to me. I understand that you can “make it work out” with an E class implementing IA and IB, but that doesn’t remove the contradiction. I think due to type erasure that if it compiles, it will run fine. It still seems to me you may have found a bug in Java generics.