A modern programming language that makes developers happier.

kotlinlang

This blog might help <https://proandroiddev.com/understanding-generics-and-variance-in-kotlin-714c14564c47>

so for clarification after reading that article, it looks like V here inherits from BaseMVPView is required?

interface BaseMvpPresenter&lt;in V : BaseMvpView&gt; {

    fun attachView(view: V)

    fun detachView()
}

-edit- This is wrong. Leaving it for continuity

So that example is actually backways. You need to use `out`. It felt backwards the first time I used it too. If you are passing in the variable then you need to use `out`.

Regarding the inheritance. V must be either of type BaseMvpView or have extend/inherited it.

<@U5PRA0FLJ> <@U5D6V79TL> the example isn't working, if I declare `V` as `out`, kotlin complains about `Type parameter V is declared as 'out' but occurs in 'in' position in type V`

oh yeah. That is correct. What I said was completely backwards. Sorry about that. It should be `in`

I have used it `val ref: Map&lt;String, Class&lt;out Fragment&gt;&gt; = mapOf()` which is what confused me.

Thanks for pointing that out <@U0D06TWMA>

So what im confused about is that in the code I posted above, it seems like covariance is achieved by `V : BaseMVPView`

why and how does `in` do anything to achieve contravariance?

and why does it seem like there are two ways to implement covariance

<@U5D6V79TL> first, we are talking about contravariance when using `in`

I was hung up on out from the example in the article

and second, `T: BaseMVPView` limits the available type arguments. passing an `Int` into a method `foo(n: Number)` is always possible, because kotlin knows that `Int` is a subtype of `Number`. `in` is useful when casting a class from `Comparable&lt;Number&gt;` into `Comparable&lt;Int&gt;`

just like `out` allows you to cast `List&lt;Int&gt;` to `List&lt;Number&gt;`

so I guess that im asking is in java, covariance is achieved by `&lt;? extends Animal&gt;`

which appears to be possible in kotlin as well

<@U5D6V79TL> The diagram at the bottom of the article might help. It contains a table of the relationship of the java version to kotlin.

that doesn't really answer my question. Is `&lt;? extends Animal&gt;` effectively not the same in kotlin as `&lt;T : Animal&gt;`?

`&lt;T: Animal&gt;` is neither covariance nor contravariance. It just limits the Types that `T` can be

`&lt;? extends Animal&gt;` is the same as `&lt;out Animal&gt;'`
`&lt;? super Animal&gt;` is the same as `&lt;in Animal&gt;`

`in` and `out` are class-level co-/contra-variance, e.g. `in` allows you to cast `Compare&lt;Animal&gt;` to `Compare&lt;Dog&gt;`. With `&lt;T: Animal&gt;` does not allow you to cast a class into `Comparable&lt;Animal&gt;` into `Comparable&lt;Dog&gt;`

okay so I guess the missing piece for me is that in Java, `&lt;? extends Animal&gt;` both limits the types that can be used and _also_ achieves covariance?