Ritorno in Scala

Question

Sono un principiante programmatore di scala e ho trovato un comportamento strano.

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

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

Sopra fondamentalmente voglio tornare vero se elem.isEmpty e count == 0. Altrimenti, voglio restituire false.

Ora ho letto sopra che non è necessario aggiungere un'istruzione return in scala. Quindi ho omesso lo return sopra. Ma non restituisce il booleano. Se aggiungo un estratto conto come return true. funziona perfettamente. Perché è così?

Inoltre, perché è considerata una cattiva pratica per avere istruzioni return a Scala

Answer 1

Non è così semplice come solo omettendo la parola chiave return. In Scala, se non esiste lo return, l'ultima espressione viene considerata come valore di ritorno. Pertanto, se l'ultima espressione è ciò che si desidera restituire, è possibile omettere la parola chiave return. Ma se quello che vuoi restituire è non l'ultima espressione, quindi Scala non saprai che volevi restituirlo.

Un esempio:

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

Qui l'ultima espressione della funzione f è un'espressione if/else che restituisce una stringa. Dato che non è stato specificato return esplicito, Scala dedurrà che si desidera restituire il risultato di questa espressione if/else: a String.

Ora, se aggiungiamo qualcosa dopo if/else espressione:

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

    if (somethingElse) 
    1 
    else 
    2 
} 

Ora l'ultima espressione è un if/else un'espressione che restituisce un int. Quindi il tipo di ritorno di f sarà Int. Se volessimo davvero restituire la stringa, allora siamo nei guai perché Scala ha nessuna idea che è quello che intendevamo. Pertanto, dobbiamo ripararlo memorizzando la stringa su una variabile e restituendola dopo la seconda espressione if/else, oppure modificando l'ordine in modo che la parte String si verifichi per ultima.

Infine, possiamo evitare la parola return anche con un'espressione nidificato if-else come la vostra:

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

Io non programmo Scala, ma usare un'altra lingua con rendimenti impliciti (Ruby). Hai il codice dopo il tuo blocco if (elem.isEmpty) - l'ultima riga di codice è ciò che viene restituito, motivo per cui non ottieni ciò che ti aspetti.

MODIFICA: ecco un modo più semplice per scrivere anche la tua funzione. Basta utilizzare il valore booleano di isEmpty e contare fino a restituire true o false automaticamente:

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

Answer 3

Per impostazione predefinita l'ultima espressione di una funzione verrà restituito. Nel tuo esempio c'è un'altra espressione dopo il punto, dove vuoi il tuo valore di ritorno. Se si desidera restituire qualcosa prima dell'ultima espressione, è comunque necessario utilizzare return.

è possibile modificare il vostro esempio come questo, per restituire un Boolean dalla prima parte

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

Non scrivere if dichiarazioni senza un corrispondente else. Dopo aver aggiunto else al frammento, vedrai che le tue true e false sono in realtà le ultime espressioni della funzione.

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

Questo argomento è in realtà un po 'più complicato come descritto nelle risposte finora. Questo blogpost by Rob Norris lo spiega in modo più dettagliato e fornisce esempi su quando utilizzare return in realtà infrange il codice (o almeno ha effetti non ovvi).

A questo punto lasciatemi solo citare l'essenza del post. L'affermazione più importante è proprio all'inizio. Stampa questo come poster e mettilo sulla tua bacheca :-)

La parola chiave return non è "opzionale" o "dedotta"; cambia il significato del tuo programma e non dovresti mai usarlo.

Dà un esempio, dove effettivamente si rompe qualcosa, quando si inline una funzione

// 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. 

perché

A return espressione, quando valutata, abbandona il calcolo corrente e ritorna al chiamante del metodo in cui appare return.

Questo è solo uno degli esempi forniti nel post collegato ed è il più semplice da capire. Ce ne sono di più e ti incoraggio molto, andare lì, leggere e capire.

Quando vieni da lingue imperative come Java, all'inizio potrebbe sembrare strano, ma una volta che ti sarai abituato a questo stile avrà senso. Lasciatemi concludere con un'altra citazione:

Se vi trovate in una situazione in cui si pensa che si desidera tornare presto, è necessario ripensare il modo in cui è stato definito il vostro calcolo.