remove some more proc syntax

Author: bishabosha

_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)
         }

_es/tour/generic-classes.md

@@ -14,13 +14,15 @@ Tal como en Java 5, Scala provee soporte nativo para clases parametrizados con t
 
 A continuación se muestra un ejemplo:
 
-    class Stack[T] {
-      var elems: List[T] = Nil
-      def push(x: T): Unit =
-    	elems = x :: elems
-      def top: T = elems.head
-      def pop() { elems = elems.tail }
-    }
+```scala mdoc
+class Stack[T] {
+  var elems: List[T] = Nil
+  def push(x: T): Unit =
+  elems = x :: elems
+  def top: T = elems.head
+  def pop(): Unit = { elems = elems.tail }
+}
+```
 
 La clase `Stack` modela una pila mutable que contiene elementos de un tipo arbitrario `T` (se dice, "una pila de elementos `T`). Los parámetros de tipos nos aseguran que solo elementos legales (o sea, del tipo `T`) sean insertados en la pila (apilados). De forma similar, con los parámetros de tipo podemos expresar que el método `top` solo devolverá elementos de un tipo dado (en este caso `T`).
 

_ja/tour/automatic-closures.md

@@ -32,7 +32,7 @@ Scalaはメソッドのパラメータとしてパラメータ無しの関数名
       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)
         }

_ko/tour/automatic-closures.md

@@ -37,7 +37,7 @@ previous-page: operators
       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)
         }

_ko/tour/generic-classes.md

@@ -12,13 +12,15 @@ previous-page: extractor-objects
 
 자바 5(다른 이름은 JDK 1.5와 같이, 스칼라는 타입으로 파라미터화된 클래스의 빌트인 지원을 제공한다. 이런 제네릭 클래스는 특히 컬렉션 클래스의 개발에 유용하다. 이에 관한 예제를 살펴보자.
 
-    class Stack[T] {
-      var elems: List[T] = Nil
-      def push(x: T): Unit =
-        elems = x :: elems
-      def top: T = elems.head
-      def pop() { elems = elems.tail }
-    }
+```scala mdoc
+class Stack[T] {
+  var elems: List[T] = Nil
+  def push(x: T): Unit =
+    elems = x :: elems
+  def top: T = elems.head
+  def pop(): Unit = { elems = elems.tail }
+}
+```
 
 클래스 `Stack`은 임의의 타입 `T`를 항목의 타입으로 하는 명령형(변경 가능한) 스택이다. 타입 파라미터는 올바른 항목(타입 `T` 인)만을 스택에 푸시하도록 강제한다. 마찬가지로 타입 파라미터를 사용해서 메소드 `top`이 항상 지정된 타입만을 반환하도록 할 수 있다.
 

_pl/tour/automatic-closures.md

@@ -39,7 +39,7 @@ object TargetTest2 extends App {
   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)
     }
@@ -68,4 +68,3 @@ i = 3
 i = 2
 i = 1
 ```
-

_pl/tour/generic-classes.md

@@ -17,9 +17,9 @@ Poniższy przykład demonstruje zastosowanie parametrów generycznych:
 class Stack[T] {
   var elems: List[T] = Nil
   def push(x: T): Unit =
-    elems = x :: elems 
+    elems = x :: elems
   def top: T = elems.head
-  def pop() { elems = elems.tail }
+  def pop(): Unit = { elems = elems.tail }
 }
 ```
 

_pt-br/tour/automatic-closures.md

@@ -41,7 +41,7 @@ object TargetTest2 extends App {
   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)
     }

_pt-br/tour/generic-classes.md

@@ -18,7 +18,7 @@ class Stack[T] {
   def push(x: T): Unit =
     elems = x :: elems
   def top: T = elems.head
-  def pop() { elems = elems.tail }
+  def pop(): Unit = { elems = elems.tail }
 }
 ```
 

_ru/tour/automatic-closures.md

@@ -33,7 +33,7 @@ Scala допускает использование в качестве пара
       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)
         }

_tour/automatic-closures.md

@@ -29,21 +29,24 @@ We can combine the use of [infix/postfix operators](operators.html) with this me
 
 Here is the implementation of a loop-unless statement:
 
-    object TargetTest2 extends Application {
-      def loop(body: => Unit): LoopUnlessCond =
-        new LoopUnlessCond(body)
-      protected class LoopUnlessCond(body: => Unit) {
-        def unless(cond: => Boolean) {
-          body
-          if (!cond) unless(cond)
-        }
-      }
-      var i = 10
-      loop {
-        println("i = " + i)
-        i -= 1
-      } unless (i == 0)
+```scala mdoc
+object TargetTest2 extends Application {
+  def loop(body: => Unit): LoopUnlessCond =
+    new LoopUnlessCond(body)
+  protected class LoopUnlessCond(body: => Unit) {
+    def unless(cond: => Boolean): Unit = {
+      body
+      if (!cond) unless(cond)
     }
+  }
+  var i = 10
+  loop {
+    println("i = " + i)
+    i -= 1
+  } unless (i == 0)
+}
+```
+
 The `loop` function just accepts a body of a loop and returns an instance of class `LoopUnlessCond` (which encapsulates this body object). Note that the body didn't get evaluated yet. Class `LoopUnlessCond` has a method `unless` which we can use as a *infix operator*. This way, we achieve a quite natural syntax for our new loop: `loop { < stats > } unless ( < cond > )`.
 
 Here's the output when `TargetTest2` gets executed: