Quand utiliser le signe égal dans une déclaration de méthode Scala?

Avec le signe égal:

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

Sans signe égal:

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

Les deux programmes ci-dessus s'exécutent de la même manière. Dans le billet de blog Choses que je n'aime pas dans Scala, j'ai lu que lorsque le signe égal est manquant, la méthode retournera Unit(identique à celle de Java void), donc les méthodes qui retournent une valeur doivent utiliser le signe égal. Mais les méthodes qui ne retournent pas de valeur peuvent être écrites de toute façon.

Quelle est la meilleure pratique pour utiliser le signe égal dans les méthodes Scala qui ne renvoient pas de valeur?

En fait, je ne suis pas du tout d'accord avec Daniel. Je pense que la syntaxe non égale ne devrait jamais être utilisée. Si votre méthode est exposée en tant qu'API et que vous craignez de renvoyer accidentellement le mauvais type, ajoutez une annotation de type explicite:

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

La syntaxe non-égale est plus courte et peut paraître "plus propre", mais je pense qu'elle ajoute simplement la possibilité de confusion. J'ai parfois oublié d'ajouter un signe égal et j'ai cru que ma méthode retournait une valeur alors qu'en réalité elle retournait Unit. Étant donné que les syntaxes de type non égal et égal à inféré sont visuellement similaires, il est facile de passer à côté de ce problème.

Même si cela me coûte un peu plus de travail, je préfère les annotations de type explicite lorsqu'elles comptent (à savoir, les interfaces exposées).

MISE À JOUR: à partir de Scala-2.10, l'utilisation du signe égal est préférable. Ancienne réponse:

Les méthodes qui retournent Unitdoivent toujours utiliser la syntaxe non égale. Cela évite d'éventuelles erreurs de mise en œuvre dans l'API. Par exemple, vous pourriez avoir accidentellement fait quelque chose comme ceci:

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

Exemple trivial bien sûr, mais vous pouvez voir comment cela pourrait être un problème. Étant donné que la dernière expression ne retourne pasUnit , la méthode elle-même aura un type de retour autre que Unit. Ceci est exposé dans l'API publique et pourrait causer d'autres problèmes ultérieurement. Avec la syntaxe non égale, peu importe quelle est la dernière expression, Scala corrige le type de retour comme Unit.

C'est aussi deux personnages plus propres. :-) J'ai aussi tendance à penser que la syntaxe non égale rend le code un peu plus facile à lire. Il est plus évident que la méthode en question renvoie Unitplutôt qu'une valeur utile.

Dans le même ordre d'idées, il existe une syntaxe analogue pour les méthodes abstraites:

trait Foo {
  def bar(s: String)
}

La méthode bara une signature String=>Unit. Scala fait cela lorsque vous omettez l'annotation de type sur un membre abstrait. Encore une fois, c'est plus propre et (je pense) plus facile à lire.

Vous devez utiliser des déclarations d'appel de signe égal à l'exception des définitions renvoyant Unit.

Dans ce dernier cas, vous pouvez renoncer au signe égal. Cette syntaxe peut cependant être obsolète, il vaut donc mieux l'éviter. L'utilisation du signe égal et la déclaration du type de retour fonctionnera toujours.

Pour les méthodes, Scala Style Guide recommande la syntaxe égale par opposition à la syntaxe de procédure

Syntaxe de la procédure

Évitez la syntaxe de la procédure, car elle a tendance à être déroutante pour très peu de gain de brièveté.

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

Une chose: imaginez la dernière instruction d'une méthode qui devrait retourner Unit ne retourne pas Unit. Utiliser la syntaxe non égale est alors très pratique, j'espère que cela ne sera pas obsolète car je vois plusieurs cas d'utilisation pour cela

Au fil du temps, le style par défaut a changé, et cela a été mentionné dans de nombreux commentaires aux réponses, il est recommandé dans le guide de style officiel d'utiliser la =syntaxe pour les déclarations de fonctions.

pour les méthodes qui n'ont pas de valeur de retour, un moyen d'exprimer de telles méthodes consiste à omettre le type de résultat et le signe égal, en suivant la méthode avec un bloc entre accolades. Sous cette forme, la méthode ressemble à une procédure, une méthode qui n'est exécutée que pour ses effets secondaires.