Finish migrating everything from tut to mdoc and update docs

Author: ckipp01

_ba/tour/abstract-type-members.md

@@ -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:
 
-```scala mdoc:reset
+```scala mdoc:nest
 abstract class Buffer[+T] {
   val element: T
 }

_ba/tour/basics.md

@@ -57,7 +57,7 @@ x = 3 // Ovo se ne kompajlira.
 
 Tipovi vrijednosti mogu biti (automatski) zaključeni, ali možete i eksplicitno navesti tip:
 
-```scala mdoc:reset
+```scala mdoc:nest
 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`.
 
-```scala mdoc:reset
+```scala mdoc:nest
 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:
 
-```scala mdoc:reset
+```scala mdoc:nest
 var x: Int = 1 + 1
 ```
 
@@ -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.
 
-```scala mdoc:reset
+```scala mdoc:nest
 def add(x: Int, y: Int): Int = x + y
 println(add(1, 2)) // 3
 ```
@@ -262,7 +262,7 @@ 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.
 
-```scala mdoc:reset
+```scala mdoc:nest
 trait Greeter {
   def greet(name: String): Unit
 }

_ba/tour/classes.md

@@ -56,7 +56,7 @@ Pošto `toString` prebrisava metodu `toString` iz [`AnyRef`](unified-types.html)
 
 Konstruktori mogu imati opcione parametre koristeći podrazumijevane vrijednosti:
 
-```scala mdoc:reset
+```scala mdoc:nest
 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
+```scala mdoc:nest
 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.
-```scala mdoc:reset
+```scala mdoc:nest
 class Point {
   private var _x = 0
   private var _y = 0

_ba/tour/higher-order-functions.md

@@ -28,7 +28,7 @@ class Decorator(left: String, right: String) {
 }
 
 object FunTest extends App {
-  def apply(f: Int => String, v: Int) = f(v)
+  override def apply(f: Int => String, v: Int) = f(v)
   val decorator = new Decorator("[", "]")
   println(apply(decorator.layout, 7))
 }

_ba/tour/inner-classes.md

@@ -54,7 +54,7 @@ Da imamo dva grafa, sistem tipova Scale ne dozvoljava miješanje  čvorova defin
 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
 val node2: graph1.Node = graph1.newNode
@@ -70,7 +70,7 @@ Za čvorove oba grafa, Java bi dodijelila isti tip `Graph.Node`; npr. `Node` bi
 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
+```scala mdoc:nest
 class Graph {
   class Node {
     var connectedNodes: List[Graph#Node] = Nil

_ba/tour/traits.md

@@ -34,7 +34,7 @@ Nasljeđivanje `trait Iterator[A]` traži tip `A` i implementacije metoda `hasNe
 
 ## Korištenje trejtova
 Koristite `extends` za nasljeđivanje trejta. Zatim implementirajte njegove apstraktne članove koristeći `override` ključnu riječ:
-```scala mdoc
+```scala mdoc:nest
 trait Iterator[A] {
   def hasNext: Boolean
   def next(): A

_es/tour/abstract-type-members.md

@@ -14,56 +14,62 @@ previous-page: tour-of-scala
 En Scala, las cases son parametrizadas con valores (los parámetros de construcción) y con tipos (si las clases son [genéricas](generic-classes.html)). Por razones de consistencia, no es posible tener solo valores como miembros de objetos; tanto los tipos como los valores son miembros de objetos. Además, ambos tipos de miembros pueden ser concretos y abstractos.
 A continuación un ejemplo el cual define de forma conjunta una asignación de valor tardía y un tipo abstracto como miembros del [trait](traits.html) `Buffer`.
 
-    trait Buffer {
-      type T
-      val element: T
-    }
+```scala mdoc
+trait Buffer {
+  type T
+  val element: T
+}
+```
 
 Los *tipos abstractos* son tipos los cuales su identidad no es precisamente conocida. En el ejemplo anterior, lo único que sabemos es que cada objeto de la clase `Buffer` tiene un miembro de tipo `T`, pero la definición de la clase `Buffer` no revela qué tipo concreto se corresponde con el tipo `T`. Tal como las definiciones de valores, es posible sobrescribir las definiciones de tipos en subclases. Esto permite revelar más información acerca de un tipo abstracto al acotar el tipo ligado (el cual describe las posibles instancias concretas del tipo abstracto).
 
 En el siguiente programa derivamos la clase `SeqBuffer` la cual nos permite almacenar solamente sequencias en el buffer al estipular que el tipo `T` tiene que ser un subtipo de `Seq[U]` para un nuevo tipo abstracto `U`:
 
-    abstract class SeqBuffer extends Buffer {
-      type U
-      type T <: Seq[U]
-      def length = element.length
-    }
+```scala mdoc
+abstract class SeqBuffer extends Buffer {
+  type U
+  type T <: Seq[U]
+  def length = element.length
+}
+```
 
 Traits o [clases](classes.html) con miembros de tipos abstractos son generalmente usados en combinación con instancias de clases anónimas. Para ilustrar este concepto veremos un programa el cual trata con un buffer de sequencia que se remite a una lista de enteros.
 
-    abstract class IntSeqBuffer extends SeqBuffer {
-      type U = Int
-    }
+```scala mdoc
+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)
-    }
+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)
+}
+```
 
 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 necesario notar que generalmente es posible transformar un tipo abstracto en un tipo paramétrico de una clase y viceversa. A continuación se muestra una versión del código anterior el cual solo usa tipos paramétricos.
 
-    abstract class Buffer[+T] {
-      val element: T
-    }
-    abstract class SeqBuffer[U, +T <: Seq[U]] extends Buffer[T] {
-      def length = element.length
-    }
-    object AbstractTypeTest2 extends App {
-      def newIntSeqBuf(e1: Int, e2: Int): SeqBuffer[Int, Seq[Int]] =
-        new SeqBuffer[Int, List[Int]] {
-          val element = List(e1, e2)
-        }
-      val buf = newIntSeqBuf(7, 8)
-      println("length = " + buf.length)
-      println("content = " + buf.element)
-    }
+```scala mdoc:reset
+abstract class Buffer[+T] {
+  val element: T
+}
+abstract class SeqBuffer[U, +T <: Seq[U]] extends Buffer[T] {
+  def length = element.length
+}
+def newIntSeqBuf(e1: Int, e2: Int): SeqBuffer[Int, Seq[Int]] =
+  new SeqBuffer[Int, List[Int]] {
+    val element = List(e1, e2)
+  }
+val buf = newIntSeqBuf(7, 8)
+println("length = " + buf.length)
+println("content = " + buf.element)
+```
 
 Nótese que es necesario usar [variance annotations](variances.html) aquí; de otra manera no sería posible ocultar el tipo implementado por la secuencia concreta del objeto retornado por `newIntSeqBuf`. Además, existen casos en los cuales no es posible remplazar tipos abstractos con tipos parametrizados.

_es/tour/basics.md

@@ -61,7 +61,7 @@ x = 3  // This does not compile.
 
 Scala es capaz de inferir el tipo de un valor. Aun así, también se puede indicar el tipo usando una anotación:
 
-```scala mdoc
+```scala mdoc:nest
 val x: Int = 1 + 1
 ```
 
@@ -71,15 +71,15 @@ Nótese que la anotación del tipo `Int` sigue al identificador `x` de la variab
 
 Una variable es como un valor, excepto que a una variable se le puede re-asignar un valor después de declararla. Una variable se declara con la palabra reservada `var`.
 
-```scala mdoc
+```scala mdoc:nest
 var x = 1 + 1
 x = 3 // This compiles because "x" is declared with the "var" keyword.
 println(x * x) // 9
 ```
 
 Como con los valores, si se quiere se puede especificar el tipo de una variable mutable:
 
-```scala mdoc
+```scala mdoc:nest
 var x: Int = 1 + 1
 ```
 
@@ -140,7 +140,7 @@ Los métodos se parecen y comportan casi como a las funciones, pero se diferenci
 Un método se define con la palabra reservada `def`, seguida por el nombre del método, la lista de parámetros, el tipo de valores que el método devuelve, y el cuerpo del método.
 
 {% scalafiddle %}
-```scala mdoc
+```scala mdoc:nest
 def add(x: Int, y: Int): Int = x + y
 println(add(1, 2)) // 3
 ```
@@ -271,7 +271,7 @@ Los traits son tipos que contienen campos y métodos. Se pueden combinar múltip
 
 Un trait se define usando la palabra reservada `trait`.
 
-```scala mdoc
+```scala mdoc:nest
 trait Greeter {
   def greet(name: String): Unit
 }
@@ -280,7 +280,7 @@ trait Greeter {
 Un `trait` también puede definir un método, o un valor, con una implementación por defecto.
 
 {% scalafiddle %}
-```scala mdoc
+```scala mdoc:reset
 trait Greeter {
   def greet(name: String): Unit =
     println("Hello, " + name + "!")

_es/tour/multiple-parameter-lists.md

@@ -18,7 +18,7 @@ Los métodos pueden definir múltiples listas de parámetros. Cuando un método
 
 A continuación hay un ejemplo, tal y como se define en el trait `TraversableOnce` en el API de colecciones de Scala:
 
-```
+```scala mdoc:fail
 def foldLeft[B](z: B)(op: (B, A) => B): B
 ```
 
@@ -59,9 +59,10 @@ _Nota: el método `modN` está parcialmente aplicado en las dos llamadas a `filt
 
 Aquí se muestra la salida del programa anterior:
 
-    List(2,4,6,8)
-    List(3,6)
-
+```scala mdoc
+List(2,4,6,8)
+List(3,6)
+```
 
 ### Casos de uso
 
@@ -107,7 +108,7 @@ Para especificar solamente ciertos parámetros como [`implicit`](https://docs.sc
 
 Un ejemplo de esto se muestra a continuación:
 
-```
+```scala mdoc
 def execute(arg: Int)(implicit ec: scala.concurrent.ExecutionContext) = ???
 ```
 
@@ -117,7 +118,7 @@ Cuando un método es invocado con menos parámetros que los que están declarado
 
 Por ejemplo,
 
-```scala mdoc
+```scala mdoc:nest
 val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
 val numberFunc = numbers.foldLeft(List[Int]()) _
 

_ja/tour/abstract-type-members.md

@@ -57,7 +57,7 @@ println("content = " + buf.element)
 
 抽象型メンバーをクラスの型パラメータに変えることも、その逆も可能です。以下は上記コードの型パラメータのみを使うバージョンです。
 
-```scala mdoc
+```scala mdoc:nest
 abstract class Buffer[+T] {
   val element: T
 }