Pourquoi dans presque tous les langages de programmation modernes (Go, Rust, Kotlin, Swift, Scala, Nim et même dernière version de Python), les types viennent toujours après la déclaration de variable, et pas avant?
Votre prémisse est défectueuse sur deux fronts:
- Il existe de nouveaux langages de programmation qui ont le type avant l'identifiant. C♯, D ou Ceylan, par exemple.
- Le type après l’identifiant n’est pas un phénomène nouveau, il remonte au moins à Pascal (conçu de 1968 à 1969, publié en 1970), mais a en fait été utilisé dans la théorie des types mathématiques, qui débute vers 1902. Il a également été utilisé dans ML (1973), CLU (1974), Hope (1970), Modula-2 (1977-1985), Ada (1980), Miranda (1985), Caml (1985), Eiffel (1985), Oberon (1986), Modula-3 (1986-1988) et Haskell (1989).
Pascal, ML, CLU, Modula-2 et Miranda étaient tous des langages très influents. Il n’est donc pas étonnant que ce style de déclaration de caractères soit resté populaire.
Pourquoi x: int = 42
et pas int x = 42
? Ce dernier n'est-il pas plus lisible que l'ancien?
La lisibilité est une question de familiarité. Personnellement, je trouve le chinois illisible, mais apparemment pas les Chinois. Avoir appris Pascal à l'école, côtoyé Eiffel, F♯, Haskell et Scala, et avoir regardé TypeScript, Fortress, Go, Rust, Kotlin, Idris, Frege, Agda, ML, Ocaml,…, cela me paraissait tout à fait naturel .
Est-ce juste une tendance ou y a-t-il des raisons vraiment significatives derrière une telle solution?
Si c'est une tendance, c'est assez persistant: comme je l'ai mentionné, cela remonte à cent ans en mathématiques.
L'un des principaux avantages d'avoir le type après l'identificateur est qu'il est facile de laisser le type en dehors si vous souhaitez l'inférer. Si vos déclarations ressemblent à ceci:
val i: Int = 10
Ensuite, il est trivial de laisser le type et de l'inférer comme ceci:
val i = 10
Considérant que si le type précède l'identifiant comme ceci:
Int i = 10
Ensuite, l'analyseur commence à avoir du mal à distinguer une expression d'une déclaration:
i = 10
La solution généralement proposée par les concepteurs de langage consiste à introduire un mot clé "je ne veux pas écrire de type" qui doit être écrit à la place du type:
var i = 10; // C♯
auto i = 10; // C++
Mais cela n'a pas vraiment de sens: vous devez fondamentalement écrire explicitement un type qui dit que vous n'écrivez pas de type. Hein? Il serait beaucoup plus facile et plus judicieux de simplement laisser tomber, mais cela rend la grammaire beaucoup plus complexe.
(Et ne parlons même pas des types de pointeurs de fonction en C.)
Les concepteurs de plusieurs des langues susmentionnées ont pesé à ce sujet:
Remarque: les concepteurs de Ceylan ont également expliqué pourquoi ils utilisaient la syntaxe de type préfixe :
Préfixe au lieu d'annotations de type postfix
Pourquoi suivez-vous C et Java pour placer les annotations de type en premier lieu, au lieu de Pascal et ML pour les placer après le nom de la déclaration?
Parce que nous pensons ceci:
shared Float e = ....
shared Float log(Float b, Float x) { ... }
Est tout simplement beaucoup plus facile à lire que cela:
shared value e: Float = ....
shared function log(b: Float, x: Float): Float { ... }
Et nous ne comprenons tout simplement pas comment quiconque pourrait penser autrement!
Personnellement, je trouve leur "argument" beaucoup moins convaincant que les autres.