Add improvements to the translation

Author: adam-wyluda

Diff for: pl/tutorials/tour/case-classes.md

@@ -1,6 +1,6 @@
 ---
 layout: tutorial
-title: Klasy case
+title: Klasy przypadków
 
 disqus: true
 
@@ -11,14 +11,14 @@ tutorial-next: pattern-matching
 tutorial-previous: currying
 ---
 
-Scala wspiera mechanizm _klas case_. Klasy case są zwykłymi klasami z dodatkowymi założeniami:
+Scala wspiera mechanizm _klas przypadków_. Klasy przypadków są zwykłymi klasami z dodatkowymi założeniami:
 
-* Domyślnie immutable
+* Domyślnie niemutowalne
 * Można je dekomponować poprzez [dopasowanie wzorca](pattern-matching.html)
 * Porównywane poprzez podobieństwo strukturalne zamiast przez referencje
 * Zwięzła składnia tworzenia obiektów i operacji na nich
 
-Poniższy przykład obrazuje hierarchię typów powiadomień, która składa się z abstrakcyjnej klasy `Notification` oraz trzech konkretnych rodzajów zaimplementowanych jako klasy case `Email`, `SMS` i `VoiceRecording`:
+Poniższy przykład obrazuje hierarchię typów powiadomień, która składa się z abstrakcyjnej klasy `Notification` oraz trzech konkretnych rodzajów zaimplementowanych jako klasy przypadków `Email`, `SMS` i `VoiceRecording`:
 
 ```tut
 abstract class Notification
@@ -33,17 +33,17 @@ Tworzenie obiektu jest bardzo proste: (Zwróć uwagę na to, że słowo `new` n
 val emailFromJohn = Email("[email protected]", "Greetings From John!", "Hello World!")
 ```
 
-Parametry konstruktora klasy case są traktowane jako publiczne wartości i można się do nich odwoływać bezpośrednio:
+Parametry konstruktora klasy przypadków są traktowane jako publiczne wartości i można się do nich odwoływać bezpośrednio:
 
 ```tut
 val title = emailFromJohn.title
 println(title) // wypisuje "Greetings From John!"
 ```
 
-W klasach case nie można modyfikować wartości pól. (Z wyjątkiem sytuacji kiedy dodasz `var` przed nazwą pola)
+W klasach przypadków nie można modyfikować wartości pól. (Z wyjątkiem sytuacji kiedy dodasz `var` przed nazwą pola)
 
 ```tut:fail
-emailFromJohn.title = "Goodbye From John!" // Jest to błąd kompilacji, gdyż pola klasy case są domyślnie immutable
+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`:
@@ -55,7 +55,7 @@ println(emailFromJohn) // wypisuje "Email([email protected],Greetings From John!
 println(editedEmail) // wypisuje "Email([email protected],I am learning Scala,It's so cool!)"
 ```
 
-Dla każdej klasy case kompilator Scali generuje 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`, która implementuje strukturalne porównanie obiektów oraz metodę `toString`. Przykład:
 
 ```tut
 val firstSms = SMS("12345", "Hello!")
@@ -75,7 +75,7 @@ They are equal!
 SMS is: SMS(12345, Hello!)
 ```
 
-Jednym z najważniejszych zastosowań klas case (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 = {
@@ -134,9 +134,9 @@ println(showNotificationSpecial(specialSms, SPECIAL_EMAIL, SPECIAL_NUMBER))
 
 ```
 
-Programując w Scali, zachęca się abyś jak najszerzej używał klas case 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 typu immutable uwalniają cię od potrzeby śledzenia zmian stanu
+* 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
 * Dopasowanie wzorca znacząco upraszcza logikę rozgałęzień, co prowadzi do mniejszej ilości błędów i czytelniejszego kodu
 

Diff for: pl/tutorials/tour/extractor-objects.md

@@ -11,7 +11,7 @@ tutorial-next: sequence-comprehensions
 tutorial-previous: regular-expression-patterns
 ---
 
-W Scali, wzorce mogą być zdefiniowane niezależnie od klas case. 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 {

Diff for: pl/tutorials/tour/generic-classes.md

@@ -24,7 +24,7 @@ class Stack[T] {
 }
 ```
 
-Klasa `Stack` modeluje zmienny stos z zawierający elementy dowolnego typu `T`. Parametr `T` narzuca ograniczenie dla metod takie, że tylko elementy typu `T` mogą zostać dodane do stosu. Podobnie metoda `top` może zwrócić tylko elementy danego typu.
+Klasa `Stack` modeluje zmienny stos zawierający elementy dowolnego typu `T`. Parametr `T` narzuca ograniczenie dla metod takie, że tylko elementy typu `T` mogą zostać dodane do stosu. Podobnie metoda `top` może zwrócić tylko elementy danego typu.
 
 Przykłady zastosowania:
 

Diff for: pl/tutorials/tour/implicit-conversions.md

@@ -1,6 +1,6 @@
 ---
 layout: tutorial
-title: Konwersje implicit
+title: Konwersje niejawne
 
 disqus: true
 
@@ -11,9 +11,9 @@ tutorial-next: polymorphic-methods
 tutorial-previous: implicit-parameters
 ---
 
-Konwersja implicit z typu `S` do `T` jest określona przez wartość implicit, która jest funkcją typu `S => T` lub przez metodę implicit odpowiadającą funkcji tego typu.
+Konwersja niejawna z typu `S` do `T` jest określona przez wartość domniemaną, która jest funkcją typu `S => T` lub przez metodę domniemaną odpowiadającą funkcji tego typu.
 
-Konwersje implicit są stosowane w dwóch sytuacjach:
+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`.
@@ -27,7 +27,7 @@ Poniższa operacja na dwóch listach `xs` oraz `ys` typu `List[Int]` jest dopusz
 xs <= ys
 ```
 
-Zakładając, że metody implicit `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])
@@ -38,9 +38,9 @@ implicit def int2ordered(x: Int): Ordered[Int] =
   new Ordered[Int] { /* .. */ }
 ```
 
-Domyślnie importowany obiekt `scala.Predef` deklaruje kilka predefiniowanych typów (np. `Pair`) i metod (np. `assert`) ale także wiele użytecznych konwersji implicit.
+Domyślnie importowany obiekt `scala.Predef` deklaruje kilka predefiniowanych typów (np. `Pair`) i metod (np. `assert`) ale także wiele użytecznych konwersji niejawnych.
 
-Przykładowo, kiedy wywołujemy metodę Javy, która wymaga typu `java.lang.Integer`, dopuszczalne jest przekazanie typu `scala.Int`. Dzieje się tak ponieważ `Predef` zawiera poniższe konwersje implicit:
+Przykładowo, kiedy wywołujemy metodę Javy, która wymaga typu `java.lang.Integer`, dopuszczalne jest przekazanie typu `scala.Int`. Dzieje się tak ponieważ `Predef` definiuje poniższe konwersje niejawne:
 
 ```tut
 import scala.language.implicitConversions
@@ -49,4 +49,4 @@ implicit def int2Integer(x: Int) =
   java.lang.Integer.valueOf(x)
 ```
 
-Aby zdefiniować własne konwersje implicit, 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 for: pl/tutorials/tour/implicit-parameters.md

@@ -1,6 +1,6 @@
 ---
 layout: tutorial
-title: Parametry implicit
+title: Parametry domniemane
 
 disqus: true
 
@@ -11,17 +11,17 @@ tutorial-next: implicit-conversions
 tutorial-previous: explicitly-typed-self-references
 ---
 
-Metodę z _parametrami implicit_ można stosować tak samo jak zwyczajną metodę. W takim przypadku etykieta `implicit` nie ma żadnego znaczenia. Jednak jeżeli odpowiednie argumenty dla parametrów implicit nie zostaną jawnie określone, to kompilator dostarczy je automatycznie.
+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 implicit 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 implicit.
-* W drugiej kolejności dobrane mogą być elementy modułów companion odpowiadających typom tych parametrów implicit, które są oznaczone jako `implicit`.
+* 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`.
 
-W poniższym przykładzie zdefiniujemy metodę `sum`, która oblicza sumę listy elementów wykorzystując operacje `add` i `unit` obiektu `Monoid`. Należy dodać, że wartości implicit nie mogą być zdefiniowane globalnie, tylko muszą być elementem pewnego modułu.
+W poniższym przykładzie zdefiniujemy metodę `sum`, która oblicza sumę listy elementów wykorzystując operacje `add` i `unit` obiektu `Monoid`. Należy dodać, że wartości domniemane nie mogą być zdefiniowane globalnie, tylko muszą być elementem pewnego modułu.
 
 ```tut
-/** Ten przykład wykorzystuje strukturę z algebry abstrakcyjnej aby zilustrować działanie parametrów implicit. Półgrupa jest strukturą algebraiczną na zbiorze A z łączna (która spełnia warunek: add(x, add(y, z)) == add(add(x, y), z)) operacją nazwaną add, która łączy parę obiektów A by zwrócić inny A. */
+/** Ten przykład wykorzystuje strukturę z algebry abstrakcyjnej aby zilustrować działanie parametrów domniemanych. Półgrupa jest strukturą algebraiczną na zbiorze A z łączną operacją (czyli taką, która spełnia warunek: add(x, add(y, z)) == add(add(x, y), z)) nazwaną add, która łączy parę obiektów A by zwrócić inny obiekt A. */
 abstract class SemiGroup[A] {
   def add(x: A, y: A): A
 }
@@ -30,7 +30,7 @@ abstract class Monoid[A] extends SemiGroup[A] {
   def unit: A
 }
 object ImplicitTest extends App {
-  /** Aby zademonstrować jak działają parametry implicit, najpierw zdefiniujemy monoidy dla łańcuchów znaków oraz liczb całkowitych. Słowo kluczowe implicit sprawia, że oznaczone nimi wartości mogą być użyte aby zrealizować parametry implicit. */
+  /** Aby zademonstrować jak działają parametry domniemane, najpierw zdefiniujemy monoidy dla łańcuchów znaków oraz liczb całkowitych. Słowo kluczowe implicit sprawia, że oznaczone nimi wartości mogą być użyte aby zrealizować parametry domniemane. */
   implicit object StringMonoid extends Monoid[String] {
     def add(x: String, y: String): String = x concat y
     def unit: String = ""
@@ -39,12 +39,12 @@ object ImplicitTest extends App {
     def add(x: Int, y: Int): Int = x + y
     def unit: Int = 0
   }
-  /** Metoda sum pobiera List[A] i zwraca A, który jest wynikiem zastosowania zastosowania monoidu do wszystkich kolejnych elementów listy. Oznaczając parametr m jako implicit sprawiamy, że potrzebne jest tylko podanie parametru xs podczas wywołania, ponieważ mamy już List[A], zatem wiemy jakiego typu jest w rzeczywistości A, zatem wiemy też jakiego typu Monoid[A] jest potrzebny. Możemy więc wyszukać wartość val lub obiekt w aktualnym zasięgu, który ma odpowiadający typu i użyć go bez jawnego określania referencji do niego. */
+  /** Metoda sum pobiera List[A] i zwraca A, który jest wynikiem zastosowania monoidu do wszystkich kolejnych elementów listy. Oznaczając parametr m jako domniemany, sprawiamy że potrzebne jest tylko podanie parametru xs podczas wywołania, ponieważ mamy już List[A], zatem wiemy jakiego typu jest w rzeczywistości A, zatem wiemy też jakiego typu Monoid[A] potrzebujemy. Możemy więc wyszukać wartość val lub obiekt w aktualnym zasięgu, który ma odpowiadający typu i użyć go bez jawnego określania referencji do niego. */
   def sum[A](xs: List[A])(implicit m: Monoid[A]): A =
     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 implicit, 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 for: pl/tutorials/tour/inner-classes.md

@@ -58,7 +58,7 @@ object GraphTest extends App {
 }
 ```
 
-Ten kod pokazuje, że typ wierzchołka jest prefikowany 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 innego grafu są określone innym przez inny typ.
+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:
 

Diff for: pl/tutorials/tour/lower-type-bounds.md

@@ -11,7 +11,7 @@ tutorial-next: inner-classes
 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 typowy `T` lub typ abstrakcyjny `T` odwołuje się do typu bazowego `A`.
+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:
 

Diff for: pl/tutorials/tour/nested-functions.md

@@ -11,7 +11,7 @@ tutorial-next: currying
 tutorial-previous: higher-order-functions
 ---
 
-Scala pozwala na zagnieżdżanie definicji funkcji. Poniższy obiekt określa funkcję `filter`, która dla danej listy filtruje elementy większe bądź równe niż podany próg `threshold`:
+Scala pozwala na zagnieżdżanie definicji funkcji. Poniższy obiekt określa funkcję `filter`, która dla danej listy filtruje elementy większe bądź równe podanemu progowi `threshold`:
 
 ```tut
 object FilterTest extends App {

Diff for: pl/tutorials/tour/pattern-matching.md

@@ -24,7 +24,7 @@ object MatchTest1 extends App {
 }
 ```
 
-Blok kodu z wyrażeniami `case` definiuje funkcję, która przekształca liczby całkowite do łańcuchów znaków. Słowo kluczowe `match` pozwala w wygodny sposób zastosować dopasowanie wzorca do obiektu.
+Blok kodu z wyrażeniami `case` definiuje funkcję, która przekształca liczby całkowite na łańcuchy znaków. Słowo kluczowe `match` pozwala w wygodny sposób zastosować dopasowanie wzorca do obiektu.
 
 Wzorce można także dopasowywać do różnych typów wartości:
 
@@ -41,5 +41,5 @@ 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.
 
-Dopasowanie wzorca w Scali jest najbardziej użyteczne z wykorzystaniem typów algebraicznych modelowanych przez [klasy case](case-classes.html).
-Scala także pozwala też na używanie wzorców niezależnie od klas case, używając metody `unapply` definiowanej przez [obiekty ekstraktorów](extractor-objects.html).
+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).

Diff for: pl/tutorials/tour/regular-expression-patterns.md

@@ -14,7 +14,7 @@ tutorial-previous: xml-processing
 
 ## Wzorce sekwencji ignorujące prawą stronę ##
 
-Wzorce ignorujące prawą stronę są użyteczne przy dekomponowaniu danych, które mogą być podtypem `Seq[A]` lub klasą case z iterowalnym parametrem, jak w poniższym przykładzie:
+Wzorce ignorujące prawą stronę są użyteczne przy dekomponowaniu danych, które mogą być podtypem `Seq[A]` lub klasą przypadku z iterowalnym parametrem, jak w poniższym przykładzie:
 
 ```
 Elem(prefix:String, label:String, attrs:MetaData, scp:NamespaceBinding, children:Node*)