====== Scala ======
===== Herramientas =====
  * {{:functional:scala:sbt.tgz|sbt}}
  * [[http://www.typesafe.com/stack/downloads/scala-ide|IDE de Scala]]

==== Uso ====
=== sbt ===
  * Es la herramienta de compilación de Scala.
  * Para agregarlo al path, en Linux, añadiremos la siguiente línea al final del .bashrc:
<code>
export PATH=/home/alfred/bin/sbt/bin:$PATH
</code>
  * 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''.


=== Scala IDE ===
  * 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.
<code>
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
}
</code>
  * ''ctrl+shift+f'' formatea el código.
===== Conceptos =====
==== Conceptos básicos ====

=== Vocabulario ===

  * **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''.

=== El main... ===

En Scala hay dos formas de indicar un punto de entrada a un programa, aunque siempre será a partir de un objeto... \\ 
Puede hacerse extendiendo el objeto de ''App''...
<code scala>
object HelloWorld extends App {
  println("Hello, World!")
}
</code>
... O añadiendo a un objeto el método ''def main(args: Array[String])'':
<code scala>
object HelloWorld {
  def main(args: Array[String]) {
    println("Hello, World!")
  }
}
</code>


=== Sintaxis de código ===

Definir un valor llamado ''radious'':
<code scala>
def radious = 10
</code>
Definir una expresión:
<code scala>
def sumOfSquares(x: Double, y: Double) = square(x) + square(y)
</code>
Definir el tipo de retorno de una expresión:
<code scala>
def sumOfSquares(x: Double, y: Double): Double = ...
</code>
Para evaluar una exprisión por nombre, en vez de por valor se usa ''<nowiki>=></nowiki>'':
<code scala>
def constOne(x:Int, y: => Int) = 1
</code>
También puedes usar expresiones ''if-else'' de la siguiente forma:
<code scala>
def abs(x:Int) = if (x >= 0) x else -x
</code>
Tabla de operadores booleanos:
<code>
true && e --> e
false && e --> false
true || e --> true
false || e --> e
</code>
''def'' significa "por nombre", ''val'' por valor. Por nombre se genera al evaluar esa expresión, por valor cuando se utiliza:
<code scala>
def loop: Boolean = loop
def x = loop // would die when it is used
val x = loop // would die here
</code>

Podemos hacer expresiones multilínea usando ''|'':
<code scala>
def and(x:Boolean, y:Boolean) =
	|	if (x) y else false
</code>
Otra opción para hacer expreiones multilínea es usando paréntesis:
<code scala>
(someLongExpression1
+ someLongExpression2)
</code>
O, una última opción de expreiones multilínea es el uso de operadores:
<code scala>
someLongExpression1 +
someLongExpression2
</code>

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:
<code scala>
val y = 1; x + x
</code>

=== Listas ===

Un objeto List contiene los siguientes métodos:
  * ''.isEmpty'': Indica si la lista está vacía.
  * ''.head'': Devuelve el primer elemento.
  * ''.tail'': Devuelve el resto de elementos distintos al primero.

<code scala>
def sum(xs: List[Int]): Int = {
  if (xs.isEmpty) 0
  else xs.head + sum(xs.tail)
}

def max(xs: List[Int]): Int = {
  if (xs.isEmpty) throw new java.util.NoSuchElementException
  if (!xs.tail.isEmpty) {
    val m = max(xs.tail)
    if (xs.head > m) xs.head
    else m
  } else xs.head
}
</code>

=== Excepciones ===
<code scala>
if (xs.isEmpty) throw new java.util.NoSuchElementException
</code>
==== Montar tests ====
  * {{:functional:scala:test_jars.tar.gz|Jars para tests}}
==== Funciones y evaluación ====
Sintaxis de definición:
<code>
def nombre (par_name : tipo) : tipo_return = { ... }
</code>
Para indicar en Scala que un parámetro (en este caso el segundo) se evaluará por nombre, haremos:
<code>
def first (x: Double, y: => Double) = x
</code>

=== Diferencia entre evaluación por nombre y por valor ===
Teniendo...
<code scala>
square (x: Double) : Double = x * x
sumOfSquares (x: Double, y: Double) : Double = square(x) + square(y)
</code>
Por valor cada argumento se evalua una vez:
<code>
sumOfSquares(3, 2+2)
sumOfSquares(3, 4)
square(3) + square(4)
3 * 3 + square(4)
9 + square(4)
9 + 4 * 4
9 + 16
25
</code>

Por nombre cada argumento se evalua cuando es llamado: 
<code>
sumOfSquares(3, 2+2)
square(3) + square(2+2)
3 * 3 + square(2+2)
9 + square(2+2)
9 + (2+2) * (2+2)
9 + 4 * (2+2)
9 + 4 * 4
25
</code>

Si tuviesemos la siguientes expresiones
<code>
def loop () = loop
def first (x: Double, y: Double) = x
first(x, loop)
</code>
Si evaluamos la tercera por nombre terminaría pero si la evaluamos por valor cae en bucle infinito. \\ 
Cuando definimos usando ''val'' lo hacemos haciéndolo por valor. Cuando lo hacemos usando ''def'' lo hacemos por nombre:
<code>
def loop () : Boolean = loop
def x = loop 
val x = loop  // bucle infinito
</code>

==== Notas ====
  * Cuando tenemos una función recursiva necesitamos indicar su valor devuelto.