Spanish: New translations and some minor changes

_es/tour/case-classes.md

@@ -10,7 +10,7 @@ next-page: compound-types
 previous-page: classes
 ---
 
-Scala da soporte a la noción de _clases caso_ (en inglés _case classes_, desde ahora _clases Case_). Las clases Case son clases regulares las cuales exportan sus parámetros constructores y a su vez proveen una descomposición recursiva de sí mismas a través de [reconocimiento de patrones](pattern-matching.html).
+Scala da soporte a la noción de _clases case_ (en inglés _case classes_, desde ahora _clases Case_). Las clases Case son clases regulares las cuales exportan sus parámetros constructores y a su vez proveen una descomposición recursiva de sí mismas a través de [reconocimiento de patrones](pattern-matching.html).
 
 A continuación se muestra un ejemplo para una jerarquía de clases la cual consiste de una super clase abstracta llamada `Term` y tres clases concretas: `Var`, `Fun` y `App`.
 
@@ -73,6 +73,8 @@ Solo tiene sentido definir una clase Case si el reconocimiento de patrones es us
       println(isIdentityFun(t))
     }
 
-En nuestro ejemplo, la función `printTerm` es expresada como una sentencia basada en reconocimiento de patrones, la cual comienza con la palabra reservada `match` y consiste en secuencias de sentencias tipo `case PatronBuscado => Código que se ejecuta`.
+En nuestro ejemplo, la función `printTerm` es expresada como una sentencia basada en reconocimiento de patrones, la cual comienza con la palabra reservada `match` y consiste en secuencias de sentencias tipo `case PatrónBuscado => Código que se ejecuta`.
 
-El programa de arriba también define una función `isIdentityFun` la cual comprueba si un término dado se corresponde con una función identidad simple. Ese ejemplo utiliza patrones y guardas más avanzados (obsrvese la guarda `if x==y`). Tras reconocer un patrón con un valor dado, la guarda (definida después de la palabra clave `if`) es evaluada. Si retorna `true` (verdadero), el reconocimiento es exitoso; de no ser así, falla y se intenta con el siguiente patrón.
+El programa de arriba también define una función `isIdentityFun` la cual comprueba si un término dado se corresponde con una función identidad simple. Ese ejemplo utiliza patrones y comparaciones más avanzadas (obsérvese la guarda `if x==y`). 
+Tras reconocer un patrón con un valor dado, se evalúa la comparación (definida después de la palabra clave `if`). 
+Si retorna `true` (verdadero), el reconocimiento es exitoso; de no ser así, falla y se intenta con el siguiente patrón.

_es/tour/multiple-parameter-lists.md

@@ -10,12 +10,35 @@ next-page: automatic-closures
 previous-page: nested-functions
 ---
 
-_Nota de traducción: Currying es una técnica de programación funcional nombrada en honor al matemático y lógico Haskell Curry. Es por eso que no se intentará hacer ninguna traducción sobre el término Currying. Entiendase este como una acción, técnica base de PF. Como una nota al paso, el lenguaje de programación Haskell debe su nombre a este eximio matemático._
+_Nota de traducción: Currying es una técnica de programación funcional nombrada en honor al matemático y lógico Haskell Curry. Es por eso que no se intentará hacer ninguna traducción sobre el término Currying. Entiéndase este como una acción, técnica base de PF. Como una nota al paso, el lenguaje de programación Haskell debe su nombre a este eximio matemático._
 
 Los métodos pueden definir múltiples listas de parámetros. Cuando un método es invocado con un número menor de listas de parámetros, en su lugar se devolverá una función que toma las listas faltantes como sus argumentos.
 
-Aquí se muestra un ejemplo:
+### Ejemplos
 
+A continuación hay un ejemplo, tal y como se define en el trait `TraversableOnce` en el API de colecciones de Scala:
+
+```
+def foldLeft[B](z: B)(op: (B, A) => B): B
+```
+
+`foldLeft` aplica una función (que recibe dos parámetros) `op` a un valor inicial `z` y todos los elementos de esta colección, de izquierda a derecha. A continuación se muestra un ejemplo de su uso.
+
+Comenzando con un valor inicial 0, `foldLeft` aplica la función `(m, n) => m + n` a cada uno de los elementos de la lista y al valor acumulado previo.
+
+{% scalafiddle %}
+```tut
+val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+val res = numbers.foldLeft(0)((m, n) => m + n)
+println(res) // 55
+```
+{% endscalafiddle %}
+
+
+A continuación se muestra otro ejemplo:
+
+{% scalafiddle %}
+```tut
     object CurryTest extends App {
 
       def filter(xs: List[Int], p: Int => Boolean): List[Int] =
@@ -29,10 +52,78 @@ Aquí se muestra un ejemplo:
       println(filter(nums, modN(2)))
       println(filter(nums, modN(3)))
     }
+```
+{% endscalafiddle %}
 
-_Nota: el método `modN` está parcialmente aplicado en las dos llamadas a `filter`; esto significa que solo su primer argumento es realmente aplicado. El término `modN(2)` devuelve una función de tipo `Int => Boolean` y es por eso un posible candidato para el segundo argumento de la función `filter`_
+_Nota: el método `modN` está parcialmente aplicado en las dos llamadas a `filter`; esto significa que solo su primer argumento es realmente aplicado. El término `modN(2)` devuelve una función de tipo `Int => Boolean` y es por eso un posible candidato para el segundo argumento de la función `filter`._
 
 Aquí se muestra la salida del programa anterior:
 
     List(2,4,6,8)
     List(3,6)
+
+
+### Casos de uso
+
+Casos de uso sugeridos para múltiples listas de parámetros incluyen:
+
+#### Inferencia de tipos
+
+En Scala, la inferencia de tipos se realiza parámetro a parámetro.
+Suponer que se dispone del siguiente método:
+
+```tut
+def foldLeft1[A, B](as: List[A], b0: B, op: (B, A) => B) = ???
+```
+
+Si se invoca de la siguiente manera, se puede comprobar que no compila correctamente:
+
+```tut:fail
+def notPossible = foldLeft1(numbers, 0, _ + _)
+```
+
+Debes invocarlo de alguna de las maneras propuestas a continuación:
+
+```tut
+def firstWay = foldLeft1[Int, Int](numbers, 0, _ + _)
+def secondWay = foldLeft1(numbers, 0, (a: Int, b: Int) => a + b)
+```
+
+Esto se debe a que Scala no será capaz de inferir el tipo de la función `_ + _`, como está aún infiriendo `A` y `B`.
+Moviéndo el parámetro `op` a su propia lista de parámetros, los tipos de `A` y `B` son inferidos en la primera lista de parámetros.
+Una vez se han inferido sus tipos, estos están disponibles para la segunda lista de parámetros y `_ + _ ` podrá casar con los tipos inferidos `(Int, Int) => Int`
+
+```tut
+def foldLeft2[A, B](as: List[A], b0: B)(op: (B, A) => B) = ???
+def possible = foldLeft2(numbers, 0)(_ + _)
+```
+
+Esta definición no necesita de ninguna pista adicional y puede inferir todos los tipos de los parámetros.
+
+
+#### Parámetros implícitos
+
+Para especificar solamente ciertos parámetros como [`implicit`](https://docs.scala-lang.org/tour/implicit-parameters.html), ellos deben ser colocados en su propia lista de parámetros implícitos (`implicit`).
+
+Un ejemplo de esto se muestra a continuación:
+
+```
+def execute(arg: Int)(implicit ec: scala.concurrent.ExecutionContext) = ???
+```
+
+#### Aplicación parcial
+
+Cuando un método es invocado con menos parámetros que los que están declarados en la definición del método, esto generará una función que toma los parámetros faltantes como argumentos. Esto se conoce formalmente como [aplicación parcial](https://en.wikipedia.org/wiki/Partial_application).
+
+Por ejemplo,
+
+```tut
+val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+val numberFunc = numbers.foldLeft(List[Int]()) _
+
+val squares = numberFunc((xs, x) => xs :+ x*x)
+println(squares) // List(1, 4, 9, 16, 25, 36, 49, 64, 81, 100)
+
+val cubes = numberFunc((xs, x) => xs :+ x*x*x)
+println(cubes)  // List(1, 8, 27, 64, 125, 216, 343, 512, 729, 1000)
+```

_es/tour/tour-of-scala.md

@@ -10,15 +10,15 @@ next-page: basics
 
 ---
 
-Scala es un lenguaje de programación moderno multi-paradigma diseñado para expresar patrones de programación comunes de una forma concisa, elegante, y de tipado seguro. Integra fácilmente características de lenguajes orientados a objetos y funcionales.
+Scala es un lenguaje de programación moderno multi-paradigma diseñado para expresar patrones de programación comunes de una forma concisa, elegante, y con tipado seguro. Integra fácilmente características de lenguajes orientados a objetos y funcionales.
 
 ## Scala es orientado a objetos ##
 Scala es un lenguaje puramente orientado a objetos en el sentido de que todo es un objeto. Los tipos y comportamientos de objetos son descritos por [clases](classes.html) y [traits](traits.html) (que podría ser traducido como un "rasgo"). Las clases pueden ser extendidas a través de subclases y un mecanismo flexible [de composición mezclada](mixin-class-composition.html) que provee un claro remplazo a la herencia múltiple.
 
 ## Scala es funcional ##
-Scala es también un lenguaje funcional en el sentido que toda función es un valor. Scala provee una sintaxis ligera para definir funciones anónimas. Soporta [funciones de primer orden](higher-order-functions.html), permite que las funciones sean [anidadas](nested-functions.html), y soporta [currying](multiple-parameter-lists.html). Las [clases caso](case-classes.html) de Scala y las construcciones incorporadas al lenguaje para [reconocimiento de patrones](pattern-matching.html) modelan tipos algebráicos usados en muchos lenguajes de programación funcionales.
+Scala es también un lenguaje funcional en el sentido que toda función es un valor. Scala provee una sintaxis ligera para definir funciones anónimas. Soporta [funciones de orden superior](higher-order-functions.html), permite funciones [anidadas](nested-functions.html), y soporta [currying](multiple-parameter-lists.html). Las [clases Case](case-classes.html) de Scala y las construcciones incorporadas al lenguaje para [reconocimiento de patrones](pattern-matching.html) modelan tipos algebraicos usados en muchos lenguajes de programación funcionales.
 
-Además, la noción de reconocimiento de patrones de Scala se puede extender naturalmente al procesamiento de datos XML con la ayuda de [patrones de expresiones regulares](regular-expression-patterns.html). En este contexto, seq comprehensions resultan útiles para formular consultas. Estas características hacen a Scala ideal para desarrollar aplicaciones como Web Services.
+Además, la noción de reconocimiento de patrones de Scala se puede extender naturalmente al procesamiento de datos XML con la ayuda de [patrones de expresiones regulares](regular-expression-patterns.html). En este contexto, la compresión de bucles `for` resultan útiles para formular consultas. Estas características hacen a Scala un lenguaje ideal para desarrollar aplicaciones como Web Services.
 
 ## Scala estáticamente tipado ##
 Scala cuenta con un expresivo sistema de tipado que fuerza estáticamente las abstracciones a ser usadas en una manera coherente y segura. En particular, el sistema de tipado soporta:
@@ -31,16 +31,25 @@ Scala cuenta con un expresivo sistema de tipado que fuerza estáticamente las ab
 * [implicit conversions](implicit-conversions.html)
 * [métodos polimórficos](polymorphic-methods.html)
 
-El [mecanismo de inferencia de tipos locales](type-inference.html) se encarga de que el usuario no tenga que anotar el programa con información redundante de tipado. Combinadas, estas características proveen una base poderosa para el reuso seguro de abstracciones de programación y para la extensión segura (en cuanto a tipos) de software.
+El [mecanismo de inferencia de tipos locales](type-inference.html) se encarga de que el usuario no tenga que anotar el programa con información redundante de tipado. Combinadas, estas características proveen una base poderosa para la reutilización segura de abstracciones de programación y para la extensión segura (en cuanto a tipos) de software.
 
 ## Scala es extensible ##
 
-En la práctica el desarrollo de aplicaciones específicas para un dominio generalmente requiere de "Lenguajes de dominio específico" (DSL). Scala provee una única combinación de mecanismos del lenguaje que simplifican la creación de construcciones propias del lenguaje en forma de librerías:
+En la práctica, el desarrollo de aplicaciones específicas para un dominio generalmente requiere de "Lenguajes de dominio específico" (DSL). Scala provee una única combinación de mecanismos del lenguaje que simplifican la creación de construcciones propias del lenguaje en forma de bibliotecas:
 * cualquier método puede ser usado como un operador de [infijo o postfijo](operators.html)
 * [las closures son construidas automáticamente dependiendo del tipo esperado](automatic-closures.html) (tipos objetivo).
 
 El uso conjunto de ambas características facilita la definición de nuevas sentencias sin tener que extender la sintaxis y sin usar facciones de meta-programación como tipo macros.
 
-Scala está diseñado para interoperar bien con el popular Entorno de ejecución de Java 2 (JRE). En particular, la interacción con el lenguaje orientado a objetos Java es muy sencillo. Scala tiene el mismo esquema de compilación (compilación separada, carga de clases dinámica) que java y permite acceder a las miles de librerías de gran calidad existentes.
+## Scala interopera
+
+Scala está diseñado para interoperar correctamente con la popular Java Runtime Environment (JRE).
+En particular, es posible la misma interacción con el lenguaje de programación Java.
+Nuevas características de Java como SAMs, [lambdas](higher-order-functions.html), [anotaciones](annotations.html), y [clases genéricas](generic-classes.html) tienen sus análogos en Scala.
+
+Aquellas características de Scala que no tienen analogías en Java, como por ejemplo [parámetros por defecto](default-parameter-values.html) y [parámetros con nombre](named-arguments.html), compilan de una forma tan similar a Java como es razonablemente posible. 
+Scala tiene el mismo modelo de compilación (compilación separada, carga de clases dinámica) que Java y permite acceder a miles de bibliotecas de alta calidad ya existentes.
+
+## ¡Disfruta el tour!
 
 Por favor continúe a la próxima página para conocer más.

_es/tour/tuples.md

@@ -10,5 +10,82 @@ previous-page: inner-classes
 
 ---
 
-(this section of the tour has not been translated yet. pull request
-with translation welcome!)
+En Scala, una tupla es un valor que contiene un número fijo de elementos,
+cada uno de ellos puede ser de distinto tipo. Las tuplas son inmutables.
+
+Las tuplas son especialmente útiles para retornar múltiples valores desde 
+un método.
+
+Una tupla con dos elementos puede ser creada del siguiente modo:
+
+```tut
+val ingredient = ("Sugar", 25)
+```
+
+Esta instrucción crea una tupla que contiene un elemento de tipo `String` 
+y un elemento de tipo `Int`.
+
+El tipo de la tupla `ingredient` se infiere que es`(String, Int)`, lo cual es
+una abreviatura de `Tuple2[String, Int]`.
+
+Para representar tuplas, Scala utiliza una serie de clases: `Tuple2`, `Tuple3`, 
+etc., hasta `Tuple22`.
+Cada clase tiene tantos parámetros como número de elementos.
+
+## Accediendo a los elementos
+
+Una forma de acceder a los elementos de una tupla es por posición.
+Los elementos concretos se llaman `_1`, `_2`, y así sucesivamente.
+
+```tut
+println(ingredient._1) // Sugar
+println(ingredient._2) // 25
+```
+
+## Reconocimiento de patrones en tuplas
+
+Una tupla también puede ser dividida/expandida usando reconocimiento de patrones (pattern matching):
+
+```tut
+val (name, quantity) = ingredient
+println(name)     // Sugar
+println(quantity) // 25
+```
+
+En esta ocasión el tipo de `name` es inferido como `String` y el de
+`quantity` como `Int`.
+
+A continuación otro ejemplo de reconocimiento de patrones con tuplas:
+
+```tut
+val planets =
+  List(("Mercury", 57.9), ("Venus", 108.2), ("Earth", 149.6),
+       ("Mars", 227.9), ("Jupiter", 778.3))
+planets.foreach{
+  case ("Earth", distance) =>
+    println(s"Nuestro planeta está a $distance millones de kilómetros del Sol.")
+  case _ =>
+}
+```
+
+O en compresión de bucles `for`:
+
+```tut
+val numPairs = List((2, 5), (3, -7), (20, 56))
+for ((a, b) <- numPairs) {
+  println(a * b)
+}
+```
+
+## Tuplas y case classes
+
+A veces los usuarios encuentran difícil elegir entre tuplas y clases Case. 
+Los elementos de las clases Case tienen nombre. Los nombres pueden mejorar
+la lectura en el código.
+En el ejemplo anterior de los planetas, podríamos haber definido 
+`case class Planet(name: String, distance: Double)` en vez de usar tuplas.
+
+
+## Más recursos
+
+* Aprende más acerca de las tuplas en el [Scala Book](/overviews/scala-book/tuples.html)

_tour/multiple-parameter-lists.md

@@ -58,7 +58,7 @@ def firstWay = foldLeft1[Int, Int](numbers, 0, _ + _)
 def secondWay = foldLeft1(numbers, 0, (a: Int, b: Int) => a + b)
 ```
 
-That's because Scala won't be able to infer the type of the function `_ + _`, as it's still inferring `A` and `B`. By moving the parameter `op` to its own parameter list, `A` and `B` are inferred in the first parameter list. These inferred types will then be available to the second parameter list and `_ + _` will match the the inferred type `(Int, Int) => Int`
+That's because Scala won't be able to infer the type of the function `_ + _`, as it's still inferring `A` and `B`. By moving the parameter `op` to its own parameter list, `A` and `B` are inferred in the first parameter list. These inferred types will then be available to the second parameter list and `_ + _` will match the inferred type `(Int, Int) => Int`
 
 ```tut
 def foldLeft2[A, B](as: List[A], b0: B)(op: (B, A) => B) = ???