Type parameter 'T' is declared as 'out' but occurs in 'in' position in type 'T (of class Raft<out T>)'
Ai marcat parametrul generic cu out (clasa doar produce T), dar ai o funcție care primește T ca parametru (poziție in). Scoate out, folosește @UnsafeVariance dacă funcția doar citește valoarea, sau schimbă parametrul în Any?.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Varianța spune cum se comportă un tip generic la moștenire. class Raft<out T> promite că T doar iese din clasă (tip returnat), ceea ce permite ca un Raft<Int> să fie folosit ca Raft<Number>. Ca promisiunea să fie sigură, T nu are voie să apară ca tip de parametru (poziție in) sau într-un var public (poziție invariant, care e și in, și out).
Mesajul îți spune exact unde a fost încălcată regula: parametrul T, declarat out, apare în poziție in (un parametru de funcție) sau invariant (un var). Reversul există și el: in T folosit ca tip returnat dă declared as 'in' but occurs in 'out' position.
Alegi între: renunți la out (clasa devine invariantă), faci proprietatea val / private, sau marchezi parametrul @UnsafeVariance când funcția doar citește valoarea (așa face List.contains).
De ce apare: cauzele frecvente
1Funcție care primește T într-o clasă out
class Raft<out T>(private val items: List<T>) {
fun contine(x: T) = x in items
}class Raft<out T>(private val items: List<T>) {
fun contine(x: @UnsafeVariance T) = x in items
}contine doar compară, nu stochează x, deci e sigur; @UnsafeVariance îi spune compilatorului că știi ce faci.
2var public cu tipul T
class Cutie<out T>(var valoare: T)class Cutie<out T>(val valoare: T)Un var are și setter (poziție in), deci mesajul spune invariant position. Cu val rămâne doar getterul.
3Interfață care și produce, și consumă
interface Depozit<out T> {
fun ia(): T
fun pune(x: T)
}interface Depozit<T> {
fun ia(): T
fun pune(x: T)
}Dacă tipul chiar primește și întoarce T, nu poate fi covariant: scoate out.
Repară eroarea, direct în pagină
Clasa Raft<out T> ține produse și are o funcție contine, dar codul nu compilează: Type parameter 'T' is declared as 'out' but occurs in 'in' position. Păstrează out T (e folosit în main când Raft<Int> devine Raft<Number>) și repară funcția ca programul să afișeze Primul: 10, contine 20: true.
class Raft<out T>(private val items: List<T>) {
fun primul(): T = items.first()
fun contine(x: T): Boolean = x in items
}
fun main() {
val numere: Raft<Number> = Raft(listOf(10, 20, 30))
println("Primul: ${numere.primul()}, contine 20: ${numere.contine(20)}")
}Primul: 10, contine 20: true
Indiciu
contine doar compară valoarea primită, deci parametrul poate fi marcat @UnsafeVariance.
Reparația
class Raft<out T>(private val items: List<T>) {
fun primul(): T = items.first()
fun contine(x: @UnsafeVariance T): Boolean = x in items
}
fun main() {
val numere: Raft<Number> = Raft(listOf(10, 20, 30))
println("Primul: ${numere.primul()}, contine 20: ${numere.contine(20)}")
}De ce merge
out T permite ca Raft<Int> să fie atribuit unui Raft<Number>, dar în schimb T nu are voie să apară ca tip de parametru, unde cineva ar putea trimite un Double într-un raft de Int. Funcția contine doar compară valoarea cu elementele, nu o stochează, deci e sigură: @UnsafeVariance dezactivează verificarea doar pentru acel parametru, exact cum face List.contains.
Alte forme ale mesajului
error: type parameter 'T' is declared as 'out' but occurs in 'in' position in type 'T (of class Raft<out T>)'.Type parameter T is declared as 'out' but occurs in 'in' position in type TType parameter 'T' is declared as 'out' but occurs in 'invariant' position in type 'T (of class Cutie<out T>)'Type parameter 'T' is declared as 'in' but occurs in 'out' position in type 'T (of interface Consumator<in T>)'
Cum o eviți pe viitor
Pune out doar pe tipurile care produc valori (surse, liste read-only, rezultate) și in doar pe cele care consumă (comparatori, validatori, handlere). Dacă nu ești sigur, începe fără varianță și adaug-o când chiar ai nevoie să atribui Raft<Int> unui Raft<Number>. Folosește @UnsafeVariance doar pentru metode care nu stochează valoarea primită, ca contains sau indexOf.
Întrebări frecvente
De ce List<out E> are totuși contains(element: E)?
Pentru că în biblioteca standard parametrul e marcat @UnsafeVariance: contains doar compară, nu adaugă elementul, deci nu poate strica tipul listei.
Care e diferența față de out la locul de folosire (MutableList<out Number>)?
Acolo e varianță de folosire (use-site): restricționezi o variabilă anume. Aici e varianță de declarare: promisiunea e făcută pentru toate folosirile clasei. Restricția de la use-site produce eroarea contains out projection which prohibits the use of ....
Erori înrudite
Receiver type 'MutableList<out Number>' contains out projection which prohibits the use of 'fun add(element: E): Boolean' Parametrul e declarat MutableList<out Number>, deci din listă poți doar citi: compilatorul nu știe dacă e o listă de Int, de Double sau de alt Number, așa că interzice add. Dacă trebuie să adaugi, declară-l MutableList<Number> sau MutableList<in Int>. Type argument is not within its bounds: type parameter 'T (of class Cutie<T : Number>)' must be subtype of 'Number', but actual: 'String' Clasa sau funcția generică cere ca T să fie de un anumit tip (de exemplu T : Number), iar tu i-ai dat altul (String). Folosește un tip care respectă limita (Int, Double) sau, dacă limita e greșită, schimb-o în declarația generică. Cannot use 'T' as reified type parameter. Use a class instead. Codul are nevoie de tipul real al lui T la rulare (T::class, is T, filterIsInstance<T>()), dar pe JVM tipurile generice se șterg. Fă funcția inline cu <reified T> sau primește clasa ca parametru (cls: KClass<T>). Învață Kotlin de la zero, cu exerciții la fiecare lecție
Curs Kotlin (Android): lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
