¿Por qué en casi todos los lenguajes de programación modernos (Go, Rust, Kotlin, Swift, Scala, Nim, incluso la última versión de Python) los tipos siempre vienen después del nombre de la variable en la declaración de la variable, y no antes?

¿Por qué x: int = 42y no int x = 42?
¿No es este último más legible que el primero?
¿Es solo una tendencia o hay alguna razón realmente significativa detrás de esta solución?

Todos los idiomas que mencionó admiten la inferencia de tipos , lo que significa que el tipo es una parte opcional de la declaración en esos idiomas porque son lo suficientemente inteligentes como para completarlos cuando proporciona una expresión de inicialización que tiene un tipo fácil de determinar.

Eso es importante porque poner las partes opcionales de una expresión más a la derecha reduce la ambigüedad de análisis y aumenta la coherencia entre las expresiones que usan esa parte y las que no. Es más simple analizar una declaración cuando sabes que la varpalabra clave y el nombre de la variable son obligatorios antes de llegar a las cosas opcionales. En teoría, todas esas cosas que facilitan el análisis de las computadoras también deberían mejorar la legibilidad general para los humanos, pero eso es mucho más discutible.

Este argumento se pone especialmente fuerte cuando se tiene en cuenta todos los modificadores de tipo opcional que un lenguaje "no modernos" como C ++ tiene, como *para los punteros, &para las referencias, const, volatiley así sucesivamente. Una vez que agrega comas para varias declaraciones, comienza a obtener algunas ambigüedades realmente extrañas, como int* a, b;no hacer bun puntero.

Incluso C ++ ahora admite declaraciones de "tipo a la derecha" en forma de auto x = int{ 4 };, y tiene algunas ventajas .

¿Por qué en casi todos los lenguajes de programación modernos (Go, Rust, Kotlin, Swift, Scala, Nim, incluso la última versión de Python) los tipos siempre vienen después de la declaración de variable, y no antes?

Su premisa es defectuosa en dos frentes:

• Hay nuevos lenguajes de programación que tienen el tipo antes del identificador. C♯, D o Ceilán, por ejemplo.
• Tener el tipo después del identificador no es un fenómeno nuevo, se remonta al menos a Pascal (diseñado entre 1968 y 1969, lanzado en 1970), pero en realidad se usó en la teoría matemática de tipos, que comienza en 1902. También se usó en ML (1973), CLU (1974), Hope (1970), Modula-2 (1977-1985), Ada (1980), Miranda (1985), Caml (1985), Eiffel (1985), Oberon (1986), Modula-3 (1986–1988) y Haskell (1989).

Pascal, ML, CLU, Modula-2 y Miranda fueron idiomas muy influyentes, por lo que no es sorprendente que este estilo de declaraciones tipográficas siguiera siendo popular.

¿Por qué x: int = 42y no int x = 42? ¿No es este último más legible que el primero?

La legibilidad es una cuestión de familiaridad. Personalmente, encuentro que los chinos son ilegibles, pero aparentemente, los chinos no lo hacen. Después de haber aprendido a Pascal en la escuela, incursionar en Eiffel, F Has, Haskell y Scala, y haber examinado TypeScript, Fortress, Go, Rust, Kotlin, Idris, Frege, Agda, ML, Ocaml, ... me parece completamente natural. .

¿Es solo una tendencia o hay alguna razón realmente significativa detrás de tal solución?

Si es una tendencia, es bastante persistente: como mencioné, se remonta a cien años en matemáticas.

Una de las principales ventajas de tener el tipo después del identificador, es que es fácil omitir el tipo si desea inferirlo. Si sus declaraciones se ven así:

val i: Int = 10

Entonces es trivial dejar de lado el tipo e inferirlo así:

val i = 10

Mientras que si el tipo viene antes del identificador como este:

Int i = 10

Entonces comienza a ser difícil para el analizador distinguir una expresión de una declaración:

i = 10

La solución que los diseñadores de idiomas suelen presentar es introducir una palabra clave "No quiero escribir un tipo" que debe escribirse en lugar del tipo:

var  i = 10; // C♯
auto i = 10; // C++

Pero esto en realidad no tiene mucho sentido: básicamente tienes que escribir explícitamente un tipo que dice que no escribes un tipo. ¿Eh? Sería mucho más fácil y más sensato dejarlo fuera, pero eso hace que la gramática sea mucho más compleja.

(Y ni siquiera hablemos sobre los tipos de puntero de función en C.)

Los diseñadores de varios de los idiomas mencionados anteriormente han intervenido en este tema:

• Preguntas frecuentes sobre Go (consulte también: Sintaxis de declaración de Go ):

  ¿Por qué las declaraciones son al revés?

  Solo están al revés si estás acostumbrado a C. En C, la noción es que una variable se declara como una expresión que denota su tipo, lo cual es una buena idea, pero las gramáticas de tipo y expresión no se mezclan muy bien y los resultados pueden ser confusos; considerar punteros de función. Ir separa principalmente la sintaxis de expresión y tipo y eso simplifica las cosas (el uso de prefijos *para punteros es una excepción que prueba la regla). En C, la declaración

  int* a, b;
  

  declara aser un puntero pero no b; en Go

  var a, b *int
  

  declara que ambos son punteros. Esto es más claro y más regular. Además, el :=formulario de declaración corta argumenta que una declaración de variable completo debe presentar el mismo orden que :=por lo

  var a uint64 = 1
  

  tiene el mismo efecto que

  a := uint64(1)
  

  El análisis también se simplifica al tener una gramática distinta para los tipos que no es solo la gramática de la expresión; palabras clave como funcy chanmantener las cosas claras.

• Preguntas frecuentes sobre Kotlin :

  ¿Por qué tener declaraciones de tipo a la derecha?

  Creemos que hace que el código sea más legible. Además, permite algunas características sintácticas agradables. Por ejemplo, es fácil dejar de lado las anotaciones de tipo. Scala también ha demostrado bastante bien que esto no es un problema.

• Programación en Scala :

  La principal desviación de Java se refiere a la sintaxis para las anotaciones de tipo: es " variable: Type" en lugar de " Type variable" en Java. La sintaxis de tipo postfix de Scala se parece a Pascal, Modula-2 o Eiffel. La razón principal de esta desviación tiene que ver con la inferencia de tipos, que a menudo le permite omitir el tipo de una variable o el tipo de retorno de un método. Usar la variable: Typesintaxis " " es fácil: simplemente omita los dos puntos y el tipo. Pero en la Type variablesintaxis " " de estilo C, no puede simplemente omitir el tipo: ya no habría ningún marcador para comenzar la definición. Necesitaría alguna palabra clave alternativa para ser un marcador de posición para un tipo faltante (C♯ 3.0, que hace alguna inferencia de tipo, utiliza varpara este propósito). Dicha palabra clave alternativa se siente más ad-hoc y menos regular que el enfoque de Scala.

Nota: los diseñadores de Ceilán también documentaron por qué usan la sintaxis de tipo de prefijo :

Anotaciones de tipo prefijo en lugar de postfijo

¿Por qué sigues C y Java al poner primero las anotaciones de tipo, en lugar de Pascal y ML al ponerlas después del nombre de la declaración?

Porque pensamos esto:

shared Float e = ....
shared Float log(Float b, Float x) { ... }

Es simplemente mucho más fácil de leer que esto:

shared value e: Float = .... 
shared function log(b: Float, x: Float): Float { ... }

¡Y simplemente no entendemos cómo alguien podría pensar lo contrario!

Personalmente, encuentro su "argumento" mucho menos convincente que los otros.

Pascal también lo hace, y no es un idioma nuevo. Sin embargo, era un lenguaje académico, diseñado desde cero.

Diría que es semánticamente más claro comenzar con el nombre de la variable. El tipo es solo un detalle técnico. Si desea leer su clase como el modelo de realidad que es, tiene sentido poner los nombres de sus entidades primero y su implementación técnica al final.

C # y Java provienen de C, por lo que tuvieron que respetar la "técnica anterior", para no confundir al programador experimentado.

¿Por qué x: int = 42y no int x = 42? ¿No es este último más legible que el primero?

En un ejemplo tan simple, no hay mucha diferencia, pero hagámoslo un poco más complejo: int* a, b;

Esta es una declaración real y válida en C, pero no hace lo que intuitivamente parece que debería hacer. Parece que estamos declarando dos variables de tipo int*, pero en realidad estamos declarando una int*y una int.

Si su idioma coloca el tipo después de los nombres de las variables en sus declaraciones, es imposible encontrar ese problema.