Update CI to check for dead links

Gemfile

@@ -1,6 +1,6 @@
 source 'https://rubygems.org'
 gem 'jekyll-redirect-from'
-# gem 'html-proofer' # link-checking: bundle exec htmlproofer ./_site/ --only-4xx --empty-alt-ignore --allow-hash-href
+gem 'html-proofer'
 
 # group :jekyll_plugins do
 #   gem 'hawkins'

Gemfile.lock

@@ -1,11 +1,31 @@
 GEM
   remote: https://rubygems.org/
   specs:
+    activesupport (5.1.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
     addressable (2.5.1)
       public_suffix (~> 2.0, >= 2.0.2)
     colorator (1.1.0)
+    colorize (0.8.1)
+    concurrent-ruby (1.0.5)
+    ethon (0.11.0)
+      ffi (>= 1.3.0)
     ffi (1.9.18)
     forwardable-extended (2.6.0)
+    html-proofer (3.7.5)
+      activesupport (>= 4.2, < 6.0)
+      addressable (~> 2.3)
+      colorize (~> 0.8)
+      mercenary (~> 0.3.2)
+      nokogiri (~> 1.7)
+      parallel (~> 1.3)
+      typhoeus (~> 0.7)
+      yell (~> 2.0)
+    i18n (0.9.1)
+      concurrent-ruby (~> 1.0)
     jekyll (3.5.1)
       addressable (~> 2.4)
       colorator (~> 1.0)
@@ -29,6 +49,11 @@ GEM
       rb-fsevent (~> 0.9, >= 0.9.4)
       rb-inotify (~> 0.9, >= 0.9.7)
     mercenary (0.3.6)
+    mini_portile2 (2.3.0)
+    minitest (5.10.3)
+    nokogiri (1.8.1)
+      mini_portile2 (~> 2.3.0)
+    parallel (1.12.0)
     pathutil (0.14.0)
       forwardable-extended (~> 2.6)
     public_suffix (2.0.5)
@@ -42,12 +67,19 @@ GEM
     sass-listen (4.0.0)
       rb-fsevent (~> 0.9, >= 0.9.4)
       rb-inotify (~> 0.9, >= 0.9.7)
+    thread_safe (0.3.6)
+    typhoeus (0.8.0)
+      ethon (>= 0.8.0)
+    tzinfo (1.2.4)
+      thread_safe (~> 0.1)
+    yell (2.0.7)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  html-proofer
   jekyll-redirect-from
 
 BUNDLED WITH
-   1.15.4
+   1.16.0

_ba/tour/automatic-closures.md

@@ -0,0 +1,10 @@
+---
+layout: tour
+title: Automatic Type-Dependent Closure Construction
+
+discourse: false
+
+partof: scala-tour
+
+language: ba
+---

_ba/tour/tour-of-scala.md

@@ -20,39 +20,39 @@ Scala elegantno objedinjuje mogućnosti objektno orijentisanih i funkcionalnih j
 ## Scala je objektno orijentisana ##
 Scala je čisto objektno orijentisan jezik u smislu da je [svaka vrijednost objekt](unified-types.html).
 Tipovi i ponašanja objekata se opisuju kroz [klase](classes.html) i [trejtove](traits.html).
-Klase se proširuju nasljeđivanjem i fleksibilnim mehanizmom [kompozicije mixina](mixin-class-composition.html) 
+Klase se proširuju nasljeđivanjem i fleksibilnim mehanizmom [kompozicije mixina](mixin-class-composition.html)
 kao čistom zamjenom za višestruko nasljeđivanje.
 
 ## Scala je funkcionalna ##
 Scala je također funkcionalni jezik u smislu da je [svaka funkcija vrijednost](unified-types.html).
-Scala ima [lahku sintaksu](anonymous-function-syntax.html) za definisanje anonimnih funkcija,
+Scala ima lahku sintaksu za definisanje anonimnih funkcija,
 i podržava [funkcije višeg reda](higher-order-functions.html), omogućuje [ugnježdavanje funkcija](nested-functions.html),
 i podržava [curry-jevanje](currying.html).
 Scaline [case klase](case-classes.html) i njen mehanizam [podudaranja uzoraka](pattern-matching.html) modeluju algebarske tipove
 koji se koriste u dosta funkcionalnih programskih jezika.
 [Singlton objekti](singleton-objects.html) omogućuju pogodan način za grupisanje funkcija koje nisu članovi klase.
 
-Nadalje, Scalin mehanizam podudaranja uzoraka (pattern-matching) prirodno podržava [procesiranje XML podataka](xml-processing.html) 
-pomoću [desno-ignorišućih uzoraka sekvenci](regular-expression-patterns.html), 
+Nadalje, Scalin mehanizam podudaranja uzoraka (pattern-matching) prirodno podržava procesiranje XML podataka
+pomoću [desno-ignorišućih uzoraka sekvenci](regular-expression-patterns.html),
 i generalnim proširivanjem s [ekstraktor objektima](extractor-objects.html).
-U ovom kontekstu, [komprehensije sekvenci](sequence-comprehensions.html) su korisne za izražavanje upita (query).
+U ovom kontekstu, komprehensije sekvenci su korisne za izražavanje upita (query).
 Ove mogućnosti čine Scalu idealnom za razvijanje aplikacija kao što su web servisi.
 
 ## Scala je statički tipizirana (statically typed) ##
-Scala je opremljena ekspresivnim sistemom tipova koji primorava da se apstrakcije koriste na bezbjedan i smislen način. 
+Scala je opremljena ekspresivnim sistemom tipova koji primorava da se apstrakcije koriste na bezbjedan i smislen način.
 Konkretno, sistem tipova podržava sljedeće:
 
 * [generičke klase](generic-classes.html)
 * [anotacije varijanse](variances.html)
 * [gornje](upper-type-bounds.html) i [donje](lower-type-bounds.html) granice tipa,
 * [unutarnje klase](inner-classes.html) i [apstraktne tipove](abstract-types.html) kao članove objekta
 * [složene tipove](compound-types.html)
-* [eksplicitno tipizirane samo-reference](explicitly-typed-self-references.html)
+* [eksplicitno tipizirane samo-reference](self-types.html)
 * implicitne [parametre](implicit-parameters.html) i [konverzije](implicit-conversions.html)
 * [polimorfne metode](polymorphic-methods.html)
 
 Mehanizam za [lokalno zaključivanje tipova](local-type-inference.html) se brine da korisnik ne mora pisati tipove varijabli
-više nego što je potrebno. 
+više nego što je potrebno.
 U kombinaciji, ove mogućnosti su jaka podloga za bezbjedno ponovno iskorištenje programskih apstrakcija
 i za tipski bezbjedno proširenje softvera.
 
@@ -65,10 +65,10 @@ jezičkih konstrukcija u formi biblioteka.
 Zajedničkom upotrebom obje mogućnosti olakšava definisanje novih izraza bez proširenja sintakse samog Scala jezika i bez
 korištenja olakšica u vidu macro-a ili meta-programiranja.
 
-Scala je dizajnirana za interoperabilnost s popularnim Java Runtime Environment (JRE). 
-Konkretno, interakcija s popularnim objektno orijentisanim Java programskim jezikom je prirodna. 
+Scala je dizajnirana za interoperabilnost s popularnim Java Runtime Environment (JRE).
+Konkretno, interakcija s popularnim objektno orijentisanim Java programskim jezikom je prirodna.
 Novije mogućnosti Jave kao [anotacije](annotations.html) i Javini generički tipovi imaju direktnu analogiju u Scali.
-Scaline mogućnosti bez analogija u Javi, kao što su [podrazumijevani](default-parameter-values.html) i [imenovani parametri](named-parameters.html), 
+Scaline mogućnosti bez analogija u Javi, kao što su [podrazumijevani](default-parameter-values.html) i [imenovani parametri](named-arguments.html),
 se kompajliraju što približnije Javi.
 Scala ima isti kompilacijski model (posebno kompajliranje, dinamičko učitavanje klasa)
 kao Java i time omogućuje pristupanje hiljadama postojećih visoko kvalitetnih biblioteka.

_books/2-scala-for-the-impatient.md

@@ -5,7 +5,6 @@ image: /resources/img/books/scala_for_the_impatient.png
 status: Available Now
 authors: ["Cay S. Horstmann"]
 publisher: Addison-Wesley
-publisherLink: https://heuk.pearson.com/about-us.html/Addison-Wesley/
 ---
 
 What you get:

_es/overviews/parallel-collections/concrete-parallel-collections.md

@@ -24,7 +24,7 @@ Una secuencia [ParArray](http://www.scala-lang.org/api/{{ site.scala-version }}/
     scala> pa map (x => (x - 1) / 2)
     res1: scala.collection.parallel.mutable.ParArray[Int] = ParArray(0, 1, 2, 3, 4, 5, 6, 7,...
 
-Internamente, para partir el array para que sea procesado de forma paralela se utilizan [splitters]({{ site.baseurl }}/es/overviews/parallel-collections/architecture.html#core_abstractions) (o "partidores"). El Splitter parte y crea dos nuevos splitters con sus índices actualizados. A continuación son utilizados los [combiners]({{ site.baseurl }}/es/overviews/parallel-collections/architecture.html#core_abstractions) (o "combinadores"), que necesitan un poco más de trabajo. Ya que en la mayoría de los métodos transformadores (ej: `flatMap`, `filter`, `takeWhile`, etc.) previamente no es sabido la cantidad de elementos (y por ende, el tamaño del array), cada combiner es esencialmente una variante de un array buffer con un tiempo constante de la operación `+=`. Diferentes procesadores añaden elementos a combiners de arrays separados, que después son combinados al encadenar sus arrays internos. El array subyacente se crea en memoria y se rellenan sus elementos después que el número total de elementos es conocido. Por esta razón, los métodos transformadores son un poco más caros que los métodos de acceso. También, nótese que la asignación de memoria final procede secuencialmente en la JVM, lo que representa un cuello de botella si la operación de mapeo (el método transformador aplicado) es en sí económico (en términos de procesamiento).
+Internamente, para partir el array para que sea procesado de forma paralela se utilizan [splitters]({{ site.baseurl }}/es/overviews/parallel-collections/architecture.html) (o "partidores"). El Splitter parte y crea dos nuevos splitters con sus índices actualizados. A continuación son utilizados los [combiners]({{ site.baseurl }}/es/overviews/parallel-collections/architecture.html) (o "combinadores"), que necesitan un poco más de trabajo. Ya que en la mayoría de los métodos transformadores (ej: `flatMap`, `filter`, `takeWhile`, etc.) previamente no es sabido la cantidad de elementos (y por ende, el tamaño del array), cada combiner es esencialmente una variante de un array buffer con un tiempo constante de la operación `+=`. Diferentes procesadores añaden elementos a combiners de arrays separados, que después son combinados al encadenar sus arrays internos. El array subyacente se crea en memoria y se rellenan sus elementos después que el número total de elementos es conocido. Por esta razón, los métodos transformadores son un poco más caros que los métodos de acceso. También, nótese que la asignación de memoria final procede secuencialmente en la JVM, lo que representa un cuello de botella si la operación de mapeo (el método transformador aplicado) es en sí económico (en términos de procesamiento).
 
 Al invocar el método `seq`, los arrays paralelos son convertidos al tipo de colección `ArraySeq`, que vendría a ser la contraparte secuencial del `ParArray`. Esta conversión es eficiente, y el `ArraySeq` utiliza a bajo nivel el mismo array que había sido obtenido por el array paralelo.
 
@@ -53,7 +53,7 @@ Un [ParRange](http://www.scala-lang.org/api/{{ site.scala-version }}/scala/colle
     scala> 15 to 5 by -2 par
     res1: scala.collection.parallel.immutable.ParRange = ParRange(15, 13, 11, 9, 7, 5)
 
-Tal como los rangos secuenciales no tienen constructores, los rangos paralelos no tienen [combiner]({{ site.baseurl }}/overviews/parallel-collections/architecture.html#core_abstractions)s. Mapear elementos de un rango paralelo produce un vector paralelo. Los rangos secuenciales y paralelos pueden ser convertidos de uno a otro utilizando los métodos `seq` y `par`.
+Tal como los rangos secuenciales no tienen constructores, los rangos paralelos no tienen [combiner]({{ site.baseurl }}/overviews/parallel-collections/architecture.html)s. Mapear elementos de un rango paralelo produce un vector paralelo. Los rangos secuenciales y paralelos pueden ser convertidos de uno a otro utilizando los métodos `seq` y `par`.
 
     scala> (1 to 5 par) map ((x) => x * 2)
     res2: scala.collection.parallel.immutable.ParSeq[Int] = ParVector(2, 4, 6, 8, 10)
@@ -85,7 +85,7 @@ y
     scala> phs map { x => x * x } sum
     res0: Int = 332833500
 
-De forma similar a las tablas hash paralelas, los [combiners]({{ site.baseurl }}/overviews/parallel-collections/architecture.html#core_abstractions) de los hash tries paralelos pre-ordenan los elementos en posiciones y construyen el hash trie resultante en paralelo al asignarle distintos grupos de posiciones a diferentes procesadores, los cuales contruyen los sub-tries independientemente.
+De forma similar a las tablas hash paralelas, los [combiners]({{ site.baseurl }}/overviews/parallel-collections/architecture.html) de los hash tries paralelos pre-ordenan los elementos en posiciones y construyen el hash trie resultante en paralelo al asignarle distintos grupos de posiciones a diferentes procesadores, los cuales contruyen los sub-tries independientemente.
 
 Los hash tries paralelos pueden ser convertidos hacia y desde hash tries secuenciales por medio de los métodos `seq` y `par`.
 
@@ -114,7 +114,7 @@ Un [concurrent.TrieMap](http://www.scala-lang.org/api/{{ site.scala-version }}/s
     ...
 
 
-Para ofrecer más detalles de lo que sucede bajo la superficie, los [Combiners]({{ site.baseurl }}/overviews/parallel-collections/architecture.html#core_abstractions) son implementados como `TrieMap`s --ya que esta es una estructura de datos concurrente, solo un combiner es construido para todo la invocación al método transformador y compartido por todos los procesadores.
+Para ofrecer más detalles de lo que sucede bajo la superficie, los [Combiners]({{ site.baseurl }}/overviews/parallel-collections/architecture.html) son implementados como `TrieMap`s --ya que esta es una estructura de datos concurrente, solo un combiner es construido para todo la invocación al método transformador y compartido por todos los procesadores.
 
 Al igual que todas las colecciones paralelas mutables, `TrieMap`s y la versión paralela, `ParTrieMap`s obtenidas mediante los métodos `seq` o `par` subyacentemente comparten la misma estructura de almacenamiento, por lo tanto modificaciones en una es visible en la otra.
 

_es/overviews/parallel-collections/overview.md

@@ -53,7 +53,7 @@ executed in parallel.
 
 De forma de ilustrar la generalidad y utilidad de las colecciones paralelizadas, proveemos un conjunto de ejemplos de uso útiles, todos ellos siendo ejecutados en paralelo de forma totalmente transparente al usuario.
 
-_Nota:_ Algunos de los siguientes ejemplos operan en colecciones pequeñas, lo cual no es recomendado. Son provistos como ejemplo para ilustrar solamente el propósito. Como una regla heurística general, los incrementos en velocidad de ejecución comienzan a ser notados cuando el tamaño de la colección es lo suficientemente grande, tipicamente algunos cuantos miles de elementos. (Para más información en la relación entre tamaño de una coleccion paralelizada y su performance, por favor véase [appropriate subsection]({{ site.baseurl}}/es/overviews/parallel-collections/performance.html#how_big_should_a_collection_be_to_go_parallel) en la sección [performance]({{ site.baseurl }}/es/overviews/parallel-collections/performance.html) (en inglés).
+_Nota:_ Algunos de los siguientes ejemplos operan en colecciones pequeñas, lo cual no es recomendado. Son provistos como ejemplo para ilustrar solamente el propósito. Como una regla heurística general, los incrementos en velocidad de ejecución comienzan a ser notados cuando el tamaño de la colección es lo suficientemente grande, tipicamente algunos cuantos miles de elementos. (Para más información en la relación entre tamaño de una coleccion paralelizada y su performance, por favor véase [appropriate subsection]({{ site.baseurl}}/es/overviews/parallel-collections/performance.html) en la sección [performance]({{ site.baseurl }}/es/overviews/parallel-collections/performance.html) (en inglés).
 
 #### map
 
@@ -195,5 +195,4 @@ _Nota:_ Generalmente se piensa que, al igual que las operaciones no asociativas,
 
 Lo que implica el "fuera de orden" en las colecciones paralelizadas es solamente que la operación será ejecutada fuera de orden (en un sentido _temporal_, es decir no secuencial, no significa que el resultado va a ser re-"*combinado*" fuera de orden (en un sentido de _espacio_). Al contrario, en general los resultados siempre serán reensamblados en roden, es decir una colección paralelizada que se divide en las siguientes particiones A, B, C, en ese orden, será reensamblada nuevamente en el orden A, B, C. No en otro orden arbitrario como B, C, A.
 
-Para más información de cómo se dividen y se combinan los diferentes tipos de colecciones paralelizadas véase el artículo sobre [Arquitectura]({{ site.baseurl }}/es/overviews
-/parallel-collections/architecture.html) de esta misma serie.
+Para más información de cómo se dividen y se combinan los diferentes tipos de colecciones paralelizadas véase el artículo sobre [Arquitectura]({{ site.baseurl }}/es/overviews/parallel-collections/architecture.html) de esta misma serie.

_es/tour/annotations.md

@@ -36,7 +36,7 @@ El significado de las anotaciones _depende de la implementación_. En la platafo
 
 En el siguiente ejemplo agregamos la anotación `throws` a la definición del método `read` de manera de capturar la excepción lanzada en el programa principal de Java.
 
-> El compilador de Java comprueba que un programa contenga manejadores para [excepciones comprobadas](http://docs.oracle.com/javase/specs/jls/se5.0/html/exceptions.html) al analizar cuales de esas excepciones comprobadas pueden llegar a lanzarse en la ejecución de un método o un constructor. Por cada excepción comprobada que sea un posible resultado, la cláusula **throws** debe para ese método o constructor debe ser mencionada en la clase de esa excepción o una de las superclases.
+> El compilador de Java comprueba que un programa contenga manejadores para excepciones comprobadas al analizar cuales de esas excepciones comprobadas pueden llegar a lanzarse en la ejecución de un método o un constructor. Por cada excepción comprobada que sea un posible resultado, la cláusula **throws** debe para ese método o constructor debe ser mencionada en la clase de esa excepción o una de las superclases.
 > Ya que Scala no tiene excepciones comprobadas, los métodos en Scala deben ser anotados con una o más anotaciones `throws` para que el código Java pueda capturar las excepciones lanzadas por un método de Scala.
 
     package examples

_es/tour/basics.md

@@ -0,0 +1,9 @@
+---
+layout: tour
+title: Basics
+
+discourse: false
+
+partof: scala-tour
+language: es
+---

_es/tour/by-name-parameters.md

@@ -0,0 +1,9 @@
+---
+layout: tour
+title: By-name Parameters
+
+discourse: false
+
+partof: scala-tour
+language: es
+---

_es/tour/compound-types.md

@@ -9,7 +9,7 @@ partof: scala-tour
 num: 6
 language: es
 
-next-page: sequence-comprehensions
+next-page: extractor-objects
 previous-page: case-classes
 ---
 

_es/tour/currying.md

@@ -10,7 +10,7 @@ num: 15
 language: es
 
 next-page: automatic-closures
-previous-page: anonymous-function-syntax
+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._

_es/tour/default-parameter-values.md

@@ -9,7 +9,7 @@ partof: scala-tour
 num: 34
 language: es
 
-next-page: named-parameters
+next-page: named-arguments
 previous-page: implicit-conversions
 ---
 
@@ -66,4 +66,4 @@ Scala cuenta con soporte directo para esto:
     // mediante parametros nombrados
     val m4 = new HashMap[String,Int](loadFactor = 0.8)
 
-Nótese cómo podemos sacar ventaja de cualquier valor por defecto al utilizar [parámetros nombrados]({{ site.baseurl }}/tutorials/tour/named-parameters.html).
+Nótese cómo podemos sacar ventaja de cualquier valor por defecto al utilizar [parámetros nombrados]({{ site.baseurl }}/tutorials/tour/named-arguments.html).