Improve punctuation in Polish translation

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] {

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/")

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`:
 

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([email protected],Greetings From John!
 println(editedEmail) // wypisuje "Email([email protected],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
 
 

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:
 

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:
 

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).

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).

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`.

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.

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
 }

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`.

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);