Scala (lenguaje de programación)

Scala ( / s k ɑː l ɑː / Skah -lah ) ^[8] es un fuerte estático de tipos lenguaje de programación de propósito general que soporta tanto la programación orientada a objetos y la programación funcional . Diseñado para ser conciso, ^[9] muchas de las decisiones de diseño de Scala tienen como objetivo abordar las críticas a Java . ^[7]

Scala

Paradigma	Multi-paradigma : concurrente , funcional , imperativo , orientado a objetos
Diseñada por	Martin Odersky
Desarrollador	Laboratorio de métodos de programación de la École Polytechnique Fédérale de Lausanne
Apareció por primera vez	20 de enero de 2004 ; Hace 17 años ( 20/01/2004 )
Lanzamiento estable	3.0.0 [1]  / 13 de mayo de 2021 ; Hace 33 dias ( 13 de mayo de 2021 )
Versión de vista previa	3.0.0-RC3 [2]  / 19 de abril de 2021 ; Hace 57 dias ( 19 de abril de 2021 )
Disciplina de mecanografía	Inferido , estático , fuerte , estructural
Lenguaje de implementación	Scala
Plataforma	Máquina virtual Java (JVM) JavaScript ( Scala.js ) LLVM ( Scala Native ) (experimental)
Licencia	Apache 2.0 [3]
Extensiones de nombre de archivo	.scala, .sc
Sitio web	www .scala-lang .org
Influenciado por
Common Lisp , [4] Eiffel , Erlang , F # , Haskell , [5] Java , [6] OCaml , [6] Oz , Pizza , [7] Scheme , [6] Smalltalk , ML estándar [6]
Influenciado
Ceilán , Cincel , Fantom , F # , Kotlin , Lazo , Rojo
Scala en Wikilibros

El código fuente de Scala se puede compilar en código de bytes Java y ejecutar en una máquina virtual Java (JVM). Scala proporciona interoperabilidad de lenguajes con Java para que las bibliotecas escritas en cualquiera de los dos lenguajes puedan ser referenciadas directamente en el código de Scala o Java. ^[10] Al igual que Java, Scala es orientado a objetos , y utiliza una sintaxis denomina rizado corsé que es similar al lenguaje C . Desde Scala 3, también hay una opción para usar la regla de fuera de lado (sangría) para estructurar bloques , y se recomienda su uso. Martin Odersky ha dicho que este resultó ser el cambio más productivo introducido en Scala 3. ^[11]

A diferencia de Java, Scala tiene muchas características de lenguajes de programación funcionales como Scheme , Standard ML y Haskell , que incluyen currización , inmutabilidad , evaluación diferida y coincidencia de patrones . También tiene un sistema de tipos avanzado que admite tipos de datos algebraicos , covarianza y contravarianza , tipos de orden superior (pero no tipos de rango superior ) y tipos anónimos . Otras características de Scala que no están presentes en Java incluyen la sobrecarga de operadores , parámetros opcionales, parámetros con nombre y cadenas sin formato . Por el contrario, una característica de Java que no está en Scala son las excepciones marcadas , lo que ha resultado controvertido. ^[12]

El nombre Scala es una combinación de escalabilidad y lenguaje , lo que significa que está diseñado para crecer con las demandas de sus usuarios. ^[13]

Historia

El diseño de Scala comenzó en 2001 en la École Polytechnique Fédérale de Lausanne (EPFL) (en Lausanne , Suiza ) por Martin Odersky . Fue la continuación del trabajo en Funnel, un lenguaje de programación que combina ideas de programación funcional y redes de Petri . ^[14] Odersky trabajó anteriormente en Java genérico y javac , el compilador de Java de Sun. ^[14]

Después de un lanzamiento interno a finales de 2003, Scala fue lanzado públicamente a principios de 2004 en la plataforma Java , ^{[15] [7] [14] [16]} Una segunda versión (v2.0) siguió en marzo de 2006. ^[7]

El 17 de enero de 2011, el equipo de Scala ganó una subvención de investigación de cinco años de más de 2,3 millones de euros del Consejo Europeo de Investigación . ^[17] El 12 de mayo de 2011, Odersky y sus colaboradores lanzaron Typesafe Inc. (luego rebautizada como Lightbend Inc. ), una empresa para proporcionar soporte comercial, capacitación y servicios para Scala. Typesafe recibió una inversión de $ 3 millones en 2011 de Greylock Partners . ^{[18] [19] [20] [21]}

Plataformas y licencia

Scala se ejecuta en la plataforma Java ( máquina virtual Java ) y es compatible con los programas Java existentes . ^[15] Como las aplicaciones de Android normalmente se escriben en Java y se traducen del código de bytes de Java al código de bytes de Dalvik (que puede traducirse posteriormente al código de máquina nativo durante la instalación) cuando se empaquetan, la compatibilidad con Java de Scala lo hace muy adecuado para el desarrollo de Android, más aún cuando se prefiere un enfoque funcional. ^[22]

La distribución de software de Scala de referencia, incluidos el compilador y las bibliotecas, se publica bajo la licencia de Apache . ^[23]

Otros compiladores y objetivos

Scala.js es un compilador de Scala que compila a JavaScript, por lo que es posible escribir programas que se pueden ejecutar en Scala en los navegadores web o Node.js . ^[24] El compilador, en desarrollo desde 2013, se anunció como ya no experimental en 2015 (v0.6). La versión v1.0.0-M1 se publicó en junio de 2018 y la versión 1.1.1 en septiembre de 2020. ^[25]

Scala Native es un compilador Scala que tiene como objetivo la infraestructura del compilador LLVM para crear código ejecutable que usa un tiempo de ejecución administrado liviano, que usa el recolector de basura Boehm . El proyecto está dirigido por Denys Shabalin y tuvo su primer lanzamiento, 0.1, el 14 de marzo de 2017.El desarrollo de Scala Native comenzó en 2015 con el objetivo de ser más rápido que la compilación justo a tiempo para la JVM al eliminar la compilación inicial en tiempo de ejecución de código y también brinda la capacidad de llamar a rutinas nativas directamente. ^{[26] [27]}

En junio de 2004 se lanzó un compilador de Scala de referencia dirigido a .NET Framework y su Common Language Runtime , ^[14] pero se eliminó oficialmente en 2012. ^[28]

Ejemplos de

Ejemplo de "Hola mundo"

El programa Hello World escrito en Scala tiene esta forma:

 objeto  HelloWorld  extiende la  aplicación  {  println ( "Hello, World!" )  }

A diferencia de la aplicación Hello World independiente para Java , no hay declaración de clase y nada se declara estático; En su lugar, se utiliza un objeto singleton creado con la palabra clave object .

Cuando el programa se almacena en el archivo HelloWorld.scala , el usuario lo compila con el comando:

$ scalac HelloWorld.scala

y lo ejecuta con

$ scala HelloWorld

Esto es análogo al proceso para compilar y ejecutar código Java. De hecho, el modelo de compilación y ejecución de Scala es idéntico al de Java, lo que lo hace compatible con herramientas de compilación de Java como Apache Ant .

Una versión más corta del programa Scala "Hello World" es:

println ( "¡Hola, mundo!" )

Scala incluye un shell interactivo y soporte para scripts. ^[29] Guardado en un archivo llamado HelloWorld2.scala, esto se puede ejecutar como un script usando el comando:

$ scala HelloWorld2.scala

Los comandos también se pueden ingresar directamente en el intérprete de Scala, usando la opción -e :

$ scala -e 'println ("¡Hola, mundo!")'

Las expresiones se pueden ingresar de forma interactiva en el REPL :

$ scala Bienvenido a Scala 2.12.2 (Java HotSpot (TM) Servidor VM de 64 bits, Java 1.8.0_131). Escriba expresiones para la evaluación. O prueba: ayuda.scala> List (1, 2, 3) .map (x => x * x) res0: List [Int] = List (1, 4, 9)scala>

Ejemplo básico

El siguiente ejemplo muestra las diferencias entre la sintaxis de Java y Scala. La función mathFunction toma un número entero, lo eleva al cuadrado y luego suma la raíz cúbica de ese número al logaritmo natural de ese número, devolviendo el resultado (es decir,${\displaystyle n^{2/3}+\ln(n^{2})}$):

// Java: int mathFunction ( int num ) { int numSquare = num * num ; return ( int ) ( Math . cbrt ( numSquare ) + Math . log ( numSquare )); }
// Scala: Conversión directa desde Java// no se necesita importación; scala.math // ya importado como `math` def mathFunction ( num : Int ) : Int = { var numSquare : Int = num * num return ( math . cbrt ( numSquare ) + math . log ( numSquare )). asInstanceOf [ Int ] }	// Scala: Más idiomático // Usa inferencia de tipo, omite la declaración `return`, // usa el método` toInt`, declara numSquare inmutableimport math._ def mathFunction ( num : Int ) = { val numSquare = num * num ( cbrt ( numSquare ) + log ( numSquare )). toInt }

Algunas diferencias sintácticas en este código son:

• Scala no requiere punto y coma para finalizar declaraciones.
• Los tipos de valor están en mayúscula: en Int, Double, Booleanlugar de int, double, boolean.
• Un parámetro y volver tipos siguen, como en Pascal , en lugar de preceder al igual que en C .
• Los métodos deben ir precedidos de def.
• Las variables locales o de clase deben estar precedidas por val(indica una variable inmutable ) o var(indica una variable mutable ).
• El returnoperador es innecesario en una función (aunque está permitido); el valor de la última declaración o expresión ejecutada es normalmente el valor de la función.
• En lugar del operador de conversión de Java (Type) foo, Scala usa foo.asInstanceOf[Type], o una función especializada como toDoubleo toInt.
• En lugar de Java import foo.*;, Scala usa import foo._.
• La función o el método foo()también se pueden llamar simplemente foo; El método thread.send(signo)también se puede llamar simplemente thread send signo; y el método foo.toString()también se puede llamar como just foo toString.

Estas relajaciones sintácticas están diseñadas para permitir la compatibilidad con lenguajes específicos de dominio .

Algunas otras diferencias sintácticas básicas:

• Las referencias de matriz se escriben como llamadas a funciones, por ejemplo, en array(i)lugar de array[i]. (Internamente en Scala, el primero se expande en array.apply (i) que devuelve la referencia)
• Los tipos genéricos se escriben como, por ejemplo, en List[String]lugar de Java List.
• En lugar del pseudo-tipo void, Scala tiene la clase singleton real Unit(ver más abajo).

Ejemplo con clases

El siguiente ejemplo contrasta la definición de clases en Java y Scala.

// Java: punto de clase pública { privado final doble x , y ; Punto público ( final doble x , final doble y ) { esto . x = x ; esto . y = y ; } público Point ( final de doble x , última doble y , final de boolean addToGrid ) { este ( x , y ); if ( addToGrid ) cuadrícula . agregar ( esto ); } Punto público () { esto ( 0.0 , 0.0 ); } public double getX () { retorno x ; } public double getY () { return y ; } double distanceToPoint ( otro punto final ) { return distanceBetweenPoints ( x , y , otro . x , otro . y ); } cuadrícula de cuadrícula estática privada = nueva cuadrícula (); static double distanceBetweenPoints ( doble final x1 , doble final y1 , doble final x2 , doble final y2 ) { return Math . hipot ( x1 - x2 , y1 - y2 ); } }

// Punto de clase Scala ( val x : Double , val y : Double , addToGrid : Boolean = false ) { import Point._ if ( addToGrid ) cuadrícula . agregar ( esto ) def esto () = esto ( 0.0 , 0.0 ) def distancia al punto ( otro : punto ) = distancia entre puntos ( x , y , otro . x , otro . y ) } Punto de objeto { cuadrícula de valor privado = nueva cuadrícula () def distancia entre puntos ( x1 : doble , y1 : doble , x2 : doble , y2 : doble ) = { matemáticas . hipot ( x1 - x2 , y1 - y2 ) } }

El código anterior muestra algunas de las diferencias conceptuales entre el manejo de clases de Java y Scala:

• Scala no tiene variables o métodos estáticos. En cambio, tiene objetos singleton , que son esencialmente clases con una sola instancia. Los objetos singleton se declaran usando en objectlugar de class. Es común colocar variables y métodos estáticos en un objeto singleton con el mismo nombre que el nombre de la clase, que luego se conoce como objeto complementario . ^[15] (La clase subyacente para el objeto singleton tiene un $apéndice. Por lo tanto, class Foocon el objeto complementario object Foo, debajo del capó hay una clase que Foo$contiene el código del objeto complementario, y se crea un objeto de esta clase, utilizando el patrón singleton ).
• En lugar de los parámetros del constructor, Scala tiene parámetros de clase , que se colocan en la clase, similares a los parámetros de una función. Cuando se declara con un modificador valo var, los campos también se definen con el mismo nombre y se inicializan automáticamente a partir de los parámetros de la clase. (Bajo el capó, el acceso externo a los campos públicos siempre pasa por los métodos de acceso (getter) y mutator (setter), que se crean automáticamente. La función de acceso tiene el mismo nombre que el campo, por lo que en el ejemplo anterior no es necesario declarar explícitamente los métodos de acceso). Tenga en cuenta que también se pueden declarar constructores alternativos, como en Java. El código que iría al constructor predeterminado (aparte de inicializar las variables miembro) va directamente al nivel de clase.
• La visibilidad predeterminada en Scala es public.

Características (con referencia a Java)

Scala tiene el mismo modelo de compilación que Java y C # , es decir, compilación separada y carga dinámica de clases , de modo que el código de Scala puede llamar a las bibliotecas de Java.

Las características operativas de Scala son las mismas que las de Java. El compilador de Scala genera un código de bytes que es casi idéntico al generado por el compilador de Java. ^[15] De hecho, el código Scala se puede descompilar en código Java legible, con la excepción de ciertas operaciones de constructor. Para la máquina virtual Java (JVM), el código Scala y el código Java son indistinguibles. La única diferencia es una biblioteca de tiempo de ejecución adicional, scala-library.jar. ^[30]

Scala agrega una gran cantidad de características en comparación con Java, y tiene algunas diferencias fundamentales en su modelo subyacente de expresiones y tipos, que hacen que el lenguaje sea teóricamente más limpio y eliminan varios casos de esquina en Java. Desde la perspectiva de Scala, esto es prácticamente importante porque varias características adicionales en Scala también están disponibles en C #.

Flexibilidad sintáctica

Como se mencionó anteriormente, Scala tiene una gran flexibilidad sintáctica, en comparación con Java. Los siguientes son algunos ejemplos:

• Los puntos y comas son innecesarios; las líneas se unen automáticamente si comienzan o terminan con un token que normalmente no puede estar en esta posición, o si hay paréntesis o corchetes sin cerrar.
• Cualquier método puede usarse como operador infijo, por ejemplo, "%d apples".format(num)y "%d apples" format numson equivalentes. De hecho, a los operadores aritméticos les gusta +y <<se tratan como cualquier otro método, ya que los nombres de funciones pueden consistir en secuencias de símbolos arbitrarios (con algunas excepciones hechas para cosas como paréntesis, corchetes y llaves que deben manejarse especialmente); el único tratamiento especial al que se someten dichos métodos con nombre de símbolo se refiere al manejo de la precedencia.
• Los métodos applyy updatetienen formas sintácticas cortas. foo()—Donde fooes un valor (objeto singleton o instancia de clase) —es la abreviatura de foo.apply()y foo() = 42es la abreviatura de foo.update(42). Del mismo modo, foo(42)es la abreviatura de foo.apply(42)y foo(4) = 2es la abreviatura de foo.update(4, 2). Se utiliza para clases de recopilación y se extiende a muchos otros casos, como las células STM .
• Scala distingue entre los métodos no-parens ( def foo = 42) y empty-parens ( def foo() = 42). Cuando se llama a un método de parens vacío, se pueden omitir los paréntesis, lo cual es útil cuando se llama a bibliotecas Java que no conocen esta distinción, por ejemplo, usar en foo.toStringlugar de foo.toString(). Por convención, un método debe definirse con parientes vacíos cuando produce efectos secundarios .
• Los nombres de métodos que terminan en dos puntos ( :) esperan el argumento en el lado izquierdo y el receptor en el lado derecho. Por ejemplo, 4 :: 2 :: Niles lo mismo que Nil.::(2).::(4)el primer formulario correspondiente visualmente al resultado (una lista con el primer elemento 4 y el segundo elemento 2).
• Las variables del cuerpo de la clase se pueden implementar de forma transparente como métodos getter y setter separados. Porque trait FooLike { var bar: Int }, una implementación puede ser . El sitio de la llamada aún podrá utilizar un archivo .object Foo extends FooLike { private var x = 0; def bar = x; def bar_=(value: Int) { x = value }} } }foo.bar = 42
• Se permite el uso de llaves en lugar de paréntesis en las llamadas a métodos. Esto permite implementaciones de bibliotecas puras de nuevas estructuras de control. ^[31] Por ejemplo, breakable { ... if (...) break() ... }parece como si breakablefuera una palabra clave definida por el lenguaje, pero en realidad es solo un método que toma un argumento de procesador . Los métodos que toman thunks o funciones a menudo los colocan en una segunda lista de parámetros, lo que permite mezclar la sintaxis de paréntesis y llaves: Vector.fill(4) { math.random }es lo mismo que Vector.fill(4)(math.random). La variante de llaves permite que la expresión abarque varias líneas.
• Las expresiones for (explicadas más abajo) pueden acomodar cualquier tipo que defina métodos monádicos como map, flatMapy filter.

Por sí mismos, pueden parecer opciones cuestionables, pero colectivamente sirven para permitir que los lenguajes específicos de dominio se definan en Scala sin necesidad de extender el compilador. Por ejemplo, la sintaxis especial de Erlang para enviar un mensaje a un actor, es decir, actor ! messagepuede ser (y está) implementada en una biblioteca Scala sin necesidad de extensiones de idioma.

Sistema de tipo unificado

Java hace una clara distinción entre tipos primitivos (por ejemplo, inty boolean) y tipos de referencia (cualquier clase ). Solo los tipos de referencia forman parte del esquema de herencia, derivado de java.lang.Object. En Scala, todos los tipos heredan de una clase de nivel superior Any, cuyos hijos inmediatos son AnyVal(tipos de valor, como Inty Boolean) y AnyRef(tipos de referencia, como en Java). Esto significa que la distinción de Java entre tipos primitivos y tipos en caja (por ejemplo, intvs. Integer) no está presente en Scala; El boxeo y unboxing es completamente transparente para el usuario. Scala 2.10 permite que el usuario defina nuevos tipos de valores.

Para-expresiones

En lugar de los bucles " foreach " de Java para recorrer un iterador, Scala tiene for-expresiones, que son similares a las listas por comprensión en lenguajes como Haskell, o una combinación de listas por comprensión y expresiones generadoras en Python . Las expresiones for que utilizan la yieldpalabra clave permiten generar una nueva colección iterando sobre una existente, devolviendo una nueva colección del mismo tipo. Ellos son traducidas por el compilador en una serie de map, flatMapy filterllamadas. Donde yieldno se usa, el código se aproxima a un bucle de estilo imperativo, traduciéndose a foreach.

Un ejemplo sencillo es:

val  s  =  para  ( x  <-  1  a  25  si  x * x  >  50 )  produce  2 * x

El resultado de ejecutarlo es el siguiente vector:

Vector(16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50)

(Tenga en cuenta que la expresión 1 to 25no es una sintaxis especial. El método tose define en la biblioteca estándar de Scala como un método de extensión en enteros, utilizando una técnica conocida como conversiones implícitas ^[32] que permite agregar nuevos métodos a los tipos existentes).

Un ejemplo más complejo de iterar sobre un mapa es:

// Dado un mapa que especifica los usuarios de Twitter mencionados en un conjunto de tweets, // y el número de veces que se mencionó a cada usuario, busque los usuarios // en un mapa de políticos conocidos y devuelva un nuevo mapa que solo muestre el // Democrático políticos (como objetos, en lugar de cuerdas). val  dem_mentions  =  for  {  ( mencionar ,  veces )  <-  cuenta de menciones  <- cuentas . obtener ( mencionar ) si cuenta . partido == "Democrático" } rendimiento ( cuenta , tiempos )          

La expresión (mention, times) <- mentionses un ejemplo de coincidencia de patrones (ver más abajo). La iteración sobre un mapa devuelve un conjunto de tuplas clave-valor , y la coincidencia de patrones permite que las tuplas se desestructuran fácilmente en variables separadas para la clave y el valor. De manera similar, el resultado de la comprensión también devuelve tuplas de valor-clave, que se crean automáticamente una copia de seguridad en un mapa porque el objeto de origen (de la variable mentions) es un mapa. Tenga en cuenta que si, en mentionscambio, tuviera una lista, conjunto, matriz u otra colección de tuplas, exactamente el mismo código anterior produciría una nueva colección del mismo tipo.

Tendencias funcionales

Si bien admite todas las características orientadas a objetos disponibles en Java (y de hecho, las aumenta de varias maneras), Scala también proporciona una gran cantidad de capacidades que normalmente se encuentran solo en lenguajes de programación funcionales . Juntas, estas características permiten que los programas Scala se escriban en un estilo casi completamente funcional y también permiten mezclar estilos funcionales y orientados a objetos.

Algunos ejemplos son:

• Sin distinción entre declaraciones y expresiones
• Inferencia de tipo
• Funciones anónimas con semántica de captura (es decir, cierres )
• Objetos y variables inmutables
• Evaluación perezosa
• Continuaciones delimitadas (desde 2.8)
• Funciones de orden superior
• Funciones anidadas
• Zurra
• La coincidencia de patrones
• Tipos de datos algebraicos (a través de clases de casos )
• Tuplas

Todo es una expresion

A diferencia de C o Java, pero similar a lenguajes como Lisp , Scala no distingue entre declaraciones y expresiones . Todas las declaraciones son de hecho expresiones que se evalúan con algún valor. Las funciones que se declararían retornadas voiden C o Java, y declaraciones como whileesa lógicamente no devuelven un valor, en Scala se considera que devuelven el tipo Unit, que es un tipo singleton , con un solo objeto de ese tipo. Las funciones y operadores que nunca regresan (por ejemplo, el throwoperador o una función que siempre sale no localmente usando una excepción) tienen lógicamente un tipo de retorno Nothing, un tipo especial que no contiene objetos; es decir, un tipo de fondo , es decir, una subclase de todos los tipos posibles. (Esto, a su vez, hace que los tipos sean Nothingcompatibles con todos los tipos, lo que permite que la inferencia de tipos funcione correctamente). ^[33]

De manera similar, una if-then-else"declaración" es en realidad una expresión, que produce un valor, es decir, el resultado de evaluar una de las dos ramas. Esto significa que dicho bloque de código se puede insertar donde se desee una expresión, obviando la necesidad de un operador ternario en Scala:

// Java: int hexDigit = x > = 10 ? x + 'A' - 10 : x + '0' ;

// Scala: val hexDigit = if ( x > = 10 ) x + 'A' - 10 else x + '0'

Por razones similares, las returndeclaraciones son innecesarias en Scala y, de hecho, no se recomiendan. Como en Lisp, la última expresión en un bloque de código es el valor de ese bloque de código, y si el bloque de código es el cuerpo de una función, será devuelto por la función.

Para dejar en claro que todas las funciones son expresiones, incluso los métodos que devuelven Unitse escriben con un signo igual

def  printValue ( x :  String ) :  Unit  =  {  println ( "Me comí% s" . format ( x )) }

o de manera equivalente (con inferencia de tipos y omitiendo las llaves innecesarias):

def  printValue ( x :  String )  =  println ( "Comí un% s"  formato  x )

Inferencia de tipo

Debido a la inferencia de tipos , el tipo de variables, los valores de retorno de la función y muchas otras expresiones normalmente se pueden omitir, ya que el compilador puede deducirlo. Los ejemplos son val x = "foo"(para una constante inmutable o un objeto inmutable ) o var x = 1.5(para una variable cuyo valor se puede cambiar más tarde). La inferencia de tipos en Scala es esencialmente local, en contraste con el algoritmo Hindley-Milner más global utilizado en Haskell , ML y otros lenguajes más puramente funcionales. Esto se hace para facilitar la programación orientada a objetos. El resultado es que ciertos tipos aún deben declararse (más notablemente, los parámetros de función y los tipos de retorno de funciones recursivas ), p. Ej.

def  formatApples ( x :  Int )  =  "Me comí% d manzanas" . formato ( x )

o (con un tipo de retorno declarado para una función recursiva)

def  factorial ( x :  Int ) :  Int  =  if  ( x  ==  0 )  1  else  x * factorial ( x  -  1 )

Funciones anónimas

En Scala, las funciones son objetos y existe una sintaxis conveniente para especificar funciones anónimas . Un ejemplo es la expresión x => x < 2, que especifica una función con un parámetro, que compara su argumento para ver si es menor que 2. Es equivalente a la forma Lisp (lambda (x) (< x 2)). Tenga en cuenta que ni el tipo ni el tipo de xretorno necesitan especificarse explícitamente y, en general, pueden inferirse mediante inferencia de tipos ; pero pueden especificarse explícitamente, por ejemplo, como (x: Int) => x < 2o incluso (x: Int) => (x < 2): Boolean.

Las funciones anónimas se comportan como cierres verdaderos en el sentido de que capturan automáticamente cualquier variable que esté disponible léxicamente en el entorno de la función adjunta. Esas variables estarán disponibles incluso después de que regrese la función adjunta y, a diferencia del caso de las clases internas anónimas de Java, no es necesario declararlas como finales. (Incluso es posible modificar tales variables si son mutables, y el valor modificado estará disponible la próxima vez que se llame a la función anónima).

Una forma aún más corta de función anónima utiliza variables de marcador de posición : por ejemplo, las siguientes:

list map { x => sqrt(x) }

se puede escribir de forma más concisa como

list map { sqrt(_) }

o incluso

list map sqrt

Inmutabilidad

Scala impone una distinción entre variables inmutables y mutables. Las variables mutables se declaran usando la varpalabra clave y los valores inmutables se declaran usando la valpalabra clave. Una variable declarada con la valpalabra clave no se puede reasignar de la misma manera que una variable declarada con la finalpalabra clave no se puede reasignar en Java. Sin embargo, debe tenerse en cuenta que los val's son solo superficialmente inmutables, es decir, no se garantiza que un objeto al que hace referencia un val sea inmutable en sí mismo.

Sin embargo, las clases inmutables se fomentan por convención, y la biblioteca estándar de Scala proporciona un rico conjunto de clases de colección inmutables . Scala proporciona variantes mutables e inmutables de la mayoría de las clases de colección, y la versión inmutable siempre se usa a menos que la versión mutable se importe explícitamente. ^[34] Las variantes inmutables son estructuras de datos persistentes que siempre devuelven una copia actualizada de un objeto antiguo en lugar de actualizar el objeto antiguo de forma destructiva en su lugar. Un ejemplo de esto son las listas enlazadas inmutables donde anteponer un elemento a una lista se realiza devolviendo un nuevo nodo de lista que consta del elemento y una referencia a la cola de la lista. Solo se puede agregar un elemento a una lista agregando todos los elementos de la lista anterior a una nueva lista con solo el nuevo elemento. De la misma manera, al insertar un elemento en medio de una lista, se copiará la primera mitad de la lista, pero mantendrá una referencia a la segunda mitad de la lista. A esto se le llama compartir estructural. Esto permite una simultaneidad muy sencilla: no se necesitan bloqueos ya que nunca se modifican los objetos compartidos. ^[35]

Evaluación perezosa (no estricta)

La evaluación es estricta ("ansiosa") por defecto. En otras palabras, Scala evalúa las expresiones tan pronto como están disponibles, en lugar de cuando sea necesario. Sin embargo, es posible declarar una variable no estricta ("lazy") con la lazypalabra clave, lo que significa que el código para producir el valor de la variable no se evaluará hasta la primera vez que se haga referencia a la variable. También existen colecciones no estrictas de varios tipos (como el tipo Stream, una lista enlazada no estricta), y cualquier colección puede hacerse no estricta con el viewmétodo. Las colecciones no estrictas proporcionan un buen ajuste semántico a cosas como datos producidos por el servidor, donde la evaluación del código para generar elementos posteriores de una lista (que a su vez desencadena una solicitud a un servidor, posiblemente ubicado en otro lugar de la web) solo sucede cuando los elementos son realmente necesarios.

Recursión de cola

Los lenguajes de programación funcional comúnmente proporcionan optimización de llamadas finales para permitir un uso extensivo de la recursividad sin problemas de desbordamiento de pila . Las limitaciones en el código de bytes de Java complican la optimización de la llamada final en la JVM. En general, una función que se llama a sí misma con una llamada de cola se puede optimizar, pero las funciones recursivas no pueden. Se han sugerido trampolines como solución. ^{[36] La} biblioteca Scala ha proporcionado soporte de trampolín con el objeto scala.util.control.TailCallsdesde Scala 2.8.0 (publicado el 14 de julio de 2010). Opcionalmente, se puede anotar una función con @tailrec, en cuyo caso no se compilará a menos que sea recursiva. ^[37]

Clases de casos y coincidencia de patrones

Scala tiene soporte incorporado para la coincidencia de patrones , que se puede considerar como una versión más sofisticada y extensible de una declaración de cambio , donde se pueden combinar tipos de datos arbitrarios (en lugar de solo tipos simples como enteros, booleanos y cadenas), incluidos los arbitrarios anidamiento. Se proporciona un tipo especial de clase conocido como clase de caso , que incluye soporte automático para la coincidencia de patrones y se puede usar para modelar los tipos de datos algebraicos usados ​​en muchos lenguajes de programación funcional. (Desde la perspectiva de Scala, una clase de caso es simplemente una clase normal para la que el compilador agrega automáticamente ciertos comportamientos que también podrían proporcionarse manualmente, por ejemplo, definiciones de métodos que proporcionan comparaciones profundas y hash, y desestructurando una clase de caso en su constructor parámetros durante la coincidencia de patrones.)

Un ejemplo de una definición del algoritmo de ordenación rápida que utiliza la coincidencia de patrones es este:

def  qsort ( lista :  Lista [ Int ]) :  Lista [ Int ]  =  lista  coincidente  {  caso  Nil  =>  Nil  caso  pivote  ::  cola  =>  val  ( menor ,  resto )  =  cola . partición ( _  <  pivote )  qsort ( más pequeño )  :::  pivote  ::  qsort ( resto ) }

La idea aquí es que dividimos una lista en los elementos menos que un pivote y los elementos no menos, ordenamos recursivamente cada parte y pegamos los resultados junto con el pivote intermedio. Utiliza la misma estrategia de divide y vencerás de mergesort y otros algoritmos de clasificación rápida.

El matchoperador se utiliza para hacer coincidir patrones en el objeto almacenado en list. Cada caseexpresión se prueba a su vez para ver si coincide, y la primera coincidencia determina el resultado. En este caso, Nilsolo coincide con el objeto literal Nil, pero pivot :: tailcoincide con una lista no vacía y, al mismo tiempo, la desestructura de acuerdo con el patrón dado. En este caso, el código asociado tendrá acceso a una variable local denominada que pivotsostiene el encabezado de la lista y otra variable que tailsostiene el final de la lista. Tenga en cuenta que estas variables son de solo lectura y semánticamente muy similares a los enlaces de variables establecidos mediante el letoperador en Lisp y Scheme.

La coincidencia de patrones también ocurre en declaraciones de variables locales. En este caso, el valor de retorno de la llamada a tail.partitiones una tupla ; en este caso, dos listas. (Las tuplas se diferencian de otros tipos de contenedores, por ejemplo, listas, en que siempre son de tamaño fijo y los elementos pueden ser de diferentes tipos, aunque aquí ambos son iguales). La coincidencia de patrones es la forma más fácil de obtener las dos partes de la tupla.

El formulario _ < pivotes una declaración de una función anónima con una variable de marcador de posición; consulte la sección anterior sobre funciones anónimas.

Aparecen los operadores de lista ::(que agrega un elemento al principio de una lista, similar a consLisp y Scheme) y :::(que agrega dos listas juntas, similar a appendLisp y Scheme). A pesar de las apariencias, no hay nada "integrado" en ninguno de estos operadores. Como se especificó anteriormente, cualquier cadena de símbolos puede servir como nombre de función, y un método aplicado a un objeto se puede escribir en estilo " infijo " sin el punto ni los paréntesis. La línea de arriba como está escrita:

qsort(smaller) ::: pivot :: qsort(rest)

también podría escribirse así:

qsort(rest).::(pivot).:::(qsort(smaller))

en notación de llamada a método más estándar. (Los métodos que terminan con dos puntos son asociativos a la derecha y se unen al objeto de la derecha).

Funciones parciales

En el ejemplo de coincidencia de patrones anterior, el cuerpo del matchoperador es una función parcial , que consta de una serie de caseexpresiones, con la primera expresión coincidente predominante, similar al cuerpo de una declaración de cambio . Las funciones parciales también se utilizan en la parte de manejo de excepciones de una trydeclaración:

try  {  ... }  catch  {  case  nfe : NumberFormatException  =>  {  println ( nfe );  Lista ( 0 )  }  caso  _  =>  Nulo }

Finalmente, una función parcial se puede usar sola, y el resultado de llamarla es equivalente a hacer una matchsobre ella. Por ejemplo, el código anterior para quicksort se puede escribir así:

val  qsort :  List [ Int ]  =>  List [ Int ]  =  {  case  Nil  =>  Nil  case  pivot  ::  tail  =>  val  ( menor ,  resto )  =  tail . partición ( _  <  pivote )  qsort ( más pequeño )  :::  pivote  ::  qsort ( resto ) }

Aquí se declara una variable de solo lectura cuyo tipo es una función de listas de enteros a listas de enteros, y la vincula a una función parcial. (Tenga en cuenta que el único parámetro de la función parcial nunca se declara o nombra explícitamente). Sin embargo, aún podemos llamar a esta variable exactamente como si fuera una función normal:

scala >  qsort ( List ( 6 , 2 , 5 , 9 )) res32 :  List [ Int ]  =  List ( 2 ,  5 ,  6 ,  9 )

Extensiones orientadas a objetos

Scala es un lenguaje puro orientado a objetos en el sentido de que cada valor es un objeto . Los tipos de datos y el comportamiento de los objetos se describen mediante clases y rasgos . Abstracciones de clase se extendieron por subclases y por un flexible de mixin mecanismo de composición con base para evitar los problemas de la herencia múltiple .

Los rasgos son el reemplazo de Scala para las interfaces de Java . Las interfaces en las versiones de Java menores de 8 están muy restringidas y solo pueden contener declaraciones de funciones abstractas. Esto ha llevado a la crítica de que proporcionar métodos de conveniencia en las interfaces es incómodo (los mismos métodos deben volver a implementarse en cada implementación) y es imposible extender una interfaz publicada de una manera compatible con versiones anteriores. Los rasgos son similares a las clases mixtas en el sentido de que tienen casi todo el poder de una clase abstracta regular, careciendo solo de parámetros de clase (el equivalente de Scala a los parámetros del constructor de Java), ya que los rasgos siempre se mezclan con una clase. El superoperador se comporta especialmente en los rasgos, lo que permite encadenar los rasgos utilizando la composición además de la herencia. El siguiente ejemplo es un sistema de ventanas simple:

 Ventana de clase  abstracta { // resumen def dibujar () }    class  SimpleWindow  amplía  Window  {  def  draw ()  {  println ( "en SimpleWindow" )  // dibuja una ventana básica  } }El rasgo  WindowDecoration  extiende la  ventana  {  }trait  HorizontalScrollbarDecoration  extiende  WindowDecoration  {  // "Aquí se necesita" anulación abstracta "para que" super () "funcione porque la  función  principal // es abstracta. Si fuera concreto, una "anulación" regular sería suficiente. anulación abstracta  def draw () { println ( "en HorizontalScrollbarDecoration" ) super . draw () // ahora dibuja una barra de desplazamiento horizontal } }       rasgo  VerticalScrollbarDecoration  extiende  WindowDecoration  {  anulación abstracta  def draw () { println ( "en VerticalScrollbarDecoration" ) super . draw () // ahora dibuja una barra de desplazamiento vertical } }       El rasgo  TitleDecoration  extiende  WindowDecoration  {  anulación abstracta  def draw () { println ( "en TitleDecoration" ) super . draw () // ahora dibuja la barra de título } }       

Una variable puede declararse así:

val  mywin  =  new  SimpleWindow  con  VerticalScrollbarDecoration  con  HorizontalScrollbarDecoration  con  TitleDecoration

El resultado de llamar mywin.draw()es:

en  TitleDecoration en  HorizontalScrollbarDecoration en  VerticalScrollbarDecoration en  SimpleWindow

En otras palabras, la llamada para drawejecutar primero el código en TitleDecoration(el último rasgo mezclado), luego (a través de las super()llamadas) volvió a pasar por los otros rasgos combinados y finalmente al código Window, aunque ninguno de los rasgos heredados de unos a otros . Esto es similar al patrón del decorador , pero es más conciso y menos propenso a errores, ya que no requiere encapsular explícitamente la ventana principal, reenviar explícitamente funciones cuya implementación no ha cambiado o depender de la inicialización en tiempo de ejecución de las relaciones entre entidades. . En otros lenguajes, se podría lograr un efecto similar en tiempo de compilación con una larga cadena lineal de herencia de implementación , pero con la desventaja en comparación con Scala de que se tendría que declarar una cadena de herencia lineal para cada combinación posible de las mezclas.

Sistema de tipo expresivo

Scala está equipado con un sistema de tipo expresivo estático que en su mayoría refuerza el uso seguro y coherente de abstracciones. Sin embargo, el sistema de tipos no es sólido . ^[38] En particular, el sistema de tipos admite:

• Clases y tipos abstractos como miembros de objeto
• Tipos estructurales
• Tipos dependientes de la ruta
• Tipos de compuestos
• Autorreferencias escritas explícitamente
• Clases genéricas
• Métodos polimórficos
• Límites de tipo superior e inferior
• Diferencia
• Anotación
• Puntos de vista

Scala puede inferir tipos por uso. Esto hace que la mayoría de las declaraciones de tipos estáticos sean opcionales. Los tipos estáticos no necesitan declararse explícitamente a menos que un error del compilador indique la necesidad. En la práctica, se incluyen algunas declaraciones de tipos estáticos en aras de la claridad del código.

Enriquecimiento de tipos

Una técnica común en Scala, conocida como "enriquecer mi biblioteca" ^[39] (originalmente denominada " proxeneta mi biblioteca " por Martin Odersky en 2006; ^[32] surgieron preocupaciones sobre esta redacción debido a sus connotaciones negativas ^[40] e inmadurez ^{[ 41]} ), permite utilizar nuevos métodos como si se añadieran a tipos existentes. Esto es similar al concepto de métodos de extensión de C # , pero más poderoso, porque la técnica no se limita a agregar métodos y puede, por ejemplo, usarse para implementar nuevas interfaces. En Scala, esta técnica implica declarar una conversión implícita del tipo que "recibe" el método a un nuevo tipo (normalmente, una clase) que envuelve el tipo original y proporciona el método adicional. Si no se puede encontrar un método para un tipo determinado, el compilador busca automáticamente las conversiones implícitas aplicables a los tipos que proporcionan el método en cuestión.

Esta técnica permite que se agreguen nuevos métodos a una clase existente utilizando una biblioteca complementaria de modo que solo el código que importa la biblioteca complementaria obtenga la nueva funcionalidad y el resto del código no se vea afectado.

El siguiente ejemplo muestra el enriquecimiento de tipo Intcon métodos isEveny isOdd:

object  MyExtensions  {  clase implícita  IntPredicates ( i : Int ) { def isEven = i % 2 == 0 def isOdd = ! isEven } }                import  MyExtensions._  // trae el enriquecimiento implícito al alcance 4. isEven  // -> true

La importación de los miembros de MyExtensionstrae la conversión implícita a la clase de extensión IntPredicatesal alcance. ^[42]

Concurrencia

La biblioteca estándar de Scala incluye soporte para futuros y promesas , además de las API estándar de concurrencia de Java. Originalmente, también incluía soporte para el modelo de actor , que ahora está disponible como una plataforma de código abierto independiente Akka ^[43] creada por Lightbend Inc. Los actores Akka pueden distribuirse o combinarse con memoria transaccional de software ( transactores ). Implementaciones alternativas de procesos secuenciales de comunicación (CSP) para el paso de mensajes basados ​​en canales son Objetos Scala Comunicadores, ^[44] o simplemente a través de JCSP .

Un actor es como una instancia de hilo con un buzón de correo. Se puede crear system.actorOfanulando el receivemétodo para recibir mensajes y utilizando el !método (signo de exclamación) para enviar un mensaje. ^[45] El siguiente ejemplo muestra un EchoServer que puede recibir mensajes y luego imprimirlos.

val  echoServer  =  actor ( new  Act  {se  convierte en  {  case  msg  =>  println ( "echo"  +  msg )  } }) echoServer  !  "Hola"

Scala también viene con soporte incorporado para programación paralela de datos en forma de Colecciones Paralelas ^[46] integradas en su Biblioteca Estándar desde la versión 2.9.0.

El siguiente ejemplo muestra cómo utilizar las colecciones paralelas para mejorar el rendimiento. ^[47]

val  urls  =  List ( "https://scala-lang.org" ,  "https://github.com/scala/scala" )def  fromURL ( url :  String )  =  scala . io . Fuente . fromURL ( url )  . getLines (). mkString ( "\ n" )val  t  =  Sistema . URL currentTimeMillis () . par . map ( fromURL ( _ )) // par devuelve la implementación paralela de una colección println ( "tiempo:" + ( System . currentTimeMillis - t ) + "ms" )       

Además de futuros y promesas, soporte de actores y paralelismo de datos , Scala también admite programación asincrónica con memoria transaccional de software y flujos de eventos. ^[48]

Computación en clúster

La solución de computación en clúster de código abierto más conocida escrita en Scala es Apache Spark . Además, Apache Kafka , la cola de mensajes de publicación-suscripción popular entre Spark y otras tecnologías de procesamiento de transmisión, está escrita en Scala.

Pruebas

Hay varias formas de probar el código en Scala. ScalaTest admite múltiples estilos de prueba y puede integrarse con marcos de prueba basados ​​en Java. ^[49] ScalaCheck es una biblioteca similar a QuickCheck de Haskell . ^[50] specs2 es una biblioteca para escribir especificaciones de software ejecutables. ^[51] ScalaMock proporciona soporte para probar funciones de alto orden y curry. ^[52] JUnit y TestNG son marcos de prueba populares escritos en Java.

Versiones

Versión	Liberado	Características
1.0.0-b2 [53]	8 de diciembre de 2003	_
1.1.0-b1 [53]	19 de febrero de 2004	scala.Enumeration La licencia de Scala se cambió a la licencia BSD revisada
1.1.1 [53]	23 de marzo de 2004	Soporte para clases internas estáticas de Java Mejoras en la clase de biblioteca para Iterable, Array, xml.Elem, Buffer
1.2.0 [53]	9 de junio de 2004	Puntos de vista Literales XML (que "se eliminarán en un futuro próximo, se reemplazarán con interpolación de cadenas XML" [54] )
1.3.0 [53]	16 de septiembre de 2004	Soporte para Microsoft .NET Cierres de métodos La sintaxis de tipos para métodos sin parámetros cambió de [] Ta=> T
1.4.0 [53]	20 de junio de 2005	Atributos matchpalabra clave reemplaza matchmétodo Soporte experimental para tipos de tiempo de ejecución
2,0 [55]	12 de marzo de 2006	Compilador completamente reescrito en Scala Soporte experimental para genéricos de Java implicity requirespalabras clave match solo palabra clave permitida infijo withconectivo solo está permitido siguiendo una extendscláusula Las líneas nuevas se pueden utilizar como separadores de instrucciones en lugar de punto y coma Patrones de coincidencia de expresiones regulares restringidos solo a patrones de secuencia Las comprensiones admiten valores y definiciones de patrones Los parámetros de clase pueden tener el prefijo val o var La visibilidad privada tiene calificadores
2.1.0 [53]	17 de marzo de 2006	herramienta sbaz integrada en la distribución Scala matchpalabra clave reemplaza matchmétodo Soporte experimental para tipos de tiempo de ejecución
2.1.8 [56]	23 de agosto de 2006	La visibilidad protegida tiene calificadores Se puede hacer referencia a los miembros privados de una clase desde el módulo complementario de la clase y viceversa Búsqueda implícita generalizada Coincidencia de patrón mecanografiado apretado para tipos singleton
2.3.0 [57]	23 de noviembre de 2006	Las funciones que regresan Unitno tienen que indicar explícitamente un tipo de devolución Las variables de tipo y los tipos se distinguen en la coincidencia de patrones Ally AllRefrenombrado a NothingyNull
2.4.0 [58]	9 de marzo de 2007	privatey los protectedmodificadores aceptan un [this]calificador Las tuplas se pueden escribir con paréntesis. El constructor principal de una clase ahora se puede marcar como privado o protegido Atributos cambiados a anotaciones con nueva sintaxis Auto alias Los operadores se pueden combinar con asignación
2.5.0 [59]	2 de mayo de 2007	Los parámetros de tipo y los miembros de tipo abstracto también pueden abstraerse sobre constructores de tipo Los campos de un objeto se pueden inicializar antes de llamar a los constructores principales Cambio de sintaxis para comprensiones Funciones anónimas implícitas (con guiones bajos para los parámetros) Coincidencia de patrones de funciones anónimas extendidas para admitir cualquier arte
2.6.0 [60]	27 de julio de 2007	Tipos existenciales Valores perezosos Tipos estructurales
2.7.0 [61]	7 de febrero de 2008	Tipos genéricos de Java compatibles de forma predeterminada Funcionalidad de clases de casos extendida
2.8.0 [62]	14 de julio de 2010	Revisar el marco común, uniforme y completo para los tipos de colecciones. Especialización de tipo Argumentos con nombre y predeterminados Objetos de paquete Anotaciones mejoradas
2.9.0 [63]	12 de mayo de 2011	Colecciones paralelas El Apprasgo seguro para subprocesos reemplaza el Applicationrasgo DelayedInit rasgo Mejoras en la interoperabilidad de Java
2.10 [64]	4 de enero de 2013	Clases de valor [65] Clases implícitas [66] Interpolación de cadenas [67] Futuros y promesas [68] Dynamic y applyDynamic [69] Tipos de métodos dependientes: def identity(x: AnyRef): x.type = x // the return type says we return exactly what we got Nuevo emisor de código de bytes basado en ASM: Puede apuntar a JDK 1.5, 1.6 y 1.7 Emite 1.6 bytecode por defecto El backend 1.5 antiguo está obsoleto Un nuevo comparador de patrones: reescrito desde cero para generar un código más robusto (no más explosiones exponenciales) La generación de código y los análisis ahora son independientes (este último se puede desactivar con -Xno-patmat-analysis) Mejoras de Scaladoc Implicitos (bandera de implicitos) Diagramas (bandera -diagrams, requiere graphviz) Grupos (-grupos) Funciones de lenguaje modularizado [70] Las colecciones paralelas [71] ahora se pueden configurar con grupos de subprocesos personalizados Los actores de Akka ahora forman parte de la distribución. scala.actors ha quedado obsoleto y la implementación de akka ahora está incluida en la distribución. Mejoras de rendimiento Inliner más rápido La suma del rango # ahora es O (1) Actualización de la biblioteca ForkJoin Correcciones en TreeSet / TreeMap inmutable Mejoras en PartialFunctions Además de ??? y NotImplementedError Adición de clases de tipo IsTraversableOnce + IsTraversableLike para métodos de extensión Desuso y limpieza Desaprobación de la sintaxis literal de coma flotante y octal Scala.dbc eliminado Funciones experimentales Reflexión Scala [72] Macros [73]
2.10.2 [74]	6 de junio de 2013	_
2.10.3 [75]	1 de octubre de 2013	_
2.10.4 [76]	18 de marzo de 2014	_
2.10.5 [77]	5 de marzo de 2015	_
2.11.0 [78]	21 de abril de 2014	Mejoras en el rendimiento de la colección Mejoras en el rendimiento del compilador
2.11.1 [79]	20 de mayo de 2014	_
2.11.2 [80]	22 de julio de 2014	_
2.11.4 [81]	31 de octubre de 2014	_
2.11.5 [82]	8 de enero de 2015	_
2.11.6 [83]	5 de marzo de 2015	_
2.11.7 [84]	23 de junio de 2015	_
2.11.8 [85]	8 de marzo de 2016	_
2.11.11 [86]	18 de abril de 2017	_
2.11.12 [87]	13 de noviembre de 2017	_
2.12.0 [88]	3 de noviembre de 2016	Se requiere Java 8 Código de bytes Java 8 generado Compatibilidad con el lenguaje Java 8 SAM ( interfaz funcional )
2.12.1 [89]	5 de diciembre de 2016	_
2.12.2 [90]	18 de abril de 2017	_
2.12.3 [91]	26 de julio de 2017	_
2.12.4 [92]	17 de octubre de 2017	_
2.12.5 [93]	15 de marzo de 2018	_
2.12.6 [94]	27 de abril de 2018	_
2.12.7 [95]	27 de septiembre de 2018	_
2.12.8 [96]	4 de diciembre de 2018	Primera versión de Scala 2.12 con la licencia cambiada a Apache v2.0
2.12.9 [97]	5 de agosto de 2019	_
2.12.10 [98]	10 de septiembre de 2019	_
2.12.11 [99]	16 de marzo de 2020	_
2.12.12 [100]	13 de julio de 2020	_
2.12.13 [101]	12 de enero de 2021	_
2.13.0 [102]	11 de junio de 2019	Biblioteca de colecciones estándar rediseñada Tipos literales Unificación de tipo parcial Implicaciones por nombre Optimizaciones del compilador
2.13.1 [103]	18 de septiembre de 2019	_
2.13.2 [104]	22 de abril de 2020	_
2.13.3 [105]	25 de junio de 2020	_
2.13.4 [106]	19 de noviembre de 2020	_
2.13.5 [107]	22 de febrero de 2021	_
3.0.0 [108]	13 de mayo de 2021	_

Comparación con otros lenguajes JVM

Scala a menudo se compara con Groovy y Clojure , otros dos lenguajes de programación que también utilizan JVM. Existen diferencias sustanciales entre estos lenguajes en el sistema de tipos, en la medida en que cada lenguaje admite programación funcional y orientada a objetos, y en la similitud de su sintaxis con la de Java.

Scala se escribe estáticamente , mientras que Groovy y Clojure se escriben dinámicamente . Esto hace que el sistema de tipos sea más complejo y difícil de entender, pero permite detectar casi todos los errores de tipo ^[38] en tiempo de compilación y puede resultar en una ejecución significativamente más rápida. Por el contrario, la escritura dinámica requiere más pruebas para garantizar la corrección del programa y, por lo tanto, generalmente es más lenta, para permitir una mayor flexibilidad y simplicidad de programación. Con respecto a las diferencias de velocidad, las versiones actuales de Groovy y Clojure permiten anotaciones de tipo opcionales para ayudar a los programas a evitar la sobrecarga de la escritura dinámica en los casos en que los tipos son prácticamente estáticos. Esta sobrecarga se reduce aún más cuando se utilizan versiones recientes de la JVM, que se ha mejorado con una instrucción dinámica de invocación para métodos que se definen con argumentos tipados dinámicamente. Estos avances reducen la brecha de velocidad entre la escritura estática y dinámica, aunque un lenguaje de escritura estática, como Scala, sigue siendo la opción preferida cuando la eficiencia de ejecución es muy importante.

En cuanto a los paradigmas de programación, Scala hereda el modelo orientado a objetos de Java y lo extiende de varias formas. Groovy, aunque también está fuertemente orientado a objetos, se centra más en reducir la verbosidad. En Clojure, la programación orientada a objetos no se enfatiza, siendo la programación funcional la principal fortaleza del lenguaje. Scala también tiene muchas facilidades de programación funcional, incluidas características que se encuentran en lenguajes funcionales avanzados como Haskell , e intenta ser agnóstico entre los dos paradigmas, permitiendo que el desarrollador elija entre los dos paradigmas o, más frecuentemente, alguna combinación de los mismos.

Con respecto a la similitud de sintaxis con Java, Scala hereda gran parte de la sintaxis de Java, como es el caso de Groovy. Clojure, por otro lado, sigue la sintaxis Lisp , que es diferente tanto en apariencia como en filosofía. Sin embargo, aprender Scala también se considera difícil debido a sus muchas funciones avanzadas. Este no es el caso de Groovy, a pesar de que también es un lenguaje rico en funciones, principalmente porque fue diseñado principalmente para ser un lenguaje de scripting. ^{[ cita requerida ]}

Adopción

Clasificaciones de idiomas

A partir de 2021^[actualizar]Los lenguajes basados ​​en JVM como Clojure, Groovy, Kotlin, Scala son significativamente menos populares que el lenguaje Java original, que normalmente se encuentra entre los tres primeros lugares, ^{[109] [110]} y que también está evolucionando simultáneamente con el tiempo.

El índice de popularidad del lenguaje de programación, ^[111] que rastrea las búsquedas de tutoriales de idiomas, clasificó a Scala en el puesto 15 en abril de 2018 con una pequeña tendencia a la baja, y en el puesto 17 en enero de 2021. Esto convierte a Scala en el segundo lenguaje basado en JVM más popular después de Java, con Kotlin , un lenguaje basado en JVM con el puesto 12.

El índice TIOBE ^[110] de popularidad de lenguajes de programación emplea clasificaciones de motores de búsqueda en Internet y recuentos de publicaciones similares para determinar la popularidad de lenguajes. En mayo de 2021^[actualizar], muestra a Scala en el puesto 32. En este ranking, Scala está por delante de Haskell (47 °) y Erlang , pero por debajo de Swift (18 °), Perl (19 °) y Go (16 °).

Las clasificaciones de lenguajes de programación de RedMonk, que establecen clasificaciones basadas en la cantidad de proyectos de GitHub y preguntas formuladas en Stack Overflow , clasifican a Scala en el puesto 14. ^[109] A continuación, Scala se coloca dentro de un grupo de segundo nivel de idiomas de la ventaja de Go , PowerShell , y Haskell , y detrás de Swift , Objective-C , Letra de imprenta , y R .

En la edición de 2018 de la encuesta State of Java , ^[112] que recopiló datos de 5160 desarrolladores sobre varios temas relacionados con Java, Scala ocupa el tercer lugar en términos de uso de lenguajes alternativos en la JVM. En relación con la edición de la encuesta del año anterior, el uso de Scala entre los lenguajes JVM alternativos cayó del 28,4% al 21,5%, superado por Kotlin, que aumentó del 11,4% en 2017 al 28,8% en 2018.

En 2013, cuando Scala estaba en la versión 2.10, ThoughtWorks Technology Radar, que es un informe semestral basado en opiniones de un grupo de tecnólogos senior, ^[113] recomendó la adopción de Scala en su categoría de lenguajes y marcos. ^[114] En julio de 2014, esta evaluación se hizo más específica y ahora se refiere a un "Scala, las partes buenas", que se describe como "Para utilizar Scala con éxito, es necesario investigar el idioma y tener una opinión muy sólida sobre qué las partes son adecuadas para usted, creando su propia definición de Scala, las partes buenas ”. ^[115]

Compañías

• En abril de 2009, Twitter anunció que había cambiado gran parte de su backend de Ruby a Scala y tenía la intención de convertir el resto. ^[116]
• Gilt usa Scala y Play Framework . ^[117]
• Foursquare usa Scala y Lift . ^[118]
• Coursera usa Scala y Play Framework . ^[119]
• Apple Inc. usa Scala en ciertos equipos, junto con Java y el marco de Play. ^{[120] [121]}
• El sitio web de alto tráfico del periódico The Guardian , guardian.co.uk ^[122], anunció en abril de 2011 que cambiaría de Java a Scala. ^{[123] [124]}
• The New York Times reveló en 2014 que su sistema de gestión de contenido interno Blackbeard está construido con Scala, Akka y Play. ^[125]
• El periódico Huffington Post comenzó a utilizar Scala como parte de su sistema de distribución de contenido Athena en 2013. ^[126]
• El banco suizo UBS aprobó Scala para uso general en producción. ^[127]
• LinkedIn utiliza el microframe de Scalatra para impulsar su API de señal. ^[128]
• Meetup utiliza un kit de herramientas sin filtrar para API en tiempo real. ^[129]
• Recuerde que Milk utiliza un kit de herramientas sin filtrar, Scala y Akka para API públicas y actualizaciones en tiempo real. ^[130]
• Verizon busca hacer "un marco de próxima generación" usando Scala. ^[131]
• Airbnb desarrolla el software de aprendizaje automático de código abierto "Aerosolve", escrito en Java y Scala. ^[132]
• Zalando trasladó su pila de tecnología de Java a Scala y Play. ^[133]
• SoundCloud utiliza Scala para su back-end, empleando tecnologías como Finagle (microservicios), ^[134] Scalding y Spark (procesamiento de datos). ^[135]
• Databricks usa Scala para la plataforma Apache Spark Big Data.
• Morgan Stanley utiliza Scala ampliamente en sus proyectos financieros y relacionados con activos. ^[136]
• Hay equipos dentro de Google y Alphabet Inc. que utilizan Scala, principalmente debido a adquisiciones como Firebase ^[137] y Nest. ^[138]
• Walmart Canadá usa Scala para su plataforma de back-end. ^[139]
• Duolingo usa Scala para su módulo de back-end que genera lecciones. ^[140]
• HMRC utiliza Scala para muchas aplicaciones fiscales del gobierno del Reino Unido. ^[141]
• M1 Finance usa Scala para su plataforma de back-end. ^[142]

Crítica

En marzo de 2015, el ex vicepresidente del grupo de ingeniería de plataformas en Twitter, Raffi Krikorian , declaró que no habría elegido Scala en 2011 debido a su curva de aprendizaje . ^[143] El mismo mes, el vicepresidente senior de LinkedIn, Kevin Scott, declaró su decisión de "minimizar [su] dependencia de Scala". ^[144] En noviembre de 2011, Yammer se alejó de Scala por razones que incluían la curva de aprendizaje para los nuevos miembros del equipo y la incompatibilidad de una versión del compilador de Scala a la siguiente. ^[145]

Ver también

• sbt , una herramienta de compilación ampliamente utilizada para proyectos Scala
• ¡Tocar! , un marco de aplicación web de código abierto que admite Scala
• Akka , un conjunto de herramientas de código abierto para crear aplicaciones concurrentes y distribuidas
• Chisel , un lenguaje de código abierto construido en Scala que se utiliza para el diseño y la generación de hardware. ^[146]

Referencias

1. https://github.com/lampepfl/dotty/releases/tag/3.0.0 ; Consultado: 20 de mayo de 2021.
2. https://github.com/lampepfl/dotty/releases/tag/3.0.0-RC3 .
3. "Archivo de notificación" . GitHub . 2019-01-24 . Consultado el 4 de diciembre de 2019 .
4. "Macros Scala" .
5. Fogus, Michael (6 de agosto de 2010). "MartinOdersky toma (5) toList" . Envíe más paramédicos . Consultado el 9 de febrero de 2012 .
6. Odersky, Martin (11 de enero de 2006). "El experimento Scala: ¿podemos ofrecer un mejor soporte lingüístico para los sistemas de componentes?" (PDF) . Consultado el 22 de junio de 2016 .
7. Odersky, Martin; et al. (2006). "Una descripción general del lenguaje de programación Scala" (PDF) (2ª ed.). École Polytechnique Fédérale de Lausanne (EPFL). Archivado (PDF) desde el original el 9 de julio de 2020.
8. Odersky, Martin (2008). Programación en Scala . Mountain View, California: Artima. pag. 3. ISBN 9780981531601. Consultado el 12 de junio de 2014 .
9. Potvin, Pascal; Bonja, Mario (24 de septiembre de 2015). Un IMS DSL desarrollado en Ericsson . Apuntes de conferencias en Ciencias de la Computación. 7916 . arXiv : 1509.07326 . doi : 10.1007 / 978-3-642-38911-5 . ISBN 978-3-642-38910-8. S2CID  1214469 .
10. "Preguntas frecuentes: interoperabilidad de Java" . Scala-lang.org . Consultado el 6 de febrero de 2015 .
11. Martin Odersky (17 de junio de 2020). Martin Odersky: Una actualización de Scala 3 (video). YouTube. El evento ocurre a las 36: 35–45: 08 . Consultado el 24 de abril de 2021 .
12. Friesen, Jeff (16 de noviembre de 2016). "¿Las excepciones marcadas son buenas o malas?" . JavaWorld . Consultado el 28 de agosto de 2018 .
13. Loverdo, Christos (2010). Pasos en Scala: Introducción a la programación funcional de objetos . Prensa de la Universidad de Cambridge . pag. xiii. ISBN 9781139490948. Consultado el 31 de julio de 2014 .
14. Odersky, Martin (9 de junio de 2006). "Una breve historia de Scala" . Artima.com .
15. Odersky, M .; Rompf, T. (2014). "Unificando la programación funcional y orientada a objetos con Scala" . Comunicaciones de la ACM . 57 (4): 76. doi : 10.1145 / 2591013 .
16. Martin Odersky, "La versión 2.7 de la especificación del lenguaje Scala"
17. "El equipo de Scala gana la beca ERC" . Consultado el 4 de julio de 2015 .
18. "Soporte comercial para Scala" . 2011-05-12 . Consultado el 18 de agosto de 2011 .
19. "Por qué invertimos en Typesafe: las aplicaciones modernas exigen herramientas modernas" . 2011-05-12 . Consultado el 8 de mayo de 2018 .
20. "Scala de código abierto gana respaldo comercial" . 2011-05-12 . Consultado el 9 de octubre de 2011 .
21. "El pionero de la computación en la nube, Martin Odersky, termina su nueva empresa Typesafe" . 2011-05-12 . Consultado el 24 de agosto de 2011 .
22. "Scala en Android" . Consultado el 8 de junio de 2016 .
23. "¡Scala 2.12.8 ya está disponible!" . 2018-12-04 . Consultado el 9 de diciembre de 2018 .
24. "Scala Js ya no es experimental | El lenguaje de programación Scala" . Scala-lang.org . Consultado el 28 de octubre de 2015 .
25. https://github.com/scala-js/scala-js/releases
26. Krill, Paul (15 de marzo de 2017). "La variante Scala reducida corta lazos con la JVM" . InfoWorld . Consultado el 21 de marzo de 2017 .
27. Krill, Paul (11 de mayo de 2016). "El lenguaje Scala se acerca al bare metal" . InfoWorld .
28. eliminó el backend .net. por paulp · Pull Request # 1718 · scala / scala · GitHub . Github.com (5 de diciembre de 2012). Consultado el 2 de noviembre de 2013.
29. "Introducción a Scala" . Scala-lang.org . 15 de julio de 2008 . Consultado el 31 de julio de 2014 .
30. "Inicio" . Blog.lostlake.org. Archivado desde el original el 31 de agosto de 2010 . Consultado el 25 de junio de 2013 .
31. Las estructuras de control integradas de Scala comoifowhileno se pueden volver a implementar. Existe un proyecto de investigación, Scala-Virtualized, que tenía como objetivo eliminar estas restricciones: Adriaan Moors, Tiark Rompf, Philipp Haller y Martin Odersky. Scala-virtualizado . Actas del taller ACM SIGPLAN 2012 sobre evaluación parcial y manipulación de programas , 117–120. Julio de 2012.
32. "Proxeneta mi biblioteca" . Artima.com. 2006-10-09 . Consultado el 25 de junio de 2013 .
33. "Expresiones | Scala 2.13" . scala-lang.org . Consultado el 24 de mayo de 2021 .
34. "Colecciones mutables e inmutables - Documentación de Scala" . Consultado el 30 de abril de 2020 .
35. "Colecciones - Clases de colección inmutables concretas - Documentación de Scala" . Consultado el 4 de julio de 2015 .
36. Dougherty, Rich. "Blog de Rich Dougherty" . Consultado el 4 de julio de 2015 .
37. "TailCalls - API de biblioteca estándar de Scala (Scaladoc) 2.10.2 - scala.util.control.TailCalls" . Scala-lang.org . Consultado el 25 de junio de 2013 .
38. "Los sistemas de tipos de Java y Scala no son sólidos" (PDF) .
39. Giarrusso, Paolo G. (2013). "¡Reifica las consultas de tu colección en cuanto a modularidad y velocidad!". Actas de la 12ª conferencia internacional anual sobre desarrollo de software orientado a aspectos . ACM. arXiv : 1210.6284 . Código bibliográfico : 2012arXiv1210.6284G . También conocido como patrón pimp-my-library
40. Gilbert, Clint (15 de noviembre de 2011). "¿Cuál es la máxima prioridad para que Scala tenga éxito en el mundo empresarial (¿debería estar en el debate de Scala?)" . Scala-lang.org . Consultado el 8 de mayo de 2019 .
41. "¿Deberíamos" enriquecer "o" engañar "las bibliotecas Scala?" . stackexchange.com . 17 de junio de 2013 . Consultado el 15 de abril de 2016 .
42. Las clases implícitas se introdujeron en Scala 2.10 para hacer que las extensiones de métodos sean más concisas. Esto equivale a agregar un métodoimplicit def IntPredicate(i: Int) = new IntPredicate(i). La clase también se puede definir comoimplicit class IntPredicates(val i: Int) extends AnyVal { ... }, produciendo una denominada clase de valor , también introducida en Scala 2.10. El compilador eliminará las instancias reales y generará métodos estáticos en su lugar, lo que permitirá que los métodos de extensión prácticamente no tengan una sobrecarga de rendimiento.
43. ¿Qué es Akka? , Documentación en línea de Akka
44. Sufrin, Bernard (2008). "Comunicación de objetos Scala". En Welch, PH; Stepney, S .; Polack, FAC; Barnes, FRM; McEwan, AA; Stiles, GS; Broenink, JF; Sampson, AT (eds.). Comunicación de arquitecturas de procesos 2008: WoTUG-31 (PDF) . ISBN 978-1586039073.
45. Yan, Kay. "Tour Scala" . Consultado el 4 de julio de 2015 .
46. "Colecciones paralelas - Descripción general - Documentación de Scala" . Docs.scala-lang.org . Consultado el 25 de junio de 2013 .
47. Yan, Kay. "Tour Scala" . Consultado el 4 de julio de 2015 .
48. Programación simultánea de aprendizaje en Scala , Aleksandar Prokopec, Packt Publishing
49. Kops, Micha (13 de enero de 2013). "Una breve introducción a ScalaTest" . hascode.com . Consultado el 7 de noviembre de 2014 .
50. Nilsson, Rickard (17 de noviembre de 2008). "ScalaCheck 1.5" . Scala-lang.org . Consultado el 7 de noviembre de 2014 .
51. "Construye aplicaciones web usando Scala y Play Framework" . workwithplay.com . 2013-05-22 . Consultado el 7 de noviembre de 2014 .
52. Carnicero, Paul (4 de junio de 2012). "Versión preliminar de ScalaMock 3.0" . paulbutcher.com . Consultado el 7 de noviembre de 2014 .
53. "Historial de cambios de Scala" . Scala-lang.org . Archivado desde el original el 9 de octubre de 2007.
54. "Eliminado: Literales XML" . dotty.epfl.ch . Consultado el 5 de marzo de 2021 .
55. "Cambios en la Versión 2.0 (12-Mar-2006)" . Scala-lang.org . 2006-03-12 . Consultado el 7 de noviembre de 2014 .
56. "Cambios en la versión 2.1.8 (23-Ago-2006)" . Scala-lang.org . 2006-08-23 . Consultado el 7 de noviembre de 2014 .
57. "Cambios en la versión 2.3.0 (23-nov-2006)" . Scala-lang.org . 2006-11-23 . Consultado el 7 de noviembre de 2014 .
58. "Cambios en la Versión 2.4.0 (09-Mar-2007)" . Scala-lang.org . 2007-03-09 . Consultado el 7 de noviembre de 2014 .
59. "Cambios en la Versión 2.5 (02-May-2007)" . Scala-lang.org . 2007-05-02 . Consultado el 7 de noviembre de 2014 .
60. "Cambios en la versión 2.6 (27-Jul-2007)" . Scala-lang.org . 2007-06-27 . Consultado el 7 de noviembre de 2014 .
61. "Cambios en la versión 2.7.0 (07-feb-2008)" . Scala-lang.org . 2008-02-07 . Consultado el 7 de noviembre de 2014 .
62. "Cambios en la versión 2.8.0 (14-Jul-2010)" . Scala-lang.org . 2010-07-10 . Consultado el 7 de noviembre de 2014 .
63. "Cambios en la versión 2.9.0 (12 de mayo de 2011)" . Scala-lang.org . 2011-05-12 . Consultado el 7 de noviembre de 2014 .
64. "Cambios en la versión 2.10.0" . Scala-lang.org . 2013-01-04 . Consultado el 7 de noviembre de 2014 .
65. Harrah, Mark. "Clases de valor y rasgos universales" . Scala-lang.org . Consultado el 7 de noviembre de 2014 .
66. Suereth, Josh. "SIP-13 - Clases implícitas" . Scala-lang.org . Consultado el 7 de noviembre de 2014 .
67. Suereth, Josh. "Interpolación de cadenas" . Scala-lang.org . Consultado el 7 de noviembre de 2014 .
68. Haller, Philipp; Prokopec, Aleksandar. "Futuros y promesas" . Scala-lang.org . Consultado el 7 de noviembre de 2014 .
69. "SIP-17 - Tipo dinámico" . Scala-lang.org . Consultado el 7 de noviembre de 2014 .
70. "SIP-18 - Modularización de características de lenguaje" . Scala-lang.org . Consultado el 7 de noviembre de 2014 .
71. Prokopec, Aleksandar; Miller, Heather. "Colecciones paralelas" . Scala-lang.org . Consultado el 7 de noviembre de 2014 .
72. Miller, Heather; Burmako, Eugene. "Visión general de la reflexión" . Scala-lang.org . Consultado el 7 de noviembre de 2014 .
73. Burmako, Eugene. "Def Macros" . Scala-lang.org . Consultado el 7 de noviembre de 2014 .
74. "¡Scala 2.10.2 ya está disponible!" . Scala-lang.org . 2013-06-06. Archivado desde el original el 8 de noviembre de 2014 . Consultado el 7 de noviembre de 2014 .
75. "¡Scala 2.10.3 ya está disponible!" . Scala-lang.org . 2013-10-01. Archivado desde el original el 8 de noviembre de 2014 . Consultado el 7 de noviembre de 2014 .
76. "¡Scala 2.10.4 ya está disponible!" . Scala-lang.org . 2014-03-18 . Consultado el 7 de enero de 2015 .
77. "¡Scala 2.10.5 ya está disponible!" . Scala-lang.org . 2015-03-04 . Consultado el 23 de marzo de 2015 .
78. "¡Scala 2.11.0 ya está disponible!" . Scala-lang.org . 2014-04-21 . Consultado el 7 de noviembre de 2014 .
79. "¡Scala 2.11.1 ya está disponible!" . Scala-lang.org . 2014-05-20 . Consultado el 7 de noviembre de 2014 .
80. "¡Scala 2.11.2 ya está disponible!" . Scala-lang.org . 2014-07-22 . Consultado el 7 de noviembre de 2014 .
81. "¡Scala 2.11.4 ya está disponible!" . Scala-lang.org . 2014-10-30 . Consultado el 7 de noviembre de 2014 .
82. "¡Scala 2.11.5 ya está disponible!" . Scala-lang.org . 2015-01-08 . Consultado el 22 de enero de 2015 .
83. "¡Scala 2.11.6 ya está disponible!" . Scala-lang.org . 2015-03-05 . Consultado el 12 de marzo de 2015 .
84. "¡Scala 2.11.7 ya está disponible!" . Scala-lang.org . 2015-06-23 . Consultado el 3 de julio de 2015 .
85. "¡Scala 2.11.8 ya está disponible!" . Scala-lang.org . 2016-03-08 . Consultado el 9 de marzo de 2016 .
86. "¡Tres nuevos lanzamientos y más bondades de GitHub!" . Scala-lang.org . 2017-04-18 . Consultado el 19 de abril de 2017 .
87. "Actualización de seguridad: 2.12.4, 2.11.12, 2.10.7 (CVE-2017-15288)" . Scala-lang.org . 2017-11-13 . Consultado el 4 de mayo de 2018 .
88. "¡Scala 2.12.0 ya está disponible!" . Scala-lang.org . 2016-11-03 . Consultado el 8 de enero de 2017 .
89. "¡Scala 2.12.1 ya está disponible!" . Scala-lang.org . 2016-12-05 . Consultado el 8 de enero de 2017 .
90. "¡Tres nuevos lanzamientos y más bondades de GitHub!" . Scala-lang.org . 2017-04-18 . Consultado el 19 de abril de 2017 .
91. "¡Scala 2.12.3 ya está disponible!" . Scala-lang.org . 2017-07-26 . Consultado el 16 de agosto de 2017 .
92. "¡Scala 2.12.4 ya está disponible!" . Scala-lang.org . 2017-10-18 . Consultado el 26 de octubre de 2017 .
93. "¡Scala 2.12.5 ya está disponible!" . Scala-lang.org . 2018-03-15 . Consultado el 20 de marzo de 2018 .
94. "¡Scala 2.12.6 ya está disponible!" . Scala-lang.org . 2018-04-27 . Consultado el 4 de mayo de 2018 .
95. "¡Scala 2.12.7 ya está disponible!" . Scala-lang.org . 2018-09-27 . Consultado el 9 de octubre de 2018 .
96. "¡Scala 2.12.8 ya está disponible!" . Scala-lang.org . 2018-12-04 . Consultado el 9 de diciembre de 2018 .
97. "¡Scala 2.12.9 ya está disponible!" . Scala-lang.org . 2019-08-05 . Consultado el 20 de enero de 2021 .
98. "¡Scala 2.12.10 ya está disponible!" . Scala-lang.org . 2019-09-10 . Consultado el 20 de enero de 2021 .
99. "¡Scala 2.12.11 ya está disponible!" . Scala-lang.org . 2020-03-16 . Consultado el 20 de enero de 2021 .
100. "¡Scala 2.12.12 ya está disponible!" . Scala-lang.org . 2020-07-13 . Consultado el 20 de enero de 2021 .
101. "¡Scala 2.12.13 ya está disponible!" . Scala-lang.org . 2021-01-12 . Consultado el 20 de enero de 2021 .
102. "¡Scala 2.13.0 ya está disponible!" . Scala-lang.org . 2019-06-11 . Consultado el 17 de junio de 2018 .
103. "¡Scala 2.13.1 ya está disponible!" . Scala-lang.org . 2019-09-18 . Consultado el 20 de enero de 2021 .
104. "¡Scala 2.13.2 ya está disponible!" . Scala-lang.org . 2020-04-22 . Consultado el 20 de enero de 2021 .
105. "¡Scala 2.13.3 ya está disponible!" . Scala-lang.org . 2020-06-25 . Consultado el 20 de enero de 2021 .
106. "¡Scala 2.13.4 ya está disponible!" . Scala-lang.org . 2020-11-19 . Consultado el 20 de enero de 2021 .
107. "¡Scala 2.13.5 ya está disponible!" . Scala-lang.org . 2021-02-22 . Consultado el 26 de febrero de 2021 .
108. "¡Scala 3 ya está aquí!" . Scala-lang.org . 2021-05-14 . Consultado el 26 de mayo de 2021 .
109. O'Grady, Stephen (1 de marzo de 2021). "Las clasificaciones de lenguajes de programación de RedMonk: enero de 2021" . RedMonk .
110. "Índice TIOBE de mayo de 2021" .
111. "Índice de popularidad del lenguaje de programación" .
112. "El estado de Java en 2018" .
113. "Preguntas frecuentes sobre el radar de tecnología ThoughtWorks" .
114. "Radar de tecnología ThoughtWorks MAYO 2013" (PDF) .
115. "Scala, las partes buenas" .
116. Greene, Kate (1 de abril de 2009). "El secreto detrás del crecimiento de Twitter, cómo un nuevo lenguaje de programación web está ayudando a la empresa a manejar su creciente popularidad" . Revisión de tecnología . MIT . Consultado el 6 de abril de 2009 .
117. "Play Framework, Akka y Scala en Gilt Groupe" . Lightbend. 15 de julio de 2013 . Consultado el 16 de julio de 2016 .
118. "Scala, Lift y el futuro" . Archivado desde el original el 13 de enero de 2016 . Consultado el 4 de julio de 2015 .
119. "Por qué amamos a Scala en Coursera" . Coursera Engineering . Consultado el 4 de julio de 2015 .
120. "PM Jarrod Nettles de Apple Engineering en Twitter" . Ortigas Jarrod . Consultado el 11 de marzo de 2016 .
121. "30 vacantes de Scala en Apple" . Alvin Alexander . Consultado el 11 de marzo de 2016 .
122. David Reid y Tania Teixeira (26 de febrero de 2010). "¿Está la gente dispuesta a pagar por las noticias online?" . BBC . Consultado el 28 de febrero de 2010 .
123. "Guardián cambiando de Java a Scala" . Heise en línea . 2011-04-05 . Consultado el 5 de abril de 2011 .
124. "Guardian.co.uk cambiando de Java a Scala" . InfoQ.com. 2011-04-04 . Consultado el 5 de abril de 2011 .
125. Roy, Suman; Sundaresan, Krishna (13 de mayo de 2014). "Construcción de Barbanegra: un sistema de distribución impulsado por Play, Scala y Akka" . The New York Times . Consultado el 20 de julio de 2014 .
126. Pavley, John (11 de agosto de 2013). "Sneak Peek: HuffPost trae colaboración en tiempo real a la sala de redacción" . Huffington Post . Consultado el 20 de julio de 2014 .
127. Binstock, Andrew (14 de julio de 2011). "Entrevista con Martin Odersky de Scala" . Diario del Dr. Dobb . Consultado el 10 de febrero de 2012 .
128. Synodinos, Dionysios G. (11 de octubre de 2010). "Señal de LinkedIn: un estudio de caso para Scala, JRuby y Voldemort" . InfoQ .
129. "Las reuniones de la vida real merecen API en tiempo real" .
130. "La actualización en tiempo real llega a la aplicación web Remember The Milk" .
131. "Ingeniero Senior Scala" . Consultado el 18 de agosto de 2014 .
132. Novet, Jordania (4 de junio de 2015). "Airbnb anuncia Aerosolve, un paquete de software de aprendizaje automático de código abierto" . Consultado el 9 de marzo de 2016 .
133. Kops, Alexander (14 de diciembre de 2015). "Zalando Tech: de Java a Scala en menos de tres meses" . Consultado el 9 de marzo de 2016 .
134. Calçado, Phil (13 de junio de 2014). "Productos de construcción en SoundCloud — Parte III: Microservicios en Scala y Finagle" . Consultado el 9 de marzo de 2016 .
135. "Estudios de casos de clientes: SoundCloud" . Concurrente Inc . 2014-11-18 . Consultado el 9 de marzo de 2016 .
136. Scala en Morgan Stanley (video). Las habilidades importan. 2015-12-03 . Consultado el 11 de marzo de 2016 .
137. Greg Soltis (3 de diciembre de 2015). SF Scala, Greg Soltis: Servicios de alto rendimiento en Scala (video). Las habilidades importan . Consultado el 11 de marzo de 2016 .
138. Lee Mighdoll. "Trabajos de Scala en Nest" . Consultado el 11 de marzo de 2016 .
139. Nurun. "Nurun lanza plataforma transaccional rediseñada con Walmart Canadá" . Consultado el 11 de diciembre de 2013 .
140. Horie, André K. (31 de enero de 2017). "Reescritura del motor de Duolingo en Scala" . Consultado el 3 de febrero de 2017 .
141. "Repositorio HMRC GitHub" .
142. Lviv, Oleh Zasadnyy, GDG. "ScalaCon. Una serie de conferencias virtuales ofrecidas por Scala eXchange y Scala Days" . ScalaCon. Una serie de conferencias virtuales ofrecidas por Scala eXchange y Scala Days . Consultado el 30 de mayo de 2021 .
143. Krikorian, Raffi (17 de marzo de 2015). Conferencia de arquitectura de software de O'Reilly 2015 Compilación completa de videos: Re-arquitectura sobre la marcha - Raffi Krikorian - Parte 3 (video). O'Reilly Media. El evento ocurre a las 4:57 . Consultado el 8 de marzo de 2016 . Lo que hubiera hecho de manera diferente hace cuatro años es usar Java y no usar Scala como parte de esta reescritura. [...] un ingeniero tardaría dos meses en ser completamente productivos y escribir código Scala.
144. Scott, Kevin (11 de marzo de 2015). "¿LinkedIn se está deshaciendo de Scala?" . quora.com . Consultado el 25 de enero de 2016 .
145. Hale, Coda (29 de noviembre de 2011). "El resto de la historia" . codahale.com . Consultado el 7 de noviembre de 2013 .
146. "Cincel: construcción de hardware en un lenguaje incrustado Scala" . UC Berkeley APSIRE . Consultado el 27 de mayo de 2020 .

Otras lecturas

• Odersky, Martin; Cuchara, Lex; Venners, Bill (15 de diciembre de 2019). Programación en Scala: una guía completa paso a paso (4ª ed.). Artima Inc . pag. 896. ISBN 978-0-9815316-1-8.
• Horstmann, Cay (15 de diciembre de 2016). Scala para los impacientes (2ª ed.). Addison-Wesley Professional . pag. 384. ISBN 978-0-134-54056-6.
• Wampler, Dean; Payne, Alex (14 de diciembre de 2014). Escala de programación: Escalabilidad = Programación funcional + Objetos (2ª ed.). O'Reilly Media . pag. 583. ISBN 978-1-491-94985-6.
• Suereth, Joshua D. (primavera de 2011). Scala en profundidad . Publicaciones Manning . pag. 225 . ISBN 978-1-935182-70-2.
• Meredith, Gregory (2011). Patrones de diseño monádico para la Web (PDF) (1ª ed.). pag. 300.
• Odersky, Martin; Cuchara, Lex; Venners, Bill (10 de diciembre de 2008). Programación en Scala, eBook (1ª ed.). Artima Inc .