¿Por qué Scala elige tener los tipos después de los nombres de las variables?

Question

Duplicar posibles:
Any reason for having “val capacity : Int” instead of “val Int Capacity” in Scala

En las variables se declaran como Scala:

var stockPrice: Double = 100. 

Si el tipo (doble) después del identificador (StockPrice). Tradicionalmente en lenguajes imperativos como C, Java, C#, el nombre del tipo precede al identificador.

double stock_price = 100.0; 

¿Es puramente una cuestión de gusto, o qué tener el nombre del tipo que al final ayudar al compilador de alguna manera? Ir también tiene el mismo estilo.

Answer 1

Además de apoyar la inferencia de tipo, esto también tiene un beneficio ergonómico.

Para cualquier nombre de variable + tipo dado, lo más probable es que el nombre sea la información más importante. Moverlo hacia la izquierda lo hace más prominente y el código más legible una vez que esté acostumbrado al estilo.

Otros beneficios ergonómicos:

• Con val, var o def antes nombres de los miembros, en lugar de su tipo, todos ellos perfectamente alineados en una columna.
• Si cambia solo el tipo de un miembro, o lo deja caer completamente a favor de la inferencia, entonces una herramienta diff de grano fino mostrará claramente que el nombre no ha cambiado
• Igualmente, cambiando entre un val/var/def es muy claro en diffs
• inferencia se debe considerar el comportamiento predeterminado en Scala, solo se necesitan especificaciones de tipo en ciertos escenarios específicos, incluso entonces se hace principalmente para el compilador. Entonces ponerlos al comienzo de una declaración enfatiza lo incorrecto.
• "name: Type" en lugar de "Type name" se acerca más a la forma en que la mayoría de los programadores pensarán en una declaración, es más natural.
• Las diferentes convenciones de C/C++ y Java para punteros y matrices (es decir, * siendo un prefijo en el siguiente nombre y no un sufijo en el tipo anterior en C/C++, o [] siendo un sufijo válido tanto en nombres como en tipos Java) siguen siendo confusos para los recién llegados o los convertidos de lenguaje, y causan algunos errores muy reales al declarar múltiples variables en una sola línea. Scala no deja lugar a dudas y confusión aquí.

Answer 2

Es después, así que se puede quitar para la inferencia de tipos:

var stockPrice: Double = 100.0 
var stockPrice = 100.0 

Sin embargo, es no cierto que los lenguajes imperativos tradicionalmente tienen tipos primero. Por ejemplo, Pascal no.

Ahora, C lo hace, y C++, Java y C# se basan en la sintaxis de C, por lo que naturalmente lo hacen de la misma manera, pero eso no tiene absolutamente nada que ver con los idiomas imperativos.

Answer 3

Cabe señalar que incluso C no define "tradicionalmente" el tipo antes del nombre de la variable, pero de hecho permite que las declaraciones se intercalen.

int foo[]; 

donde se declara el tipo de foo antes y después, léxicamente.

Más allá de eso, supongo que esta es una distinción sin ninguna diferencia. Los desarrolladores de compiladores ciertamente no podrían preocuparse de una manera u otra.

Answer 4

Kevin tiene razón. La principal observación es que el "nombre de tipo" sintaxis funciona muy bien, siempre y cuando los tipos son palabras clave cortas como int o flotador:

int x = 1 
float d = 0.0 

Por el precio de uno a obtener dos tipos de información: " Aquí comienza una nueva definición ", y" aquí está el tipo (resultado) de la definición ". Pero estamos pasando el área de tipos primitivos simples hoy en día. Si se escribe

HashMap<Shape, Pair<String, String>> shapeInfo = makeInfo() 

la parte más importante de lo que se define (el nombre) está enterrado detrás de la expresión de tipo. Comparar con

val shapeInfo: HashMap[Shape, (String, String)] = makeInfo() 

Se dice claramente

• Definimos un valor aquí, no una variable o método (val)
• El nombre de la cosa que definimos es shapeInfo
• Si se preocupan al respecto, este es el tipo (HashMap [...])