remove some procedure syntax

Author: bishabosha

_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,7 +69,7 @@ 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 {
@@ -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`.

_es/tour/inner-classes.md

@@ -15,7 +15,7 @@ En Scala es posible que las clases tengan como miembro otras clases. A diferenci
     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
           }

_ja/tour/inner-classes.md

@@ -19,7 +19,7 @@ Javaのような、内部クラスが外側のクラスのメンバーとなる
 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
       }

_ko/tour/inner-classes.md

@@ -11,11 +11,11 @@ previous-page: lower-type-bounds
 ---
 
 스칼라의 클래스는 다른 클래스를 멤버로 가질 수 있다. 자바와 같은 언어의 내부 클래스는 자신을 감싸고 있는 클래스의 멤버인 반면에, 스칼라에선 내부 클래스가 외부 객체의 경계 안에 있다. 이런 차이점을 분명히 하기 위해 그래프 데이터타입의 구현을 간단히 그려보자.
- 
+
     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
           }
@@ -28,9 +28,9 @@ previous-page: lower-type-bounds
         res
       }
     }
- 
+
 이 프로그램에선 노드의 리스트로 그래프를 나타냈다. 노드는 내부 클래스 `Node`의 객체다. 각 노드는 리스트 `connectedNodes`에 저장되는 이웃의 목록을 갖고 있다. 이제 몇몇 노드를 선택하고 이에 연결된 노드를 추가하면서 점진적으로 그래프를 구축할 수 있다.
- 
+
     object GraphTest extends App {
       val g = new Graph
       val n1 = g.newNode
@@ -39,9 +39,9 @@ previous-page: lower-type-bounds
       n1.connectTo(n2)
       n3.connectTo(n1)
     }
- 
+
 정의된 여러 엔티티의 타입이 무엇인지 명시적으로 알려주는 타입 정보를 사용해 위의 예제를 확장해보자.
- 
+
     object GraphTest extends App {
       val g: Graph = new Graph
       val n1: g.Node = g.newNode
@@ -50,10 +50,10 @@ previous-page: lower-type-bounds
       n1.connectTo(n2)
       n3.connectTo(n1)
     }
- 
+
 이 코드는 외부 인스턴스(이 예제의 객체 `g`)를 접두어로 지정해 노드 타입을 분명히 나타내고 있다. 두 그래프가 있는 상황에서, 스칼라의 타입 시스템은 한 그래프에 정의된 노드를 다른 그래프에서도 정의해 공유하는 상황을 허용하지 않는다. 이는 다른 그래프의 노드는 다른 타입을 갖기 때문이다.
 다음은 잘못된 프로그램이다.
- 
+
     object IllegalGraphTest extends App {
       val g: Graph = new Graph
       val n1: g.Node = g.newNode
@@ -63,9 +63,9 @@ previous-page: lower-type-bounds
       val n3: h.Node = h.newNode
       n1.connectTo(n3)      // illegal!
     }
- 
+
 자바에선 이 예제 프로그램의 마지막 줄이 올바른 표현임을 상기하자. 자바는 두 그래프의 노드에 `Graph.Node`라는 동일한 타입을 할당한다. 즉, `Node`에는 클래스 `Graph`가 접두어로 붙는다. 스칼라에서도 이런 타입을 표현할 수 있으며, 이를 `Graph#Node`로 나타낸다. 서로 다른 그래프 간에 노드를 연결할 수 있길 원한다면 초기 그래프 구현의 정의를 다음과 같이 변경해야 한다.
- 
+
     class Graph {
       class Node {
         var connectedNodes: List[Graph#Node] = Nil
@@ -82,7 +82,7 @@ previous-page: lower-type-bounds
         res
       }
     }
- 
+
 > 이 프로그램에선 하나의 노드를 서로 다른 두 그래프에 추가할 수 없음에 주의하자. 이 제약도 함께 제거하기 위해선 변수 nodes의 타입을 `Graph#Node`로 바꿔야 한다.
 
 윤창석, 이한욱 옮김

_pl/tour/inner-classes.md

@@ -10,12 +10,12 @@ previous-page: lower-type-bounds
 ---
 
 W Scali możliwe jest zdefiniowanie klasy jako element innej klasy. W przeciwieństwie do języków takich jak Java, gdzie tego typu wewnętrzne klasy są elementami ujmujących ich klas, w Scali są one związane z zewnętrznym obiektem. Aby zademonstrować tę różnicę, stworzymy teraz prostą implementację grafu:
- 
+
 ```scala mdoc
 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
       }
@@ -29,9 +29,9 @@ 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
 object GraphTest extends App {
   val g = new Graph
@@ -42,9 +42,9 @@ object GraphTest extends App {
   n3.connectTo(n1)
 }
 ```
- 
+
 Teraz wzbogacimy nasz przykład o jawne typowanie, aby można było zobaczyć powiązanie typów wierzchołków z grafem:
- 
+
 ```scala mdoc:nest
 object GraphTest extends App {
   val g: Graph = new Graph
@@ -55,11 +55,11 @@ object GraphTest extends App {
   n3.connectTo(n1)
 }
 ```
- 
+
 Ten kod pokazuje, że typ wierzchołka jest prefiksowany przez swoją zewnętrzną instancję (która jest obiektem `g` w naszym przykładzie). Jeżeli mielibyśmy dwa grafy, system typów w Scali nie pozwoli nam na pomieszanie wierzchołków jednego z wierzchołkami drugiego, ponieważ wierzchołki drugiego grafu są określone przez inny typ.
 
 Przykład niedopuszczalnego programu:
- 
+
 ```scala mdoc:fail
 object IllegalGraphTest extends App {
   val g: Graph = new Graph
@@ -71,9 +71,9 @@ object IllegalGraphTest extends App {
   n1.connectTo(n3)      // niedopuszczalne!
 }
 ```
- 
+
 Warto zwrócić uwagę na to, że ostatnia linia poprzedniego przykładu byłaby poprawnym programem w Javie. Dla wierzchołków obu grafów Java przypisałaby ten sam typ `Graph.Node`. W Scali także istnieje możliwość wyrażenia takiego typu, zapisując go w formie: `Graph#Node`. Jeżeli byśmy chcieli połączyć wierzchołki różnych grafów, musielibyśmy wtedy zmienić definicję implementacji naszego grafu w następujący sposób:
- 
+
 ```scala mdoc:nest
 class Graph {
   class Node {
@@ -92,5 +92,5 @@ class Graph {
   }
 }
 ```
- 
+
 > Ważne jest, że ten program nie pozwala nam na dołączenie wierzchołka do dwóch różnych grafów. Jeżeli chcielibyśmy znieść to ograniczenie, należy zmienić typ zmiennej `nodes` na `Graph#Node`.

_pt-br/tour/inner-classes.md

@@ -15,7 +15,7 @@ Em Scala é possível declarar classes que tenham outras classes como membros. E
 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
       }
@@ -31,7 +31,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
 object GraphTest extends App {
   val g = new Graph
@@ -44,7 +44,7 @@ object GraphTest extends App {
 ```
 
 Agora melhoramos o exemplo acima com tipos, para assim declarar explicitamente qual o tipo das várias entidades definidas:
- 
+
 ```scala mdoc:nest
 object GraphTest extends App {
   val g: Graph = new Graph
@@ -58,7 +58,7 @@ object GraphTest extends App {
 
 Este código mostra claramente que o tipo nó é prefixado com sua instância externa (em nosso exemplo é o objeto `g`). Se agora temos dois grafos, o sistema de tipos de Scala não nos permite misturar nós definidos dentro de um grafo com os nós de outro, já que os nós do outro grafo têm um tipo diferente.
 Aqui está um programa inválido:
- 
+
 ```scala mdoc:fail
 object IllegalGraphTest extends App {
   val g: Graph = new Graph
@@ -72,7 +72,7 @@ object IllegalGraphTest extends App {
 ```
 
 Observe que em Java a última linha no programa do exemplo anterior é válida. Para nós de ambos os grafos, Java atribuiria o mesmo tipo `Graph.Node`; isto é, `Node` é prefixado com a classe `Graph`. Em Scala, esse tipo também pode ser expresso, e é escrito `Graph#Node`. Se quisermos ser capazes de conectar nós de diferentes grafos, temos que mudar a definição inicial da nossa implementação do grafo da seguinte maneira:
- 
+
 ```scala mdoc:nest
 class Graph {
   class Node {

_ru/tour/inner-classes.md

@@ -8,15 +8,15 @@ next-page: abstract-type-members
 previous-page: lower-type-bounds
 ---
 
-В Scala классам можно иметь в качестве членов другие классы. В отличие от Java-подобных языков, где такие внутренние классы являются членами окружающего класса, в Scala такие внутренние классы привязаны к содержащему его объекту. Предположим, мы хотим, чтобы компилятор не позволял нам на этапе компиляции смешивать узлы этого графа. Для решения этой задачи нам подойдут типы, зависящие от своего расположения. 
+В Scala классам можно иметь в качестве членов другие классы. В отличие от Java-подобных языков, где такие внутренние классы являются членами окружающего класса, в Scala такие внутренние классы привязаны к содержащему его объекту. Предположим, мы хотим, чтобы компилятор не позволял нам на этапе компиляции смешивать узлы этого графа. Для решения этой задачи нам подойдут типы, зависящие от своего расположения.
 
 Чтобы проиллюстрировать суть подхода, мы быстро набросаем реализацию такого графа:
 
 ```scala mdoc
 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
       }

_zh-cn/tour/inner-classes.md

@@ -19,7 +19,7 @@ previous-page: lower-type-bounds
 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
       }
@@ -77,4 +77,3 @@ class Graph {
   }
 }
 ```
-