Fix example code example in explicitly-typed-self-references.md and several minor corrections

Author: adam-wyluda

pl/tutorials/tour/abstract-types.md

@@ -12,9 +12,9 @@ tutorial-next: compound-types
 tutorial-previous: inner-classes
 ---
 
-W Scali, klasy są parametryzowane wartościami (parametry konstruktora) oraz typami (jeżeli klasa jest [generyczna](generic-classes.html)). Aby zachować regularność, zarówno typy jak i wartości są elementami klasy. Analogicznie, mogą być konkretne albo abstrakcyjne.
+W Scali, klasy są parametryzowane wartościami (parametry konstruktora) oraz typami (jeżeli klasa jest [generyczna](generic-classes.html)). Aby zachować regularność, zarówno typy jak i wartości są elementami klasy. Analogicznie mogą one być konkretne albo abstrakcyjne.
 
-Poniższy przykład definiuje wartość określaną przez abstrakcyjny typ, będący elementem [cechy](traits.html) `Buffer`:
+Poniższy przykład definiuje wartość określaną przez abstrakcyjny typ będący elementem [cechy](traits.html) `Buffer`:
 
 ```tut
 trait Buffer {
@@ -23,7 +23,7 @@ trait Buffer {
 }
 ```
 
-*Typy abstrakcyjne* są typami, które nie są jednoznacznie określone. W powyższym przykładzie wiemy tylko, że każdy obiekt klasy `Buffer` posiada typ `T`, ale definicja klasy `Buffer` nie zdradza jakiemu konkretnie typowi odpowiada `T`. Tak jak definicje wartość, możemy także nadpisać definicje typów w klasach pochodnych. Pozwala to nam na odkrywanie dodatkowych informacji o abstrakcyjnym typie poprzez zawężanie jego ograniczeń (które opisują możliwe warianty konkretnego typu).
+*Typy abstrakcyjne* są typami, które nie są jednoznacznie określone. W powyższym przykładzie wiemy tylko, że każdy obiekt klasy `Buffer` posiada typ `T`, ale definicja klasy `Buffer` nie zdradza jakiemu konkretnie typowi on odpowiada. Tak jak definicje wartości, możemy także nadpisać definicje typów w klasach pochodnych. Pozwala to nam na odkrywanie dodatkowych informacji o abstrakcyjnym typie poprzez zawężanie jego ograniczeń (które opisują możliwe warianty konkretnego typu).
 
 W poniższym programie definiujemy klasę `SeqBuffer`, która ogranicza możliwe typy `T` do pochodnych sekwencji `Seq[U]` dla nowego typu `U`:
 
@@ -35,7 +35,7 @@ abstract class SeqBuffer extends Buffer {
 }
 ```
 
-Cechy oraz [klasy](classes.html) z abstrakcyjnymi typami są często używane w połączeniu z anonimowymi klasami. Aby to zilustrować wykorzystamy program, w którym utworzymy bufor sekwencji, ograniczony do listy liczb całkowitych:
+Cechy oraz [klasy](classes.html) z abstrakcyjnymi typami są często używane w połączeniu z anonimowymi klasami. Aby to zilustrować wykorzystamy program, w którym utworzymy bufor sekwencji ograniczony do listy liczb całkowitych:
 
 ```tut
 abstract class IntSeqBuffer extends SeqBuffer {
@@ -76,4 +76,4 @@ object AbstractTypeTest2 extends App {
 }
 ```
 
-Należy pamięctać o tym, żeby zastosować [adnotacji wariancji](variance.html). Inaczej nie byłoby możliwe ukrycie konkretnego typu sekwencji obiektu zwracanego przez metodę `newIntSeqBuf`.
+Należy też pamiętać o tym, żeby zastosować [adnotacji wariancji](variance.html). Inaczej nie byłoby możliwe ukrycie konkretnego typu sekwencji obiektu zwracanego przez metodę `newIntSeqBuf`.

pl/tutorials/tour/annotations.md

@@ -13,11 +13,11 @@ language: pl
 
 Adnotacje dodają meta-informacje do różnego rodzaju definicji.
 
-Podstawową formą adnotacji jest `@C` lub `@C(a1, ..., an)`. Tutaj `C` jest konstruktorem klasy `C`, który musi odpowiadać klasie `scala.Annotation`. Wszystkie argumenty konstruktora `a1, ..., an` muszą być stałymi wyrażeniami (czyli wyrażeniami takimi jak liczby, łańcuchy znaków, literały klasowe, enumeracji Javy oraz ich jednowymiarowe tablice).
+Podstawową formą adnotacji jest `@C` lub `@C(a1, ..., an)`. Tutaj `C` jest konstruktorem klasy `C`, który musi odpowiadać klasie `scala.Annotation`. Wszystkie argumenty konstruktora `a1, ..., an` muszą być stałymi wyrażeniami (czyli wyrażeniami takimi jak liczby, łańcuchy znaków, literały klasowe, enumeracje Javy oraz ich jednowymiarowe tablice).
 
 Adnotację stosuje się do pierwszej definicji lub deklaracji która po niej następuje. Możliwe jest zastosowanie więcej niż jednej adnotacji przed definicją lub deklaracją. Kolejność według której są one określone nie ma istotnego znaczenia.
 
-Znaczenie adnotacji jest zależne od implementacji. Na platformie Java, poniższe adnotacje mają standardowe znaczenie:
+Znaczenie adnotacji jest zależne od implementacji. Na platformie Java, poniższe adnotacje domyślnie oznaczają:
 
 |           Scala           |           Java           |
 |           ------          |          ------          |

pl/tutorials/tour/explicitly-typed-self-references.md

@@ -67,14 +67,30 @@ Jeżeli przyjrzymy się bliżej implementacji metody `connectWith`, możemy dost
 Scala rozwiązuje ten problem pozwalając na powiązanie klasy z innym typem poprzez jawne typowanie samoreferencji. Możemy użyć tego mechanizmu, aby naprawić powyższy kod:
 
 ```tut
-class NodeImpl extends NodeIntf {
-  self: Node =>                     // określenie typu "self"
-  def connectWith(node: Node): Edge = {
-    val edge = newEdge(this, node)  // w tej chwili się skompiluje
-    edges = edge :: edges
-    edge
-  }
-}
+    abstract class DirectedGraph extends Graph {
+      type Edge <: EdgeImpl
+      class EdgeImpl(origin: Node, dest: Node) {
+        def from = origin
+        def to = dest
+      }
+      class NodeImpl extends NodeIntf {
+        self: Node =>                     // określenie typu "self"
+        def connectWith(node: Node): Edge = {
+          val edge = newEdge(this, node)  // w tej chwili się skompiluje
+          edges = edge :: edges
+          edge
+        }
+      }
+      protected def newNode: Node
+      protected def newEdge(from: Node, to: Node): Edge
+      var nodes: List[Node] = Nil
+      var edges: List[Edge] = Nil
+      def addNode: Node = {
+        val node = newNode
+        nodes = node :: nodes
+        node
+      }
+    }
 ```
 
 W nowej definicji klasy `NodeImpl` referencja `this` jest typu `Node`. Ponieważ typ `Node` jest abstrakcyjny i stąd nie wiemy jeszczy, czy `NodeImpl` w rzeczywistości odpowiada `Node`, system typów w Scali nie pozwoli nam na utworzenie tego typu. Mimo wszystko za pomocą jawnej adnotacji typu stwierdzamy, że w pewnym momencie klasa pochodna od `NodeImpl` musi odpowiadać typowi `Node` aby dało się ją utworzyć.