fix formatting and scalafiddle

Author: gclaramunt

_es/tour/basics.md

@@ -6,76 +6,95 @@ 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
 ```
 
 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,56 +107,64 @@ 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
 ```
 
 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
+{% 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,58 +173,58 @@ 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
 }
 ```
 
 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)
 ```
 
 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,39 +258,39 @@ 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
 }
 ```
 
 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!")