Merge branch 'master' into scalafiddle-integration

Author: heathermiller

Gemfile

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

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)
@@ -31,6 +51,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)
@@ -44,13 +69,21 @@ 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
   jekyll-scalafiddle
 
 BUNDLED WITH
    1.16.1
+

_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/case-classes.md

@@ -9,7 +9,7 @@ partof: scala-tour
 
 num: 11
 next-page: pattern-matching
-previous-page: currying
+previous-page: multiple-parameter-lists
 prerequisite-knowledge: classes, basics, mutability
 
 ---

_ba/tour/lower-type-bounds.md

@@ -22,17 +22,17 @@ Kroz sljedeći primjer vidjećemo zašto je ovo korisno:
 
 ```tut:fail
 trait Node[+B] {
-  def prepend(elem: B): Unit
+  def prepend(elem: B): Node[B]
 }
 
 case class ListNode[+B](h: B, t: Node[B]) extends Node[B] {
-  def prepend(elem: B) = ListNode[B](elem, this)
+  def prepend(elem: B): ListNode[B] = ListNode(elem, this)
   def head: B = h
-  def tail = t
+  def tail: Node[B] = t
 }
 
 case class Nil[+B]() extends Node[B] {
-  def prepend(elem: B) = ListNode[B](elem, this)
+  def prepend(elem: B): ListNode[B] = ListNode(elem, this)
 }
 ```
 
@@ -48,17 +48,17 @@ Ovo radimo uvođenjem novog tipskog parametra `U` koji ima `B` kao svoju donju g
 
 ```tut
 trait Node[+B] {
-  def prepend[U >: B](elem: U)
+  def prepend[U >: B](elem: U): Node[U]
 }
 
 case class ListNode[+B](h: B, t: Node[B]) extends Node[B] {
-  def prepend[U >: B](elem: U) = ListNode[U](elem, this)
+  def prepend[U >: B](elem: U): ListNode[U] = ListNode(elem, this)
   def head: B = h
-  def tail = t
+  def tail: Node[B] = t
 }
 
 case class Nil[+B]() extends Node[B] {
-  def prepend[U >: B](elem: U) = ListNode[U](elem, this)
+  def prepend[U >: B](elem: U): ListNode[U] = ListNode(elem, this)
 }
 ```
 

_ba/tour/currying.md renamed to _ba/tour/multiple-parameter-lists.md

@@ -8,7 +8,7 @@ discourse: true
 partof: scala-tour
 
 num: 9
-next-page: currying
+next-page: multiple-parameter-lists
 previous-page: higher-order-functions
 
 ---

_ba/tour/nested-functions.md

@@ -9,7 +9,7 @@ partof: scala-tour
 
 num: 30
 next-page: by-name-parameters
-previous-page: local-type-inference
+previous-page: type-inference
 prerequisite-knowledge: case-classes
 
 ---

_ba/tour/operators.md

@@ -0,0 +1,18 @@
+---
+layout: tour
+title: Packages and Imports
+language: ba
+
+discourse: true
+
+partof: scala-tour
+
+num: 35
+previous-page: named-arguments
+next-page: type-inference
+---
+
+# Packages and Imports
+
+(this section of the tour has not been translated yet. pull request
+with translation welcome!)

_ba/tour/packages-and-imports.md

@@ -9,7 +9,7 @@ partof: scala-tour
 
 num: 28
 
-next-page: local-type-inference
+next-page: type-inference
 previous-page: implicit-conversions
 prerequisite-knowledge: unified-types
 

_ba/tour/polymorphic-methods.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).
+i podržava [curry-jevanje](multiple-parameter-lists.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. 
+Mehanizam za [lokalno zaključivanje tipova](type-inference.html) se brine da korisnik ne mora pisati tipove varijabli
+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.

_ba/tour/tour-of-scala.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:

_ba/tour/local-type-inference.md renamed to _ba/tour/type-inference.md

@@ -63,6 +63,10 @@
       description: "When two versions of Scala are binary compatible, it is safe to compile your project on one Scala version and link against another Scala version at run time. Safe run-time linkage (only!) means that the JVM does not throw a (subclass of) LinkageError when executing your program in the mixed scenario, assuming that none arise when compiling and running on the same version of Scala. Concretely, this means you may have external dependencies on your run-time classpath that use a different version of Scala than the one you’re compiling with, as long as they’re binary compatible. In other words, separate compilation on different binary compatible versions does not introduce problems compared to compiling and running everything on the same version of Scala."
       icon: puzzle-piece
       url: "core/binary-compatibility-of-scala-releases.html"
+    - title: Binary Compatibility for library authors
+      description: "A diverse and comprehensive set of libraries is important to any productive software ecosystem. While it is easy to develop and distribute Scala libraries, good library authorship goes beyond just writing code and publishing it. In this guide, we cover the important topic of Binary Compatibility."
+      icon: puzzle-piece
+      url: "core/binary-compatibility-for-library-authors.html"
 
 - category: "Reference/Documentation"
   description: "Reference material on core Scala tools like Scaladoc and the Scala REPL."

_books/2-scala-for-the-impatient.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.
 

_data/overviews.yml

@@ -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.