This blog might help

Question

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

kevin.cianfarini · Answer

This is really good thanks

kevin.cianfarini · Answer

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

kevin.cianfarini · Answer

interface BaseMvpPresenter lt in V BaseMvpView gt fun attachView view V fun detachView

spragg · Answer

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`

spragg · Answer

edit removed because it was wrong

spragg · Answer

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

Andreas Sinz · Answer

< spragg> < kevin cianfarini> 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`

spragg · Answer

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

spragg · Answer

I have used it `val ref Map lt String Class lt out Fragment gt gt = mapOf ` which is what confused me

spragg · Answer

Thanks for pointing that out < Andreas Sinz>

kevin.cianfarini · Answer

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

kevin.cianfarini · Answer

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

kevin.cianfarini · Answer

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

kevin.cianfarini · Answer

< spragg>

Andreas Sinz · Answer

< kevin cianfarini> first we are talking about contravariance when using `in`

kevin.cianfarini · Answer

sorry that s what i meant

kevin.cianfarini · Answer

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

Andreas Sinz · Answer

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 `

Andreas Sinz · Answer

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

kevin.cianfarini · Answer

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

kevin.cianfarini · Answer

in the article

kevin.cianfarini · Answer

which appears to be possible in kotlin as well

kevin.cianfarini · Answer

` lt T BaseMVPView gt `

kevin.cianfarini · Answer

that s where I m confused

spragg · Answer

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

kevin.cianfarini · Answer

that doesn t really answer my question Is ` lt extends Animal gt ` effectively not the same in kotlin as ` lt T Animal gt `

Andreas Sinz · Answer

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

spragg · Answer

` lt extends Animal gt ` is the same as ` lt out Animal gt ` ` lt super Animal gt ` is the same as ` lt in Animal gt `

Andreas Sinz · Answer

`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 `

kevin.cianfarini · Answer

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

Andreas Sinz · Answer

exactly