• sbt
• IDE de Scala

• Es la herramienta de compilación de Scala.
• Para agregarlo al path, en Linux, añadiremos la siguiente línea al final del .bashrc:

export PATH=/home/alfred/bin/sbt/bin:$PATH

• Una vez lo ejecutemos, la carpeta donde lo hagamos será el directorio del proyecto.
• Existen los siguientes comandos:
  • console, empieza el REPL (Scala interprete), para salir de él ctrl+d.
  • compile, compila el código en ese directorio.
  • run, ejecutará el código que hay en el directorio del proyecto si este tiene un método main.

• Podemos crear una worksheet (botón derecho y añadir worksheet), esto es código Scala que se evalua a tiempo real cada vez que se guarda el fichero.

object test {
  println("Welcome to the Scala worksheet")       //> Welcome to the Scala worksheet
  val x = 4                                       //> x  : Int = 4
  def inc (i: Int) =  i + 1                       //> inc: (i: Int)Int
  inc(x)*5                                        //> res0: Int = 25
}

• Clases, el concepto es parecido al de la POO. Contienen propiedades y métodos, como en Java, pueden inicializarse a partir del new y de un constructor y pueden haber diversas instancias (u objetos) de la misma clase.
• Traits, son parecidas a las interfaces de la POO aunque también pueden contener implementaciones de métodos o definiciones de campos.
• Objetos, son como clases en POO pero la diferencia es que únicamente existe una instancia.
• Paquetes, Haciendo package foo.bar al principio de un fichero de código diremos que ese fichero pertenece al paquete foo.bar al cual, para importarlo, será necesario hacer import foo.bar._ o haciendo foo.bar.MyClass si quiere importar una clase concreta o import.bar.baz._ si queremos importar el objeto baz.

Definir un valor llamado radious:

def radious = 10

Definir una expresión:

def sumOfSquares(x: Double, y: Double) = square(x) + square(y)

Definir el tipo de retorno de una expresión:

def sumOfSquares(x: Double, y: Double): Double = ...

Para evaluar una exprisión por nombre, en vez de por valor se usa =>:

def constOne(x:Int, y: => Int) = 1

También puedes usar expresiones if-else de la siguiente forma:

def abs(x:Int) = if (x >= 0) x else -x

Tabla de operadores booleanos:

true && e --> e
false && e --> false
true || e --> true
false || e --> e

def significa “por nombre”, val por valor. Por nombre se genera al evaluar esa expresión, por valor cuando se utiliza:

def loop: Boolean = loop
def x = loop // would die when it is used
val x = loop // would die here

Podemos hacer expresiones multilínea usando |:

def and(x:Boolean, y:Boolean) =
	|	if (x) y else false

Otra opción para hacer expreiones multilínea es usando paréntesis:

(someLongExpression1
+ someLongExpression2)

O, una última opción de expreiones multilínea es el uso de operadores:

someLongExpression1 +
someLongExpression2

Los bloques se delimitan por { … } y las definiciones existentes dentro de un bloque son visibles dentro de este, además ocultan las definiciones de fuera.

Semicolons are optional in most cases. We can put several expression in one line: El punto y coma es opcional en muchos casos, aún así nos permite para añadir más expresiones en una sola línea:

val y = 1; x + x