¿Cuándo usar el signo igual en una declaración de método de Scala?

Con signo igual:

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

Sin signo igual:

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

Ambos programas anteriores se ejecutan de la misma manera. En la publicación del blog Cosas que no me gustan en Scala , leí que cuando falta el signo igual, el método regresará Unit(igual que el de Java void), por lo que los métodos que devuelven un valor deben usar el signo igual. Pero los métodos que no devuelven un valor se pueden escribir de cualquier manera.

¿Cuál es la mejor práctica para usar el signo igual en los métodos de Scala que no devuelven un valor?

De hecho, no estoy de acuerdo con Daniel. Creo que la sintaxis no igual nunca debería usarse. Si su método se expone como una API y le preocupa devolver accidentalmente el tipo incorrecto, agregue una anotación de tipo explícita:

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

La sintaxis no igual es más corta y puede parecer "más limpia", pero creo que solo agrega la posibilidad de confusión. A veces me olvidé de agregar un signo igual y creí que mi método estaba devolviendo un valor cuando en realidad estaba devolviendo Unit. Debido a que las sintaxis de tipo no igual e igual con inferido son tan similares visualmente, es fácil pasar por alto este problema.

Aunque me cuesta un poco más de trabajo, prefiero las anotaciones de tipo explícito cuando son importantes (es decir, interfaces expuestas).

ACTUALIZACIÓN: a partir de Scala-2.10, se prefiere el uso del signo igual. Respuesta anterior:

Los métodos que devuelven siempreUnit deben usar la sintaxis no igual. Esto evita posibles errores en la implementación que se transfieren a la API. Por ejemplo, podría haber hecho accidentalmente algo como esto:

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

Un ejemplo trivial, por supuesto, pero puede ver cómo esto podría ser un problema. Dado que la última expresión no devuelve Unit, el método en sí tendrá un tipo de retorno distinto de Unit. Esto se expone en la API pública y podría causar otros problemas en el futuro. Con la sintaxis no igual, no importa cuál sea la última expresión, Scala fija el tipo de retorno como Unit.

También es un limpiador de dos personajes. :-) También tiendo a pensar que la sintaxis no igual hace que el código sea un poco más fácil de leer. Es más obvio que el método en cuestión devuelve en Unitlugar de algún valor útil.

En una nota relacionada, hay una sintaxis análoga para los métodos abstractos:

trait Foo {
  def bar(s: String)
}

El método bartiene firma String=>Unit. Scala hace esto cuando omite la anotación de tipo en un miembro abstracto. Una vez más, esto es más limpio y (creo) más fácil de leer.

Usted debe utilizar el signo de igualdad en las declaraciones de llamadas excepto las definiciones que regresan Unidad.

En este último caso, puede renunciar al signo igual. Sin embargo, esta sintaxis puede estar obsoleta, por lo que es mejor evitarla. Usar el signo igual y declarar el tipo de retorno siempre funcionará.

Para los métodos, Scala Style Guide recomienda la sintaxis igual en lugar de la sintaxis de procedimiento

Sintaxis del procedimiento

Evite la sintaxis del procedimiento, ya que tiende a ser confuso para obtener muy poca brevedad.

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

Una cosa: imagine la última instrucción de un método que debería devolver Unit no devuelve Unit. Usar la sintaxis no igual es entonces muy conveniente, espero que esto no quede obsoleto ya que veo varios casos de uso para ello

A medida que avanzó el tiempo, el estilo predeterminado ha cambiado, y esto se ha mencionado en muchos de los comentarios a las respuestas, se recomienda en la guía de estilo oficial utilizar la =sintaxis para las declaraciones de funciones.

para los métodos que no tienen un valor de retorno, una forma de expresar dichos métodos es omitir el tipo de resultado y el signo igual, siguiendo el método con un bloque entre llaves. De esta forma, el método parece un procedimiento, un método que se ejecuta solo por sus efectos secundarios.