fixed next/previous links in es tutorials tour

devsdmf · devsdmf · commit 3a7476f72a24 · 2017-06-10T17:12:42.000-03:00
diff --git a/es/tutorials/tour/_posts/2017-02-13-abstract-types.md b/es/tutorials/tour/_posts/2017-02-13-abstract-types.md
@@ -9,6 +9,9 @@ categories: tour
 num: 2
 outof: 33
 language: es
+
+next-page: annotations
+previous-page: tour-of-scala
 ---
 
 En Scala, las cases son parametrizadas con valores (los parámetros de construcción) y con tipos (si las clases son [genéricas](generic-classes.html)). Por razones de consistencia, no es posible tener solo valores como miembros de objetos; tanto los tipos como los valores son miembros de objetos. Además, ambos tipos de miembros pueden ser concretos y abstractos.
diff --git a/es/tutorials/tour/_posts/2017-02-13-annotations.md b/es/tutorials/tour/_posts/2017-02-13-annotations.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 3
 language: es
+
+next-page: classes
+previous-page: abstract-types
 ---
 
 Las anotaciones sirven para asociar meta-información con definiciones.
diff --git a/es/tutorials/tour/_posts/2017-02-13-anonymous-function-syntax.md b/es/tutorials/tour/_posts/2017-02-13-anonymous-function-syntax.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 14
 language: es
+
+next-page: currying
+previous-page: nested-functions
 ---
 
 Scala provee una sintaxis relativamente livana para definir funciones anónimas. La siguiente expresión crea una función incrementadora para números enteros:
diff --git a/es/tutorials/tour/_posts/2017-02-13-automatic-closures.md b/es/tutorials/tour/_posts/2017-02-13-automatic-closures.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 16
 language: es
+
+next-page: operators
+previous-page: currying
 ---
 
 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").
diff --git a/es/tutorials/tour/_posts/2017-02-13-case-classes.md b/es/tutorials/tour/_posts/2017-02-13-case-classes.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 5
 language: es
+
+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).
diff --git a/es/tutorials/tour/_posts/2017-02-13-classes.md b/es/tutorials/tour/_posts/2017-02-13-classes.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 4
 language: es
+
+next-page: case-classes
+previous-page: annotations
 ---
 En Scala, las clases son plantillas estáticas que pueden ser instanciadas por muchos objetos en tiempo de ejecución.
 Aquí se presenta una clase la cual define la clase `Point`:
diff --git a/es/tutorials/tour/_posts/2017-02-13-compound-types.md b/es/tutorials/tour/_posts/2017-02-13-compound-types.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 6
 language: es
+
+next-page: sequence-comprehensions
+previous-page: case-classes
 ---
 
 Algunas veces es necesario expresar que el tipo de un objeto es un subtipo de varios otros tipos. En Scala esto puede ser expresado con la ayuda de *tipos compuestos*, los cuales pueden entenderse como la intersección de otros tipos.
diff --git a/es/tutorials/tour/_posts/2017-02-13-currying.md b/es/tutorials/tour/_posts/2017-02-13-currying.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 15
 language: es
+
+next-page: automatic-closures
+previous-page: anonymous-function-syntax
 ---
 
 _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._
diff --git a/es/tutorials/tour/_posts/2017-02-13-default-parameter-values.md b/es/tutorials/tour/_posts/2017-02-13-default-parameter-values.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 34
 language: es
+
+next-page: named-parameters
+previous-page: implicit-conversions
 ---
 
 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.
diff --git a/es/tutorials/tour/_posts/2017-02-13-explicitly-typed-self-references.md b/es/tutorials/tour/_posts/2017-02-13-explicitly-typed-self-references.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 27
 language: es
+
+next-page: local-type-inference
+previous-page: lower-type-bounds
 ---
 
 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.
diff --git a/es/tutorials/tour/_posts/2017-02-13-extractor-objects.md b/es/tutorials/tour/_posts/2017-02-13-extractor-objects.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 8
 language: es
+
+next-page: generic-classes
+previous-page: sequence-comprehensions
 ---
 
 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`
diff --git a/es/tutorials/tour/_posts/2017-02-13-generic-classes.md b/es/tutorials/tour/_posts/2017-02-13-generic-classes.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 9
 language: es
+
+next-page: implicit-parameters
+previous-page: extractor-objects
 ---
 
 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.
diff --git a/es/tutorials/tour/_posts/2017-02-13-higher-order-functions.md b/es/tutorials/tour/_posts/2017-02-13-higher-order-functions.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 18
 language: es
+
+next-page: pattern-matching
+previous-page: operators
 ---
 
 Scala permite la definición de funciones de orden superior. Estas funciones son las que _toman otras funciones como parámetros_, o las cuales _el resultado es una función_. Aquí mostramos una función `apply` la cual toma otra función `f` y un valor `v` como parámetros y aplica la función `f` a `v`:
diff --git a/es/tutorials/tour/_posts/2017-02-13-implicit-conversions.md b/es/tutorials/tour/_posts/2017-02-13-implicit-conversions.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 32
 language: es
+
+next-page: default-parameter-values
+previous-page: variances
 ---
 
 (this page has not been translated into Spanish)
diff --git a/es/tutorials/tour/_posts/2017-02-13-implicit-parameters.md b/es/tutorials/tour/_posts/2017-02-13-implicit-parameters.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 10
 language: es
+
+next-page: inner-classes
+previous-page: generic-classes
 ---
 
 Un método con _parámetros implícitos_ puede ser aplicado a argumentos tal como un método normal. En este caso la etiqueta `implicit` no tiene efecto. De todas maneras, si a un método le faltan argumentos para sus parámetros implícitos, tales argumentos serán automáticamente provistos.
diff --git a/es/tutorials/tour/_posts/2017-02-13-inner-classes.md b/es/tutorials/tour/_posts/2017-02-13-inner-classes.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 11
 language: es
+
+next-page: mixin-class-composition
+previous-page: implicit-parameters
 ---
 
 En Scala es posible que las clases tengan como miembro otras clases. A diferencia de lenguajes similares a Java donde ese tipo de clases internas son miembros de las clases que las envuelven, en Scala esas clases internas están ligadas al objeto externo. Para ilustrar esta diferencia, vamos a mostrar rápidamente una implementación del tipo grafo:
diff --git a/es/tutorials/tour/_posts/2017-02-13-local-type-inference.md b/es/tutorials/tour/_posts/2017-02-13-local-type-inference.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 29
 language: es
+
+next-page: unified-types
+previous-page: explicitly-typed-self-references
 ---
 
 Scala tiene incorporado un mecanismo de inferencia de tipos el cual permite al programador omitir ciertos tipos de anotaciones. Por ejemplo, generalmente no es necesario especificar el tipo de una variable, ya que el compilador puede deducir el tipo mediante la expresión de inicialización de la variable. También puede generalmente omitirse los tipos de retorno de métodos ya que se corresponden con el tipo del cuerpo, que es inferido por el compilador. 
diff --git a/es/tutorials/tour/_posts/2017-02-13-lower-type-bounds.md b/es/tutorials/tour/_posts/2017-02-13-lower-type-bounds.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 26
 language: es
+
+next-page: explicitly-typed-self-references
+previous-page: upper-type-bounds
 ---
 
 Mientras que los [límites de tipado superior](upper-type-bounds.html) limitan el tipo de un subtipo de otro tipo, los *límites de tipado inferior* declaran que un tipo sea un supertipo de otro tipo. El término `T >: A` expresa que el parámetro de tipo `T` o el tipo abstracto `T` se refiera a un supertipo del tipo `A`
diff --git a/es/tutorials/tour/_posts/2017-02-13-mixin-class-composition.md b/es/tutorials/tour/_posts/2017-02-13-mixin-class-composition.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 12
 language: es
+
+next-page: singleton-objects
+previous-page: inner-classes
 ---
 _Nota de traducción: La palabra `mixin` puede ser traducida como mezcla, dando título a esta sección de: Composición de clases Mezcla, pero es preferible utilizar la notación original_
 
diff --git a/es/tutorials/tour/_posts/2017-02-13-named-parameters.md b/es/tutorials/tour/_posts/2017-02-13-named-parameters.md
@@ -8,6 +8,8 @@ tutorial: scala-tour
 categories: tour
 num: 35
 language: es
+
+previous-page: default-parameter-values
 ---
 
 En la invocación de métodos y funciones se puede usar el nombre de las variables explícitamente en la llamada, de la siguiente manera:
diff --git a/es/tutorials/tour/_posts/2017-02-13-nested-functions.md b/es/tutorials/tour/_posts/2017-02-13-nested-functions.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 13
 language: es
+
+next-page: anonymous-function-syntax
+previous-page: singleton-objects
 ---
 
 En scala es posible anidar definiciones de funciones. El siguiente objeto provee una función `filter` para extraer valores de una lista de enteros que están por debajo de un valor determinado:
diff --git a/es/tutorials/tour/_posts/2017-02-13-operators.md b/es/tutorials/tour/_posts/2017-02-13-operators.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 17
 language: es
+
+next-page: higher-order-functions
+previous-page: automatic-closures
 ---
 
 En Scala, cualquier método el cual reciba un solo parámetro puede ser usado como un *operador de infijo (infix)*. Aquí se muestra la definición de la clase `MyBool`, la cual define tres métodos `and`, `or`, y `negate`.
diff --git a/es/tutorials/tour/_posts/2017-02-13-pattern-matching.md b/es/tutorials/tour/_posts/2017-02-13-pattern-matching.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 20
 language: es
+
+next-page: polymorphic-methods
+previous-page: higher-order-functions
 ---
 
 _Nota de traducción: Es dificil encontrar en nuestro idioma una palabra que se relacione directamente con el significado de `match` en inglés. Podemos entender a `match` como "coincidir" o "concordar" con algo. En algunos lugares se utiliza la palabra `machear`, aunque esta no existe en nuestro idioma con el sentido que se le da en este texto, sino que se utiliza como traducción de `match`._
diff --git a/es/tutorials/tour/_posts/2017-02-13-polymorphic-methods.md b/es/tutorials/tour/_posts/2017-02-13-polymorphic-methods.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 21
 language: es
+
+next-page: regular-expression-patterns
+previous-page: pattern-matching
 ---
 
 Los métodos en Scala pueden ser parametrizados tanto con valores como con tipos. Como a nivel de clase, parámetros de valores son encerrados en un par de paréntesis, mientras que los parámetros de tipo son declarados dentro de un par de corchetes.
diff --git a/es/tutorials/tour/_posts/2017-02-13-regular-expression-patterns.md b/es/tutorials/tour/_posts/2017-02-13-regular-expression-patterns.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 22
 language: es
+
+next-page: traits
+previous-page: polymorphic-methods
 ---
 
 ## Patrones de secuencias que ignoran a la derecha ##
diff --git a/es/tutorials/tour/_posts/2017-02-13-sequence-comprehensions.md b/es/tutorials/tour/_posts/2017-02-13-sequence-comprehensions.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 7
 language: es
+
+next-page: extractor-objects
+previous-page: compound-types
 ---
 
 Scala cuenta con una notación ligera para expresar *sequencias por comprensión* (*sequence comprehensions*). Las comprensiones tienen la forma `for (enumeradores) yield e`, donde `enumeradores` se refiere a una lista de enumeradores separados por el símbolo punto y coma (;). Un *enumerador* puede ser tanto un generador el cual introduce nuevas variables, o un filtro. La comprensión evalúa el cuerpo `e` por cada paso (o ciclo) generado por los enumeradores y retorna una secuencia de estos valores.
diff --git a/es/tutorials/tour/_posts/2017-02-13-singleton-objects.md b/es/tutorials/tour/_posts/2017-02-13-singleton-objects.md
@@ -8,8 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 12
 language: es
-next-page: regular-expression-patterns
-previous-page: pattern-matching
+
+next-page: nested-functions
+previous-page: mixin-class-composition
 ---
 
 Métodos y valores que no están asociados con instancias individuales de una [clase](classes.html) se denominan *objetos singleton* y se denotan con la palabra reservada `object` en vez de `class`.
diff --git a/es/tutorials/tour/_posts/2017-02-13-tour-of-scala.md b/es/tutorials/tour/_posts/2017-02-13-tour-of-scala.md
@@ -8,6 +8,8 @@ tutorial: scala-tour
 categories: tour
 num: 1
 language: es
+
+next-page: abstract-types
 ---
 
 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.
diff --git a/es/tutorials/tour/_posts/2017-02-13-traits.md b/es/tutorials/tour/_posts/2017-02-13-traits.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 24
 language: es
+
+next-page: upper-type-bounds
+previous-page: regular-expression-patterns
 ---
 
 _Nota de traducción: La palabra `trait` en inglés puede traducirse literalmente como `rasgo` o `caracteristica`. Preferimos la designación original trait por ser una característica muy natural de Scala._
diff --git a/es/tutorials/tour/_posts/2017-02-13-unified-types.md b/es/tutorials/tour/_posts/2017-02-13-unified-types.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 30
 language: es
+
+next-page: variances
+previous-page: local-type-inference
 ---
 
 A diferencia de Java, todos los valores en Scala son objetos (incluyendo valores numéricos y funciones). Dado que Scala está basado en clases, todos los valores son instancias de una clase. El diagrama siguiente ilustra esta jerarquía de clases:
diff --git a/es/tutorials/tour/_posts/2017-02-13-upper-type-bounds.md b/es/tutorials/tour/_posts/2017-02-13-upper-type-bounds.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 25
 language: es
+
+next-page: lower-type-bounds
+previous-page: traits
 ---
 
 En Scala, los [parámetros de tipo](generic-classes.html) y los [tipos abstractos](abstract-types.html) pueden ser restringidos por un límite de tipado. Tales límites de tipado limitan los valores concretos de las variables de tipo y posiblemente revelan más información acerca de los miembros de tales tipos. Un _límite de tipado superior_ `T <: A` declara que la variable de tipo `T` es un subtipo del tipo `A`.
diff --git a/es/tutorials/tour/_posts/2017-02-13-variances.md b/es/tutorials/tour/_posts/2017-02-13-variances.md
@@ -8,6 +8,9 @@ tutorial: scala-tour
 categories: tour
 num: 31
 language: es
+
+next-page: implicit-conversions
+previous-page: unified-types
 ---
 
 Scala soporta anotaciones de varianza para parámetros de tipo para [clases genéricas](generic-classes.html). A diferencia de Java 5 ([JDK 1.5](http://java.sun.com/j2se/1.5/)), las anotaciones de varianza pueden ser agregadas cuando una abstracción de clase es definidia, mientras que en Java 5, las anotaciones de varianza son dadas por los clientes cuando una albstracción de clase es usada.
