From 3c14f0f13d2f396e851642acb222c6b16a12901b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Pociecha?= <michal.pociecha@gmail.com>
Date: Sun, 12 Feb 2017 21:07:24 +0100
Subject: [PATCH] Improve punctuation in Polish translation

Other than that there are a few changes related to wording etc.
---
 .../tour/_posts/2017-02-13-abstract-types.md     |  6 +++---
 .../tour/_posts/2017-02-13-annotations.md        |  8 ++++----
 .../tour/_posts/2017-02-13-automatic-closures.md |  4 ++--
 .../tour/_posts/2017-02-13-case-classes.md       | 10 +++++-----
 pl/tutorials/tour/_posts/2017-02-13-classes.md   |  2 +-
 pl/tutorials/tour/_posts/2017-02-13-currying.md  |  4 ++--
 .../2017-02-13-default-parameter-values.md       |  2 +-
 .../tour/_posts/2017-02-13-extractor-objects.md  |  4 ++--
 .../_posts/2017-02-13-higher-order-functions.md  |  4 ++--
 .../_posts/2017-02-13-implicit-conversions.md    |  6 +++---
 .../_posts/2017-02-13-implicit-parameters.md     |  4 ++--
 .../tour/_posts/2017-02-13-inner-classes.md      |  2 +-
 .../_posts/2017-02-13-local-type-inference.md    |  2 +-
 .../tour/_posts/2017-02-13-lower-type-bounds.md  |  6 +++---
 .../_posts/2017-02-13-mixin-class-composition.md |  6 +++---
 pl/tutorials/tour/_posts/2017-02-13-operators.md |  2 +-
 .../tour/_posts/2017-02-13-pattern-matching.md   |  6 +++---
 .../_posts/2017-02-13-polymorphic-methods.md     |  4 ++--
 .../2017-02-13-regular-expression-patterns.md    |  2 +-
 .../_posts/2017-02-13-sequence-comprehensions.md |  4 ++--
 .../tour/_posts/2017-02-13-singleton-objects.md  | 16 ++++++++--------
 .../tour/_posts/2017-02-13-tour-of-scala.md      | 14 +++++++-------
 pl/tutorials/tour/_posts/2017-02-13-traits.md    |  4 ++--
 .../tour/_posts/2017-02-13-unified-types.md      |  4 ++--
 .../tour/_posts/2017-02-13-upper-type-bounds.md  |  2 +-
 pl/tutorials/tour/_posts/2017-02-13-variances.md |  4 ++--
 26 files changed, 66 insertions(+), 66 deletions(-)

diff --git a/pl/tutorials/tour/_posts/2017-02-13-abstract-types.md b/pl/tutorials/tour/_posts/2017-02-13-abstract-types.md
index 2e8ed1059c..f10b877fd3 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-abstract-types.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-abstract-types.md
@@ -13,7 +13,7 @@ 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ą one 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`:
  
@@ -36,7 +36,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 {
@@ -57,7 +57,7 @@ object AbstractTypeTest1 extends App {
  
 Typ zwracany przez metodę `newIntSeqBuf` nawiązuje do specjalizacji cechy `Buffer`, w której typ `U` jest równy `Int`. Podobnie w anonimowej klasie tworzonej w metodzie `newIntSeqBuf` określamy `T` jako `List[Int]`.
 
-Warto zwrócić uwagę na to, że często jest możliwa zamiana abstrakcyjnych typów w parametry typów klas i odwrotnie. Poniższy przykład stosuje wyłącznie parametry typów:
+Warto zwrócić uwagę, że często jest możliwa zamiana abstrakcyjnych typów w parametry typów klas i odwrotnie. Poniższy przykład stosuje wyłącznie parametry typów:
  
 ```tut
 abstract class Buffer[+T] {
diff --git a/pl/tutorials/tour/_posts/2017-02-13-annotations.md b/pl/tutorials/tour/_posts/2017-02-13-annotations.md
index d0c1972ac1..88882dda35 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-annotations.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-annotations.md
@@ -18,7 +18,7 @@ Podstawową formą adnotacji jest `@C` lub `@C(a1, ..., an)`. Tutaj `C` jest kon
 
 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 domyślnie oznaczają:
+Znaczenie adnotacji jest zależne od implementacji. Na platformie Java poniższe adnotacje domyślnie oznaczają:
 
 |           Scala           |           Java           |
 |           ------          |          ------          |
@@ -37,8 +37,8 @@ Znaczenie adnotacji jest zależne od implementacji. Na platformie Java, poniższ
 
 W poniższym przykładzie dodajemy adnotację `throws` do definicji metody `read` w celu obsługi rzuconego wyjątku w programie w Javie.
 
-> Kompilator Javy sprawdza czy program zawiera obsługę dla [wyjątków kontrolowanych](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html) poprzez sprawdzenie, które wyjątki mogą być wynikiem wykonania metody lub konstruktora. Dla każdego kontrolowanego wyjątku który może być wynikiem wykonania, adnotacja **throws** musi określić klasę tego wyjątku lub jedną z jej klas bazowych.
-> Ponieważ Scala nie pozwala na definiowanie wyjątków kontrolowanych, jeżeli chcemy obsłużyć wyjątek z kodu w Scali w Javie, należy dodać jedną lub więcej adnotacji `throws` określającej klasy wyjątków przez nią rzucanych.
+> Kompilator Javy sprawdza, czy program zawiera obsługę dla [wyjątków kontrolowanych](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html) poprzez sprawdzenie, które wyjątki mogą być wynikiem wykonania metody lub konstruktora. Dla każdego kontrolowanego wyjątku, który może być wynikiem wykonania, adnotacja **throws** musi określić klasę tego wyjątku lub jedną z jej klas bazowych.
+> Ponieważ Scala nie pozwala na definiowanie wyjątków kontrolowanych, jeżeli chcemy obsłużyć wyjątek z kodu w Scali w Javie, należy dodać jedną lub więcej adnotacji `throws` określających klasy rzucanych wyjątków.
 
 ```
 package examples
@@ -123,7 +123,7 @@ Następnie ją można zastosować:
 public class MyClass extends HisClass ...
 ```
 
-W tym przypadku, Scala daje taką samą możliwość:
+W tym przypadku Scala daje taką samą możliwość:
 
 ```
 @SourceURL("http://coders.com/")
diff --git a/pl/tutorials/tour/_posts/2017-02-13-automatic-closures.md b/pl/tutorials/tour/_posts/2017-02-13-automatic-closures.md
index c42a8a1f29..f99b8affe1 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-automatic-closures.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-automatic-closures.md
@@ -31,7 +31,7 @@ object TargetTest1 extends App {
 }
 ```
 
-Funkcja `whileLoop` pobiera dwa parametry: `cond` i `body`. Kiedy funkcja jest aplikowana, jej właściwe parametry nie są ewaluowane. Lecz gdy te parametry są wykorzystane w ciele `whileLoop`, zostanie ewaluowana niejawnie utworzona funkcja, zwracająca ich prawdziwą wartość. Zatem metoda `whileLoop` implementuje rekursywnie pętlę while w stylu Javy.
+Funkcja `whileLoop` pobiera dwa parametry: `cond` i `body`. Kiedy funkcja jest aplikowana, jej właściwe parametry nie są ewaluowane. Lecz gdy te parametry są wykorzystane w ciele `whileLoop`, zostanie ewaluowana niejawnie utworzona funkcja zwracająca ich prawdziwą wartość. Zatem metoda `whileLoop` implementuje rekursywnie pętlę while w stylu Javy.
 
 Możemy połączyć ze sobą wykorzystanie [operatorów infiksowych/postfiksowych](operators.html) z tym mechanizmem aby utworzyć bardziej złożone wyrażenia.
 
@@ -55,7 +55,7 @@ object TargetTest2 extends App {
 }
 ```
 
-Funkcja `loop` przyjmuje ciało pętli oraz zwraca instancję klasy `LoopUnlessCond` (która enkapsuluje to ciało). Warto zwrócić uwagę, że ciało tej funkcji nie zostało jeszcze ewaluowane. Klasa `LoopUnlessCond` posiada metodę `unless`, którą możemy wykorzystać jako *operator infiksowy*. W ten sposób, uzyskaliśmy całkiem naturalną składnię dla naszej nowej pętli: `loop { < stats > } unless ( < cond > )`.
+Funkcja `loop` przyjmuje ciało pętli oraz zwraca instancję klasy `LoopUnlessCond` (która enkapsuluje to ciało). Warto zwrócić uwagę, że ciało tej funkcji nie zostało jeszcze ewaluowane. Klasa `LoopUnlessCond` posiada metodę `unless`, którą możemy wykorzystać jako *operator infiksowy*. W ten sposób uzyskaliśmy całkiem naturalną składnię dla naszej nowej pętli: `loop { < stats > } unless ( < cond > )`.
 
 Oto wynik działania programu `TargetTest2`:
 
diff --git a/pl/tutorials/tour/_posts/2017-02-13-case-classes.md b/pl/tutorials/tour/_posts/2017-02-13-case-classes.md
index e5fb094c1c..dab5eca2e6 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-case-classes.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-case-classes.md
@@ -47,7 +47,7 @@ W klasach przypadków nie można modyfikować wartości pól. (Z wyjątkiem sytu
 emailFromJohn.title = "Goodbye From John!" // Jest to błąd kompilacji, gdyż pola klasy przypadku są domyślnie niezmienne
 ```
 
-Zamiast tego, możesz utworzyć kopię używając metody `copy`:
+Zamiast tego możesz utworzyć kopię używając metody `copy`:
 
 ```tut
 val editedEmail = emailFromJohn.copy(title = "I am learning Scala!", body = "It's so cool!")
@@ -56,7 +56,7 @@ println(emailFromJohn) // wypisuje "Email(john.doe@mail.com,Greetings From John!
 println(editedEmail) // wypisuje "Email(john.doe@mail.com,I am learning Scala,It's so cool!)"
 ```
 
-Dla każdej klasy przypadku kompilator Scali wygeneruje metodę `equals`, która implementuje strukturalne porównanie obiektów oraz metodę `toString`. Przykład:
+Dla każdej klasy przypadku kompilator Scali wygeneruje metodę `equals` implementującą strukturalne porównanie obiektów oraz metodę `toString`. Przykład:
 
 ```tut
 val firstSms = SMS("12345", "Hello!")
@@ -76,7 +76,7 @@ They are equal!
 SMS is: SMS(12345, Hello!)
 ```
 
-Jednym z najważniejszych zastosowań klas przypadków (skąd też się wzięła ich nazwa), jest **dopasowanie wzorca**. Poniższy przykład pokazuje działanie funkcji, która zwraca różne komunikaty, w zależności od rodzaju powiadomienia:
+Jednym z najważniejszych zastosowań klas przypadków (skąd też się wzięła ich nazwa) jest **dopasowanie wzorca**. Poniższy przykład pokazuje działanie funkcji, która zwraca różne komunikaty w zależności od rodzaju powiadomienia:
 
 ```tut
 def showNotification(notification: Notification): String = {
@@ -135,10 +135,10 @@ println(showNotificationSpecial(specialSms, SPECIAL_EMAIL, SPECIAL_NUMBER))
 
 ```
 
-Programując w Scali, zachęca się abyś jak najszerzej używał klas przypadków do modelowania danych, jako że kod który je wykorzystuje jest bardziej ekspresywny i łatwiejszy do utrzymania:
+Programując w Scali zachęca się, abyś jak najszerzej używał klas przypadków do modelowania danych, jako że kod, który je wykorzystuje, jest bardziej ekspresywny i łatwiejszy do utrzymania:
 
 * Obiekty niemutowalne uwalniają cię od potrzeby śledzenia zmian stanu
-* Porównanie przez wartość pozwala na porównywanie instancji tak jakby były prymitywnymi wartościami
+* Porównanie przez wartość pozwala na porównywanie instancji tak, jakby były prymitywnymi wartościami
 * Dopasowanie wzorca znacząco upraszcza logikę rozgałęzień, co prowadzi do mniejszej ilości błędów i czytelniejszego kodu
 
 
diff --git a/pl/tutorials/tour/_posts/2017-02-13-classes.md b/pl/tutorials/tour/_posts/2017-02-13-classes.md
index e8137017e4..ec97b5aeb7 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-classes.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-classes.md
@@ -44,7 +44,7 @@ object Classes {
 }
 ```
 
-Program definiuje wykonywalną aplikację w postaci [obiektu singleton](singleton-objects.html) z główną metodą `main`. Metoda `main` tworzy nową instancję typu `Point` i zapisuje ją do wartości `pt`. Istotną rzeczą jest to, że wartości zdefiniowane z użyciem słowa kluczowego `val` różnią się od zmiennych określonych przez `var` (jak w klasie `Point` powyżej), tym że nie dopuszczają aktualizacji ich wartości.
+Program definiuje wykonywalną aplikację w postaci [obiektu singleton](singleton-objects.html) z główną metodą `main`. Metoda `main` tworzy nową instancję typu `Point` i zapisuje ją do wartości `pt`. Istotną rzeczą jest to, że wartości zdefiniowane z użyciem słowa kluczowego `val` różnią się od zmiennych określonych przez `var` (jak w klasie `Point` powyżej) tym, że nie dopuszczają aktualizacji ich wartości.
 
 Wynik działania programu:
 
diff --git a/pl/tutorials/tour/_posts/2017-02-13-currying.md b/pl/tutorials/tour/_posts/2017-02-13-currying.md
index 91d8b9848c..069ff853ff 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-currying.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-currying.md
@@ -12,7 +12,7 @@ tutorial-next: case-classes
 tutorial-previous: nested-functions
 ---
 
-Funkcja może określić dowolną ilość list parametrów. Kiedy jest ona wywołana dla mniejszej liczby niż zostało to zdefiniowane, wtedy zwraca ona funkcję pobierającą dalsze listy parametrów jako jej argument.
+Funkcja może określić dowolną ilość list parametrów. Kiedy jest ona wywołana dla mniejszej liczby niż zostało to zdefiniowane, zwraca funkcję pobierającą dalsze listy parametrów jako jej argument.
 
 Przykład rozwijania funkcji:
 
@@ -32,7 +32,7 @@ object CurryTest extends App {
 }
 ```
 
-_Uwaga: metoda `modN` jest częściowo zastosowana dla dwóch wywołań `filter`, gdyż jest wywołana tylko dla jej pierwszego argumentu. Wyrażenie `modN(2)` zwraca funkcję typu `Int => Boolean` stąd też może być przekazane jako drugi argument funkcji `filter`._
+_Uwaga: metoda `modN` jest częściowo zastosowana dla dwóch wywołań `filter`, gdyż jest wywołana tylko dla jej pierwszego argumentu. Wyrażenie `modN(2)` zwraca funkcję typu `Int => Boolean` - stąd też może być przekazane jako drugi argument funkcji `filter`._
 
 Wynik działania powyższego programu:
 
diff --git a/pl/tutorials/tour/_posts/2017-02-13-default-parameter-values.md b/pl/tutorials/tour/_posts/2017-02-13-default-parameter-values.md
index 3e55846c68..bc67155828 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-default-parameter-values.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-default-parameter-values.md
@@ -70,4 +70,4 @@ val m3 = new HashMap[String,Int](20,0.8f)
 val m4 = new HashMap[String,Int](loadFactor = 0.8f)
 ```
 
-Należy zwrócić uwagę na to, w jaki sposób możemy wykorzystać *dowolną* domyślną wartość poprzez użycie [parametrów nazwanych](named-parameters.html).
+Należy zwrócić uwagę, w jaki sposób możemy wykorzystać *dowolną* domyślną wartość poprzez użycie [parametrów nazwanych](named-parameters.html).
diff --git a/pl/tutorials/tour/_posts/2017-02-13-extractor-objects.md b/pl/tutorials/tour/_posts/2017-02-13-extractor-objects.md
index de03c13668..db33e4784d 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-extractor-objects.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-extractor-objects.md
@@ -12,7 +12,7 @@ tutorial-next: sequence-comprehensions
 tutorial-previous: regular-expression-patterns
 ---
 
-W Scali, wzorce mogą być zdefiniowane niezależnie od klas przypadków. Obiekt posiadający metodę `unapply` może funkcjonować jako tak zwany ekstraktor. Jest to szczególna metoda, która pozwala na odwrócenie zastosowania obiektu dla pewnych danych. Jego celem jest ekstrakcja danych, z których został on utworzony. Dla przykładu, poniższy kod definiuje ekstraktor dla [obiektu](singleton-objects.html) `Twice`:
+W Scali wzorce mogą być zdefiniowane niezależnie od klas przypadków. Obiekt posiadający metodę `unapply` może funkcjonować jako tak zwany ekstraktor. Jest to szczególna metoda, która pozwala na odwrócenie zastosowania obiektu dla pewnych danych. Jego celem jest ekstrakcja danych, z których został on utworzony. Dla przykładu, poniższy kod definiuje ekstraktor dla [obiektu](singleton-objects.html) `Twice`:
 
 ```tut
 object Twice {
@@ -38,6 +38,6 @@ Typ zwracany przez `unapply` powinien odpowiadać jednemu przypadkowi:
 * Jeżeli zwraca pojedynczą wartość typu T, powinien zwrócić `Option[T]`
 * Jeżeli zwraca kilka wartości typów: `T1, ..., Tn`, należy je pogrupować jako opcjonalna krotka `Option[(T1, ..., Tn)]`
 
-Zdarza się, że chcielibyśmy dopasować określoną liczbę wartości oraz sekwencję. Z tego powodu, możesz także zdefiniować wzorce poprzez metodę `unapplySeq`. Ostatnia wartość typu `Tn` powinna być `Seq[S]`. Ten mechanizm pozwala na dopasowanie wzorców takich jak `case List(x1, ..., xn)`.
+Zdarza się, że chcielibyśmy dopasować określoną liczbę wartości oraz sekwencję. Z tego powodu możesz także zdefiniować wzorce poprzez metodę `unapplySeq`. Ostatnia wartość typu `Tn` powinna być `Seq[S]`. Ten mechanizm pozwala na dopasowanie wzorców takich jak `case List(x1, ..., xn)`.
 
 Ekstraktory sprawiają, że kod jest łatwiejszy do utrzymania. Aby dowiedzieć się więcej, możesz przeczytać publikację ["Matching Objects with Patterns"](http://lamp.epfl.ch/~emir/written/MatchingObjectsWithPatterns-TR.pdf) (zobacz sekcję 4) autorstwa Emir, Odersky i Williams (styczeń 2007).
diff --git a/pl/tutorials/tour/_posts/2017-02-13-higher-order-functions.md b/pl/tutorials/tour/_posts/2017-02-13-higher-order-functions.md
index b6a1d396cd..1026c2572c 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-higher-order-functions.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-higher-order-functions.md
@@ -12,7 +12,7 @@ tutorial-next: nested-functions
 tutorial-previous: anonymous-function-syntax
 ---
 
-Scala pozwala na definiowanie funkcji wyższego rzędu. Są to funkcje, które przyjmują funkcje jako parametry lub których wynik jest też funkcją. Poniżej znajduje się przykład funkcji `apply` który pobiera inną funkcję `f` i wartość `v`, po to by zwrócić wynik zastosowania `f` do `v`:
+Scala pozwala na definiowanie funkcji wyższego rzędu. Są to funkcje, które przyjmują funkcje jako parametry lub których wynik jest też funkcją. Poniżej znajduje się przykład funkcji `apply`, która pobiera inną funkcję `f` i wartość `v` po to, by zwrócić wynik zastosowania `f` do `v`:
 
 ```tut
 def apply(f: Int => String, v: Int) = f(v)
@@ -40,4 +40,4 @@ Wykonanie zwraca poniższy wynik:
 [7]
 ```
 
-W tym przykładzie, metoda `decorator.layout` jest automatycznie konwertowana do funkcji typu `Int => String`, czego wymaga funkcja `apply`. Warto dodać, że metoda `decorator.layout` jest polimorficzna, co oznacza, że jej sygnatura jest odpowiednio dopasowana przez kompilator, dzięki czemu gdy jest przekazana do funkcji `apply`, jest ona traktowana jako `Int => String`.
+W tym przykładzie metoda `decorator.layout` jest automatycznie konwertowana do funkcji typu `Int => String`, czego wymaga funkcja `apply`. Warto dodać, że metoda `decorator.layout` jest polimorficzna, co oznacza, że jej sygnatura jest odpowiednio dopasowana przez kompilator, dzięki czemu, gdy jest przekazana do funkcji `apply`, jest ona traktowana jako `Int => String`.
diff --git a/pl/tutorials/tour/_posts/2017-02-13-implicit-conversions.md b/pl/tutorials/tour/_posts/2017-02-13-implicit-conversions.md
index 752a909026..f40ee628bb 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-implicit-conversions.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-implicit-conversions.md
@@ -19,7 +19,7 @@ Konwersje niejawne mogą być są zastosowane w jednej z dwóch sytuacji:
 * Jeżeli wyrażenie `e` jest typu `S` i `S` nie odpowiada wymaganemu typowi `T`.
 * W przypadku wyboru `e.m` z `e` typu `T`, jeżeli `m` nie jest elementem `T`.
 
-W pierwszym przypadku wyszukiwana jest konwersja `c`, którą można zastosować do `e` aby uzyskać wynik typu `T`.
+W pierwszym przypadku wyszukiwana jest konwersja `c`, którą można zastosować do `e`, aby uzyskać wynik typu `T`.
 W drugim przypadku wyszukiwana jest konwersja `c`, którą można zastosować do `e` i której wynik zawiera element nazwany `m`.
 
 Poniższa operacja na dwóch listach `xs` oraz `ys` typu `List[Int]` jest dopuszczalna:
@@ -28,7 +28,7 @@ Poniższa operacja na dwóch listach `xs` oraz `ys` typu `List[Int]` jest dopusz
 xs <= ys
 ```
 
-Zakładając, że metody niejawne `list2ordered` oraz `int2ordered` zdefiniowane poniżej znajdują się w danym zakresie:
+Zakładając że metody niejawne `list2ordered` oraz `int2ordered` zdefiniowane poniżej znajdują się w danym zakresie:
 
 ```
 implicit def list2ordered[A](x: List[A])
@@ -50,4 +50,4 @@ implicit def int2Integer(x: Int) =
   java.lang.Integer.valueOf(x)
 ```
 
-Aby zdefiniować własne konwersje niejawne, należy zaimportować `scala.language.implicitConversions` (albo uruchomić kompilator z opcją `-language:implicitConversions`). Ta funkcjonalność musi być włączona jawnie, ze względu na problemy jakie mogą się wiązać z ich nadmiernym stosowaniem.
+Aby zdefiniować własne konwersje niejawne, należy zaimportować `scala.language.implicitConversions` (albo uruchomić kompilator z opcją `-language:implicitConversions`). Ta funkcjonalność musi być włączona jawnie ze względu na problemy, jakie mogą się wiązać z ich nadmiernym stosowaniem.
diff --git a/pl/tutorials/tour/_posts/2017-02-13-implicit-parameters.md b/pl/tutorials/tour/_posts/2017-02-13-implicit-parameters.md
index 4b28a4922d..67485941c3 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-implicit-parameters.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-implicit-parameters.md
@@ -14,7 +14,7 @@ tutorial-previous: explicitly-typed-self-references
 
 Metodę z _parametrami domniemanymi_ można stosować tak samo jak każdą zwyczajną metodę. W takim przypadku etykieta `implicit` nie ma żadnego znaczenia. Jednak jeżeli odpowiednie argumenty dla parametrów domniemanych nie zostaną jawnie określone, to kompilator dostarczy je automatycznie.
 
-Argumenty które mogą być przekazywane jako parametry domniemane można podzielić na dwie kategorie:
+Argumenty, które mogą być przekazywane jako parametry domniemane, można podzielić na dwie kategorie:
 
 * Najpierw dobierane są takie identyfikatory, które są dostępne bezpośrednio w punkcie wywołania metody i które określają definicję lub parametr domniemany.
 * W drugiej kolejności dobrane mogą być elementy modułów towarzyszących odpowiadających typom tych parametrów domniemanych, które są oznaczone jako `implicit`.
@@ -45,7 +45,7 @@ object ImplicitTest extends App {
     if (xs.isEmpty) m.unit
     else m.add(xs.head, sum(xs.tail))
 
-  /** Wywołamy tutaj dwa razy sum, podając za każdym razem tylko listę. Ponieważ drugi parametr (m) jest domniemany, jego wartość jest wyszukiwana przez kompilator w aktualnym zasięgu, na podstawie typu monoidu wymaganego w każdym przypadku, co oznacza że oba wyrażenia mogą być w pełni ewaluowane. */
+  /** Wywołamy tutaj dwa razy sum podając za każdym razem tylko listę. Ponieważ drugi parametr (m) jest domniemany, jego wartość jest wyszukiwana przez kompilator w aktualnym zasięgu na podstawie typu monoidu wymaganego w każdym przypadku, co oznacza że oba wyrażenia mogą być w pełni ewaluowane. */
   println(sum(List(1, 2, 3)))          // używa IntMonoid
   println(sum(List("a", "b", "c")))    // używa StringMonoid
 }
diff --git a/pl/tutorials/tour/_posts/2017-02-13-inner-classes.md b/pl/tutorials/tour/_posts/2017-02-13-inner-classes.md
index 4deb3d0497..9e4a37150c 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-inner-classes.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-inner-classes.md
@@ -96,4 +96,4 @@ 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 byśmy chcieli znieść to ograniczenie, należy zmienić typ zmiennej `nodes` na `Graph#Node`.
+> 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`.
diff --git a/pl/tutorials/tour/_posts/2017-02-13-local-type-inference.md b/pl/tutorials/tour/_posts/2017-02-13-local-type-inference.md
index 8370cfe2d1..6817b613a5 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-local-type-inference.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-local-type-inference.md
@@ -34,7 +34,7 @@ object InferenceTest2 {
 
 Nie jest też konieczne określenie parametrów typu, kiedy są wywoływane [metody polimorficzne](polymorphic-methods.html) lub kiedy tworzymy [klasy generyczne](generic-classes.html). Kompilator Scali sam określi typ brakujących parametrów typów na podstawie kontekstu oraz typów właściwych parametrów metody/konstruktora.
 
-Oto przykład który to ilustruje:
+Oto ilustrujący to przykład:
 
 ```
 case class MyPair[A, B](x: A, y: B);
diff --git a/pl/tutorials/tour/_posts/2017-02-13-lower-type-bounds.md b/pl/tutorials/tour/_posts/2017-02-13-lower-type-bounds.md
index d6e6b8933f..45424e934b 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-lower-type-bounds.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-lower-type-bounds.md
@@ -14,7 +14,7 @@ tutorial-previous: upper-type-bounds
 
 Podczas gdy [górne ograniczenia typów](upper-type-bounds.html) zawężają typ do podtypu innego typu, *dolne ograniczenia typów* określają dany typ jako typ bazowy innego typu. Sformułowanie `T >: A` wyraża, że parametr typu `T` lub typ abstrakcyjny `T` odwołuje się do typu bazowego `A`.
 
-Oto przykład w którym jest to użyteczne:
+Oto przykład, w którym jest to użyteczne:
 
 ```tut
 case class ListNode[T](h: T, t: ListNode[T]) {
@@ -31,7 +31,7 @@ Powyższy program implementuje listę jednokierunkową z operacją dodania eleme
 case class ListNode[+T](h: T, t: ListNode[T]) { ... }
 ```
 
-Niestety ten program się nie skompiluje, ponieważ adnotacja kowariancji może być zastosowana tylko jeżeli zmienna typu jest używana wyłącznie w pozycji kowariantnej. Jako że zmienna typu `T` występuje jako parametr typu metody `prepend`, ta zasada jest złamana. Z pomocą *dolnego ograniczenia typu*, możemy jednak zaimplementować tą metodę w taki sposób, że `T` występuje tylko w pozycji kowariantnej:
+Niestety ten program się nie skompiluje, ponieważ adnotacja kowariancji może być zastosowana tylko, jeżeli zmienna typu jest używana wyłącznie w pozycji kowariantnej. Jako że zmienna typu `T` występuje jako parametr typu metody `prepend`, ta zasada jest złamana. Z pomocą *dolnego ograniczenia typu* możemy jednak zaimplementować tą metodę w taki sposób, że `T` występuje tylko w pozycji kowariantnej:
 
 ```tut
 case class ListNode[+T](h: T, t: ListNode[T]) {
@@ -44,7 +44,7 @@ case class ListNode[+T](h: T, t: ListNode[T]) {
 
 _Uwaga:_ nowa wersja metody `prepend` ma mniej ograniczający typ. Przykładowo pozwala ona na dodanie obiektu typu bazowego elementów istniejącej listy. Wynikowa lista będzie listą tego typu bazowego.
 
-Przykład który to ilustruje:
+Przykład, który to ilustruje:
 
 ```tut
 object LowerBoundTest extends App {
diff --git a/pl/tutorials/tour/_posts/2017-02-13-mixin-class-composition.md b/pl/tutorials/tour/_posts/2017-02-13-mixin-class-composition.md
index 3ac60d4807..0c9a5fd0f2 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-mixin-class-composition.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-mixin-class-composition.md
@@ -12,7 +12,7 @@ tutorial-next: anonymous-function-syntax
 tutorial-previous: traits
 ---
 
-W przeciwieństwie do języków które wspierają jedynie pojedyncze dziedziczenie, Scala posiada bardziej uogólniony mechanizm ponownego wykorzystania klas. Scala umożliwia na wykorzystanie _nowych elementów klasy_ (różnicy w stosunku do klasy bazowej) w definicji nowej klasy. Wyraża się to przy pomocy _kompozycji domieszek_.
+W przeciwieństwie do języków, które wspierają jedynie pojedyncze dziedziczenie, Scala posiada bardziej uogólniony mechanizm ponownego wykorzystania klas. Scala umożliwia wykorzystanie _nowych elementów klasy_ (różnicy w stosunku do klasy bazowej) w definicji nowej klasy. Wyraża się to przy pomocy _kompozycji domieszek_.
 
 Rozważmy poniższe uogólnienie dla iteratorów:
 
@@ -24,7 +24,7 @@ abstract class AbsIterator {
 }
 ```
  
-Następnie, rozważmy klasę domieszkową, która doda do klasy `AbsIterator` metodę `foreach` wykonującą podaną funkcję dla każdego elementu zwracanego przez iterator. Aby zdefiniować klasę domieszkową użyjemy słowa kluczowego `trait`:
+Następnie rozważmy klasę domieszkową, która doda do klasy `AbsIterator` metodę `foreach` wykonującą podaną funkcję dla każdego elementu zwracanego przez iterator. Aby zdefiniować klasę domieszkową, użyjemy słowa kluczowego `trait`:
 
 ```tut
 trait RichIterator extends AbsIterator {
@@ -43,7 +43,7 @@ class StringIterator(s: String) extends AbsIterator {
 }
 ```
  
-Chcielibyśmy także połączyć funkcjonalność `StringIterator` oraz `RichIterator` w jednej klasie. Z pojedynczym dziedziczeniem czy też samymi interfejsami jest to niemożliwe, gdyż obie klasy zawierają implementacje metod. Scala pozwala na rozwiązanie tego problemu z użyciem _kompozycji domieszek_. Umożliwia ona na ponowne wykorzystanie różnicy definicji klas, tzn. wszystkich definicji które nie zostały odziedziczone. Ten mechanizm pozwala nam na połączenie `StringIterator` z `RichIterator`, tak jak w poniższym przykładzie, gdzie chcielibyśmy wypisać w kolumnie wszystkie znaki z danego łańcucha:
+Chcielibyśmy także połączyć funkcjonalność `StringIterator` oraz `RichIterator` w jednej klasie. Z pojedynczym dziedziczeniem czy też samymi interfejsami jest to niemożliwe, gdyż obie klasy zawierają implementacje metod. Scala pozwala na rozwiązanie tego problemu z użyciem _kompozycji domieszek_. Umożliwia ona ponowne wykorzystanie różnicy definicji klas, tzn. wszystkich definicji, które nie zostały odziedziczone. Ten mechanizm pozwala nam na połączenie `StringIterator` z `RichIterator`, tak jak w poniższym przykładzie - gdzie chcielibyśmy wypisać w kolumnie wszystkie znaki z danego łańcucha:
  
 ```tut
 object StringIteratorTest {
diff --git a/pl/tutorials/tour/_posts/2017-02-13-operators.md b/pl/tutorials/tour/_posts/2017-02-13-operators.md
index 4818b24bce..5e9c67d1f3 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-operators.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-operators.md
@@ -12,7 +12,7 @@ tutorial-next: automatic-closures
 tutorial-previous: local-type-inference
 ---
 
-Każda metoda, która przyjmuje jeden parametr może być użyta jako *operator infiksowy*. Oto definicja klasy `MyBool` która zawiera metody `and` i `or`:
+Każda metoda, która przyjmuje jeden parametr, może być użyta jako *operator infiksowy*. Oto definicja klasy `MyBool` która zawiera metody `and` i `or`:
 
 ```tut
 case class MyBool(x: Boolean) {
diff --git a/pl/tutorials/tour/_posts/2017-02-13-pattern-matching.md b/pl/tutorials/tour/_posts/2017-02-13-pattern-matching.md
index 4c3d0e9096..2d9e68f69b 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-pattern-matching.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-pattern-matching.md
@@ -12,7 +12,7 @@ tutorial-next: singleton-objects
 tutorial-previous: case-classes
 ---
 
-Scala posiada wbudowany mechanizm dopasowania wzorców. Umożliwia on dopasowanie dowolnego rodzaju danych, na podstawie zasady że zwracamy zawsze pierwsze dopasowanie. Przykład dopasowania liczby całkowitej:
+Scala posiada wbudowany mechanizm dopasowania wzorców. Umożliwia on dopasowanie dowolnego rodzaju danych, przy czym zawsze zwracamy pierwsze dopasowanie. Przykład dopasowania liczby całkowitej:
 
 ```tut
 object MatchTest1 extends App {
@@ -40,7 +40,7 @@ object MatchTest2 extends App {
 }
 ```
 
-Pierwszy przypadek jest dopasowany, gdy `x` jest liczbą całkowitą równą `1`. Drugi określa przypadek, gdy `x` jest równe łańcuchowi znaków `"two"`. Ostatecznie mamy wzorzec dopasowania typu. Jest on spełniony gdy `x` jest dowolną liczbą całkowitą oraz gwarantuje, że `y` jest (statycznie) typu liczby całkowitej.
+Pierwszy przypadek jest dopasowany, gdy `x` jest liczbą całkowitą równą `1`. Drugi określa przypadek, gdy `x` jest równe łańcuchowi znaków `"two"`. Ostatecznie mamy wzorzec dopasowania typu. Jest on spełniony, gdy `x` jest dowolną liczbą całkowitą oraz gwarantuje, że `y` jest (statycznie) typu liczby całkowitej.
 
 Dopasowanie wzorca w Scali jest najbardziej użyteczne z wykorzystaniem typów algebraicznych modelowanych przez [klasy przypadków](case-classes.html).
-Scala także pozwala też na używanie wzorców niezależnie od klas przypadków, używając metody `unapply` definiowanej przez [obiekty ekstraktorów](extractor-objects.html).
+Scala pozwala też na używanie wzorców niezależnie od klas przypadków - używając metody `unapply` definiowanej przez [obiekty ekstraktorów](extractor-objects.html).
diff --git a/pl/tutorials/tour/_posts/2017-02-13-polymorphic-methods.md b/pl/tutorials/tour/_posts/2017-02-13-polymorphic-methods.md
index 551ed4c74f..32494797ab 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-polymorphic-methods.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-polymorphic-methods.md
@@ -12,7 +12,7 @@ tutorial-next: local-type-inference
 tutorial-previous: implicit-conversions
 ---
 
-Metody w Scali mogą być parametryzowane zarówno przez wartości jak i typy. Tak jak na poziomie klas, wartości parametrów zawierają się w parze nawiasów okrągłych, podczas gdy parametry typów są deklarawane w parze nawiasów kwadratowych.
+Metody w Scali mogą być parametryzowane zarówno przez wartości, jak i typy. Tak jak na poziomie klas, wartości parametrów zawierają się w parze nawiasów okrągłych, podczas gdy parametry typów są deklarawane w parze nawiasów kwadratowych.
 
 Przykład poniżej:
 
@@ -28,4 +28,4 @@ println(dup[Int](3, 4))
 println(dup("three", 3))
 ```
 
-Metoda `dup` jest sparametryzowana przez typ `T` i parametry wartości `x: T` oraz `n: Int`. W pierwszym wywołaniu `dup` są przekazane wszystkie parametry, ale jak pokazuje kolejna linijka, nie jest wymagane jawne podanie właściwych parametrów typów. System typów w Scali może inferować tego rodzaju typy. Dokonuje się tego poprzez sprawdzenie jakiego typu są parametry dane jako wartości argumentów oraz na podstawie kontekstu wywołania metody.
+Metoda `dup` jest sparametryzowana przez typ `T` i parametry wartości `x: T` oraz `n: Int`. W pierwszym wywołaniu `dup` są przekazane wszystkie parametry, ale - jak pokazuje kolejna linijka - nie jest wymagane jawne podanie właściwych parametrów typów. System typów w Scali może inferować tego rodzaju typy. Dokonuje się tego poprzez sprawdzenie, jakiego typu są parametry dane jako wartości argumentów oraz na podstawie kontekstu wywołania metody.
diff --git a/pl/tutorials/tour/_posts/2017-02-13-regular-expression-patterns.md b/pl/tutorials/tour/_posts/2017-02-13-regular-expression-patterns.md
index dbd0c2c9a2..20b02421ca 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-regular-expression-patterns.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-regular-expression-patterns.md
@@ -21,7 +21,7 @@ Wzorce ignorujące prawą stronę są użyteczne przy dekomponowaniu danych, kt
 Elem(prefix:String, label:String, attrs:MetaData, scp:NamespaceBinding, children:Node*)
 ```
 
-W tych przypadkach, Scala pozwala wzorcom na zastosowanie symbolu `_*` w ostatniej pozycji aby dopasować sekwencje dowolnej długości.
+W tych przypadkach Scala pozwala wzorcom na zastosowanie symbolu `_*` w ostatniej pozycji, aby dopasować sekwencje dowolnej długości.
 Poniższy przykład demonstruje dopasowanie wzorca, który rozpoznaje początek sekwencji i wiąże resztę do zmiennej `rest`:
 
 ```tut
diff --git a/pl/tutorials/tour/_posts/2017-02-13-sequence-comprehensions.md b/pl/tutorials/tour/_posts/2017-02-13-sequence-comprehensions.md
index ec69b2a95c..358aac4a1b 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-sequence-comprehensions.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-sequence-comprehensions.md
@@ -47,7 +47,7 @@ object ComprehensionTest2 extends App {
 }
 ```
  
-Ten przykład pokazuje, że wyrażenia for nie są ograniczone do list. Każdy typ danych, który wspiera operacje: `withFilter`, `map` oraz `flatMap` (z odpowiednimi typami) może być użyty w instrukcjach for.
+Ten przykład pokazuje, że wyrażenia for nie są ograniczone do list. Każdy typ danych, który wspiera operacje: `withFilter`, `map` oraz `flatMap` (z odpowiednimi typami), może być użyty w instrukcjach for.
 
 Wynik powyższego programu:
 
@@ -58,7 +58,7 @@ Wynik powyższego programu:
 (16, 16)
 ```
 
-Istnieje szczególna postać instrukcji for, które zwracają `Unit`. Tutaj wiązania utworzone przez listę generatorów i filtrów są użyte do wykonania efektów ubocznych. Aby to osiągnąć należy pominąć słowo kluczowe `yield`:
+Istnieje szczególna postać instrukcji for, które zwracają `Unit`. Tutaj wiązania utworzone przez listę generatorów i filtrów są użyte do wykonania efektów ubocznych. Aby to osiągnąć, należy pominąć słowo kluczowe `yield`:
  
 ```
 object ComprehensionTest3 extends App {
diff --git a/pl/tutorials/tour/_posts/2017-02-13-singleton-objects.md b/pl/tutorials/tour/_posts/2017-02-13-singleton-objects.md
index e080f59095..9ded93e707 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-singleton-objects.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-singleton-objects.md
@@ -13,7 +13,7 @@ tutorial-next: xml-processing
 tutorial-previous: pattern-matching
 ---
 
-Metody i wartości które nie są powiązane z konkretną instancją [klasy](classes.html) należą do *obiektów singleton*, określanych za pomocą słowa kluczowego `object` zamiast `class`.
+Metody i wartości, które nie są powiązane z konkretną instancją [klasy](classes.html), należą do *obiektów singleton* określanych za pomocą słowa kluczowego `object` zamiast `class`.
 
 ```
 package test
@@ -27,13 +27,13 @@ Metoda `sum` jest dostępna globalnie i można się do niej odwołać lub import
 
 Obiekty singleton są swego rodzaju skrótem do definiowania pojedynczej instancji klasy, która nie powinna być bezpośrednio tworzona i która sama w sobie stanowi referencję do tego obiektu, jakby była określona jako `val`. 
 
-Obiekt singleton może rozszerzać klasę lub cechę. Przykładowo [klasa przypadku](case-class.html) bez [parametrów typu](generic-class.html), domyślnie generuje obiekt singleton o tej samej nazwie, który implementuje cechę [`Function*`](http://www.scala-lang.org/api/current/scala/Function1.html).
+Obiekt singleton może rozszerzać klasę lub cechę. Przykładowo [klasa przypadku](case-class.html) bez [parametrów typu](generic-class.html) domyślnie generuje obiekt singleton o tej samej nazwie, który implementuje cechę [`Function*`](http://www.scala-lang.org/api/current/scala/Function1.html).
 
 ## Obiekt towarzyszący ##
 
 Duża część obiektów singleton nie istnieje samodzielnie, ale jest powiązana z klasą o tej samej nazwie. Obiekt singleton generowany dla klasy przypadku jest tego przykładem. Kiedy tak się dzieje, obiekt singleton jest zwany *obiektem towarzyszącym*.
 
-Klasa i jej obiekt towaryszący mogą być zdefiniowane tylko w tym samym pliku, przykład:
+Klasa i jej obiekt towarzyszący mogą być zdefiniowane tylko w tym samym pliku, przykład:
 
 ```tut
 class IntPair(val x: Int, val y: Int)
@@ -46,13 +46,13 @@ object IntPair {
 }
 ```
 
-Bardzo powszechne jest użycie wzorca typeclass w połączeniu z [wartościami domniemanymi](implicit-parameters.html), takich jak `ipord` powyżej, zdefiniowanych w obiekcie towarzyszącym. Dzieje się tak, ponieważ elementy obiektu towarzyszącego są uwzględniane w procesie wyszukiwania domyślnych wartości domniemanych.
+Bardzo powszechne jest użycie wzorca typeclass w połączeniu z [wartościami domniemanymi](implicit-parameters.html) takimi jak `ipord` powyżej, zdefiniowanymi w obiekcie towarzyszącym. Dzieje się tak, ponieważ elementy obiektu towarzyszącego są uwzględniane w procesie wyszukiwania domyślnych wartości domniemanych.
 
 ## Uwagi dla programistów Javy ##
 
-`static` nie jest słowem kluczowym w Scali. Zamiast tego, wszystkie elementy, które powinny być statyczne (wliczając w to klasy) powinny zostać zamieszczone w obiekcie singleton.
+`static` nie jest słowem kluczowym w Scali. Zamiast tego wszystkie elementy, które powinny być statyczne (wliczając w to klasy), powinny zostać zamieszczone w obiekcie singleton.
 
-Często spotykanym wzorcem jest definiowanie statycznych elementów, np. jako prywatne, pomocniczo dla ich instancji. W Scali przenosi się je do obiektu towarzyszącego:
+Często spotykanym wzorcem jest definiowanie statycznych elementów, np. jako prywatne, pomocnicze dla ich instancji. W Scali przenosi się je do obiektu towarzyszącego:
 
 ```
 class X {
@@ -66,6 +66,6 @@ object X {
 }
 ```
 
-Ten przykład ilustruje inną właściwość Scali: w kontekście zasięgu prywatnego, klasa i jej obiekt towarzyszący mają wzajemny dostęp do swoich pól. Aby sprawić, żeby dany element klasy jest *naprawdę* stał się prywatny należy go zadeklarować jako `private[this]`.
+Ten przykład ilustruje inną właściwość Scali: w kontekście zasięgu prywatnego klasa i jej obiekt towarzyszący mają wzajemny dostęp do swoich pól. Aby sprawić, żeby dany element klasy *naprawdę* stał się prywatny, należy go zadeklarować jako `private[this]`.
 
-Dla wygodnej współpracy z Javą, metody oraz pola klasy w obiekcie singleton, mają także statyczne metody zdefiniowane w obiekcie towarzyszącym, nazywane *static forwarder*. Dostęp do innych elementów można uzyskać poprzez statyczne pole `X$.MODULE$` dla obiektu `X`.
+Dla wygodnej współpracy z Javą metody oraz pola klasy w obiekcie singleton mają także statyczne metody zdefiniowane w obiekcie towarzyszącym (nazywane *static forwarder*). Dostęp do innych elementów można uzyskać poprzez statyczne pole `X$.MODULE$` dla obiektu `X`.
diff --git a/pl/tutorials/tour/_posts/2017-02-13-tour-of-scala.md b/pl/tutorials/tour/_posts/2017-02-13-tour-of-scala.md
index 14fd5e2fbe..678b77ae77 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-tour-of-scala.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-tour-of-scala.md
@@ -18,12 +18,12 @@ Scala jest nowoczesnym, wieloparadygmatowym językiem programowania zaprojektowa
 Scala jest czysto obiektowym językiem w tym sensie, że każda [wartość jest obiektem](unified-types.html). Typy oraz zachowania obiektów są opisane przez [klasy](classes.html) oraz [cechy](traits.html). Klasy są rozszerzane przez podtypowanie i elastyczny mechanizm [kompozycji domieszek](mixin-class-composition.html) jako zastępnik dla wielodziedziczenia.
 
 ## Scala jest funkcyjna ##
-Scala jest też funkcyjnym językiem w tym sensie, że [każda funkcja jest wartością](unified-types.html). Scala dostarcza [lekką składnię](anonymous-function-syntax.html) do definiowana funkcji anonimowych, wspiera [funkcje wyższego rzędu](higher-order-functions.html), pozwala funkcjom by były [zagnieżdżone](nested-functions.html) oraz umożliwia [rozwijanie funkcji](currying.html). [Klasy przypadków](case-classes.html) oraz wbudowane wsparcie dla [dopasowania wzorców](pattern-matching.html) wprowadzają do Scali mechanizm typów algebraicznych, stosowany w wielu funkcyjnych językach programowania. [Obiekty singleton](singleton-objects) są wygodną metodą grupowania funkcji, które nie należą do żadnej klasy. 
+Scala jest też funkcyjnym językiem w tym sensie, że [każda funkcja jest wartością](unified-types.html). Scala dostarcza [lekką składnię](anonymous-function-syntax.html) do definiowana funkcji anonimowych, wspiera [funkcje wyższego rzędu](higher-order-functions.html), pozwala funkcjom, by były [zagnieżdżone](nested-functions.html), a także umożliwia [rozwijanie funkcji](currying.html). [Klasy przypadków](case-classes.html) oraz wbudowane wsparcie dla [dopasowania wzorców](pattern-matching.html) wprowadzają do Scali mechanizm typów algebraicznych stosowany w wielu funkcyjnych językach programowania. [Obiekty singleton](singleton-objects) są wygodną metodą grupowania funkcji, które nie należą do żadnej klasy. 
 
-Ponadto, mechanizm dopasowania wzorca w naturalny sposób rozszerza się do obsługi [przetwarzania danych w formacie XML](xml-processing.html) z pomocą [wzorców sekwencji ignorujących prawą stronę](regular-expression-patterns.html), z wykorzystaniem rozszerzeń [obiektów ekstraktorów](extractor-objects.html). W tym kontekście, [instrukcje for](sequence-comprehensions.html) są użyteczne w formułowaniu zapytań. Ta funkcjonalność sprawia, że Scala jest idealnym językiem do tworzenia aplikacji takich jak usługi sieciowe.
+Ponadto mechanizm dopasowania wzorca w naturalny sposób rozszerza się do obsługi [przetwarzania danych w formacie XML](xml-processing.html) z pomocą [wzorców sekwencji ignorujących prawą stronę](regular-expression-patterns.html), z wykorzystaniem rozszerzeń [obiektów ekstraktorów](extractor-objects.html). W tym kontekście [instrukcje for](sequence-comprehensions.html) są użyteczne w formułowaniu zapytań. Ta funkcjonalność sprawia, że Scala jest idealnym językiem do tworzenia aplikacji takich jak usługi sieciowe.
 
 ## Scala jest statycznie typowana ##
-Scala posiada ekspresywny system typów, który zapewnia, że abstrakcje są używane w sposób zgodny oraz bezpieczny. W szczególności, system typów wspiera:
+Scala posiada ekspresywny system typów zapewniający, że abstrakcje są używane w sposób zgodny oraz bezpieczny. W szczególności system typów wspiera:
 
 * [klasy generyczne](generic-classes.html)
 * [adnotacje wariancji](variances.html)
@@ -34,14 +34,14 @@ Scala posiada ekspresywny system typów, który zapewnia, że abstrakcje są uż
 * [parametry domniemane](implicit-parameters.html) i [konwersje niejawne](implicit-conversions.html)
 * [metody polimorficzne](polymorphic-methods.html)
 
-[Mechanizm lokalnej inferencji typów](local-type-inference.html) sprawia, że nie jest konieczne podawanie nadmiarowych informacji o typach w programie. W połączeniu, te funkcje języka pozwalają na bezpiecznie typowane ponowne wykorzystanie programistycznych abstrakcji.
+[Mechanizm lokalnej inferencji typów](local-type-inference.html) sprawia, że nie jest konieczne podawanie nadmiarowych informacji o typach w programie. W połączeniu te funkcje języka pozwalają na bezpiecznie typowane ponowne wykorzystanie programistycznych abstrakcji.
 
 ## Scala jest rozszerzalna ##
-W praktyce, rozwiązania specyficzne dla domeny wymagają odpowiednich rozszerzeń języka. Scala dostarcza unikalne mechanizmy, dzięki którym można łatwo dodawać nowe konstrukcje do języka w postaci bibliotek:
+W praktyce rozwiązania specyficzne dla domeny wymagają odpowiednich rozszerzeń języka. Scala dostarcza unikalne mechanizmy, dzięki którym można łatwo dodawać nowe konstrukcje do języka w postaci bibliotek:
 
 * każda metoda może być używana jako [operator infiksowy lub prefiksowy](operators.html)
 * [domknięcia są konstruowane automatycznie zależnie od wymaganego typu](automatic-closures.html)
 
-Powyższe mechanizmy pozwalają na definicję nowych rodzajów wyrażeń, bez potrzeby rozszerzania składni języka czy też wykorzystywania meta-programowania w postaci makr.
+Powyższe mechanizmy pozwalają na definicję nowych rodzajów wyrażeń bez potrzeby rozszerzania składni języka czy też wykorzystywania meta-programowania w postaci makr.
 
-Scala jest zaprojektowana tak, aby współpracować dobrze ze środowiskiem uruchomieniowym JRE oraz językiem Java. Funkcje Javy takie jak [adnotacje](annotations.html) oraz typy generyczne posiadają swoje bezpośrednie odwzorowanie w Scali. Unikalne funkcje Scali, jak na przykład [domyślne wartości parametrów](default-parameter-values.html) oraz [nazwane parametry](named-parameters.html) są kompilowane w taki sposób, aby zachować jak największą zgodność z Javą. Scala ma także taki sam model kompilacji (oddzielna kompilacja, dynamiczne ładowanie klas) dzięki czemu umożliwia korzystanie z całego ekosystemu Javy.
+Scala jest zaprojektowana tak, aby współpracować dobrze ze środowiskiem uruchomieniowym JRE oraz językiem Java. Funkcje Javy takie jak [adnotacje](annotations.html) oraz typy generyczne posiadają swoje bezpośrednie odwzorowanie w Scali. Unikalne funkcje Scali, jak na przykład [domyślne wartości parametrów](default-parameter-values.html) oraz [nazwane parametry](named-parameters.html), są kompilowane tak, aby zachować jak największą zgodność z Javą. Scala ma także taki sam model kompilacji (oddzielna kompilacja, dynamiczne ładowanie klas), dzięki czemu umożliwia korzystanie z całego ekosystemu Javy.
diff --git a/pl/tutorials/tour/_posts/2017-02-13-traits.md b/pl/tutorials/tour/_posts/2017-02-13-traits.md
index 72ce32b6ed..dc43a856c1 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-traits.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-traits.md
@@ -12,7 +12,7 @@ tutorial-next: mixin-class-composition
 tutorial-previous: classes
 ---
 
-Zbliżone do interfejsów Javy, cechy są wykorzystywane do definiowania typów obiektów poprzez określenie sygnatur wspieranych metod. Podobnie jak w Javie 8, Scala pozwala cechom na częściową implementację, tzn. jest możliwe podanie domyślnej implementacji dla niektórych metod. W przeciwieństwie do klas, cechy nie mogą posiadać parametrów konstruktora.
+Zbliżone do interfejsów Javy cechy są wykorzystywane do definiowania typów obiektów poprzez określenie sygnatur wspieranych metod. Podobnie jak w Javie 8, Scala pozwala cechom na częściową implementację, tzn. jest możliwe podanie domyślnej implementacji dla niektórych metod. W przeciwieństwie do klas, cechy nie mogą posiadać parametrów konstruktora.
 
 Przykład definicji cechy której zadaniem jest określanie podobieństwa z innym obiektem:
 
@@ -23,7 +23,7 @@ trait Similarity {
 }
 ```
  
-Powyższa cecha składa się z dwóch metod: `isSimilar` oraz `isNotSimilar`. Mimo że `isSimilar` nie posiada implementacji (odpowiada metodzie abstrakcyjnej w Javie), `isNotSimilar` definiuje konkretną implementację. W ten sposób klasy które łączą tą cechę, muszą tylko zdefiniować implementacją dla metody `isSimilar`. Zachowanie `isNotSimilar` jest dziedziczone bezpośrednio z tej cechy. Cechy są zazwyczaj łączone z [klasami](classes.html) lub innymi cechami poprzez [kompozycję domieszek](mixin-class-composition.html):
+Powyższa cecha składa się z dwóch metod: `isSimilar` oraz `isNotSimilar`. Mimo że `isSimilar` nie posiada implementacji (odpowiada metodzie abstrakcyjnej w Javie), `isNotSimilar` definiuje konkretną implementację. W ten sposób klasy, które łączą tą cechę, muszą tylko zdefiniować implementacją dla metody `isSimilar`. Zachowanie `isNotSimilar` jest dziedziczone bezpośrednio z tej cechy. Cechy są zazwyczaj łączone z [klasami](classes.html) lub innymi cechami poprzez [kompozycję domieszek](mixin-class-composition.html):
 
 ```tut
 class Point(xc: Int, yc: Int) extends Similarity {
diff --git a/pl/tutorials/tour/_posts/2017-02-13-unified-types.md b/pl/tutorials/tour/_posts/2017-02-13-unified-types.md
index 185255ee41..49bae64862 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-unified-types.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-unified-types.md
@@ -12,13 +12,13 @@ tutorial-next: classes
 tutorial-previous: tour-of-scala
 ---
 
-W przeciwieństwie do Javy, wszystkie wartości w Scali są obiektami (wliczając w to wartości numeryczne i funkcje). Ponieważ Scala bazuje na klasach, wszystkie wartości są instancjami klasy. Można zatem powiedzieć, że Scala posiada zunifikowany system typów. Poniższy diagram ilustruje hierarchię klas Scali:
+W przeciwieństwie do Javy wszystkie wartości w Scali są obiektami (wliczając w to wartości numeryczne i funkcje). Ponieważ Scala bazuje na klasach, wszystkie wartości są instancjami klasy. Można zatem powiedzieć, że Scala posiada zunifikowany system typów. Poniższy diagram ilustruje hierarchię klas Scali:
 
 ![Scala Type Hierarchy]({{ site.baseurl }}/resources/images/classhierarchy.img_assist_custom.png)
 
 ## Hierarchia Klas Scali ##
 
-Klasa bazowa dla wszystkich klas `scala.Any` posiada dwie bezpośrednie klasy pochodne: `scala.AnyVal` oraz `scala.AnyRef`, które reprezentują dwie różne rodziny klas: klasy wartości oraz klasy referencji. Klasy wartości są predefiniowane i odpowiadają one typom prymitywnym z języków takich jak Java. Wszystkie inne klasy definiują typy referencyjne. Klasy zdefiniowane przez użytkownika są domyślnie typami referencyjnymi, tzn. są one zawsze podtypem klasy `scala.AnyRef`. W kontekście maszyny wirtualnej Javy, `scala.AnyRef` odpowiada typowi `java.lang.Object`. Powyższy diagram ilustruje także konwersje implicit pomiędzy klasami wartości.
+Klasa bazowa dla wszystkich klas `scala.Any` posiada dwie bezpośrednie klasy pochodne: `scala.AnyVal` oraz `scala.AnyRef`, które reprezentują dwie różne rodziny klas: klasy wartości oraz klasy referencji. Klasy wartości są predefiniowane i odpowiadają one typom prymitywnym z języków takich jak Java. Wszystkie inne klasy definiują typy referencyjne. Klasy zdefiniowane przez użytkownika są domyślnie typami referencyjnymi, tzn. są one zawsze podtypem klasy `scala.AnyRef`. W kontekście maszyny wirtualnej Javy `scala.AnyRef` odpowiada typowi `java.lang.Object`. Powyższy diagram ilustruje także konwersje implicit pomiędzy klasami wartości.
 
 Poniższy przykład pokazuje, że liczby, znaki, wartości logiczne oraz funkcje są obiektami:
 
diff --git a/pl/tutorials/tour/_posts/2017-02-13-upper-type-bounds.md b/pl/tutorials/tour/_posts/2017-02-13-upper-type-bounds.md
index 6259124550..6f02374235 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-upper-type-bounds.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-upper-type-bounds.md
@@ -47,6 +47,6 @@ object Main extends App {
 }
 ```
 
-Instancja klasy `Cage` może zawierać `Animal` z górnym ograniczeniem `Pet`. Obiekt typu `Lion` nie należy do klasy `Pet` zatem nie może być włożony do obiektu `Cage`.
+Instancja klasy `Cage` może zawierać `Animal` z górnym ograniczeniem `Pet`. Obiekt typu `Lion` nie należy do klasy `Pet`, zatem nie może być włożony do obiektu `Cage`.
 
 Zastosowanie dolnych ograniczeń typów jest opisane [tutaj](lower-type-bounds.html).
diff --git a/pl/tutorials/tour/_posts/2017-02-13-variances.md b/pl/tutorials/tour/_posts/2017-02-13-variances.md
index cb58f0a995..904f4914b9 100644
--- a/pl/tutorials/tour/_posts/2017-02-13-variances.md
+++ b/pl/tutorials/tour/_posts/2017-02-13-variances.md
@@ -12,9 +12,9 @@ tutorial-next: upper-type-bounds
 tutorial-previous: generic-classes
 ---
 
-Scala wspiera adnotacje wariancji parametrów typów [klas generycznych](generic-classes.html). W porównaniu do Javy, adnotacje wariancji mogą zostać dodane podczas definiowania abstrakcji klasy, gdy w Javie adnotacje wariancji są podane przez użytkowników tych klas.
+Scala wspiera adnotacje wariancji parametrów typów [klas generycznych](generic-classes.html). W porównaniu do Javy adnotacje wariancji mogą zostać dodane podczas definiowania abstrakcji klasy, gdy w Javie adnotacje wariancji są podane przez użytkowników tych klas.
 
-Na stronie o [klasach generycznych](generic-classes.html) omówiliśmy przykład zmiennego stosu. Wyjaśniliśmy, że typ definiowany przez klasę `Stack[T]` jest poddany niezmiennemu podtypowaniu w stosunku do parametru typu. Może to ograniczyć możliwość ponownego wykorzystania abstrakcji tej klasy. Spróbujemy teraz opracować funkcyjną (tzn. niemutowalną) implementację dla stosów, które nie posiadają tego ograniczenia. Warto zwrócić uwagę na to, że jest to zaawansowany przykład łączący w sobie zastosowanie [funkcji polimorficznych](polymorphic-methods.html), [dolnych ograniczeń typu](lower-type-bounds.html) oraz kowariantnych adnotacji parametru typu. Dodatkowo stosujemy też [klasy wewnętrzne](inner-classes.html), aby połączyć ze sobą elementy stosu bez jawnych powiązań.
+Na stronie o [klasach generycznych](generic-classes.html) omówiliśmy przykład zmiennego stosu. Wyjaśniliśmy, że typ definiowany przez klasę `Stack[T]` jest poddany niezmiennemu podtypowaniu w stosunku do parametru typu. Może to ograniczyć możliwość ponownego wykorzystania abstrakcji tej klasy. Spróbujemy teraz opracować funkcyjną (tzn. niemutowalną) implementację dla stosów, które nie posiadają tego ograniczenia. Warto zwrócić uwagę, że jest to zaawansowany przykład łączący w sobie zastosowanie [funkcji polimorficznych](polymorphic-methods.html), [dolnych ograniczeń typu](lower-type-bounds.html) oraz kowariantnych adnotacji parametru typu. Dodatkowo stosujemy też [klasy wewnętrzne](inner-classes.html), aby połączyć ze sobą elementy stosu bez jawnych powiązań.
 
 ```tut
 class Stack[+A] {