Scala (lenguaje de programación)

De Wikipedia, la enciclopedia libre
Ir a la navegación Ir a la búsqueda
Scala
Ј2.png
Desarrollador(es)
Laboratorio de métodos de programación de la EPFL
http://www.scala-lang.org/ y https://www.scala-lang.org/
Información general
Extensiones comunes scala y sc
Paradigma funcional, orientado a objetos
Apareció en 2003
Diseñado por Martin Odersky
Última versión estable 2.13.0 (01 de abril de 2019 (8 meses y 7 días))
Sistema de tipos estático, fuerte
Influido por Smalltalk, Java, Haskell, Standard ML, OCaml
Licencia BSD

Scala es un lenguaje de programación multi-paradigma diseñado para expresar patrones comunes de programación en forma concisa, elegante y con tipos seguros. Integra sutilmente características de lenguajes funcionales y orientados a objetos. La implementación actual se ejecuta en la máquina virtual de Java y es compatible con las aplicaciones Java existentes.

Características[editar]

Orientación a objetos[editar]

Scala es un lenguaje de programación puro orientado a objetos, en el sentido de que cada valor es un objeto. El tipo y comportamiento de los objetos se describe por medio de clases y traits. La abstracción de clases se realiza extendiendo otras clases y usando un mecanismo de composición basado en mixins como un reemplazo limpio de la herencia múltiple.

Lenguaje funcional[editar]

Scala también posee características propias de los lenguajes funcionales. En Scala las funciones son valores de primera clase, soportando funciones anónimas, orden superior, funciones anidadas y currificación. Scala viene integrado de fábrica con la técnica de pattern matching para modelar tipos algebraicos usados en muchos lenguajes funcionales.

Tipificado estático[editar]

Scala está equipado con un sistema de tipos expresivo que refuerza a que las abstracciones de tipos se usen en forma coherente y segura.

Extensibilidad[editar]

Scala se diseñó teniendo en mente el hecho de que en la práctica el desarrollo de aplicaciones requiere a menudo de extensiones específicas del lenguaje. Para ello, Scala proporciona una combinación única de mecanismos que hacen fácil y sin problemas agregar construcciones nuevas al lenguaje en forma de bibliotecas.

Ejemplos[editar]

Hola Mundo escrito en Scala[editar]

 object HelloWorld extends App {
   println("Hola mundo")
 }

Nótese lo similar a un programa Java. La diferencia es que no declaramos nada estático o un retorno vacío; la palabra reservada object nos devuelve un objeto Singleton que nos libera de realizar por nosotros mismos tales construcciones.

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

$ scalac HelloWorld.scala

Y se ejecuta con:

$ scala HelloWorld

Esto es análogo al proceso de compilación y ejecución de código Java. De hecho, el proceso de compilación y ejecución de Scala es idéntico al de Java, haciéndolo compatible con herramientas como Apache Ant.

Una version mas corta del "Hola mundo" en Scala es:

println("Hello, world!")

Scala incluye un shell interactivo y soporte de scripting incorporado. Guardado en un archivo llamado HelloWorld2.scala, el cual puede ser ejecutado como script sin prioridad de compilación usando:

$ scala HelloWorld2.scala

Los comandos también pueden ser ingresados en el interprete de Scala, usando la opcion -e:

$ scala -e 'println("Hello, World!")'

Las expresiones pueden ser ingresadas en el REPL:

$ scala
Welcome to Scala 2.12.2 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_131).
Type in expressions for evaluation. Or try :help.

scala> List(1, 2, 3).map(x => x * x)
res0: List[Int] = List(1, 4, 9)

scala>

Ejemplo Básico[editar]

El siguiente ejemplo muestra las diferencias entre la sintaxis de Java y Scala.

// Java:
int mathFunction(int num) {
    int numSquare = num*num;
    return (int) (Math.cbrt(numSquare) +
      Math.log(numSquare));
}
// Scala: Direct conversion from Java

// no import needed; scala.math
// already imported as `math`
def mathFunction(num: Int): Int = {
  var numSquare: Int = num*num
  return (math.cbrt(numSquare) + math.log(numSquare)).
    asInstanceOf[Int]
}
// Scala: More idiomatic
// Uses type inference, omits `return` statement,
// uses `toInt` method, declares numSquare immutable

import 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 al final de las sentencias.
  • Los tipos están capitalizados: Int, Double, Boolean en vez de int, double, boolean.
  • Parámetros y tipos de retorno continúan, como en Pascal, en vez de preceder como en C.
  • Los métodos deben ser precedidos por def.
  • Variables locales y de clase deben ser precedidos por val (indica una variable inmutable) o var (indica una variable mutable).
  • El operador return es innecesario en una función (a pesar de estar permitido); el valor de la ultima sentencia o expresión ejecutada es normalmente el valor de la función.
  • En vez de el operador cast (Type) foo, Scala usa foo.asInstanceOf[type], o una función especializada como toDouble o toInt.
  • En vez de la importación de paquetes de Java import foo.*;, Scala usa import foo._.
  • Una función o método foo() también puede ser llamado solo foo; el metodo thread.send(signo) también puede ser llamado solamente como thread send signo; y el método foo.toString() también puede ser llamado solo como foo toString.

Ejemplo con Clases[editar]

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

// Java:
public class Point {
  private final double x, y;

  public Point(final double x, final double y) {
    this.x = x;
    this.y = y;
  }

  public Point(
    final double x, final double y,
    final boolean addToGrid
  ) {
    this(x, y);

    if (addToGrid)
      grid.add(this);
  }

  public Point() {
    this(0.0, 0.0);
  }

  public double getX() {
    return x;
  }

  public double getY() {
    return y;
  }

  double distanceToPoint(final Point other) {
    return distanceBetweenPoints(x, y,
      other.x, other.y);
  }

  private static Grid grid = new Grid();

  static double distanceBetweenPoints(
      final double x1, final double y1,
      final double x2, final double y2
  ) {
    return Math.hypot(x1 - x2, y1 - y2);
  }
}
// Scala
class Point(
    val x: Double, val y: Double,
    addToGrid: Boolean = false
) {
  import Point._

  if (addToGrid)
    grid.add(this)

  def this() = this(0.0, 0.0)

  def distanceToPoint(other: Point) =
    distanceBetweenPoints(x, y, other.x, other.y)
}

object Point {
  private val grid = new Grid()

  def distanceBetweenPoints(x1: Double, y1: Double,
      x2: Double, y2: Double) = {
    math.hypot(x1 - x2, y1 - y2)
  }
}

Enlaces externos[editar]