From ff6a56bab84958abc40fc5fb6cd86efb57e2f147 Mon Sep 17 00:00:00 2001
From: Gabriel Claramunt <gabriel.claramunt@gmail.com>
Date: Wed, 1 May 2019 12:57:26 -0300
Subject: [PATCH 1/8] Update basics.md

---
 _es/tour/basics.md | 288 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 288 insertions(+)

diff --git a/_es/tour/basics.md b/_es/tour/basics.md
index bd86428a9b..78464b51d1 100644
--- a/_es/tour/basics.md
+++ b/_es/tour/basics.md
@@ -7,3 +7,291 @@ discourse: false
 partof: scala-tour
 language: es
 ---
+
+# Scala básico
+
+
+## Expresiones
+
+En Scala todo es una expresión (cada sentencia "devuelve" un valor).
+
+```scala
+1 + 1
+```
+
+Se puede ver el resultado de evaluar expresiones usando println.
+
+```scala
+println(1) // 1
+println(1 + 1) // 2
+println("Hello!") // Hello!
+println("Hello," + " world!") // Hello, world!
+```
+
+## Valores
+
+Se puede nombrar el resultado de expresiones con la palabra clave *val*.
+
+```scala
+val x = 1 + 1
+println(x) // 2
+```
+
+Los resultados con nombre, como x en el ejemplo, son llamados *valores*. Referenciar un valor no lo vuelve a computar.
+
+Los valores no pueden ser reasignados.
+
+```scala
+x = 3 // This does not compile.
+```
+
+Los tipos de los valores pueden ser inferidos, pero tambien se pueden anotar explicitamente de la siguiente forma:
+
+```scala
+val x: Int = 1 + 1
+```
+
+Noten como la declaración de tipo Int va después del identificador.
+
+## Variables
+
+Las variables son como los valores, excepto que no es posible re-asignarlos. Las variables se definen con la palabra clave *var*.
+
+```scala
+var x = 1 + 1
+x = 3 // This compiles because "x" is declared with the "var" keyword.
+println(x * x) // 9
+```
+
+Igual que con los valores, si queremos se puede especificar el tipo:
+
+```scala
+var x: Int = 1 + 1
+```
+
+## Bloques
+
+Se pueden combinar expresiones rodeándolas con { y } . A esto le llamamos un *bloque*.
+
+El resultado de la ultima expresión del bloque es también el resultado total del bloque.
+
+```scala
+println({
+  val x = 1 + 1
+  x + 1
+}) // 3
+```
+
+## Funciones
+
+Las funciones son expresiones que reciben parámetros.
+
+Se pueden definir funciones anónimas, por ejemplo, una que retorne x + 1 para x entero:
+
+```scala
+(x: Int) => x + 1
+```
+
+A la izquierda de => esta la lista de parámetros. A la derecha esta el cuerpo de la función
+
+También podemos asignarle un nombre a la función.
+
+```scala
+val addOne = (x: Int) => x + 1
+println(addOne(1)) // 2
+```
+
+Las funciones pueden tomar muchos parámetros.
+
+```scala
+val add = (x: Int, y: Int) => x + y
+println(add(1, 2)) // 3
+```
+
+O ninguno.
+
+```scala
+val getTheAnswer = () => 42
+println(getTheAnswer()) // 42
+```
+
+
+## Métodos
+
+Los métodos se parecen y se comportan de forma muy similar a las funciones, pero hay un par de diferencias clave entre ellos.
+Los métodos se definen con la palabra clave *def*, seguida por un nombre, una lista de parámetros, un tipo de retorno (opcional pero recomendado), y el cuerpo del método.
+
+```scala
+def add(x: Int, y: Int): Int = x + y
+println(add(1, 2)) // 3
+```
+
+Notar como el tipo de retorno es declarado después de la lista de parámetros y con dos puntos.
+
+Los métodos pueden tener mutiles listas de parámetros.
+
+```scala
+def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier
+println(addThenMultiply(1, 2)(3)) // 9
+```
+
+O ninguna.
+
+```scala
+def name: String = System.getProperty("user.name")
+println("Hello, " + name + "!")
+```
+
+Hay otras diferencias, pero para simplificar, podemos pensar que son similares a las funciones.
+
+Los métodos también pueden tener expresiones de varias lineas.
+
+```scala
+def getSquareString(input: Double): String = {
+  val square = input * input
+  square.toString
+}
+```
+
+La ultima expresión en el cuerpo del método es el valor de retorno del mismo.
+(Scala tiene la palabra clave *return* pero no se usa y no hace lo que uds. piensan que hace)
+
+## Clases
+
+Se puede definir clases con la palabra clave *class* seguida del nombre y los parámetros del constructor.
+
+```scala
+class Greeter(prefix: String, suffix: String) {
+  def greet(name: String): Unit =
+    println(prefix + name + suffix)
+}
+```
+
+El tipo de retorno del método greet es Unit, que dice que no hay nada significativo que retornar. Se usa de forma similar al void de Java y C (con la diferencia de que como toda expresión en Scala debe retornar un valor, existe un valor singleton para el tipo Unit que se escribe `()` y no lleva información )
+
+Puedes crear una instancia de una clase con la palabra clave *new*.
+
+```scala
+val greeter = new Greeter("Hello, ", "!")
+greeter.greet("Scala developer") // Hello, Scala developer!
+```
+
+Mas adelante, cubriremos las clases en profundidad.
+
+## Case Classes
+
+Scala tiene un tipo especial de clases llamadas "case" classes. Por defecto, las case classes son inmutables y son comparadas por valor.
+Las case classes se definen usando las palabras clave *case class*.
+
+```scala
+case class Point(x: Int, y: Int)
+```
+
+Se pueden instanciar sin necesidad de usar la palabra clave new.
+
+```scala
+val point = Point(1, 2)
+val anotherPoint = Point(1, 2)
+val yetAnotherPoint = Point(2, 2)
+```
+
+Y son comparadas por valor.
+
+```scala
+if (point == anotherPoint) {
+  println(point + " and " + anotherPoint + " are the same.")
+} else {
+  println(point + " and " + anotherPoint + " are different.")
+} // Point(1,2) and Point(1,2) are the same.
+
+if (point == yetAnotherPoint) {
+  println(point + " and " + yetAnotherPoint + " are the same.")
+} else {
+  println(point + " and " + yetAnotherPoint + " are different.")
+} // Point(1,2) and Point(2,2) are different.
+```
+
+Hay mucho mas sobre las case classes que queremos presentar, y estamos convencidos de que te vas a enamorar de ellas. Las cubriremos en profundidad mas adelante.
+
+## Objetos
+
+Los objetos son instancias de una sola clase de su propia definición. Puedes pensar en ellos como singleton de sus propias clases
+
+Puedes definir objectos con la palabra clave *object*.
+
+```scala
+object IdFactory {
+  private var counter = 0
+  def create(): Int = {
+    counter += 1
+    counter
+  }
+}
+```
+
+Para acceder al objeto, lo referencias por su nombre.
+
+```scala
+val newId: Int = IdFactory.create()
+println(newId) // 1
+val newerId: Int = IdFactory.create()
+println(newerId) // 2
+```
+
+Mas adelante, cubriremos los objetos en profundidad.
+
+## Traits
+
+Los traits son tipos que contienen campos y métodos. Se pueden combinar múltiples traits.
+
+Los traits se definen con la palabra clave *trait*.
+
+```scala
+trait Greeter {
+  def greet(name: String): Unit
+}
+```
+
+Los traits pueden también tener implementación por defecto.
+
+```scala
+trait Greeter {
+  def greet(name: String): Unit =
+    println("Hello, " + name + "!")
+}
+```
+
+También puedes extender traits con la palabra clave *extends* y sobrescribir una implementación con la palabra clave *override* .
+
+```scala
+class DefaultGreeter extends Greeter
+
+class CustomizableGreeter(prefix: String, postfix: String) extends Greeter {
+  override def greet(name: String): Unit = {
+    println(prefix + name + postfix)
+  }
+}
+
+val greeter = new DefaultGreeter()
+greeter.greet("Scala developer") // Hello, Scala developer!
+
+val customGreeter = new CustomizableGreeter("How are you, ", "?")
+customGreeter.greet("Scala developer") // How are you, Scala developer?
+```
+
+Aquí, DefaultGreeter extiende un solo trait, pero puede extender múltiples traits.
+
+Mas adelante, cubriremos los traits en profundidad.
+
+## Metodo principal (Main Method)
+
+El metodo principal (main) es el punto de entrada de un programa. La maquina virtual de java (JVM) requiere que el método principal sea llamado `main` y que tome un solo argumento: un arrray de Strings.
+
+Usando un objeto, puedes definir el método principal de la siguiente forma:
+
+```scala
+object Main {
+  def main(args: Array[String]): Unit =
+    println("Hello, Scala developer!")
+}
+```

From 9263c69c11ed51379e47b277db50901a8bdca563 Mon Sep 17 00:00:00 2001
From: Gabriel Claramunt <gabriel.claramunt@gmail.com>
Date: Sat, 4 May 2019 14:36:31 -0300
Subject: [PATCH 2/8] fix formatting and scalafiddle

---
 _es/tour/basics.md | 138 +++++++++++++++++++++++++++------------------
 1 file changed, 83 insertions(+), 55 deletions(-)

diff --git a/_es/tour/basics.md b/_es/tour/basics.md
index 78464b51d1..24819b1d86 100644
--- a/_es/tour/basics.md
+++ b/_es/tour/basics.md
@@ -6,58 +6,77 @@ discourse: false
 
 partof: scala-tour
 language: es
+
+num: 2
+next-page: unified-types
+previous-page: tour-of-scala
 ---
 
-# Scala básico
+En esta página, cubriremos lo básico de Scala.
+
+## Probando Scala en el navegador
+
+Puedes ejecutar Scala en tu navegador con ScalaFiddle.
+
+1. Ve a [https://scalafiddle.io](https://scalafiddle.io).
+2. Pega `println("Hello, world!")` en el panel izquierdo.
+3. Presiona el botón de "Run". El resultado aparece en el panel de la derecha.
 
+Esta es una forma simple y con cero configuración de experimentar con piezas de código en Scala.
+
+Many of the code examples in this documentation are also integrated with ScalaFiddle, so you
+can directly experiment with them simply by clicking the Run-button.
+Muchos de los ejemplos de código en esta documentación están integrados también con ScalaFiddle, para que puedas experimentar directamente con ellos simplemente presionando el botón de "Run".
 
 ## Expresiones
 
 En Scala todo es una expresión (cada sentencia "devuelve" un valor).
 
-```scala
+```tut
 1 + 1
 ```
 
-Se puede ver el resultado de evaluar expresiones usando println.
+Se puede ver el resultado de evaluar expresiones usando `println`.
 
-```scala
+{% scalafiddle %}
+```tut
 println(1) // 1
 println(1 + 1) // 2
 println("Hello!") // Hello!
 println("Hello," + " world!") // Hello, world!
 ```
+{% endscalafiddle %}
 
 ## Valores
 
-Se puede nombrar el resultado de expresiones con la palabra clave *val*.
+Se puede nombrar el resultado de expresiones con la palabra clave `val`.
 
-```scala
+```tut
 val x = 1 + 1
 println(x) // 2
 ```
 
-Los resultados con nombre, como x en el ejemplo, son llamados *valores*. Referenciar un valor no lo vuelve a computar.
+Los resultados con nombre, como `x` en el ejemplo, son llamados valores. Referenciar un valor no lo vuelve a computar.
 
 Los valores no pueden ser reasignados.
 
-```scala
+```tut:fail
 x = 3 // This does not compile.
 ```
 
-Los tipos de los valores pueden ser inferidos, pero tambien se pueden anotar explicitamente de la siguiente forma:
+Los tipos de los valores pueden ser inferidos, pero también se pueden anotar explicitamente de la siguiente forma:
 
-```scala
+```tut
 val x: Int = 1 + 1
 ```
 
-Noten como la declaración de tipo Int va después del identificador.
+Noten como la declaración de tipo `Int` va después del identificador `x`. También necesitas un `:`.
 
 ## Variables
 
-Las variables son como los valores, excepto que no es posible re-asignarlos. Las variables se definen con la palabra clave *var*.
+Las variables son como los valores, excepto que no es posible re-asignarlos. Las variables se definen con la palabra clave `var`.
 
-```scala
+```tut
 var x = 1 + 1
 x = 3 // This compiles because "x" is declared with the "var" keyword.
 println(x * x) // 9
@@ -65,17 +84,17 @@ println(x * x) // 9
 
 Igual que con los valores, si queremos se puede especificar el tipo:
 
-```scala
+```tut
 var x: Int = 1 + 1
 ```
 
 ## Bloques
 
-Se pueden combinar expresiones rodeándolas con { y } . A esto le llamamos un *bloque*.
+Se pueden combinar expresiones rodeándolas con `{}` . A esto le llamamos un bloque.
 
 El resultado de la ultima expresión del bloque es también el resultado total del bloque.
 
-```scala
+```tut
 println({
   val x = 1 + 1
   x + 1
@@ -88,7 +107,7 @@ Las funciones son expresiones que reciben parámetros.
 
 Se pueden definir funciones anónimas, por ejemplo, una que retorne x + 1 para x entero:
 
-```scala
+```tut
 (x: Int) => x + 1
 ```
 
@@ -96,48 +115,56 @@ A la izquierda de => esta la lista de parámetros. A la derecha esta el cuerpo d
 
 También podemos asignarle un nombre a la función.
 
-```scala
+{% scalafiddle %}
+```tut
 val addOne = (x: Int) => x + 1
 println(addOne(1)) // 2
 ```
+{% endscalafiddle %}
 
 Las funciones pueden tomar muchos parámetros.
 
-```scala
+{% scalafiddle %}
+```tut
 val add = (x: Int, y: Int) => x + y
 println(add(1, 2)) // 3
 ```
+{% endscalafiddle %}
 
 O ninguno.
 
-```scala
+```tut
 val getTheAnswer = () => 42
 println(getTheAnswer()) // 42
 ```
 
-
 ## Métodos
 
 Los métodos se parecen y se comportan de forma muy similar a las funciones, pero hay un par de diferencias clave entre ellos.
-Los métodos se definen con la palabra clave *def*, seguida por un nombre, una lista de parámetros, un tipo de retorno (opcional pero recomendado), y el cuerpo del método.
 
-```scala
+Los métodos se definen con la palabra clave `def`, seguida por un nombre, una lista de parámetros, un tipo de retorno, y el cuerpo del método.
+
+{% scalafiddle %}
+```tut
 def add(x: Int, y: Int): Int = x + y
 println(add(1, 2)) // 3
 ```
+{% endscalafiddle %}
 
-Notar como el tipo de retorno es declarado después de la lista de parámetros y con dos puntos.
+Notar como el tipo de retorno es declarado _después_ de la lista de parámetros y con dos puntos `: Int`.
 
 Los métodos pueden tener mutiles listas de parámetros.
 
-```scala
+{% scalafiddle %}
+```tut
 def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier
 println(addThenMultiply(1, 2)(3)) // 9
 ```
+{% endscalafiddle %}
 
-O ninguna.
+O ninguna lista de parametros.
 
-```scala
+```tut
 def name: String = System.getProperty("user.name")
 println("Hello, " + name + "!")
 ```
@@ -146,7 +173,7 @@ Hay otras diferencias, pero para simplificar, podemos pensar que son similares a
 
 Los métodos también pueden tener expresiones de varias lineas.
 
-```scala
+```tut
 def getSquareString(input: Double): String = {
   val square = input * input
   square.toString
@@ -154,42 +181,42 @@ def getSquareString(input: Double): String = {
 ```
 
 La ultima expresión en el cuerpo del método es el valor de retorno del mismo.
-(Scala tiene la palabra clave *return* pero no se usa y no hace lo que uds. piensan que hace)
+(Scala tiene la palabra clave `return` pero raramente se usa)
 
 ## Clases
 
-Se puede definir clases con la palabra clave *class* seguida del nombre y los parámetros del constructor.
+Se puede definir clases con la palabra clave `class` seguida del nombre y los parámetros del constructor.
 
-```scala
+```tut
 class Greeter(prefix: String, suffix: String) {
   def greet(name: String): Unit =
     println(prefix + name + suffix)
 }
 ```
 
-El tipo de retorno del método greet es Unit, que dice que no hay nada significativo que retornar. Se usa de forma similar al void de Java y C (con la diferencia de que como toda expresión en Scala debe retornar un valor, existe un valor singleton para el tipo Unit que se escribe `()` y no lleva información )
+El tipo de retorno del método `greet` es `Unit`, que dice que no hay nada significativo que retornar. Se usa de forma similar al `void` de Java y C (Con la diferencia de que como toda expresión en Scala debe retornar un valor, existe un valor singleton para el tipo Unit que se escribe () y no lleva información )
 
 Puedes crear una instancia de una clase con la palabra clave *new*.
 
-```scala
+```tut
 val greeter = new Greeter("Hello, ", "!")
 greeter.greet("Scala developer") // Hello, Scala developer!
 ```
 
-Mas adelante, cubriremos las clases en profundidad.
+Cubriremos las clases en profundidad [mas adelante](classes.html).
 
 ## Case Classes
 
 Scala tiene un tipo especial de clases llamadas "case" classes. Por defecto, las case classes son inmutables y son comparadas por valor.
-Las case classes se definen usando las palabras clave *case class*.
+Las case classes se definen usando las palabras clave `case class`.
 
-```scala
+```tut
 case class Point(x: Int, y: Int)
 ```
 
-Se pueden instanciar sin necesidad de usar la palabra clave new.
+Se pueden instanciar sin necesidad de usar la palabra clave `new`.
 
-```scala
+```tut
 val point = Point(1, 2)
 val anotherPoint = Point(1, 2)
 val yetAnotherPoint = Point(2, 2)
@@ -197,7 +224,7 @@ val yetAnotherPoint = Point(2, 2)
 
 Y son comparadas por valor.
 
-```scala
+```tut
 if (point == anotherPoint) {
   println(point + " and " + anotherPoint + " are the same.")
 } else {
@@ -211,15 +238,15 @@ if (point == yetAnotherPoint) {
 } // Point(1,2) and Point(2,2) are different.
 ```
 
-Hay mucho mas sobre las case classes que queremos presentar, y estamos convencidos de que te vas a enamorar de ellas. Las cubriremos en profundidad mas adelante.
+Hay mucho mas sobre las case classes que queremos presentar, y estamos convencidos de que te vas a enamorar de ellas. Las cubriremos en profundidad [mas adelante](case-classes.html).
 
 ## Objetos
 
 Los objetos son instancias de una sola clase de su propia definición. Puedes pensar en ellos como singleton de sus propias clases
 
-Puedes definir objectos con la palabra clave *object*.
+Puedes definir objectos con la palabra clave `object`.
 
-```scala
+```tut
 object IdFactory {
   private var counter = 0
   def create(): Int = {
@@ -231,22 +258,22 @@ object IdFactory {
 
 Para acceder al objeto, lo referencias por su nombre.
 
-```scala
+```tut
 val newId: Int = IdFactory.create()
 println(newId) // 1
 val newerId: Int = IdFactory.create()
 println(newerId) // 2
 ```
 
-Mas adelante, cubriremos los objetos en profundidad.
+Cubriremos los objetos en profundidad [mas adelante](singleton-objects.html).
 
 ## Traits
 
 Los traits son tipos que contienen campos y métodos. Se pueden combinar múltiples traits.
 
-Los traits se definen con la palabra clave *trait*.
+Los traits se definen con la palabra clave `trait`.
 
-```scala
+```tut
 trait Greeter {
   def greet(name: String): Unit
 }
@@ -254,16 +281,16 @@ trait Greeter {
 
 Los traits pueden también tener implementación por defecto.
 
-```scala
+{% scalafiddle %}
+```tut
 trait Greeter {
   def greet(name: String): Unit =
     println("Hello, " + name + "!")
 }
-```
 
-También puedes extender traits con la palabra clave *extends* y sobrescribir una implementación con la palabra clave *override* .
+También puedes extender traits con la palabra clave `extends` y sobrescribir una implementación con la palabra clave `override` .
 
-```scala
+```tut
 class DefaultGreeter extends Greeter
 
 class CustomizableGreeter(prefix: String, postfix: String) extends Greeter {
@@ -278,18 +305,19 @@ greeter.greet("Scala developer") // Hello, Scala developer!
 val customGreeter = new CustomizableGreeter("How are you, ", "?")
 customGreeter.greet("Scala developer") // How are you, Scala developer?
 ```
+{% endscalafiddle %}
 
-Aquí, DefaultGreeter extiende un solo trait, pero puede extender múltiples traits.
+Aquí, `DefaultGreeter` extiende un solo trait, pero puede extender múltiples traits.
 
-Mas adelante, cubriremos los traits en profundidad.
+Cubriremos los traits en profundidad [mas adelante](traits.html).
 
-## Metodo principal (Main Method)
+## Método principal (Main Method)
 
-El metodo principal (main) es el punto de entrada de un programa. La maquina virtual de java (JVM) requiere que el método principal sea llamado `main` y que tome un solo argumento: un arrray de Strings.
+El método principal (main) es el punto de entrada de un programa. La maquina virtual de java (JVM) requiere que el método principal sea llamado `main` y que tome un solo argumento: un arrray de Strings.
 
 Usando un objeto, puedes definir el método principal de la siguiente forma:
 
-```scala
+```tut
 object Main {
   def main(args: Array[String]): Unit =
     println("Hello, Scala developer!")

From 0ff8f50cacaf22ceaca3102251d035689f5e54ac Mon Sep 17 00:00:00 2001
From: Gabriel Claramunt <gabriel.claramunt@gmail.com>
Date: Sat, 4 May 2019 23:14:13 -0300
Subject: [PATCH 3/8] add missing closing quotes

---
 _es/tour/basics.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/_es/tour/basics.md b/_es/tour/basics.md
index 24819b1d86..2b613c7bec 100644
--- a/_es/tour/basics.md
+++ b/_es/tour/basics.md
@@ -287,6 +287,7 @@ trait Greeter {
   def greet(name: String): Unit =
     println("Hello, " + name + "!")
 }
+```
 
 También puedes extender traits con la palabra clave `extends` y sobrescribir una implementación con la palabra clave `override` .
 

From 16c153cc515aa141f37e39305c01aefd961e6089 Mon Sep 17 00:00:00 2001
From: "Diego E. Alonso Blas" <diesalbla@gmail.com>
Date: Sun, 5 May 2019 23:59:11 -0300
Subject: [PATCH 4/8] Apply suggestions from code review

Co-Authored-By: gclaramunt <gabriel.claramunt@gmail.com>
---
 _es/tour/basics.md | 50 +++++++++++++++++++++++-----------------------
 1 file changed, 25 insertions(+), 25 deletions(-)

diff --git a/_es/tour/basics.md b/_es/tour/basics.md
index 2b613c7bec..c8f45e7c5a 100644
--- a/_es/tour/basics.md
+++ b/_es/tour/basics.md
@@ -19,14 +19,14 @@ En esta página, cubriremos lo básico de Scala.
 Puedes ejecutar Scala en tu navegador con ScalaFiddle.
 
 1. Ve a [https://scalafiddle.io](https://scalafiddle.io).
-2. Pega `println("Hello, world!")` en el panel izquierdo.
-3. Presiona el botón de "Run". El resultado aparece en el panel de la derecha.
+2. Escribe `println("Hello, world!")` en el panel a la izquierda.
+3. Presiona el botón "Run". En el panel de la derecha aparecerá el resultado.
 
-Esta es una forma simple y con cero configuración de experimentar con piezas de código en Scala.
+Así, de manera fácil y sin preparación, puedes probar fragmentos de código Scala.
 
 Many of the code examples in this documentation are also integrated with ScalaFiddle, so you
 can directly experiment with them simply by clicking the Run-button.
-Muchos de los ejemplos de código en esta documentación están integrados también con ScalaFiddle, para que puedas experimentar directamente con ellos simplemente presionando el botón de "Run".
+Muchos ejemplos de código en esta documentación están integrados con ScalaFiddle, y así puedes probarlos directamente solo con pulsar el botón "Run".
 
 ## Expresiones
 
@@ -49,7 +49,7 @@ println("Hello," + " world!") // Hello, world!
 
 ## Valores
 
-Se puede nombrar el resultado de expresiones con la palabra clave `val`.
+Se puede dar un nombre al resultado de una expresión usando la palabra reservada `val`.
 
 ```tut
 val x = 1 + 1
@@ -74,7 +74,7 @@ Noten como la declaración de tipo `Int` va después del identificador `x`. Tamb
 
 ## Variables
 
-Las variables son como los valores, excepto que no es posible re-asignarlos. Las variables se definen con la palabra clave `var`.
+Una variable es como un valor, excepto que a una variable se le puede re-asignar un valor después de declararla. Una variable se declara con la palabra reservada `var`.
 
 ```tut
 var x = 1 + 1
@@ -82,7 +82,7 @@ x = 3 // This compiles because "x" is declared with the "var" keyword.
 println(x * x) // 9
 ```
 
-Igual que con los valores, si queremos se puede especificar el tipo:
+Como con los valores, si se quiere se puede especificar el tipo de una variable mutable:
 
 ```tut
 var x: Int = 1 + 1
@@ -103,7 +103,7 @@ println({
 
 ## Funciones
 
-Las funciones son expresiones que reciben parámetros.
+Una función es una expresión que acepta parámetros.
 
 Se pueden definir funciones anónimas, por ejemplo, una que retorne x + 1 para x entero:
 
@@ -111,7 +111,7 @@ Se pueden definir funciones anónimas, por ejemplo, una que retorne x + 1 para x
 (x: Int) => x + 1
 ```
 
-A la izquierda de => esta la lista de parámetros. A la derecha esta el cuerpo de la función
+La lista de parámetros de la función está a la izquierda de la flecha `=>`, y a su derecha está el cuerpo de la función.
 
 También podemos asignarle un nombre a la función.
 
@@ -140,9 +140,9 @@ println(getTheAnswer()) // 42
 
 ## Métodos
 
-Los métodos se parecen y se comportan de forma muy similar a las funciones, pero hay un par de diferencias clave entre ellos.
+Los métodos se parecen y comportan casi como a las funciones, pero se diferencian en dos aspectos clave: 
 
-Los métodos se definen con la palabra clave `def`, seguida por un nombre, una lista de parámetros, un tipo de retorno, y el cuerpo del método.
+Un método se define con la palabra reservada `def`, seguida por el nombre del método, la lista de parámetros, el tipo de valores que el método devuelve, y el cuerpo del método.
 
 {% scalafiddle %}
 ```tut
@@ -151,9 +151,9 @@ println(add(1, 2)) // 3
 ```
 {% endscalafiddle %}
 
-Notar como el tipo de retorno es declarado _después_ de la lista de parámetros y con dos puntos `: Int`.
+Observe que el tipo de retorno se declara _después_ de la lista de parámetros, y separado con dos puntos, e.g. `: Int`.
 
-Los métodos pueden tener mutiles listas de parámetros.
+Un método puede tener varias listas de parámetros
 
 {% scalafiddle %}
 ```tut
@@ -181,11 +181,11 @@ def getSquareString(input: Double): String = {
 ```
 
 La ultima expresión en el cuerpo del método es el valor de retorno del mismo.
-(Scala tiene la palabra clave `return` pero raramente se usa)
+(Scala tiene una palabra reservada `return`, pero se usa raramente, y no se aconseja usarla)
 
 ## Clases
 
-Se puede definir clases con la palabra clave `class` seguida del nombre y los parámetros del constructor.
+Una clase se define con la palabra reservada `class`, seguida del nombre, y la lista de parámetros del constructor.
 
 ```tut
 class Greeter(prefix: String, suffix: String) {
@@ -194,27 +194,27 @@ class Greeter(prefix: String, suffix: String) {
 }
 ```
 
-El tipo de retorno del método `greet` es `Unit`, que dice que no hay nada significativo que retornar. Se usa de forma similar al `void` de Java y C (Con la diferencia de que como toda expresión en Scala debe retornar un valor, existe un valor singleton para el tipo Unit que se escribe () y no lleva información )
+El método `greet` tiene un tipo de retorno `Unit`, que indica que el método no tiene nada significativo que devolver. Esto es similar al tipo `void` en C, C++, o Java. La diferencia con estos lenguajes es que, dado que en Scala toda  expresión debe devuelvor un valor, se usa un tipo `Unit`, con un solo valor, que se escribe `()` y no lleva información.
 
-Puedes crear una instancia de una clase con la palabra clave *new*.
+Se puede crear una instancia de una clase con la palabra reservada *new*.
 
 ```tut
 val greeter = new Greeter("Hello, ", "!")
 greeter.greet("Scala developer") // Hello, Scala developer!
 ```
 
-Cubriremos las clases en profundidad [mas adelante](classes.html).
+Las clases se tratan en profundidad [mas adelante](classes.html).
 
 ## Case Classes
 
-Scala tiene un tipo especial de clases llamadas "case" classes. Por defecto, las case classes son inmutables y son comparadas por valor.
-Las case classes se definen usando las palabras clave `case class`.
+Hay un tipo especial de clases en Scala, las llamadas "case" classes. Por defecto, las instancias de una case class  son inmutables, y se comparan con otras solo por los valores que contienen en cada campo.
+Una case class se define con las palabras reservadas  `case class`:
 
 ```tut
 case class Point(x: Int, y: Int)
 ```
 
-Se pueden instanciar sin necesidad de usar la palabra clave `new`.
+Se puede crear una instancia de una `case class`, sin usar la palabra reservada `new`.  
 
 ```tut
 val point = Point(1, 2)
@@ -238,7 +238,7 @@ if (point == yetAnotherPoint) {
 } // Point(1,2) and Point(2,2) are different.
 ```
 
-Hay mucho mas sobre las case classes que queremos presentar, y estamos convencidos de que te vas a enamorar de ellas. Las cubriremos en profundidad [mas adelante](case-classes.html).
+Hay mucho mas sobre las case classes que queremos presentar, y estamos convencidos de que te vas a enamorar de ellas. Se tratan con más detalle [mas adelante](case-classes.html).
 
 ## Objetos
 
@@ -271,7 +271,7 @@ Cubriremos los objetos en profundidad [mas adelante](singleton-objects.html).
 
 Los traits son tipos que contienen campos y métodos. Se pueden combinar múltiples traits.
 
-Los traits se definen con la palabra clave `trait`.
+Un trait se define usando la palabra reservada `trait`.
 
 ```tut
 trait Greeter {
@@ -310,11 +310,11 @@ customGreeter.greet("Scala developer") // How are you, Scala developer?
 
 Aquí, `DefaultGreeter` extiende un solo trait, pero puede extender múltiples traits.
 
-Cubriremos los traits en profundidad [mas adelante](traits.html).
+Los `traits` se tratan con detalle [en otra página](traits.html).
 
 ## Método principal (Main Method)
 
-El método principal (main) es el punto de entrada de un programa. La maquina virtual de java (JVM) requiere que el método principal sea llamado `main` y que tome un solo argumento: un arrray de Strings.
+El método principal (main) es el punto donde comienza la ejecución de un programa en Scala. La máquina virtual de java (_Java Virtual Machine_ or JVM) requiere, para ejecutar un código Scala, que éste tenga un método principal llamado `main` cuyo único parámetro sea un arrray de Strings.
 
 Usando un objeto, puedes definir el método principal de la siguiente forma:
 

From 6de4ca5c19c03f0d597798b58a6efe86fdb5c376 Mon Sep 17 00:00:00 2001
From: Gabriel Claramunt <gabriel.claramunt@gmail.com>
Date: Mon, 6 May 2019 00:07:54 -0300
Subject: [PATCH 5/8] review comments

---
 _es/tour/basics.md | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/_es/tour/basics.md b/_es/tour/basics.md
index c8f45e7c5a..4147f63df1 100644
--- a/_es/tour/basics.md
+++ b/_es/tour/basics.md
@@ -24,13 +24,11 @@ Puedes ejecutar Scala en tu navegador con ScalaFiddle.
 
 Así, de manera fácil y sin preparación, puedes probar fragmentos de código Scala.
 
-Many of the code examples in this documentation are also integrated with ScalaFiddle, so you
-can directly experiment with them simply by clicking the Run-button.
 Muchos ejemplos de código en esta documentación están integrados con ScalaFiddle, y así puedes probarlos directamente solo con pulsar el botón "Run".
 
 ## Expresiones
 
-En Scala todo es una expresión (cada sentencia "devuelve" un valor).
+Las expresiones son sentencias computables.
 
 ```tut
 1 + 1
@@ -105,7 +103,7 @@ println({
 
 Una función es una expresión que acepta parámetros.
 
-Se pueden definir funciones anónimas, por ejemplo, una que retorne x + 1 para x entero:
+Una función se puede declarar anónima, sin nombre. Por ejemplo, ésta es una función que acepta un número entero `x`, y devuelve el resultado de incrementarlo `x+1`:
 
 ```tut
 (x: Int) => x + 1
@@ -244,7 +242,7 @@ Hay mucho mas sobre las case classes que queremos presentar, y estamos convencid
 
 Los objetos son instancias de una sola clase de su propia definición. Puedes pensar en ellos como singleton de sus propias clases
 
-Puedes definir objectos con la palabra clave `object`.
+Un objeto se define usando la palabra reservada `object`.
 
 ```tut
 object IdFactory {

From 0e2289195e42a1fbaa136d6bcf010510e360a485 Mon Sep 17 00:00:00 2001
From: Ignasi Marimon-Clos <ignasi@lightbend.com>
Date: Mon, 6 May 2019 11:08:38 -0300
Subject: [PATCH 6/8] Apply suggestions from code review

Co-Authored-By: gclaramunt <gabriel.claramunt@gmail.com>
---
 _es/tour/basics.md | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/_es/tour/basics.md b/_es/tour/basics.md
index 4147f63df1..c8155a77f8 100644
--- a/_es/tour/basics.md
+++ b/_es/tour/basics.md
@@ -12,7 +12,7 @@ next-page: unified-types
 previous-page: tour-of-scala
 ---
 
-En esta página, cubriremos lo básico de Scala.
+En esta página, practicaremos conceptos básicos de Scala.
 
 ## Probando Scala en el navegador
 
@@ -59,10 +59,10 @@ Los resultados con nombre, como `x` en el ejemplo, son llamados valores. Referen
 Los valores no pueden ser reasignados.
 
 ```tut:fail
-x = 3 // This does not compile.
+x = 3 // Producirá un error de compilación.
 ```
 
-Los tipos de los valores pueden ser inferidos, pero también se pueden anotar explicitamente de la siguiente forma:
+Los tipos de los valores pueden ser inferidos, pero también se pueden anotar explícitamente de la siguiente forma:
 
 ```tut
 val x: Int = 1 + 1
@@ -90,7 +90,7 @@ var x: Int = 1 + 1
 
 Se pueden combinar expresiones rodeándolas con `{}` . A esto le llamamos un bloque.
 
-El resultado de la ultima expresión del bloque es también el resultado total del bloque.
+El resultado de la última expresión del bloque es también el resultado total del bloque.
 
 ```tut
 println({
@@ -120,7 +120,7 @@ println(addOne(1)) // 2
 ```
 {% endscalafiddle %}
 
-Las funciones pueden tomar muchos parámetros.
+Las funciones pueden tomar varios parámetros.
 
 {% scalafiddle %}
 ```tut
@@ -149,9 +149,9 @@ println(add(1, 2)) // 3
 ```
 {% endscalafiddle %}
 
-Observe que el tipo de retorno se declara _después_ de la lista de parámetros, y separado con dos puntos, e.g. `: Int`.
+Observe que el tipo de retorno se declara _después_ de la lista de parámetros, y separado con dos puntos, p.ej. `: Int`.
 
-Un método puede tener varias listas de parámetros
+Un método puede tener varias listas de parámetros.
 
 {% scalafiddle %}
 ```tut
@@ -179,7 +179,7 @@ def getSquareString(input: Double): String = {
 ```
 
 La ultima expresión en el cuerpo del método es el valor de retorno del mismo.
-(Scala tiene una palabra reservada `return`, pero se usa raramente, y no se aconseja usarla)
+(Scala tiene una palabra reservada `return`, pero se usa raramente y no se aconseja usarla)
 
 ## Clases
 
@@ -192,7 +192,7 @@ class Greeter(prefix: String, suffix: String) {
 }
 ```
 
-El método `greet` tiene un tipo de retorno `Unit`, que indica que el método no tiene nada significativo que devolver. Esto es similar al tipo `void` en C, C++, o Java. La diferencia con estos lenguajes es que, dado que en Scala toda  expresión debe devuelvor un valor, se usa un tipo `Unit`, con un solo valor, que se escribe `()` y no lleva información.
+El método `greet` tiene un tipo de retorno `Unit`, que indica que el método no tiene nada significativo que devolver. Esto es similar al tipo `void` en C, C++, o Java. La diferencia con estos lenguajes es que en Scala toda expresión debe devolver un valor. Se usa un tipo `Unit` que tiene con un solo valor que se escribe `()` y no lleva información.
 
 Se puede crear una instancia de una clase con la palabra reservada *new*.
 
@@ -201,7 +201,7 @@ val greeter = new Greeter("Hello, ", "!")
 greeter.greet("Scala developer") // Hello, Scala developer!
 ```
 
-Las clases se tratan en profundidad [mas adelante](classes.html).
+Las clases se tratan en profundidad [más adelante](classes.html).
 
 ## Case Classes
 
@@ -236,11 +236,11 @@ if (point == yetAnotherPoint) {
 } // Point(1,2) and Point(2,2) are different.
 ```
 
-Hay mucho mas sobre las case classes que queremos presentar, y estamos convencidos de que te vas a enamorar de ellas. Se tratan con más detalle [mas adelante](case-classes.html).
+Hay mucho más sobre las case classes que queremos presentar, y estamos convencidos de que te vas a enamorar de ellas. Se tratan con más detalle [mas adelante](case-classes.html).
 
 ## Objetos
 
-Los objetos son instancias de una sola clase de su propia definición. Puedes pensar en ellos como singleton de sus propias clases
+Los objetos son instancias de una sola clase de su propia definición. Puedes pensar en ellos como _singleton_ de sus propias clases.
 
 Un objeto se define usando la palabra reservada `object`.
 
@@ -263,7 +263,7 @@ val newerId: Int = IdFactory.create()
 println(newerId) // 2
 ```
 
-Cubriremos los objetos en profundidad [mas adelante](singleton-objects.html).
+Cubriremos los objetos en profundidad [más adelante](singleton-objects.html).
 
 ## Traits
 
@@ -287,7 +287,7 @@ trait Greeter {
 }
 ```
 
-También puedes extender traits con la palabra clave `extends` y sobrescribir una implementación con la palabra clave `override` .
+También puedes extender traits con la palabra clave `extends` y sobrescribir una implementación con la palabra clave `override`.
 
 ```tut
 class DefaultGreeter extends Greeter

From d17ca9078857b64ecb9f0e7479ddc9389bb8f1bc Mon Sep 17 00:00:00 2001
From: Gabriel Claramunt <gabriel.claramunt@gmail.com>
Date: Mon, 6 May 2019 13:46:57 -0300
Subject: [PATCH 7/8] Apply suggestions from code review

Co-Authored-By: gclaramunt <gabriel.claramunt@gmail.com>
---
 _es/tour/basics.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/_es/tour/basics.md b/_es/tour/basics.md
index c8155a77f8..d472a60ddf 100644
--- a/_es/tour/basics.md
+++ b/_es/tour/basics.md
@@ -62,7 +62,7 @@ Los valores no pueden ser reasignados.
 x = 3 // Producirá un error de compilación.
 ```
 
-Los tipos de los valores pueden ser inferidos, pero también se pueden anotar explícitamente de la siguiente forma:
+Scala es capaz de inferir el tipo de un valor. Aun asi, también se puede indicar el tipo usando una anotación:
 
 ```tut
 val x: Int = 1 + 1
@@ -103,7 +103,7 @@ println({
 
 Una función es una expresión que acepta parámetros.
 
-Una función se puede declarar anónima, sin nombre. Por ejemplo, ésta es una función que acepta un número entero `x`, y devuelve el resultado de incrementarlo `x+1`:
+Una función se puede declarar anónima, sin nombre. Por ejemplo, ésta es una función que acepta un número entero `x`, y devuelve el resultado de incrementarlo:
 
 ```tut
 (x: Int) => x + 1
@@ -192,7 +192,7 @@ class Greeter(prefix: String, suffix: String) {
 }
 ```
 
-El método `greet` tiene un tipo de retorno `Unit`, que indica que el método no tiene nada significativo que devolver. Esto es similar al tipo `void` en C, C++, o Java. La diferencia con estos lenguajes es que en Scala toda expresión debe devolver un valor. Se usa un tipo `Unit` que tiene con un solo valor que se escribe `()` y no lleva información.
+El método `greet` tiene un tipo de retorno `Unit`, que indica que el método no tiene nada significativo que devolver. Esto es similar al tipo `void` en C, C++, o Java. La diferencia con estos lenguajes es que en Scala toda expresión debe devolver un valor. Por ello, se usa un tipo `Unit` que tiene con un solo valor que se escribe `()` y no lleva información.
 
 Se puede crear una instancia de una clase con la palabra reservada *new*.
 
@@ -277,7 +277,7 @@ trait Greeter {
 }
 ```
 
-Los traits pueden también tener implementación por defecto.
+Un `trait` también puede definit un método, o un valor, con una implementación por defecto.
 
 {% scalafiddle %}
 ```tut
@@ -287,7 +287,7 @@ trait Greeter {
 }
 ```
 
-También puedes extender traits con la palabra clave `extends` y sobrescribir una implementación con la palabra clave `override`.
+Un `trait` también puede extender otros traits, usando la palabra clave `extends`. Asimismo, en un `trait` se puede redefinir la implementación de un método heredado, usando la palabra reservada `override`.
 
 ```tut
 class DefaultGreeter extends Greeter

From e70979eafa06e361b5353b6f91898c3fc80e1e72 Mon Sep 17 00:00:00 2001
From: Gabriel Claramunt <gabriel.claramunt@gmail.com>
Date: Mon, 6 May 2019 15:27:47 -0300
Subject: [PATCH 8/8] spellcheck

---
 _es/tour/basics.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/_es/tour/basics.md b/_es/tour/basics.md
index d472a60ddf..80977f061b 100644
--- a/_es/tour/basics.md
+++ b/_es/tour/basics.md
@@ -59,16 +59,16 @@ Los resultados con nombre, como `x` en el ejemplo, son llamados valores. Referen
 Los valores no pueden ser reasignados.
 
 ```tut:fail
-x = 3 // Producirá un error de compilación.
+x = 3  // This does not compile.
 ```
 
-Scala es capaz de inferir el tipo de un valor. Aun asi, también se puede indicar el tipo usando una anotación:
+Scala es capaz de inferir el tipo de un valor. Aun así, también se puede indicar el tipo usando una anotación:
 
 ```tut
 val x: Int = 1 + 1
 ```
 
-Noten como la declaración de tipo `Int` va después del identificador `x`. También necesitas un `:`.
+Nótese que la anotación del tipo `Int` sigue al identificador `x` de la variable, separado por dos puntos `:`.
 
 ## Variables
 
@@ -160,7 +160,7 @@ println(addThenMultiply(1, 2)(3)) // 9
 ```
 {% endscalafiddle %}
 
-O ninguna lista de parametros.
+O ninguna lista de parámetros.
 
 ```tut
 def name: String = System.getProperty("user.name")
@@ -277,7 +277,7 @@ trait Greeter {
 }
 ```
 
-Un `trait` también puede definit un método, o un valor, con una implementación por defecto.
+Un `trait` también puede definir un método, o un valor, con una implementación por defecto.
 
 {% scalafiddle %}
 ```tut