• 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
}

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