add more mdoc

Author: bishabosha

_es/tour/inner-classes.md

@@ -12,26 +12,28 @@ previous-page: implicit-parameters
 
 En Scala es posible que las clases tengan como miembro otras clases. A diferencia de lenguajes similares a Java donde ese tipo de clases internas son miembros de las clases que las envuelven, en Scala esas clases internas están ligadas al objeto externo. Para ilustrar esta diferencia, vamos a mostrar rápidamente una implementación del tipo grafo:
 
-    class Graph {
-      class Node {
-        var connectedNodes: List[Node] = Nil
-        def connectTo(node: Node): Unit = {
-          if (!connectedNodes.exists(node.equals)) {
-            connectedNodes = node :: connectedNodes
-          }
-        }
-      }
-      var nodes: List[Node] = Nil
-      def newNode: Node = {
-        val res = new Node
-        nodes = res :: nodes
-        res
+```scala mdoc
+class Graph {
+  class Node {
+    var connectedNodes: List[Node] = Nil
+    def connectTo(node: Node): Unit = {
+      if (!connectedNodes.exists(node.equals)) {
+        connectedNodes = node :: connectedNodes
       }
     }
+  }
+  var nodes: List[Node] = Nil
+  def newNode: Node = {
+    val res = new Node
+    nodes = res :: nodes
+    res
+  }
+}
+```
 
 En nuestro programa, los grafos son representados mediante una lista de nodos. Estos nodos son objetos de la clase interna `Node`. Cada nodo tiene una lista de vecinos que se almacena en la lista `connectedNodes`. Ahora podemos crear un grafo con algunos nodos y conectarlos incrementalmente:
 
-```scala mdoc
+```scala mdoc:nest
 def graphTest: Unit = {
   val g = new Graph
   val n1 = g.newNode

_es/tour/self-types.md

@@ -91,14 +91,12 @@ Por favor nótese que en esta clase nos es posible instanciar `NodoImpl` porque
 
 Aquí hay un ejemplo de uso de la clase `GrafoDirigidoConcreto`:
 
-```scala mdoc
-def graphTest: Unit = {
-  val g: Grafo = new GrafoDirigidoConcreto
-  val n1 = g.agregarNodo
-  val n2 = g.agregarNodo
-  val n3 = g.agregarNodo
-  n1.conectarCon(n2)
-  n2.conectarCon(n3)
-  n1.conectarCon(n3)
-}
-```
+    def graphTest: Unit = {
+      val g: Grafo = new GrafoDirigidoConcreto
+      val n1 = g.agregarNodo
+      val n2 = g.agregarNodo
+      val n3 = g.agregarNodo
+      n1.conectarCon(n2)
+      n2.conectarCon(n3)
+      n1.conectarCon(n3)
+    }

_ko/tour/inner-classes.md

@@ -12,26 +12,28 @@ previous-page: lower-type-bounds
 
 스칼라의 클래스는 다른 클래스를 멤버로 가질 수 있다. 자바와 같은 언어의 내부 클래스는 자신을 감싸고 있는 클래스의 멤버인 반면에, 스칼라에선 내부 클래스가 외부 객체의 경계 안에 있다. 이런 차이점을 분명히 하기 위해 그래프 데이터타입의 구현을 간단히 그려보자.
 
-    class Graph {
-      class Node {
-        var connectedNodes: List[Node] = Nil
-        def connectTo(node: Node): Unit = {
-          if (!connectedNodes.exists(node.equals)) {
-            connectedNodes = node :: connectedNodes
-          }
-        }
-      }
-      var nodes: List[Node] = Nil
-      def newNode: Node = {
-        val res = new Node
-        nodes = res :: nodes
-        res
+```scala mdoc
+class Graph {
+  class Node {
+    var connectedNodes: List[Node] = Nil
+    def connectTo(node: Node): Unit = {
+      if (!connectedNodes.exists(node.equals)) {
+        connectedNodes = node :: connectedNodes
       }
     }
+  }
+  var nodes: List[Node] = Nil
+  def newNode: Node = {
+    val res = new Node
+    nodes = res :: nodes
+    res
+  }
+}
+```
 
 이 프로그램에선 노드의 리스트로 그래프를 나타냈다. 노드는 내부 클래스 `Node`의 객체다. 각 노드는 리스트 `connectedNodes`에 저장되는 이웃의 목록을 갖고 있다. 이제 몇몇 노드를 선택하고 이에 연결된 노드를 추가하면서 점진적으로 그래프를 구축할 수 있다.
 
-```scala mdoc
+```scala mdoc:nest
 def graphTest: Unit = {
   val g = new Graph
   val n1 = g.newNode

_ko/tour/self-types.md

@@ -88,16 +88,14 @@ previous-page: compound-types
 
 다음은 클래스 `ConcreteDirectedGraph`를 사용하는 예다.
 
-```scala mdoc
-def graphTest: Unit = {
-  val g: Graph = new ConcreteDirectedGraph
-  val n1 = g.addNode
-  val n2 = g.addNode
-  val n3 = g.addNode
-  n1.connectWith(n2)
-  n2.connectWith(n3)
-  n1.connectWith(n3)
-}
-```
+    def graphTest: Unit = {
+      val g: Graph = new ConcreteDirectedGraph
+      val n1 = g.addNode
+      val n2 = g.addNode
+      val n3 = g.addNode
+      n1.connectWith(n2)
+      n2.connectWith(n3)
+      n1.connectWith(n3)
+    }
 
 윤창석, 이한욱 옮김

_pl/tour/inner-classes.md

@@ -32,7 +32,7 @@ class Graph {
 
 W naszym programie grafy są reprezentowane przez listę wierzchołków. Wierzchołki są obiektami klasy wewnętrznej `Node`. Każdy wierzchołek zawiera listę sąsiadów, które są przechowywane w liście `connectedNodes`. Możemy teraz skonfigurować graf z kilkoma wierzchołkami i połączyć je ze sobą:
 
-```scala mdoc
+```scala mdoc:nest
 def graphTest: Unit = {
   val g = new Graph
   val n1 = g.newNode

_pt-br/tour/inner-classes.md

@@ -32,7 +32,7 @@ class Graph {
 
 Em nosso programa, os grafos são representados por uma lista de nós. Os nós são objetos da classe interna `Node`. Cada nó tem uma lista de vizinhos, que são armazenados na lista `connectedNodes`. Agora podemos configurar um grafo com alguns nós e conectar os nós de forma incremental:
 
-```scala mdoc
+```scala mdoc:nest
 def graphTest: Unit = {
   val g = new Graph
   val n1 = g.newNode