I wrote next class (the simpliest version to show ...

# announcements

[Mikhail Buzuverov]

I wrote next class (the simpliest version to show the mistake)

abstract class MockedMethod<in I, out O> {
    abstract fun execute(arg: I): O
    abstract fun combine(method: MockedMethod<I, O>): MockedMethod<I, O>
}

But I get error for combine argument:

Type parameter I is declared as 'in' but occurs in 'out' position in type MockedMethod<I, O>
Type parameter O is declared as 'out' but occurs in 'in' position in type MockedMethod<I, O>

I don't understand why there is error. What is wrong?

[Mikhail Buzuverov]

For example:

class A

class A1: A()

class B

class B1: B()

val method1 = MockedMethod<A1, B>()
val method2 = MockedMethod<A, B1>()

val combined: MockedMethod<A1, B> = method1.combine(method2) //correct, isn;t it? Because we can cast A1 to A and B1 to B

[kevinherron]

because I and O are both used in both in and out positions (accepted by combine and returned by combine)

[Roukanken]

(no, that doesn't actually help)

[Roukanken]

abstract class MockedMethod<in I, out O> {
    abstract fun execute(arg: I): O
    abstract fun combine(method: MockedMethod<I, Any>): MockedMethod<Any, Any>
}

this, and various variants to it, throw too

[Roukanken]

trying to think why would that ↑ throw, but unsure yet

[andries.fc]

This will go pass the compiler error:

abstract class MockedMethod<in T, out R> {
    abstract fun execute(arg: T): R
    abstract fun combine(mockedMethod: MockedMethod<Any, Any>): MockedMethod<T, R>
}

May be a bit tricky to handle the call the combine as you have no type safety any more.

[andries.fc]

Also this is also a work around, but you will loose the combine method in the inheritance hierarchy:

abstract class MockedMethod<in T, out R> {
    abstract fun execute(arg: T): R
}

fun <T,R> MockedMethod<T,R>.combine(m: MockedMethod<T,R>): MockedMethod<T, R> {
    return object : MockedMethod<T,R>() {
        override fun execute(arg: T): R {
            TODO("Implement combine")
        }
    }
}

[Mikhail Buzuverov]

I found another workaround:

abstract class MockedMethod<I, O> {
    abstract fun execute(arg: I): O
    abstract fun combine(method: MockedMethod<in I, out O>): MockedMethod<I, O>
}

But it looks weird. Why is there error when in and out in class definition, but no error when they are in method definition?

Looks like compiler bug.

[Mikhail Buzuverov]

Created ticket: https://youtrack.jetbrains.com/issue/KT-46610

[Mikhail Buzuverov]

And found old one with similar issue: https://youtrack.jetbrains.com/issue/KT-7305

[Mikhail Buzuverov]

Checked Scala compiler: the same issue

[Mikhail Buzuverov]

Oh! I catched it! Let's assume there is equivalent interfaces and classes and contravariant type I is allowed:

interface Processor<in I, out O> {
    fun setArg(arg: I)
    fun process(fn: (I) -> O): O
}

interface A {
    val a: Int
}

interface B: A {
    val b: Int
}

class ProcessorImpl: Processor<A, Int> {
    lateinit var value: A
    
    override fun setArg(a: A) { value = a }    
    override fun process(fn: (A) -> Int): Int = fn(value)
}

fun main() {
    val p1: Processor<A, Int> = ProcessorImpl()
    p1.setArg(object: A { override val a = 10 }) //OK: type argument is compartible
    val p2: Processor<B, Int> = p1 //OK: B can be casted to A and A is contravariant
    p2.process { it: B -> it.b } //Ohhhh... Function expects B, but there is A as argument
}

So, Kotlin (and Scala) rejects this case absolutely correctly.