Fixes spanish typos and translation errors

es/tutorials/tour/abstract-types.md

@@ -65,4 +65,4 @@ Es necesario notar que generalmente es posible transformar un tipo abstracto en
       println("content = " + buf.element)
     }
 
-Nótese que es debido usar [variance annotations](variances.html) aquí; de otra manera no sería posible ocultar el tipo implementado por la secuencia concreta del objeto retornado por `newIntSeqBuf`. Además, existen casos en los cuales no es posible remplazar tipos abstractos con tipos parametrizados.
+Nótese que es necesario usar [variance annotations](variances.html) aquí; de otra manera no sería posible ocultar el tipo implementado por la secuencia concreta del objeto retornado por `newIntSeqBuf`. Además, existen casos en los cuales no es posible remplazar tipos abstractos con tipos parametrizados.

es/tutorials/tour/annotations.md

@@ -88,7 +88,7 @@ Y después utilizarlo de la siguiente manera
             mail = "support@coders.com")
     public class MyClass extends HisClass ...
 
-Una anotación en Scala aparenta como una invocación a un constructor. Para instanciar una anotación de Java es necesario usar los argumentos nombrados:
+Una anotación en Scala se asemeja a una invocación a un constructor. Para instanciar una anotación de Java es necesario usar los argumentos nombrados:
 
     @Source(URL = "http://coders.com/",
             mail = "support@coders.com")

es/tutorials/tour/anonymous-function-syntax.md

@@ -27,7 +27,7 @@ o sin parámetros:
 
     () => { System.getProperty("user.dir") }
 
-Esiste también una forma simple para escribir los tipos de las funciones. A continuación se muestran los tipos de las tre funciones escritas anteriormente:
+Existe también una forma simple para escribir los tipos de las funciones. A continuación se muestran los tipos de las trés funciones escritas anteriormente:
 
     Int => Int
     (Int, Int) => String

es/tutorials/tour/automatic-closures.md

@@ -9,7 +9,7 @@ num: 16
 language: es
 ---
 
-Scala permite pasar a un método como parámetro funciones que no reciban parámetros. Cuando un método así es invocado, los parámetros reales de la función enviada sin parámetros no son evaluados y una función "nularia" (de aridad creo, 0-aria, o sin parámetros) es pasada en su llugar la cual encapsula el comportamiento del parámetro correspondiente (comunmente conocido como "llamada por nombre").
+Scala permite pasar funciones sin parámetros como parámetros de un método. Cuando un método así es invocado, los parámetros reales de la función enviada sin parámetros no son evaluados y una función "nularia" (de aridad cero, 0-aria, o sin parámetros) es pasada en su lugar. Esta función encapsula el comportamiento del parámetro correspondiente (comunmente conocido como "llamada por nombre").
 
 Para aclarar un poco esto aquí se muestra un ejemplo:
 
@@ -26,9 +26,9 @@ Para aclarar un poco esto aquí se muestra un ejemplo:
       }
     }
 
-La función `whileLoop` recibe dos parámetros `cond` y `body`. Cuando la función es llamada, los parámetros reales no son evaluados en ese momento. Pero cuando los parámetros son utilizados en el cuerpo de la función `whileLoop`, las funciones nularias creadas implicitamente serán evaluadas en su lugar. Así, nuestro método `whileLoop` implementa un bucle tipo Java mediante una implementación recursiva.
+La función `whileLoop` recibe dos parámetros `cond` y `body`. Cuando la función es llamada, los parámetros reales no son evaluados en ese momento. Pero cuando los parámetros son utilizados en el cuerpo de la función `whileLoop`, las funciones nularias creadas implícitamente serán evaluadas en su lugar. Así, nuestro método `whileLoop` implementa un bucle tipo Java mediante una implementación recursiva.
 
-Es posible combinar el uso de [operadores de infijo y postfijo (infix/postfix)](operators.html) con este mecanismo para crear declaraciones más complejas (con una sintaxis agrdadable).
+Es posible combinar el uso de [operadores de infijo y postfijo (infix/postfix)](operators.html) con este mecanismo para crear declaraciones más complejas (con una sintaxis agradadable).
 
 Aquí mostramos la implementación de una declaración tipo repetir-a-menos-que (repetir el bucle a no ser que se cumpla X condición):
 
@@ -48,7 +48,7 @@ Aquí mostramos la implementación de una declaración tipo repetir-a-menos-que
       } unless (i == 0)
     }
 
-La función `loop` solo acepta el cuerpo de un bucle y retorna una instancia de la clase `LoopUnlessCond` (la cual encapsula el cuerpo del objeto). Es importante notar que en este punto el cuerpo del bucle no ha sido evaluado aun. La clase `LoopUnlessCond` tiene un método `unless` el cual puede ser usado como un *operador de infijo (infix)*. De esta manera podemos lograr una sintaxis muy natural para nuestro nuevo bucle `repetir { <estas declaraciones> a_menos_que ( <condición>)`.
+La función `loop` solo acepta el cuerpo de un bucle y retorna una instancia de la clase `LoopUnlessCond` (la cual encapsula el cuerpo del objeto). Es importante notar que en este punto el cuerpo del bucle no ha sido evaluado aún. La clase `LoopUnlessCond` tiene un método `unless` el cual puede ser usado como un *operador de infijo (infix)*. De esta manera podemos lograr una sintaxis muy natural para nuestro nuevo bucle `repetir { <estas declaraciones> a_menos_que ( <condición>)`.
 
 A continuación se expone el resultado de la ejecución de `TargetTest2`:
 

es/tutorials/tour/case-classes.md

@@ -42,7 +42,7 @@ imprime
     Var(x) == Var(x) => true
     Var(x) == Var(y) => false
 
-Solo tiene sentido definir una clase Case si el reconocimiento de patrones es usado para descomponer la estructura de los datos de la clase. El siguiente objeto define define una linda función que imprime en pantalla nuestra representación del cálculo lambda:
+Solo tiene sentido definir una clase Case si el reconocimiento de patrones es usado para descomponer la estructura de los datos de la clase. El siguiente objeto define define una función de impresión `elegante` (en inglés `pretty`) que imprime en pantalla nuestra representación del cálculo lambda:
 
     object TermTest extends scala.App {
       def printTerm(term: Term) {

es/tutorials/tour/classes.md

@@ -21,11 +21,11 @@ Aquí se presenta una clase la cual define la clase `Point`:
       override def toString(): String = "(" + x + ", " + y + ")";
     }
 
-Esta clase define dos variables `x` e `y`, y dos métodos: `move` y `toString`. El método `move` recibe dos argumentos de tipo entero, pero no retorna ningún valor (implicitamente se retorna el tipo `Unit`, el cual se corresponde a `void` en lenguajes tipo Java). `toString`, por otro lado, no recibe ningún parámetro pero retorna un valor tipo `String`. Ya que `toString` sobreescribe el método `toString` predefinido en una superclase, tiene que ser anotado con `override`.
+Esta clase define dos variables `x` e `y`, y dos métodos: `move` y `toString`. El método `move` recibe dos argumentos de tipo entero, pero no retorna ningún valor (implícitamente se retorna el tipo `Unit`, el cual se corresponde a `void` en lenguajes tipo Java). `toString`, por otro lado, no recibe ningún parámetro pero retorna un valor tipo `String`. Ya que `toString` sobreescribe el método `toString` predefinido en una superclase, tiene que ser anotado con `override`.
 
-Las clases en Scala son parametrizadas con argumentos constructores (inicializadores). En el código anterior se definen dos argumentos contructores, `xc` y `yc`; ambos son visibles en toda la clase. En nuestro ejemplo son utilizzados para inicializar las variables `x` e `y`.
+Las clases en Scala son parametrizadas con argumentos constructores (inicializadores). En el código anterior se definen dos argumentos contructores, `xc` y `yc`; ambos son visibles en toda la clase. En nuestro ejemplo son utilizados para inicializar las variables `x` e `y`.
 
-Para instanciar una clase es necesario usar la primitiva new, como se muestra en el siguiente ejemplo:
+Para instanciar una clase es necesario usar la primitiva `new`, como se muestra en el siguiente ejemplo:
 
     object Classes {
       def main(args: Array[String]) {
@@ -36,7 +36,7 @@ Para instanciar una clase es necesario usar la primitiva new, como se muestra en
       }
     }
 
-El programa define una aplicación ejecutable a través del método `main` del objeto singleton Classes. El método `main` crea un nuevo `Point` y lo almacena en `pt`. _Note que valores definidos con la signatura `val` son distintos de los definidos con `var` (véase la clase `Point` arriba) ya que los primeros (`val`) no permiten reasignaciones; es decir, que el valor es una constante._
+El programa define una aplicación ejecutable a través del método `main` del objeto singleton `Classes`. El método `main` crea un nuevo `Point` y lo almacena en `pt`. _Note que valores definidos con la signatura `val` son distintos de los definidos con `var` (véase la clase `Point` arriba) ya que los primeros (`val`) no permiten reasignaciones; es decir, que el valor es una constante._
 
 Aquí se muestra la salida del programa:
 

es/tutorials/tour/compound-types.md

@@ -30,7 +30,7 @@ Ahora suponga que queremos escribir una función `cloneAndReset` la cual recibe
       cloned
     }
 
-La pregunta que surge es cuál es el tipo del parámetro `obj`. Si este fuera `Cloneable` entonces el objeto puede ser clonado mediante el método `clone`, pero no puede usarse el método `reset`; Si fuera `Resetable` podríamos resetearlo mediante el método `reset`, pero no sería posible clonarlo. Para evitar casteos (refundiciones) de tipos en situaciones como la descripta, podemos especificar que el tipo del objeto `obj` sea tanto `Clonable` como `Resetable`. En tal caso estaríamos creando un tipo compuesto; de la siguiente manera:
+La pregunta que surge es cuál es el tipo del parámetro `obj`. Si este fuera `Cloneable` entonces el objeto puede ser clonado mediante el método `clone`, pero no puede usarse el método `reset`; Si fuera `Resetable` podríamos resetearlo mediante el método `reset`, pero no sería posible clonarlo. Para evitar casteos (refundiciones, en inglés `casting`) de tipos en situaciones como la descrita, podemos especificar que el tipo del objeto `obj` sea tanto `Clonable` como `Resetable`. En tal caso estaríamos creando un tipo compuesto; de la siguiente manera:
 
     def cloneAndReset(obj: Cloneable with Resetable): Cloneable = {
       //...

es/tutorials/tour/currying.md

@@ -11,7 +11,7 @@ language: es
 
 _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._
 
-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.
+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:
 

es/tutorials/tour/default-parameter-values.md

@@ -9,9 +9,9 @@ num: 34
 language: es
 ---
 
-Scala tiene la capacidad de de dar a los parámetros valores por defecto que pueden ser usados para permitir a quien invoca el método o función que omita dichos parámetros.
+Scala tiene la capacidad de dar a los parámetros valores por defecto que pueden ser usados para permitir a quien invoca el método o función que omita dichos parámetros.
 
-En Java, uno tiende a ver muchos métodos sobrecargados que solamente sirven para proveer valores por defecto para ciertos parámetros de un método largo. En especial se ve este comportamiento en contstructores:
+En Java, uno tiende a ver muchos métodos sobrecargados que solamente sirven para proveer valores por defecto para ciertos parámetros de un método largo. En especial se ve este comportamiento en constructores:
 
     public class HashMap<K,V> {
       public HashMap(Map<? extends K,? extends V> m);
@@ -24,9 +24,9 @@ En Java, uno tiende a ver muchos métodos sobrecargados que solamente sirven par
       public HashMap(int initialCapacity, float loadFactor);
     }
 
-Existen realmente dos constructores aquí; uno que toma otro mapa y uno que toma una capacidad y un factor de carga. El tercer y cuarto constructores están ahí para premitir a los usuarios de la clase <code>HashMap</code> crear instancias con el valor por defecto que probablemente sea el mejor para ambos, el factor de carga y la capacidad.
+Existen realmente dos constructores aquí; uno que toma otro mapa y uno que toma una capacidad y un factor de carga. Los constructores tercero y cuarto están ahí para premitir a los usuarios de la clase <code>HashMap</code> crear instancias con el valor por defecto que probablemente sea el mejor para ambos, el factor de carga y la capacidad.
 
-Más problemático es que los valores usados para ser por defecto están tanto en la documentación (Javadoc) y en el código. Mantener esto actualizado es fácil de olvidar. Un típico patrón utilizado para no cometer estos errores es agregar constantes públicas cuyo valor será mostrado en el Javadoc:
+Más problemático es que los valores usados para ser por defecto están tanto en la documentación (Javadoc) como en el código. Mantener ambos actualizado es dificil. Un patrón típico utilizado para no cometer estos errores es agregar constantes públicas cuyo valor será mostrado en el Javadoc:
 
     public class HashMap<K,V> {
       public static final int DEFAULT_CAPACITY = 16;

es/tutorials/tour/explicitly-typed-self-references.md

@@ -9,7 +9,7 @@ num: 27
 language: es
 ---
 
-Cuando se está construyendo software extensible, algunas veces resulta útil declarar el tipo de la variable `this` explicitamente. Para motivar esto, realizaremos una pequeña representación de una estructura de datos Grafo, en Scala.
+Cuando se está construyendo software extensible, algunas veces resulta útil declarar el tipo de la variable `this` explícitamente. Para motivar esto, realizaremos una pequeña representación de una estructura de datos Grafo, en Scala.
 
 Aquí hay una definición que sirve para describir un grafo:
 
@@ -52,7 +52,9 @@ Una posible implementación de la clase `Grafo`es dada en el siguiente programa:
       }
     }
 
-La clase `GrafoDirigido` especializa la clase `Grafo` al proveer una implementación parcial. La implementación es solamente parcial, porque queremos que sea posible extender `GrafoDirigido` aun más. Por lo tanto, esta clase deja todos los detalles de implementación abiertos y así tanto los tipos vértice como nodo son abstractos.  De todas maneras, la clase `GrafoDirigido` revela algunos detalles adicionales sobre la implementación del tipo vértice al acotar el límite a la clase `VerticeImpl`. Además, tenemos algunas implementaciones preliminares de vértices y nodos representados por las clases `VerticeImpl` y `NodoImpl`. Ya que es necesario crear nuevos objetos nodo y vértice con nuestra implementación parcial del grafo, también debimos agregar los métodos constructores `nuevoNodo` y `nuevoVertice`. Los métodos `agregarNodo` y `conectarCon` están ambos definidos en términos de estos métodos constructores. Una mirada más cercana a la implementación del método `conectarCon` revela que para crear un vértice es necesario pasar la auto-referencia `this` al método constructor `newEdge`. Pero a `this` en ese contexto le es asignado el tipo `NodoImpl`, por lo tanto no es compatible con el tipo `Nodo` el cual es requerido por el correspondiente método constructor. Como consecuencia, el programa superior no está bien definido y compilador mostrará un mensaje de error.
+La clase `GrafoDirigido` especializa la clase `Grafo` al proveer una implementación parcial. La implementación es solamente parcial, porque queremos que sea posible extender `GrafoDirigido` aun más. Por lo tanto, esta clase deja todos los detalles de implementación abiertos y así tanto los tipos vértice como nodo son abstractos.  De todas maneras, la clase `GrafoDirigido` revela algunos detalles adicionales sobre la implementación del tipo vértice al acotar el límite a la clase `VerticeImpl`. Además, tenemos algunas implementaciones preliminares de vértices y nodos representados por las clases `VerticeImpl` y `NodoImpl`.
+
+Ya que es necesario crear nuevos objetos nodo y vértice con nuestra implementación parcial del grafo, también debimos agregar los métodos constructores `nuevoNodo` y `nuevoVertice`. Los métodos `agregarNodo` y `conectarCon` están ambos definidos en términos de estos métodos constructores. Una mirada más cercana a la implementación del método `conectarCon` revela que para crear un vértice es necesario pasar la auto-referencia `this` al método constructor `newEdge`. Pero a `this` en ese contexto le es asignado el tipo `NodoImpl`, por lo tanto no es compatible con el tipo `Nodo` el cual es requerido por el correspondiente método constructor. Como consecuencia, el programa superior no está bien definido y compilador mostrará un mensaje de error.
 
 En Scala es posible atar a una clase otro tipo (que será implementado en el futuro) al darle su propia auto-referencia `this` el otro tipo explicitamente. Podemos usar este mecanismo para arreglar nuestro código de arriba. El tipo the `this` explícito es especificado dentro del cuerpo de la clase `GrafoDirigido`.
 
@@ -71,7 +73,7 @@ Este es el progama arreglado:
       ...
     }
 
-En esta nueva definición de la clase `NodoImpl`, `this` tiene el tipo `Nodo`. Ya que `Nodo` es abstracta y por lo tanto todavía no sabemos si `NodoImpl` es realmente un subtipo de `Nodo`, el sistema de tipado de Scala no permitirá instanciar esta clase. Pero de todas maneras, estipulamos con esta anotación explicita de tipo que que en algún momento en el tiempo , una subclase de `NodeImpl` tiene que denotar un subtipo del tipo `Nodo` de forma de ser instanciable.
+En esta nueva definición de la clase `NodoImpl`, `this` tiene el tipo `Nodo`. Ya que `Nodo` es abstracta y por lo tanto todavía no sabemos si `NodoImpl` es realmente un subtipo de `Nodo`, el sistema de tipado de Scala no permitirá instanciar esta clase. Pero de todas maneras, estipulamos con esta anotación explicita de tipo que en algún momento en el tiempo, una subclase de `NodeImpl` tiene que denotar un subtipo del tipo `Nodo` de forma de ser instanciable.
 
 Aquí presentamos una especialización concreta de `GrafoDirigido` donde todos los miembros abstractos son definidos:
 

es/tutorials/tour/extractor-objects.md

@@ -9,7 +9,7 @@ num: 8
 language: es
 ---
 
-En Scala pueden ser definidos patrones independientemente de las clases Caso. Para este fin exite un método llamado `unapply` que proveera el ya dicho extractor. Por ejemplo, en el código siguiente se define el objeto extractor `Twice`
+En Scala pueden ser definidos patrones independientemente de las clases Caso (en inglés case classes, desde ahora clases Case). Para este fin exite un método llamado `unapply` que proveera el ya dicho extractor. Por ejemplo, en el código siguiente se define el objeto extractor `Twice`
 
     object Twice {
       def apply(x: Int): Int = x * 2

es/tutorials/tour/generic-classes.md

@@ -9,7 +9,7 @@ num: 9
 language: es
 ---
 
-Tal como en Java 5 ([JDK 1.5](http://java.sun.com/j2se/1.5/)), Scala provee soporte nativo para parametrizar clases con tipos. Eso es llamado clases genéricas y son especialmente importantes para el desarrollo de clases tipo colección.
+Tal como en Java 5 ([JDK 1.5](http://java.sun.com/j2se/1.5/)), Scala provee soporte nativo para clases parametrizados con tipos. Eso es llamado clases genéricas y son especialmente importantes para el desarrollo de clases tipo colección.
 
 A continuación se muestra un ejemplo: