Overload resolution ambiguity between candidates
Există mai multe funcții cu același nume care se potrivesc la fel de bine cu apelul tău, iar compilatorul nu poate alege. Cazul tipic: f(null) când ai f(x: String?) și f(x: Int?). Fă apelul precis: dă tipul explicit (null as String?), folosește argumente cu nume sau redenumește una dintre funcții.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Când apelezi o funcție supraîncărcată (overloaded), compilatorul caută varianta care se potrivește cel mai bine cu argumentele. Dacă două sau mai multe variante sunt la fel de potrivite, nu alege la întâmplare: dă eroare și listează candidații, unul pe linie, sub mesaj.
Situații frecvente:
- argumentul
null, care se potrivește oricărui tip nullable; - parametri cu valori implicite:
f(a: Int, b: Long = 1)șif(a: Int, c: String = ""), apelate cuf(1); - două declarații identice (de exemplu după copy-paste sau două import-uri cu același nume), când apare și
Conflicting overloads; - o lambda fără tipuri, care se potrivește mai multor tipuri de funcții.
În Kotlin 1.x mesajul începea cu Overload resolution ambiguity: urmat de candidații public fun ....
De ce apare: cauzele frecvente
1null se potrivește mai multor tipuri
fun afiseaza(x: String?) = println("text: $x")
fun afiseaza(x: Int?) = println("numar: $x")
fun main() {
afiseaza(null)
}fun afiseaza(x: String?) = println("text: $x")
fun afiseaza(x: Int?) = println("numar: $x")
fun main() {
val nimic: String? = null
afiseaza(nimic)
}O variabilă cu tip declarat (String?) indică exact varianta dorită.
2Valori implicite care fac apelurile identice
fun log(m: String, nivel: Int = 1) = println("$nivel $m")
fun log(m: String, tag: String = "app") = println("$tag $m")
fun main() {
log("pornit")
}fun log(m: String, nivel: Int = 1, tag: String = "app") = println("$tag $nivel $m")
fun main() {
log("pornit")
}O singură funcție cu doi parametri opționali înlocuiește cele două variante care se ciocneau.
Repară eroarea, direct în pagină
Programul de mai jos are două funcții trimite, una pentru email și una pentru numărul de telefon, și nu compilează: Overload resolution ambiguity between candidates. Repară apelul cu null (fără să ștergi funcțiile) ca programul să afișeze Email: lipsa.
fun trimite(email: String?) = println("Email: ${email ?: "lipsa"}")
fun trimite(telefon: Long?) = println("Telefon: ${telefon ?: "lipsa"}")
fun main() {
trimite(null)
}Email: lipsa
Indiciu
Pune null într-o variabilă de tip String?, ca să fie clar ce variantă vrei.
Reparația
fun trimite(email: String?) = println("Email: ${email ?: "lipsa"}")
fun trimite(telefon: Long?) = println("Telefon: ${telefon ?: "lipsa"}")
fun main() {
val email: String? = null
trimite(email)
}De ce merge
null se potrivește la fel de bine cu String? și cu Long?, deci compilatorul nu poate alege între cele două funcții. O variabilă declarată String? are un tip precis, iar apelul trimite(email) duce clar la varianta pentru email. Elvis-ul ?: afișează apoi lipsa.
Alte forme ale mesajului
error: overload resolution ambiguity between candidates: fun f(a: Int, b: Long = ...): Int fun f(a: Int, c: String = ...): IntOverload resolution ambiguity: public fun afiseaza(x: Int?): Unit defined in root package public fun afiseaza(x: String?): Unit defined in root packageOverload resolution ambiguity. All these functions match.
Cum o eviți pe viitor
Fă overloading doar între tipuri care nu se pot confunda și evită combinația „parametri nullable + overloading”. În Kotlin, valorile implicite și argumentele cu nume înlocuiesc de cele mai multe ori nevoia de mai multe variante ale unei funcții. Dacă două variante fac lucruri diferite, dă-le nume diferite (afiseazaText, afiseazaNumar).
Întrebări frecvente
Am o singură funcție și tot primesc eroarea. De ce?
Probabil ai două import-uri cu același nume sau ai declarat funcția de două ori (atunci apare și Conflicting overloads). Uită-te la lista de candidați din mesaj: îți spune unde sunt.
Ajută dacă scriu null as String??
Da, afiseaza(null as String?) spune explicit tipul și rezolvă ambiguitatea. O variabilă cu tip declarat e mai lizibilă.
Erori înrudite
Conflicting overloads: fun f(a: Int): Int Ai două funcții cu același nume și aceiași tipuri de parametri. Kotlin le deosebește doar după numărul și tipul parametrilor, nu după numele lor sau după tipul returnat. Redenumește una dintre funcții sau schimbă-i parametrii. Too many arguments for 'fun salut(nume: String): String' Ai apelat funcția cu mai multe argumente decât are parametri. Mesajul îți arată semnătura funcției: compară-o cu apelul și scoate argumentul în plus, sau adaugă parametrul lipsă în declarație (eventual cu valoare implicită). No value passed for parameter 'b' Ai apelat o funcție sau un constructor fără unul dintre argumentele obligatorii; mesajul spune care parametru lipsește (b). Trimite și acel argument sau dă-i parametrului o valoare implicită în declarație: fun f(a: Int, b: Int = 0). Î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.
