Check mdoc code fences with scala 2.13 syntax

_ba/tour/basics.md

@@ -46,7 +46,7 @@ val x = 1 + 1
 println(x) // 2
 ```
 
-Imenovani rezultati, kao `x` ovdje, nazivaju se vrijednostima. 
+Imenovani rezultati, kao `x` ovdje, nazivaju se vrijednostima.
 Referenciranje vrijednosti ne okida njeno ponovno izračunavanje.
 
 Vrijednosti se ne mogu mijenjati.
@@ -61,7 +61,7 @@ Tipovi vrijednosti mogu biti (automatski) zaključeni, ali možete i eksplicitno
 val x: Int = 1 + 1
 ```
 
-Primijetite da deklaracija tipa `Int` dolazi nakon identifikatora `x`. Također morate dodati i `:`.  
+Primijetite da deklaracija tipa `Int` dolazi nakon identifikatora `x`. Također morate dodati i `:`.
 
 ### Varijable
 
@@ -177,9 +177,9 @@ class Greeter(prefix: String, suffix: String) {
     println(prefix + name + suffix)
 }
 ```
-Povratni tip metode `greet` je `Unit`, koji kaže da metoda ne vraća ništa značajno. 
-Koristi se slično kao `void` u Javi ili C-u. 
-(Razlika je u tome što svaki Scalin izraz mora imati neku vrijednost, postoji singlton vrijednost tipa `Unit`, piše se `()`. 
+Povratni tip metode `greet` je `Unit`, koji kaže da metoda ne vraća ništa značajno.
+Koristi se slično kao `void` u Javi ili C-u.
+(Razlika je u tome što svaki Scalin izraz mora imati neku vrijednost, postoji singlton vrijednost tipa `Unit`, piše se `()`.
 Ne prenosi nikakvu korisnu informaciju.)
 
 Instancu klase možete kreirati pomoću ključne riječi `new`.
@@ -193,7 +193,7 @@ Detaljniji pregled klasa biće dat [kasnije](classes.html).
 
 ## Case klase
 
-Scala ima poseban tip klase koji se zove "case" klasa.  
+Scala ima poseban tip klase koji se zove "case" klasa.
 Po defaultu, case klase su nepromjenjive i porede se po vrijednosti. Možete ih definisati s `case class` ključnim riječima.
 
 ```scala mdoc
@@ -212,15 +212,15 @@ I porede se po vrijednosti.
 
 ```scala mdoc
 if (point == anotherPoint) {
-  println(point + " and " + anotherPoint + " are the same.")
+  println(s"$point and $anotherPoint are the same.")
 } else {
-  println(point + " and " + anotherPoint + " are different.")
+  println(s"$point and $anotherPoint are different.")
 } // Point(1,2) i Point(1,2) su iste.
 
 if (point == yetAnotherPoint) {
-  println(point + " and " + yetAnotherPoint + " are the same.")
+  println(s"$point and $yetAnotherPoint are the same.")
 } else {
-  println(point + " and " + yetAnotherPoint + " are different.")
+  println(s"$point and $yetAnotherPoint are different.")
 } // Point(1,2) su Point(2,2) različite.
 ```
 
@@ -299,7 +299,7 @@ Trejtove ćemo pokriti u dubinu [kasnije](traits.html).
 
 ## Glavna metoda
 
-Glavna metoda je ulazna tačka programa.  
+Glavna metoda je ulazna tačka programa.
 Java Virtuelna Mašina traži da se glavna metoda zove `main` i da prima jedan argument, niz stringova.
 
 Koristeći objekt, možete definisati glavnu metodu ovako:

_ba/tour/extractor-objects.md

@@ -11,15 +11,15 @@ previous-page: regular-expression-patterns
 ---
 
 Ekstraktor objekat je objekat koji ima `unapply` metodu.
-Dok je `apply` metoda kao konstruktor koji uzima argumente i kreira objekat, `unapply` metoda prima objekat i pokušava vratiti argumente. 
+Dok je `apply` metoda kao konstruktor koji uzima argumente i kreira objekat, `unapply` metoda prima objekat i pokušava vratiti argumente.
 Ovo se najčešće koristi u podudaranju uzoraka i parcijalnim funkcijama.
 
 ```scala mdoc
 import scala.util.Random
 
 object CustomerID {
 
-  def apply(name: String) = s"$name--${Random.nextLong}"
+  def apply(name: String) = s"$name--${Random.nextLong()}"
 
   def unapply(customerID: String): Option[String] = {
     val name = customerID.split("--").head
@@ -34,9 +34,9 @@ customer1ID match {
 }
 ```
 
-Metoda `apply` kreira `CustomerID` string od argumenta `name`. 
-Metoda `unapply` radi suprotno da dobije `name` nazad. 
-Kada pozovemo `CustomerID("Sukyoung")`, to je skraćena sintaksa za `CustomerID.apply("Sukyoung")`. 
+Metoda `apply` kreira `CustomerID` string od argumenta `name`.
+Metoda `unapply` radi suprotno da dobije `name` nazad.
+Kada pozovemo `CustomerID("Sukyoung")`, to je skraćena sintaksa za `CustomerID.apply("Sukyoung")`.
 Kada pozovemo `case CustomerID(name) => customer1ID`, ustvari pozivamo `unapply` metodu.
 
 Metoda `unapply` se može koristiti i za dodjelu vrijednosti.

_ba/tour/higher-order-functions.md

@@ -21,19 +21,19 @@ def apply(f: Int => String, v: Int) = f(v)
 _Napomena: metode se automatski pretvaraju u funkcije ako to kontekst zahtijeva._
 
 Ovo je još jedan primjer:
- 
+
 ```scala mdoc
 class Decorator(left: String, right: String) {
   def layout[A](x: A) = left + x.toString() + right
 }
 
 object FunTest extends App {
-  override def apply(f: Int => String, v: Int) = f(v)
+  def apply(f: Int => String, v: Int) = f(v)
   val decorator = new Decorator("[", "]")
   println(apply(decorator.layout, 7))
 }
 ```
- 
+
 Izvršavanjem se dobije izlaz:
 
 ```

_ba/tour/inner-classes.md

@@ -21,7 +21,7 @@ Radi ilustracije razlike, prikazaćemo implementaciju klase grafa:
 class Graph {
   class Node {
     var connectedNodes: List[Node] = Nil
-    def connectTo(node: Node) {
+    def connectTo(node: Node): Unit = {
       if (!connectedNodes.exists(node.equals)) {
         connectedNodes = node :: connectedNodes
       }
@@ -35,7 +35,7 @@ class Graph {
   }
 }
 ```
- 
+
 U našem programu, grafovi su predstavljeni listom čvorova (`List[Node]`).
 Svaki čvor ima listu drugih čvorova s kojima je povezan (`connectedNodes`). Klasa `Node` je _path-dependent tip_ jer je ugniježdena u klasi `Graph`. Stoga, svi čvorovi u `connectedNodes` moraju biti kreirani koristeći `newNode` iz iste instance klase `Graph`.
 
@@ -47,13 +47,13 @@ val node3: graph1.Node = graph1.newNode
 node1.connectTo(node2)
 node3.connectTo(node1)
 ```
- 
+
 Eksplicitno smo deklarisali tip `node1`, `node2`, i `node3` kao `graph1.Node` zbog jasnosti ali ga je kompajler mogao sam zaključiti. Pošto kada pozivamo `graph1.newNode` koja poziva `new Node`, metoda koristi instancu `Node` specifičnu instanci `graph1`.
 
 Da imamo dva grafa, sistem tipova Scale ne dozvoljava miješanje  čvorova definisanih u različitim grafovima,
 jer čvorovi različitih grafova imaju različit tip.
 Ovo je primjer netačnog programa:
- 
+
 ```scala mdoc:fail
 val graph1: Graph = new Graph
 val node1: graph1.Node = graph1.newNode
@@ -69,12 +69,12 @@ U Javi bi zadnja linija prethodnog primjera bila tačna.
 Za čvorove oba grafa, Java bi dodijelila isti tip `Graph.Node`; npr. `Node` bi imala prefiks klase `Graph`.
 U Scali takav tip je također moguće izraziti, piše se kao `Graph#Node`.
 Ako želimo povezati čvorove različitih grafova, moramo promijeniti definiciju naše inicijalne implementacije grafa:
- 
+
 ```scala mdoc:nest
 class Graph {
   class Node {
     var connectedNodes: List[Graph#Node] = Nil
-    def connectTo(node: Graph#Node) {
+    def connectTo(node: Graph#Node): Unit = {
       if (!connectedNodes.exists(node.equals)) {
         connectedNodes = node :: connectedNodes
       }
@@ -88,6 +88,6 @@ class Graph {
   }
 }
 ```
- 
+
 > Primijetite da ovaj program ne dozvoljava da dodamo čvor u dva različita grafa.
 Ako bi htjeli ukloniti i ovo ograničenje, moramo promijeniti tipski parametar `nodes` u `Graph#Node`.

_ba/tour/mixin-class-composition.md

@@ -29,19 +29,19 @@ val d = new D
 d.message  // I'm an instance of class B
 d.loudMessage  // I'M AN INSTANCE OF CLASS B
 ```
-Klasa `D` je nadklasa od `B` i mixina `C`. 
+Klasa `D` je nadklasa od `B` i mixina `C`.
 Klase mogu imati samo jednu nadklasu alid mogu imati više mixina (koristeći ključne riječi `extends` i `with` respektivno). Mixini i nadklasa mogu imati isti nadtip.
 
 Pogledajmo sada zanimljiviji primjer počevši od apstraktne klase:
- 
+
 ```scala mdoc
 abstract class AbsIterator {
   type T
   def hasNext: Boolean
   def next(): T
 }
 ```
- 
+
 Klasa ima apstraktni tip `T` i standardne metode iteratora.
 Dalje, implementiraćemo konkretnu klasu (svi apstraktni članovi `T`, `hasNext`, i `next` imaju implementacije):
 
@@ -59,9 +59,9 @@ class StringIterator(s: String) extends AbsIterator {
 ```
 
 `StringIterator` prima `String` i može se koristiti za iteraciju nad `String`om (npr. da vidimo da li sadrži određeni karakter).
- 
+
     trait RichIterator extends AbsIterator {
-      def foreach(f: T => Unit) { while (hasNext) f(next()) }
+      def foreach(f: T => Unit): Unit = { while (hasNext) f(next()) }
     }
 
 Kreirajmo sada trejt koji također nasljeđuje `AbsIterator`.
@@ -74,7 +74,7 @@ trait RichIterator extends AbsIterator {
 
 Pošto je `RichIterator` trejt, on ne mora implementirati apstraktne članove `AbsIterator`a.
 
-Željeli bismo iskombinirati funkcionalnosti `StringIterator`a i `RichIterator`a u jednoj klasi.  
+Željeli bismo iskombinirati funkcionalnosti `StringIterator`a i `RichIterator`a u jednoj klasi.
 
 ```scala mdoc
 object StringIteratorTest extends App {
@@ -83,7 +83,7 @@ object StringIteratorTest extends App {
   iter foreach println
 }
 ```
- 
+
 Nova klasa `Iter` ima `StringIterator` kao nadklasu i `RichIterator` kao mixin.
 
 S jednostrukim nasljeđivanjem ne bismo mogli postići ovaj nivo fleksibilnosti.

_ba/tour/unified-types.md

@@ -18,14 +18,14 @@ Dijagram ispod prikazuje hijerarhiju Scala klasa.
 
 ## Hijerarhija tipova u Scali ##
 
-[`Any`](https://www.scala-lang.org/api/2.12.1/scala/Any.html) je nadtip svih tipova, zove se još i vrh-tip. 
+[`Any`](https://www.scala-lang.org/api/2.12.1/scala/Any.html) je nadtip svih tipova, zove se još i vrh-tip.
 Definiše određene univerzalne metode kao što su `equals`, `hashCode` i `toString`.
 `Any` ima dvije direktne podklase, `AnyVal` i `AnyRef`.
 
 
-`AnyVal` predstavlja vrijednosne tipove. Postoji devet predefinisanih vrijednosnih tipova i oni ne mogu biti `null`: 
+`AnyVal` predstavlja vrijednosne tipove. Postoji devet predefinisanih vrijednosnih tipova i oni ne mogu biti `null`:
 `Double`, `Float`, `Long`, `Int`, `Short`, `Byte`, `Char`, `Unit` i `Boolean`.
-`Unit` je vrijednosni tip koji ne nosi značajnu informaciju. Postoji tačno jedna instanca tipa `Unit` koja se piše `()`. 
+`Unit` je vrijednosni tip koji ne nosi značajnu informaciju. Postoji tačno jedna instanca tipa `Unit` koja se piše `()`.
 Sve funkcije moraju vratiti nešto tako da je `Unit` ponekad koristan povratni tip.
 
 `AnyRef` predstavlja referencne tipove. Svi nevrijednosni tipovi definišu se kao referencni.
@@ -66,7 +66,7 @@ Npr:
 
 ```scala mdoc
 val x: Long = 987654321
-val y: Float = x  // 9.8765434E8 (određena doza preciznosti se gubi ovdje)
+val y: Float = x.toFloat  // 9.8765434E8 (određena doza preciznosti se gubi ovdje)
 
 val face: Char = '☺'
 val number: Int = face  // 9786
@@ -76,17 +76,17 @@ Kastovanje je jednosmjerno. Ovo se ne kompajlira:
 
 ```
 val x: Long = 987654321
-val y: Float = x  // 9.8765434E8
+val y: Float = x.toFloat  // 9.8765434E8
 val z: Long = y  // Does not conform
 ```
 
 Također možete kastovati i referencni tip u podtip. Ovo će biti pokriveno kasnije.
 
 ## Nothing i Null
-`Nothing` je podtip svih tipova, također se zove i donji tip (en. bottom type). Ne postoji vrijednost koja ima tip `Nothing`.  
+`Nothing` je podtip svih tipova, također se zove i donji tip (en. bottom type). Ne postoji vrijednost koja ima tip `Nothing`.
 Česta upotreba ovog tipa je signalizacija neterminacije kao što je bacanje izuzetka, izlaz iz programa, ili beskonačna petlja (tj. tip izraza koji se ne izračunava u vrijednost, ili metoda koja se ne završava normalno).
 
-`Null` je podtip svih referencnih tipova (tj. bilo kog podtipa `AnyRef`). 
-Ima jednu vrijednost koja se piše literalom `null`. 
-`Null` se uglavnom koristi radi interoperabilnosti s ostalim JVM jezicima i skoro nikad se ne koristi u Scala kodu. 
+`Null` je podtip svih referencnih tipova (tj. bilo kog podtipa `AnyRef`).
+Ima jednu vrijednost koja se piše literalom `null`.
+`Null` se uglavnom koristi radi interoperabilnosti s ostalim JVM jezicima i skoro nikad se ne koristi u Scala kodu.
 Alternative za `null` obradićemo kasnije.

_de/tutorials/scala-for-java-programmers.md

@@ -23,7 +23,7 @@ einfach ist, eignet es sich sehr gut, Scalas Funktionsweise zu demonstrieren, oh
 über die Sprache wissen muss.
 
     object HalloWelt {
-      def main(args: Array[String]) {
+      def main(args: Array[String]): Unit = {
         println("Hallo, Welt!")
       }
     }
@@ -93,7 +93,7 @@ Klassen der Java-Pakete importieren:
     import java.text.DateFormat._
 
     object FrenchDate {
-      def main(args: Array[String]) {
+      def main(args: Array[String]): Unit = {
         val now = new Date
         val df = getDateInstance(LONG, Locale.FRANCE)
         println(df format now)
@@ -183,7 +183,7 @@ einmal pro Sekunde aus.
         println("Die Zeit vergeht wie im Flug.")
       }
 
-      def main(args: Array[String]) {
+      def main(args: Array[String]): Unit = {
         oncePerSecond(timeFlies)
       }
     }
@@ -209,7 +209,7 @@ Variante des obigen Timer-Programmes verwendet eine anonyme Funktion anstatt der
         }
       }
 
-      def main(args: Array[String]) {
+      def main(args: Array[String]): Unit = {
         oncePerSecond(() => println("Die Zeit vergeht wie im Flug."))
       }
     }
@@ -256,7 +256,7 @@ Ein Problem der obigen Methoden `re` und `im` ist, dass man, um sie zu verwenden
 Klammerpaar hinter ihren Namen anhängen muss:
 
     object ComplexNumbers {
-      def main(args: Array[String]) {
+      def main(args: Array[String]): Unit = {
         val c = new Complex(1.2, 3.4)
         println("imaginary part: " + c.im())
       }
@@ -433,7 +433,7 @@ noch aus. Zu diesem Zweck soll eine `main`-Methode dienen, die den Ausdruck `(x+
 Beispiel verwendet: zuerst wird der Wert in der Umgebung `{ x -> 5, y -> 7 }` berechnet und darauf
 die beiden partiellen Ableitungen gebildet:
 
-    def main(args: Array[String]) {
+    def main(args: Array[String]): Unit = {
       val exp: Tree = Sum(Sum(Var("x"),Var("x")),Sum(Const(7),Var("y")))
       val env: Environment = {
         case "x" => 5
@@ -597,7 +597,7 @@ Um diese Referenz-Klasse zu verwenden, muss der generische Typ bei der Erzeugung
 angegeben werden. Für einen Ganzzahl-Container soll folgendes Beispiel dienen:
 
     object IntegerReference {
-      def main(args: Array[String]) {
+      def main(args: Array[String]): Unit = {
         val cell = new Reference[Int]
         cell.set(13)
         println("Reference contains the half of " + (cell.get * 2))

_es/tour/abstract-type-members.md

@@ -40,16 +40,14 @@ abstract class IntSeqBuffer extends SeqBuffer {
   type U = Int
 }
 
-object AbstractTypeTest1 extends App {
-  def newIntSeqBuf(elem1: Int, elem2: Int): IntSeqBuffer =
-    new IntSeqBuffer {
-         type T = List[U]
-         val element = List(elem1, elem2)
-       }
-  val buf = newIntSeqBuf(7, 8)
-  println("length = " + buf.length)
-  println("content = " + buf.element)
-}
+def newIntSeqBuf(elem1: Int, elem2: Int): IntSeqBuffer =
+  new IntSeqBuffer {
+    type T = List[U]
+    val element = List(elem1, elem2)
+  }
+val buf = newIntSeqBuf(7, 8)
+println("length = " + buf.length)
+println("content = " + buf.element)
 ```
 
 El tipo retornado por el método `newIntSeqBuf` está ligado a la especialización del trait `Buffer` en el cual el tipo `U` es ahora equivalente a `Int`. Existe un tipo alias similar en la instancia de la clase anónima dentro del cuerpo del método `newIntSeqBuf`. En ese lugar se crea una nueva instancia de `IntSeqBuffer` en la cual el tipo `T` está ligado a `List[Int]`.

_es/tour/automatic-closures.md

@@ -37,7 +37,7 @@ Aquí mostramos la implementación de una declaración tipo repetir-a-menos-que
       def loop(body: => Unit): LoopUnlessCond =
         new LoopUnlessCond(body)
       protected class LoopUnlessCond(body: => Unit) {
-        def unless(cond: => Boolean) {
+        def unless(cond: => Boolean): Unit = {
           body
           if (!cond) unless(cond)
         }