Returns are prohibited in functions with expression body and without explicit return type. Use block body '{...}' or add an explicit return type.
Ai folosit return într-o funcție scrisă cu = (corp-expresie) și fără tip returnat declarat. Kotlin nu poate deduce tipul în acest caz. Scrie funcția cu acolade { ... } și return, sau adaugă tipul returnat (fun f(x: Int): String = ...).
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
O funcție se poate scrie în două feluri: cu corp-bloc (fun f(x: Int): Int { return x * 2 }) sau cu corp-expresie (fun f(x: Int) = x * 2). La corpul-expresie, tipul returnat se deduce din expresie.
Dacă în interiorul expresiei apare un return (de exemplu într-un if sau într-un try), tipul ar depinde de valoarea din return, care la rândul ei depinde de tipul funcției: o deducție circulară. Kotlin o refuză cu Returns are prohibited in functions with expression body and without explicit return type.
Mesajul îți dă și reparațiile: treci la corp-bloc {...} sau declari tipul returnat (: String), caz în care return devine permis. Cel mai curat este, de obicei, să scoți return și să lași expresia if / when să întoarcă valoarea.
De ce apare: cauzele frecvente
1return într-un if din corp-expresie
fun semn(x: Int) = if (x > 0) { return "pozitiv" } else "negativ"fun semn(x: Int) = if (x > 0) "pozitiv" else "negativ"if e expresie și întoarce singur valoarea ramurii, deci return nu e necesar.
2Validare cu return la început
fun pret(x: Double?) = run {
if (x == null) return 0.0
x * 1.19
}fun pret(x: Double?): Double = run {
if (x == null) return 0.0
x * 1.19
}Cu tipul returnat declarat, return devine permis: compilatorul nu mai trebuie să-l deducă.
3try/catch scris ca expresie
fun citeste(s: String) = try { s.toInt() } catch (e: NumberFormatException) { return -1 }fun citeste(s: String) = try { s.toInt() } catch (e: NumberFormatException) { -1 }Și try este expresie: ultima valoare din fiecare bloc este rezultatul.
Repară eroarea, direct în pagină
Funcția categorie e scrisă cu corp-expresie, dar folosește return și nu compilează: Returns are prohibited in functions with expression body. Repară funcția (fără să declari tipul returnat) ca programul să afișeze ieftin, mediu, scump.
fun categorie(pret: Int) = when {
pret < 50 -> return "ieftin"
pret < 500 -> return "mediu"
else -> "scump"
}
fun main() {
println(listOf(20, 120, 900).map { categorie(it) }.joinToString(", "))
}ieftin, mediu, scump
Indiciu
when întoarce singur valoarea ramurii; scoate cuvintele return.
Reparația
fun categorie(pret: Int) = when {
pret < 50 -> "ieftin"
pret < 500 -> "mediu"
else -> "scump"
}
fun main() {
println(listOf(20, 120, 900).map { categorie(it) }.joinToString(", "))
}De ce merge
La o funcție cu = și fără tip declarat, tipul returnat se deduce din expresie. Un return în interiorul ei ar fi făcut deducția circulară, așa că Kotlin l-a interzis. when este însă o expresie: valoarea ramurii alese devine rezultatul funcției, deci return nu era necesar. Fără el, tipul se deduce simplu ca String.
Alte forme ale mesajului
error: returns are prohibited in functions with expression body and without explicit return type. Use block body '{...}' or add an explicit return type.Returns are not allowed for functions with expression body. Use block body in '{...}'
Cum o eviți pe viitor
La funcțiile scurte cu =, nu folosi return: lasă if, when și try să întoarcă valoarea, pentru că sunt expresii. Când funcția are validări cu ieșire timpurie, scrie-o cu corp-bloc și tip returnat explicit. Pentru funcțiile publice, declararea tipului returnat e oricum o practică bună: documentează API-ul și evită schimbări accidentale de tip.
Întrebări frecvente
De ce cu tipul declarat merge?
Pentru că problema era doar deducerea tipului. Când scrii : String, compilatorul verifică return-ul față de tipul declarat, fără deducție circulară.
Și return din lambda?
Într-o lambda, return simplu iese din funcția care o conține (doar la lambda-urile inline). Pentru a întoarce o valoare doar din lambda, folosește return@eticheta, de exemplu return@map.
Erori înrudite
'return' is prohibited here Ai scris return simplu într-o lambda care nu e inline (de exemplu una stocată într-o variabilă). Acolo return ar încerca să iasă din funcția exterioară, ceea ce nu se poate. Scoate return (ultima expresie e rezultatul lambdei) sau folosește return@eticheta. Missing return statement Funcția declară un tip de return (de exemplu : Int), dar există un drum prin cod care ajunge la acolada de final fără return. Adaugă un return pentru cazul rămas (de obicei după if sau după o buclă) sau scrie funcția ca expresie cu if/else sau when. Type checking has run into a recursive problem. Easiest workaround: specify the types of your declarations explicitly. O funcție recursivă scrisă cu = (expression body) nu are tipul returnat declarat, iar compilatorul ar trebui să-i știe tipul ca să-l afle. Scrie tipul explicit: fun factorial(n: Int): Long = ... Î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.
