software - scala vs java

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

Question

En Scala, las variables se declaran como:

var stockPrice: Double = 100.

Donde el tipo (Doble) sigue el 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 gustos, o tener el tipo de letra al final ayuda 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 de los nombres de los miembros, en lugar de su tipo, todos se alinean ordenadamente 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 sido alterado
• Del mismo modo, cambiar entre val / var / def es muy claro en diferencias
• la inferencia se debe considerar como un 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.
• "nombre: tipo" en lugar de "nombre de tipo" se aproxima 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, * es un prefijo en el siguiente nombre y no un sufijo en el tipo anterior en C / C ++, o [] es un sufijo válido tanto para los nombres como para los tipos en 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

Cabe señalar que incluso C no define "tradicionalmente" el tipo anterior al nombre de la variable, sino que permite que las declaraciones se intercalen.

int foo[];

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

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

Answer 3

Es después para que pueda eliminarse para la inferencia de tipo:

var stockPrice: Double = 100.0
var stockPrice = 100.0

Sin embargo, no es cierto que los lenguajes imperativos tradicionalmente tengan 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 también lo hacen de esa manera, pero eso no tiene absolutamente nada que ver con los lenguajes imperativos.

Answer 4

Kevin lo hizo bien. La principal observación es que la sintaxis de "nombre de tipo" funciona de maravilla siempre que los tipos sean palabras clave cortas como int o float :

int x = 1
float d = 0.0

Por el precio de uno, obtiene dos piezas 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 tú escribes

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

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

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

Dice claramente

• Definimos un valor aquí, no una variable o método (val)
• El nombre de lo que definimos es shapeInfo
• Si te importa, este es el tipo (HashMap [...])