Quando utilizzare il segno di uguale in una dichiarazione del metodo Scala?

Con segno di uguale:

object HelloWorld {
  def main(args: Array[String]) = {
    println("Hello!")
  }
}

Senza segno di uguale:

object HelloWorld {
  def main(args: Array[String]) {
    println("Hello!")
  }
}

Entrambi i programmi di cui sopra vengono eseguiti allo stesso modo. Nel post del blog Le cose che non mi piacciono in Scala ho letto che quando manca il segno di uguale, il metodo tornerà Unit(come quello di Java void), quindi i metodi che restituiscono un valore devono usare il segno di uguale. Ma i metodi che non restituiscono un valore possono essere scritti in entrambi i modi.

Qual è la procedura migliore per utilizzare il segno di uguale nei metodi Scala che non restituiscono un valore?

In realtà non sono abbastanza d'accordo con Daniel. Penso che la sintassi non uguale non dovrebbe mai essere utilizzata. Se il tuo metodo viene esposto come API e temi di restituire accidentalmente il tipo sbagliato, aggiungi un'annotazione di tipo esplicita:

object HelloWorld {
  def main(args: Array[String]): Unit = {
    println("Hello!")
    123
  }
}

La sintassi non uguale è più breve e potrebbe sembrare "più pulita", ma penso che aggiunga solo la possibilità di confusione. A volte ho dimenticato di aggiungere un segno di uguale e credevo che il mio metodo restituisse un valore quando in realtà restituiva Unità. Poiché le sintassi di tipo non uguale e uguale a inferito sono visivamente simili, è facile non notare questo problema.

Anche se mi costa un po 'più di lavoro, preferisco le annotazioni di tipo esplicito quando sono importanti (vale a dire, le interfacce esposte).

AGGIORNAMENTO: a partire da Scala-2.10, è preferibile utilizzare il segno di uguale. Vecchia risposta:

I metodi che restituiscono Unitdovrebbero sempre utilizzare la sintassi non uguale. Ciò evita che potenziali errori di implementazione vengano trasferiti nell'API. Ad esempio, potresti aver accidentalmente fatto qualcosa del genere:

object HelloWorld {
  def main(args: Array[String]) = {
    println("Hello!")
    123
  }
}

Un esempio banale ovviamente, ma puoi vedere come questo potrebbe essere un problema. Poiché l'ultima espressione non viene restituita Unit, il metodo stesso avrà un tipo restituito diverso da Unit. Questo è esposto nell'API pubblica e potrebbe causare altri problemi lungo la strada. Con la sintassi non uguale, non importa quale sia l'ultima espressione, Scala corregge il tipo restituito come Unit.

È anche due personaggi più puliti. :-) Tendo anche a pensare che la sintassi non uguale renda il codice un po 'più facile da leggere. È più ovvio che il metodo in questione restituisce Unitpiuttosto che un valore utile.

In una nota correlata, c'è una sintassi analoga per i metodi astratti:

trait Foo {
  def bar(s: String)
}

Il metodo barha la firma String=>Unit. Scala lo fa quando ometti l'annotazione del tipo su un membro astratto. Ancora una volta, questo è più pulito e (penso) più facile da leggere.

È necessario utilizzare le dichiarazioni di chiamata con segno di uguale ad eccezione delle definizioni che restituiscono Unità.

In quest'ultimo caso, si può rinunciare il segno di uguale. Questa sintassi potrebbe essere deprecata, quindi è meglio evitarla. L'utilizzo del segno di uguale e la dichiarazione del tipo restituito funzioneranno sempre.

Per i metodi, Scala Style Guide consiglia la sintassi uguale anziché la sintassi delle procedure

Sintassi della procedura

Evita la sintassi della procedura, poiché tende a creare confusione per un guadagno minimo di brevità.

// don't do this
def printBar(bar: Baz) {
  println(bar)
}
// write this instead
def printBar(bar: Bar): Unit = {
  println(bar)
}

Una cosa: immagina che l'ultima affermazione di un metodo che dovrebbe restituire Unit non restituisca Unit. L'utilizzo della sintassi non uguale è quindi molto conveniente, spero che non sia deprecato poiché vedo diversi casi d'uso per questo

Con il passare del tempo lo stile predefinito è cambiato, e questo è stato menzionato in molti dei commenti alle risposte, si raccomanda nella guida allo stile ufficiale di usare la =sintassi per le dichiarazioni di funzione.

per i metodi che non hanno un valore di ritorno, un modo per esprimere tali metodi è tralasciare il tipo di risultato e il segno di uguale, seguendo il metodo con un blocco racchiuso tra parentesi graffe. In questa forma, il metodo sembra una procedura, un metodo che viene eseguito solo per i suoi effetti collaterali.