Initial run through of changing tut to mdoc

Author: ckipp01

_ba/tour/abstract-type-members.md

@@ -15,7 +15,7 @@ Trejtovi i apstraktne klase mogu imati apstraktne tipove kao članove.
 To znači da konkretne implementacije definišu stvarni tip.
 Slijedi primjer:
 
-```tut
+```scala mdoc
 trait Buffer {
   type T
   val element: T
@@ -26,7 +26,7 @@ U gornjem primjeru smo definisali apstraktni tip `T`.
 On se koristi za opis člana `element`.
 Ovaj trejt možemo naslijediti u apstraktnoj klasi i dodati gornju granicu tipa za `T` da bi ga učinili preciznijim.
 
-```tut
+```scala mdoc
 abstract class SeqBuffer extends Buffer {
   type U
   type T <: Seq[U]
@@ -40,7 +40,7 @@ mora biti podtip `Seq[U]` za neki novi apstraktni tip `U`.
 Trejtovi ili [klase](classes.html) s apstraktnim tip-članovima se često koriste u kombinaciji s instanciranjem anonimnih klasa.
 Radi ilustracije, pogledaćemo program koji radi s sekvencijalnim baferom koji sadrži listu integera:
 
-```tut
+```scala mdoc
 abstract class IntSeqBuffer extends SeqBuffer {
   type U = Int
 }
@@ -61,7 +61,7 @@ Metoda `newIntSeqBuf` koristi anonimnu klasu kao implementaciju  `IntSeqBuf` pos
 Često je moguće pretvoriti apstraktni tip-član u tipski parametar klase i obrnuto.
 Slijedi verzija gornjeg koda koji koristi tipske parametre:
 
-```tut
+```scala mdoc:reset
 abstract class Buffer[+T] {
   val element: T
 }

_ba/tour/annotations.md

@@ -30,7 +30,7 @@ Redoslijed anotacijskih klauza nije bitan.
 Određene anotacije će uzrokovati pad kompajliranja ako određeni uslovi nisu ispunjeni. 
 Npr, anotacija `@tailrec` osigurava da je metoda [tail-rekurzivna](https://en.wikipedia.org/wiki/Tail_call). Tail-rekurzija može zadržati memorijske zahtjeve konstantnim. 
 Evo kako se koristi na metodi koja izračunava faktorijel:
-```tut
+```scala mdoc
 import scala.annotation.tailrec
 
 def factorial(x: Int): Int = {

_ba/tour/basics.md

@@ -30,7 +30,7 @@ Izrazi su izjave koje imaju vrijednost.
 ```
 Rezultate izraza možete prikazati pomoću `println`.
 
-```tut
+```scala mdoc
 println(1) // 1
 println(1 + 1) // 2
 println("Hello!") // Hello!
@@ -41,7 +41,7 @@ println("Hello," + " world!") // Hello, world!
 
 Rezultatima možete dodijeliti naziv pomoću ključne riječi `val`.
 
-```tut
+```scala mdoc
 val x = 1 + 1
 println(x) // 2
 ```
@@ -51,13 +51,13 @@ Referenciranje vrijednosti ne okida njeno ponovno izračunavanje.
 
 Vrijednosti se ne mogu mijenjati.
 
-```tut:fail
+```scala mdoc:fail
 x = 3 // Ovo se ne kompajlira.
 ```
 
 Tipovi vrijednosti mogu biti (automatski) zaključeni, ali možete i eksplicitno navesti tip:
 
-```tut
+```scala mdoc:reset
 val x: Int = 1 + 1
 ```
 
@@ -67,15 +67,15 @@ Primijetite da deklaracija tipa `Int` dolazi nakon identifikatora `x`. Također
 
 Varijable su kao vrijednosti, osim što ih možete promijeniti. Varijable se definišu ključnom riječju `var`.
 
-```tut
+```scala mdoc:reset
 var x = 1 + 1
 x = 3 // Ovo se kompajlira jer je "x" deklarisano s "var" ključnom riječju.
 println(x * x) // 9
 ```
 
 Kao i s vrijednostima, tip možete eksplicitno navesti ako želite:
 
-```tut
+```scala mdoc:reset
 var x: Int = 1 + 1
 ```
 
@@ -86,7 +86,7 @@ Izraze možete kombinovati okružujući ih s `{}`. Ovo se naziva blok.
 
 Rezultat zadnjeg izraza u bloku je rezultat cijelog bloka, također.
 
-```tut
+```scala mdoc
 println({
   val x = 1 + 1
   x + 1
@@ -99,29 +99,29 @@ Funkcije su izrazi koji primaju parametre.
 
 Možete definisati anonimnu funkciju (bez imena) koja vraća cijeli broj plus jedan:
 
-```tut
+```scala mdoc
 (x: Int) => x + 1
 ```
 
 Na lijevoj strani `=>` je lista parametara. Na desnoj strani je izraz koji koristi date parametre.
 
 Funkcije možete i imenovati.
 
-```tut
+```scala mdoc
 val addOne = (x: Int) => x + 1
 println(addOne(1)) // 2
 ```
 
 Funkcije mogu imati više parametara.
 
-```tut
+```scala mdoc
 val add = (x: Int, y: Int) => x + y
 println(add(1, 2)) // 3
 ```
 
 Ili bez parametara.
 
-```tut
+```scala mdoc
 val getTheAnswer = () => 42
 println(getTheAnswer()) // 42
 ```
@@ -132,7 +132,7 @@ Metode izgledaju i ponašaju se vrlo slično funkcijama, ali postoji nekoliko ra
 
 Metode se definišu ključnom riječju `def`.  Nakon `def` slijedi naziv, lista parametara, povratni tip, i tijelo.
 
-```tut
+```scala mdoc:reset
 def add(x: Int, y: Int): Int = x + y
 println(add(1, 2)) // 3
 ```
@@ -141,14 +141,14 @@ Primijetite da je povratni tip deklarisan _nakon_ liste parametara i dvotačke `
 
 Metode mogu imati više listi parametara.
 
-```tut
+```scala mdoc
 def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier
 println(addThenMultiply(1, 2)(3)) // 9
 ```
 
 Ili bez listi parametara ikako.
 
-```tut
+```scala mdoc
 def name: String = System.getProperty("name")
 println("Hello, " + name + "!")
 ```
@@ -158,7 +158,7 @@ Postoje i neke druge razlike, ali zasad, možete misliti o njima kao nečemu sli
 Metode mogu imati višelinijske izraze također.
 
 {% scalafiddle %}
-```tut
+```scala mdoc
 def getSquareString(input: Double): String = {
   val square = input * input
   square.toString
@@ -173,7 +173,7 @@ Zadnjo izraz u tijelu metode je povratna vrijednost metode. (Scala ima ključnu
 
 Klasu možete definisati ključnom riječju `class` praćenom imenom i parametrima konstruktora.
 
-```tut
+```scala mdoc
 class Greeter(prefix: String, suffix: String) {
   def greet(name: String): Unit =
     println(prefix + name + suffix)
@@ -186,7 +186,7 @@ Ne prenosi nikakvu korisnu informaciju.)
 
 Instancu klase možete kreirati pomoću ključne riječi `new`.
 
-```tut
+```scala mdoc
 val greeter = new Greeter("Hello, ", "!")
 greeter.greet("Scala developer") // Hello, Scala developer!
 ```
@@ -198,21 +198,21 @@ Detaljniji pregled klasa biće dat [kasnije](classes.html).
 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.
 
-```tut
+```scala mdoc
 case class Point(x: Int, y: Int)
 ```
 
 Instancu case klase možete kreirati i bez ključne riječi `new`.
 
-```tut
+```scala mdoc
 val point = Point(1, 2)
 val anotherPoint = Point(1, 2)
 val yetAnotherPoint = Point(2, 2)
 ```
 
 I porede se po vrijednosti.
 
-```tut
+```scala mdoc
 if (point == anotherPoint) {
   println(point + " and " + anotherPoint + " are the same.")
 } else {
@@ -235,7 +235,7 @@ Objasnićemo ih u dubinu [kasnije](case-classes.html).
 Objekti su jedine instance svojih definicija. Možete misliti o njima kao singltonima svoje vlastite klase.
 Objekte možete definisati ključnom riječju `object`.
 
-```tut
+```scala mdoc
 object IdFactory {
   private var counter = 0
   def create(): Int = {
@@ -247,7 +247,7 @@ object IdFactory {
 
 Objektima možete pristupati referenciranjem njihovog imena.
 
-```tut
+```scala mdoc
 val newId: Int = IdFactory.create()
 println(newId) // 1
 val newerId: Int = IdFactory.create()
@@ -262,15 +262,15 @@ Trejtovi su tipovi koji sadrže polja i metode.  Više trejtova se može kombino
 
 Definišu se pomoću `trait` ključne riječi.
 
-```tut
+```scala mdoc:reset
 trait Greeter {
   def greet(name: String): Unit
 }
 ```
 
 Metode trejtova mogu imati defaultnu implementaciju.
 
-```tut
+```scala mdoc:reset
 trait Greeter {
   def greet(name: String): Unit =
     println("Hello, " + name + "!")
@@ -279,7 +279,7 @@ trait Greeter {
 
 Možete naslijediti trejtove s `extends` ključnom riječi i redefinisati (override) implementacije s `override` ključnom riječi.
 
-```tut
+```scala mdoc
 class DefaultGreeter extends Greeter
 
 class CustomizableGreeter(prefix: String, postfix: String) extends Greeter {
@@ -306,7 +306,7 @@ Java Virtuelna Mašina traži da se glavna metoda zove `main` i da prima jedan a
 
 Koristeći objekt, možete definisati glavnu metodu ovako:
 
-```tut
+```scala mdoc
 object Main {
   def main(args: Array[String]): Unit =
     println("Hello, Scala developer!")

_ba/tour/by-name-parameters.md

@@ -13,15 +13,15 @@ previous-page: operators
 _By-name parametri_ (u slobodnom prevodu "po-imenu parametri") se izračunavaju samo kada se koriste. 
 Oni su kontrastu sa _by-value parametrima_ ("po-vrijednosti parametri"). 
 Da bi parametar bio pozivan by-name, dodajte `=>` prije njegovog tipa.
-```tut
+```scala mdoc
 def calculate(input: => Int) = input * 37
 ```
 By-name parametri imaju prednost da se ne izračunavaju ako se ne koriste u tijelu funkcije. 
 U drugu ruku, by-value parametri imaju prednost da se izračunavaju samo jednom.
 
 Ovo je primjer kako bi mogli implementirati while petlju:
 
-```tut
+```scala mdoc
 def whileLoop(condition: => Boolean)(body: => Unit): Unit =
   if (condition) {
     body

_ba/tour/case-classes.md

@@ -17,7 +17,7 @@ U sljedećem koraku turneje, vidjećemo kako su korisne u [podudaranju uzoraka (
 
 ## Definisanje case klase
 Minimalna case klasa se sastoji iz ključnih riječi `case class`,  identifikatora, i liste parametara (koja može biti prazna):
-```tut
+```scala mdoc
 case class Book(isbn: String)
 
 val frankenstein = Book("978-0486282114")

_ba/tour/classes.md

@@ -18,7 +18,7 @@ Tipovi, objekti i trejtovi biće pokriveni kasnije.
 
 ## Definisanje klase
 Minimalna definicija klase sastoji se od riječi `class` i identifikatora. Imena klasa bi trebala počinjati velikim slovom.
-```tut
+```scala mdoc
 class User
 
 val user1 = new User
@@ -28,7 +28,7 @@ Ključna riječ `new` koristi se za kreiranje instance klase.
 Međutim, često ćete imati konstruktor i tijelo klase.
 Slijedi definicija klase `Point` (en. tačka):
 
-```tut
+```scala mdoc
 class Point(var x: Int, var y: Int) {
 
   def move(dx: Int, dy: Int): Unit = {
@@ -56,7 +56,7 @@ Pošto `toString` prebrisava metodu `toString` iz [`AnyRef`](unified-types.html)
 
 Konstruktori mogu imati opcione parametre koristeći podrazumijevane vrijednosti:
 
-```tut
+```scala mdoc:reset
 class Point(var x: Int = 0, var y: Int = 0)
 
 val origin = new Point  // x and y are both set to 0
@@ -67,7 +67,7 @@ println(point1.x)  // prints 1
 
 U ovoj verziji klase `Point`, `x` i `y` imaju podrazumijevanu vrijednost `0` tako da ne morate proslijediti argumente.
 Međutim, pošto se argumenti konstruktora čitaju s lijeva na desno, ako želite proslijediti samo `y` vrijednost, morate imenovati parametar.
-```
+```scala mdoc:reset
 class Point(var x: Int = 0, var y: Int = 0)
 val point2 = new Point(y=2)
 println(point2.y)  // prints 2
@@ -78,7 +78,7 @@ Ovo je također dobra praksa zbog poboljšanja čitljivosti.
 ## Privatni članovi i sintaksa getera/setera
 Članovi su javni (`public`) po defaultu. 
 Koristite `private` modifikator pristupa da sakrijete članove klase.
-```tut
+```scala mdoc:reset
 class Point {
   private var _x = 0
   private var _y = 0
@@ -108,14 +108,14 @@ Primijetite specijalnu sintaksu za setere: metoda ima `_=` nadodano na identifik
 
 Parametri primarnog konstruktora s `val` i `var` su javni. 
 Međutim, pošto su `val` nepromjenjivi, ne možete napisati sljedeće.
-```
+```scala mdoc:fail
 class Point(val x: Int, val y: Int)
 val point = new Point(1, 2)
 point.x = 3  // <-- does not compile
 ```
 
 Parametri bez `val` ili `var` su privatne vrijednosti, vidljive samo unutar klase.
-```
+```scala mdoc:fail
 class Point(x: Int, y: Int)
 val point = new Point(1, 2)
 point.x  // <-- does not compile

_ba/tour/compound-types.md

@@ -15,7 +15,7 @@ U Scali ovo može biti izraženo pomoću *složenih tipova*, koji su presjeci ti
 
 Pretpostavimo da imamo dva trejta: `Cloneable` i `Resetable`:
 
-```tut
+```scala mdoc
 trait Cloneable extends java.lang.Cloneable {
   override def clone(): Cloneable = {
     super.clone().asInstanceOf[Cloneable]

_ba/tour/default-parameter-values.md

@@ -13,7 +13,7 @@ prerequisite-knowledge: named-arguments, function syntax
 
 Scala omogućuje davanje podrazumijevanih vrijednosti parametrima koje dozvoljavaju korisniku metode da izostavi te parametre.
 
-```tut
+```scala mdoc
 def log(message: String, level: String = "INFO") = println(s"$level: $message")
 
 log("System starting")  // prints INFO: System starting
@@ -22,7 +22,7 @@ log("User not found", "WARNING")  // prints WARNING: User not found
 
 Parametar `level` ima podrazumijevanu vrijednost tako da je opcioni. Na zadnjoj liniji, argument `"WARNING"` prebrisava podrazumijevani argument `"INFO"`. Gdje biste koristili overloadane metode u Javi, možete koristiti metode s opcionim parametrima da biste postigli isti efekat. Međutim, ako korisnik izostavi argument, bilo koji sljedeći argumenti moraju biti imenovani.
 
-```tut  
+```scala mdoc  
 class Point(val x: Double = 0, val y: Double = 0)
 
 val point1 = new Point(y = 1)
@@ -31,7 +31,7 @@ Ovdje moramo reći `y = 1`.
 
 Podrazumijevani parametri u Scali nisu opcioni kada se koriste iz Java koda:
 
-```tut
+```scala mdoc:reset
 // Point.scala
 class Point(val x: Double = 0, val y: Double = 0)
 ```