wip: use scala 3 to compile docs

Author: bishabosha

_ba/tour/extractor-objects.md

@@ -43,14 +43,14 @@ Metoda `unapply` se može koristiti i za dodjelu vrijednosti.
 
 ```scala mdoc
 val customer2ID = CustomerID("Nico")
-val CustomerID(name) = customer2ID
+val CustomerID(name) = customer2ID: @unchecked
 println(name)  // prints Nico
 ```
 
 Ovo je ekvivalentno `val name = CustomerID.unapply(customer2ID).get`. Ako se uzorak ne podudari, baciće se  `scala.MatchError` izuzetak:
 
 ```scala mdoc:crash
-val CustomerID(name2) = "--asdfasdfasdf"
+val CustomerID(name2) = "--asdfasdfasdf": @unchecked
 ```
 
 Povratni tip od `unapply` se bira na sljedeći način:

_ba/tour/implicit-parameters.md

@@ -21,7 +21,7 @@ Argumenti koji se mogu proslijediti kao implicitni parametri spadaju u dvije kat
 
 U sljedećem primjeru definisaćemo metodu `sum` koja izračunava sumu liste elemenata koristeći `add` i `unit` operacije monoida.
 Molimo primijetite da implicitne vrijednosti ne mogu biti top-level, već moraju biti članovi templejta.
- 
+
 ```scala mdoc
 abstract class SemiGroup[A] {
   def add(x: A, y: A): A
@@ -31,7 +31,7 @@ abstract class Monoid[A] extends SemiGroup[A] {
 }
 object ImplicitTest extends App {
   implicit object StringMonoid extends Monoid[String] {
-    def add(x: String, y: String): String = x concat y
+    def add(x: String, y: String): String = x ++ y
     def unit: String = ""
   }
   implicit object IntMonoid extends Monoid[Int] {
@@ -51,13 +51,13 @@ Ovaj primjer koristi strukturu iz apstraktne algebre da pokaže kako implicitni
 
 Monoid, modelovan s `Monoid` ovdje, je polugrupa s posebnim elementom `A`, zvanim `unit`, koji kada se kombinujes nekim drugim elementom `A` vraća taj drugi element.
 
-Da bismo pokazali kako implicitni parametri rade, prvo definišemo monoide `StringMonoid` i `IntMonoid` za stringove i integere, respektivno. 
+Da bismo pokazali kako implicitni parametri rade, prvo definišemo monoide `StringMonoid` i `IntMonoid` za stringove i integere, respektivno.
 Ključna riječ `implicit` kaže da se dati objekat može koristiti implicitno, unutar ovog domena, kao parametar funkcije obilježene s implicit.
 
-Metoda `sum` prima `List[A]` i vraća `A`, koji predstavlja rezultat primjene operacije monoida sukcesivno kroz cijelu listu. Navodeći parametar `m` implicitnim ovdje znači da samo moramo proslijediti `xs` parametar pri pozivu, pošto imamo `List[A]` znamo šta je tip `A` ustvari i stoga tip `Monoid[A]` se traži. 
+Metoda `sum` prima `List[A]` i vraća `A`, koji predstavlja rezultat primjene operacije monoida sukcesivno kroz cijelu listu. Navodeći parametar `m` implicitnim ovdje znači da samo moramo proslijediti `xs` parametar pri pozivu, pošto imamo `List[A]` znamo šta je tip `A` ustvari i stoga tip `Monoid[A]` se traži.
 Možemo implicitno naći bilo koji `val` ili `object` u trenutnom domenu koji ima taj tip i koristiti ga bez da ga navedemo eksplicitno.
 
-Napokon, zovemo `sum` dvaput, sa samo jednim parametrom svaki put. 
+Napokon, zovemo `sum` dvaput, sa samo jednim parametrom svaki put.
 Pošto je drugi parametar metode `sum`, `m`, implicitan, njegova vrijednost se traži u trenutnom domenu, bazirano na tipu monoida koji se traži, što znači da se oba izraza mogu izračunati potpuno.
 
 Ovo je izlaz navedenog Scala programa:

_ba/tour/mixin-class-composition.md

@@ -51,7 +51,7 @@ class StringIterator(s: String) extends AbsIterator {
   private var i = 0
   def hasNext = i < s.length
   def next() = {
-    val ch = s charAt i
+    val ch = s.charAt(i)
     i += 1
     ch
   }
@@ -80,7 +80,7 @@ Pošto je `RichIterator` trejt, on ne mora implementirati apstraktne članove `A
 object StringIteratorTest extends App {
   class Iter extends StringIterator("Scala") with RichIterator
   val iter = new Iter
-  iter foreach println
+  iter.foreach(println)
 }
 ```
 

_ba/tour/operators.md

@@ -11,7 +11,7 @@ prerequisite-knowledge: case-classes
 
 ---
 
-U Scali, operatori su metode. 
+U Scali, operatori su metode.
 Bilo koja metoda koja prima samo jedan parametar može biti korištena kao _infiksni operator_. Npr, `+` se može pozvati s tačka-notacijom:
 ```
 10.+(1)
@@ -23,7 +23,7 @@ Međutim, lakše je čitati kada se napiše kao infiksni operator:
 ```
 
 ## Definisanje i korištenje operatora
-Možete koristiti bilo koji legalni identifikator kao operator. 
+Možete koristiti bilo koji legalni identifikator kao operator.
 To uključuje i imena kao `add` ili simbole kao `+`.
 ```scala mdoc
 case class Vec(x: Double, y: Double) {
@@ -37,15 +37,15 @@ val vector3 = vector1 + vector2
 vector3.x  // 3.0
 vector3.y  // 3.0
 ```
-Klasa `Vec` ima metodu `+` koja se može koristiti za sabiranje  `vector1` i `vector2`. 
+Klasa `Vec` ima metodu `+` koja se može koristiti za sabiranje  `vector1` i `vector2`.
 Koristeći zagrade, možete pisati kompleksne izraze s čitljivom sintaksom.
 
 Slijedi definicija klase `MyBool` koja definiše tri metode `and`, `or`, i `negate`.
 
 ```scala mdoc
 case class MyBool(x: Boolean) {
-  def and(that: MyBool): MyBool = if (x) that else this
-  def or(that: MyBool): MyBool = if (x) this else that
+  infix def and(that: MyBool): MyBool = if (x) that else this
+  infix def or(that: MyBool): MyBool = if (x) this else that
   def negate: MyBool = MyBool(!x)
 }
 ```

_es/tour/basics.md

@@ -300,7 +300,7 @@ El método principal (main) es el punto donde comienza la ejecución de un progr
 
 Usando un objeto, puedes definir el método principal de la siguiente forma:
 
-```scala mdoc
+```scala mdoc:fail
 object Main {
   def main(args: Array[String]): Unit =
     println("Hello, Scala developer!")

_es/tour/implicit-parameters.md

@@ -26,7 +26,7 @@ En el siguiente ejemplo definimos un método `sum` el cual computa la suma de un
     }
     object ImplicitTest extends App {
       implicit object StringMonoid extends Monoid[String] {
-        def add(x: String, y: String): String = x concat y
+        def add(x: String, y: String): String = x ++ y
         def unit: String = ""
       }
       implicit object IntMonoid extends Monoid[Int] {

_es/tour/mixin-class-composition.md

@@ -31,7 +31,7 @@ Aquí se muestra una clase iterador concreta, la cual retorna caracteres sucesiv
       type T = Char
       private var i = 0
       def hasNext = i < s.length()
-      def next() = { val ch = s charAt i; i += 1; ch }
+      def next() = { val ch = s.charAt(i); i += 1; ch }
     }
 
 Nos gustaría combinar la funcionalidad de `StringIterator` y `RichIterator` en una sola clase. Solo con herencia simple e interfaces esto es imposible, ya que ambas clases contienen implementaciones para sus miembros. Scala nos ayuda con sus _compisiciones de clases mezcladas_. Permite a los programadores reutilizar el delta de la definición de una clase, esto es, todas las nuevas definiciones que no son heredadas. Este mecanismo hace posible combinar `StringIterator` con `RichIterator`, como es hecho en el siguiente programa, el cual imprime una columna de todos los caracteres de una cadena de caracteres dada.
@@ -40,7 +40,7 @@ Nos gustaría combinar la funcionalidad de `StringIterator` y `RichIterator` en
       def main(args: Array[String]): Unit = {
         class Iter extends StringIterator("Scala") with RichIterator
         val iter = new Iter
-        iter foreach println
+        iter.foreach(println)
       }
     }
 

_es/tour/multiple-parameter-lists.md

@@ -116,7 +116,7 @@ Por ejemplo,
 
 ```scala mdoc:nest
 val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
-val numberFunc = numbers.foldLeft(List[Int]()) _
+val numberFunc = numbers.foldLeft(List[Int]())
 
 val squares = numberFunc((xs, x) => xs :+ x*x)
 println(squares) // List(1, 4, 9, 16, 25, 36, 49, 64, 81, 100)

_es/tour/operators.md

@@ -13,8 +13,8 @@ previous-page: multiple-parameter-lists
 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`.
 
     class MyBool(x: Boolean) {
-      def and(that: MyBool): MyBool = if (x) that else this
-      def or(that: MyBool): MyBool = if (x) this else that
+      infix def and(that: MyBool): MyBool = if (x) that else this
+      infix def or(that: MyBool): MyBool = if (x) this else that
       def negate: MyBool = new MyBool(!x)
     }
 

_fr/tour/extractor-objects.md

@@ -39,14 +39,14 @@ Sachant qu'une définition de valeur peut utiliser une décomposition pour intro
 
 ```scala mdoc
 val customer2ID = CustomerID("Nico")
-val CustomerID(name) = customer2ID
+val CustomerID(name) = customer2ID: @unchecked
 println(name)  // prints Nico
 ```
 
 C'est équivalent à `val name = CustomerID.unapply(customer2ID).get`.
 
 ```scala mdoc
-val CustomerID(name2) = "--asdfasdfasdf"
+val CustomerID(name2) = "--asdfasdfasdf": @unchecked
 ```
 
 S'il n'y a pas de correspondance, une `scala.MatchError` est levée :