Powrót w Scala

Question

Jestem początkującym programistą scala i natknąłem się na dziwne zachowanie.

def balanceMain(elem: List[Char]): Boolean = 
    { 
    if (elem.isEmpty) 
     if (count == 0) 
     true; 
     else false; 

    if (elem.head == '(') 
     balanceMain(elem.tail, open, count + 1);.... 

Przede zasadzie chcę wrócić true jeśli elem.isEmpty i count == 0. W przeciwnym razie chcę zwrócić false.

Teraz powyżej przeczytałem, że nie ma potrzeby dodawania zwrotu w scala. Tak więc pominąłam return powyżej. Ale nie zwraca wartości boolowskiej. Jeśli dodaję instrukcję return jako return true. działa idealnie. Dlaczego tak jest?

Ponadto, dlaczego jest ono uważane za złą praktyką mieć sprawozdań powrotne w Scala

Answer 1

To nie jest tak proste, jak to tylko pominięcie słowa kluczowego return. W programie Scala, jeśli nie ma wartości return, za ostatnie wyrażenie przyjmuje się wartość zwracaną. Jeśli więc ostatnim wyrażeniem jest to, co chcesz zwrócić, możesz pominąć słowo kluczowe return. Ale jeśli to, co chcesz zwrócić, nie jest ostatnim zdaniem, to nie będzie to, wtedy Scala nie będzie wiedziała, że ​​chcesz go zwrócić:.

Przykład:

def f() = { 
    if (something) 
    "A" 
    else 
    "B" 
} 

Oto ostatni wyraz funkcji f jest if/else wyrażenie, którego wynikiem jest String. Ponieważ nie zaznaczono żadnego wyraźnego return, Scala wywnioskuje, że chciałeś zwrócić wynik tego wyrażenia if/else: a String.

Teraz, jeśli dodamy coś po if/else wyrażenie:

def f() = { 
    if (something) 
    "A" 
    else 
    "B" 

    if (somethingElse) 
    1 
    else 
    2 
} 

Teraz ostatnie wyrażenie jest if/else wyrażenie dające do Int. Tak więc typem zwrotu f będzie Int. Jeśli naprawdę chcemy, aby zwrócił String, to mamy kłopoty, ponieważ Scala ma nie ma pojęcia, że to jest to, co zamierzaliśmy. W związku z tym musimy to naprawić, przechowując ciąg do zmiennej i zwracając go po drugim wyrażeniu if/else lub zmieniając kolejność tak, aby część String stała się ostatnia.

Wreszcie możemy uniknąć słowa kluczowego return nawet z zagnieżdżonego wyrażenia if-else jak Twoja:

def f() = { 
    if(somethingFirst) { 
    if (something)  // Last expression of `if` returns a String 
    "A" 
    else 
    "B" 
    } 
    else { 
    if (somethingElse) 
     1 
    else 
     2 

    "C"    // Last expression of `else` returns a String 
    } 

}

Answer 2

Nie programować Scala, ale użyć innego języka z ukrytych zwrotów (Ruby). Masz kod po swoim bloku if (elem.isEmpty) - ostatnia linia kodu jest tym, co zostało zwrócone, dlatego nie dostajesz tego, czego się spodziewasz.

EDYCJA: Oto prostszy sposób, aby napisać swoją funkcję. Wystarczy użyć logiczną wartość isEmpty i liczyć na powrót automatycznie prawda czy fałsz:

def balanceMain(elem: List[Char]): Boolean = 
{ 
    elem.isEmpty && count == 0 
} 

Answer 3

domyślnie zostaną zwrócone ostatnim wyrazem funkcji. W twoim przykładzie jest inne wyrażenie po punkcie, w którym chcesz zwrócić wartość. Jeśli chcesz zwrócić wszystko przed ostatnim wyrażeniem, musisz nadal używać return.

Można zmodyfikować przykład takiego, aby powrócić do Boolean z pierwszej części

def balanceMain(elem: List[Char]): Boolean = { 
    if (elem.isEmpty) { 
    // == is a Boolean resulting function as well, so your can write it this way 
    count == 0 
    } else { 
    // keep the rest in this block, the last value will be returned as well 
    if (elem.head == "(") { 
     balanceMain(elem.tail, open, count + 1) 
    } 
    // some more statements 
    ... 
    // just don't forget your Boolean in the end 
    someBoolExpression 
    } 
} 

Answer 4

Nie pisz if wypowiedzi bez odpowiedniego else. Po dodaniu else do fragmentu zobaczysz, że twoje true i false są w rzeczywistości ostatnimi wyrażeniami funkcji.

def balanceMain(elem: List[Char]): Boolean = 
    { 
    if (elem.isEmpty) 
     if (count == 0) 
     true 
     else 
     false 
    else 
     if (elem.head == '(') 
     balanceMain(elem.tail, open, count + 1) 
     else.... 

Answer 5

Ten temat jest nieco bardziej skomplikowany, jak opisano w dotychczasowych odpowiedziach. Ten blogpost by Rob Norris wyjaśnia to bardziej szczegółowo i podaje przykłady, kiedy użycie zwrotu spowoduje złamanie kodu (lub przynajmniej nieoczywiste efekty).

W tym miejscu chciałbym przytoczyć esencję postu. Najważniejsze stwierdzenie jest na samym początku. Wydrukuj to jako plakat i przyłóż do ściany :-)

Słowo kluczowe return nie jest "opcjonalne" ani "wnioskowane"; zmienia to znaczenie twojego programu i nigdy nie powinieneś go używać.

Daje jeden przykład, gdzie faktycznie łamie coś, kiedy inline funkcję

// Inline add and addR 
def sum(ns: Int*): Int = ns.foldLeft(0)((n, m) => n + m) // inlined add 

scala> sum(33, 42, 99) 
res2: Int = 174 // alright 

def sumR(ns: Int*): Int = ns.foldLeft(0)((n, m) => return n + m) // inlined addR 

scala> sumR(33, 42, 99) 
res3: Int = 33 // um. 

ponieważ

return wyrażenie, gdy oceniano, porzuca bieżący obliczeń i powraca do wywołującego metody, w której pojawia się return.

Jest to tylko jeden z przykładów podanych w połączonym poście i jest to najłatwiejsze do zrozumienia. Jest więcej i gorąco Cię zachęcam, abyś tam poszedł, przeczytał i zrozumiał.

Kiedy pochodzisz z języków imperatywnych, takich jak Java, może się to wydawać dziwne, ale gdy już przyzwyczaisz się do tego stylu, będzie to miało sens. Pozwolę sobie zamknąć kolejny cytat:

Jeśli znajdziesz się w sytuacji, w której myślisz, że chcesz wrócić wcześniej, musisz ponownie przemyśleć sposób, w jaki zdefiniowałeś swoje obliczenia.