Quando usar o sinal de igual em uma declaração de método Scala?

Com sinal de igual:

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

Sem sinal de igual:

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

Ambos os programas acima são executados da mesma maneira. Na postagem do blog Coisas que eu não gosto no Scala , li que quando o sinal de igual está faltando, o método retornará Unit(o mesmo que o de Java void), então os métodos que retornam um valor devem usar o sinal de igual. Mas os métodos que não retornam um valor podem ser escritos de qualquer maneira.

Qual é a prática recomendada para usar o sinal de igual em métodos Scala que não retornam um valor?

Na verdade, eu discordo fortemente de Daniel. Eu acho que a sintaxe não igual nunca deve ser usada. Se seu método está sendo exposto como uma API e você está preocupado em retornar acidentalmente o tipo errado, adicione uma anotação de tipo explícita:

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

A sintaxe não igual é mais curta e pode parecer "mais limpa", mas acho que apenas adiciona a possibilidade de confusão. Algumas vezes esqueci de adicionar um sinal de igual e acreditei que meu método estava retornando um valor quando na verdade estava retornando Unit. Como as sintaxes não igual e igual ao tipo inferido são visualmente semelhantes, é fácil perder esse problema.

Embora me custe um pouco mais de trabalho, prefiro as anotações de tipo explícito quando importam (ou seja, interfaces expostas).

ATUALIZAÇÃO: a partir do Scala-2.10, é preferível usar o sinal de igual. Resposta antiga:

Os métodos que retornam Unitdevem sempre usar a sintaxe não igual. Isso evita possíveis erros de implementação na API. Por exemplo, você pode ter feito algo assim acidentalmente:

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

É um exemplo trivial, mas você pode ver como isso pode ser um problema. Como a última expressão não retorna Unit, o próprio método terá um tipo de retorno diferente de Unit. Isso é exposto na API pública e pode causar outros problemas no futuro. Com a sintaxe não igual, não importa qual seja a última expressão, Scala corrige o tipo de retorno como Unit.

Também é mais limpo de dois personagens. :-) Eu também tendo a pensar que a sintaxe não igual torna o código um pouco mais fácil de ler. É mais óbvio que o método em questão retorna Unitao invés de algum valor útil.

Em uma nota relacionada, há uma sintaxe análoga para métodos abstratos:

trait Foo {
  def bar(s: String)
}

O método barpossui assinatura String=>Unit. Scala faz isso quando você omite a anotação de tipo em um membro abstrato. Mais uma vez, é mais limpo e (eu acho) mais fácil de ler.

Você deve usar declarações de chamada de sinal de igual, exceto as definições que retornam Unit.

Neste último caso, você pode renunciar ao sinal de igual. Essa sintaxe pode estar obsoleta, portanto, é melhor evitá-la. Usar o sinal de igual e declarar o tipo de retorno sempre funcionará.

Para métodos, o Guia de Estilo Scala recomenda a sintaxe equals em oposição à sintaxe de procedimento

Sintaxe de procedimento

Evite a sintaxe do procedimento, pois ela tende a ser confusa para obter muito pouco ganho de brevidade.

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

Uma coisa: imagine que o último comando de um método que deve retornar Unit não retorna Unit. Usar a sintaxe não igual é muito conveniente, espero que não se torne obsoleto, pois vejo vários casos de uso para ela

Conforme o tempo avançava, o estilo padrão mudou, e isso foi mencionado em muitos dos comentários às respostas, é recomendado no guia de estilo oficial usar a =sintaxe para declarações de função.

para métodos que não possuem valor de retorno, uma forma de expressar tais métodos é omitir o tipo de resultado e o sinal de igual, seguindo o método com um bloco entre chaves. Nesta forma, o método parece um procedimento, um método que é executado apenas para seus efeitos colaterais.