Pourquoi Scala nécessite-t-il que les fonctions aient un type de retour explicite?

J'ai récemment commencé à apprendre à programmer à Scala, et ça a été amusant jusqu'à présent. J'aime vraiment la possibilité de déclarer des fonctions dans une autre fonction qui semble être une chose intuitive à faire.

Une bête noire que j'ai sur Scala est le fait que Scala nécessite un type de retour explicite dans ses fonctions . Et j'ai l'impression que cela entrave l'expressivité de la langue. Il est également difficile de programmer avec cette exigence. C'est peut-être parce que je viens de la zone de confort Javascript et Ruby. Mais pour un langage comme Scala qui aura des tonnes de fonctions connectées dans une application, je ne peux pas imaginer comment je réfléchis dans ma tête exactement quel type la fonction particulière que j'écris devrait retourner avec des récursions après récursions.

Cette exigence de déclaration explicite de type de retour sur les fonctions, ne me dérange pas pour les langages comme Java et C ++. Les récursions en Java et C ++, lorsqu'elles se sont produites, ont souvent été traitées avec 2 à 3 fonctions max. Jamais plusieurs fonctions enchaînées comme Scala.

Donc je suppose que je me demande s'il y a une bonne raison pour laquelle Scala devrait avoir l'exigence de fonctions ayant un type de retour explicite?

Scala ne nécessite pas de type de retour explicite sur toutes les fonctions, juste récursives. La raison en est que l'algorithme d'inférence de type de Scala est (quelque chose de proche) un simple scan du début à la fin qui est incapable de regarder en avant.

Cela signifie qu'une fonction comme celle-ci:

def fortuneCookieJoke(message: String) = message + " in bed."

n'a pas besoin d'un type de retour, car le compilateur Scala peut clairement voir, sans utiliser de variables logiques ou regarder autre chose que les paramètres de la méthode, que le type de retour doit être String.

D'un autre côté, une fonction comme celle-ci:

def mapInts(f: (Int) => Int, l: List[Int]) = l match {
  case Nil => Nil
  case x :: xs => f(x) :: mapInts(f, xs)
}

provoquera une erreur au moment de la compilation, car le compilateur Scala ne peut pas voir, sans utiliser de variables de recherche ou de logique, quel est exactement le type de mapInts. Le plus qu'il pourrait dire, s'il était assez intelligent, est que le type de retour est un sur-type List[Nothing], puisqu'il Nilest de ce type. Cela ne lui donne pas assez d'informations pour déterminer avec précision le type de retour de mapInts.

Veuillez noter que ceci est spécifique à Scala et qu'il existe d'autres langages typés statiquement (la plupart de la famille Miranda / Haskell / Clean, la plupart de la famille ML et quelques autres dispersés) qui utilisent des algorithmes d'inférence de type beaucoup plus complets et capables. que Scala utilise. Sachez également que ce n'est pas entièrement la faute de Scala; le sous-typage nominal et l'inférence de type module entier sont fondamentalement en contradiction les uns avec les autres, et les concepteurs de Scala ont choisi de privilégier le premier sur le second pour des raisons de compatibilité Java, tandis que les langages fonctionnels typés "plus purs" statiquement ont été principalement conçus avec le choix opposé à l'esprit.