Ventajas del sistema de tipo de Scala

Question

Estoy explorando el lenguaje Scala. Una afirmación que a menudo escucho es que Scala tiene un sistema de tipo más fuerte que Java. Por esto creo que lo que la gente quiere decir es que:

• scalac rechaza ciertos programas con errores, que javac compilará felizmente, sólo para causar un error de ejecución.
• Ciertas invariantes se pueden codificar en un programa Scala de modo que el compilador no permita que el programador escriba código que viole la condición.

¿Estoy en lo cierto al pensar en eso? Si es así, señale artículos/blogs/documentos que ilustren dichos ejemplos.

Answer 1

La principal ventaja del sistema Tipo Scala es no ser tan fuerte sino más bien ser mucho más rica (ver "The Scala Type System").
(Java puede definir algunos de ellos e implementar otros, pero Scala los tiene incorporados).
Véase también The Myth Makers 1: Scala's "Type Types", comentando Steve Yegge's blog post, donde "descarta" a Scala como "Monstruo de Frankenstein" porque "hay tipos de tipos y tipos de tipo de tipo".

• clases de tipo Valor (útil para estructuras de datos razonablemente pequeños que tienen semántica de valor) que se utilizan en lugar de los tipos primitivos (int, dobles, ...), la conversión implícita a clases "rico" de métodos adicionales.
• Nonnullable type
• Monad types
• tipos de Rasgos (y el mixin composition que viene con él)
• tipos de objetos Singleton (acaba de definir un 'objeto' y tiene uno),
• Compound types (intersecciones de tipos de objetos , para expresar que el tipo de un objeto es un subtipo de varios otros tipos),
• Functional types ((type1, …)=>returnType sintaxis),
• Case classes (clases regulares que exportan sus parámetros de constructor y que proporcionan un mecanismo de descomposición recursiva a través de la coincidencia de patrones),
• Path-dependent types (Idiomas que permiten tipos de nidos proporcionan formas de referirse a aquellos trazados de texto),
• Anonymous types (para definir el anonimato funciones),
• Self types (puede ser used for instance in Trait),
• Type aliases, junto con:
• package object (introducido en 2,8)
• Generic types (como Java), con un type parameter annotation mechanism para controlar el comportamiento de subtipos de tipos genéricos,
  • tipos genéricos covariantes: La anotación +T declara escriba T para ser utilizado sólo en posiciones covariantes. Stack[T] es un subtipo de Stack[S] si T es un subtipo de S.
  • Tipos genéricos contravariantes: -T declararían T para usarse solo en posiciones contravariantes.
• tipos acotadas genéricos (a pesar de que Java supports some part of it),
• Higher kinded types, que le permiten a uno para expresar relaciones de tipo más avanzado que es posible con Java genéricos,
• Abstract types (el alternativos de tipo genérico),
• Existential types (utilizado in Scala como el tipo de comodín de Java),
• Implicit types (ver "The awesomeness of Scala is implicit",
• View bounded types y
• Structural types, para especificar un tipo especificando las características del tipo deseado (pato).

Answer 2

El principal problema de seguridad con Java se relaciona con la varianza. Básicamente, un programador puede usar declaraciones de varianza incorrectas que pueden dar lugar a excepciones lanzadas en tiempo de ejecución en Java, mientras que Scala no lo permitirá.

De hecho, el hecho mismo de que el Array de Java sea una variante es ya un problema, ya que permite que se genere código incorrecto. Por ejemplo, como se ejemplifica en sepp2k:

String[] strings = {"foo"}; 
Object[] objects = strings; 
objects[0] = new Object(); 

Luego, por supuesto, hay tipos primas en Java, que permite todo tipo de cosas.

Además, aunque Scala también lo tiene, hay fundición. La API de Java es rica en moldeados de tipos, y no hay lenguaje como el de Scala case x: X => // x is now safely cast. Claro, un caso usa instanceof para lograr eso, pero no hay ningún incentivo para hacerlo. De hecho, el asInstanceOf de Scala es intencionalmente detallado.

Estas son las cosas que fortalecen el sistema de tipos de Scala. También es mucho más rico, como muestra VonC.