Update Polish translation for tour of scala

Fix numbers of eng mixin and tuples pages

Add Polish introduction page

Add Polish "basics" page

Remove outof tags

Make Polish "tuples" page visible

Rewrite Polish "unified-types" page

Remove tut fail assertion

Remove redundant lines

Remove tut from code example - should contain error

Fix broken links

Apply review suggestion

Fix typo "powyższeego"

Author: kamil-duda

_pl/tour/basics.md

@@ -1,9 +1,350 @@
 ---
 layout: tour
-title: Basics
+title: Podstawy
 
 discourse: false
 
 partof: scala-tour
+
+num: 2
 language: pl
+next-page: unified-types
+previous-page: tour-of-scala
 ---
+
+Na tej stronie omówimy podstawy języka Scala.
+
+## Uruchamianie Scali w przeglądarce
+
+Dzięki ScalaFiddle możesz uruchomić Scalę w swojej przeglądarce.
+
+1. Przejdź do [https://scalafiddle.io](https://scalafiddle.io).
+2. Wklej kod `println("Hello, world!")` w polu po lewej stronie.
+3. Naciśnij przycisk "Run". W panelu po prawej stronie pojawi się wynik działania programu.
+
+Jest to prosta i niewymagająca żadnej instalacji metoda do eksperymentowania z kodem w Scali.
+
+Wiele przykładów kodu w tym przewodniku jest również zintegrowana ze ScalaFiddle,
+dzięki czemu można je wypróbować wciskając po prostu przycisk "Run".
+
+## Wyrażenia
+
+Wyrażenia są rezultatem ewaluacji fragmentów kodu.
+
+```
+1 + 1
+```
+
+Wyniki wyrażeń można wyświetlić za pomocą funkcji `println`.
+
+{% scalafiddle %}
+```tut
+println(1) // 1
+println(1 + 1) // 2
+println("Hello!") // Hello!
+println("Hello," + " world!") // Hello, world!
+```
+{% endscalafiddle %}
+
+### Wartości
+
+Rezultaty wyrażeń mogą zostać nazwane za pomocą słowa kluczowego `val`.
+
+```tut
+val x = 1 + 1
+println(x) // 2
+```
+
+Nazwane wyniki, tak jak `x` w ww. przykładzie, to wartości.
+Odniesienie się do wartości nie powoduje jej ponownego obliczenia.
+
+Wartości nie można przypisać ponownie.
+
+```tut:fail
+x = 3 // Nie kompiluje się.
+```
+
+Typy wartości mogą być wywnioskowane przez kompilator, ale można również wyraźnie określić type:
+
+```tut
+val x: Int = 1 + 1
+```
+
+Zauważ, że deklaracja `Int` pojawia po identyfikatorze `x`, potrzebny jest rówmież dwukropek `:`.
+
+### Zmienne
+
+Zmienne są podobne do wartości, ale z tym wyjątkiem, że można je ponownie przypisywać.
+Zmienną można zdefiniować używając słowa kluczowego `var`.
+
+{% scalafiddle %}
+```tut
+var x = 1 + 1
+x = 3 // Kompiluje się, ponieważ "x" jest zdefiniowane z użyciem "var".
+println(x * x) // 9
+```
+{% endscalafiddle %}
+
+Tak jak przy wartościach, można wyraźnie zdefiniować żądany typ:
+
+```tut
+var x: Int = 1 + 1
+```
+
+## Wyrażenia blokowe
+
+Wyrażenia mogą być łączone poprzez zamknięcie ich w nawiasie klamrowym`{}`.
+Taką konstrukcję nazywamy blokiem.
+Wynikiem całego bloku kodu jest wynik ostatniego wyrażenia w tym bloku.
+
+{% scalafiddle %}
+```tut
+println({
+  val x = 1 + 1
+  x + 1
+}) // 3
+```
+{% endscalafiddle %}
+
+## Funkcje
+
+Funkcje to wyrażenia, które przyjmują pewne parametry.
+
+Poniżej zdefiniowana jest funkcja anonimowa (nieposiadająca nazwy), która zwraca liczbę całkowitą przekazaną jako parametr, zwiększoną o 1.
+
+```tut
+(x: Int) => x + 1
+```
+
+Po lewej stronie od `=>` znajduje się lista parametrów.
+Po prawej stronie - wyrażenie wykorzystujące te parametry.
+
+Funkcje można również nazywać.
+
+{% scalafiddle %}
+```tut
+val addOne = (x: Int) => x + 1
+println(addOne(1)) // 2
+```
+{% endscalafiddle %}
+
+Funkcje mogą przyjmować wiele parametrów.
+
+{% scalafiddle %}
+```tut
+val add = (x: Int, y: Int) => x + y
+println(add(1, 2)) // 3
+```
+{% endscalafiddle %}
+
+Mogą też wcale nie mieć parametrow.
+
+{% scalafiddle %}
+```tut
+val getTheAnswer = () => 42
+println(getTheAnswer()) // 42
+```
+{% endscalafiddle %}
+
+## Metody
+
+Metody wyglądają i zachowują się bardzo podobnie jak funkcje, jednak jest między nimi kilka kluczowych różnic.
+
+Metody są definiowane z użyciem słowa kluczowego `def`.
+Po `def` następuje nazwa metody, lista parametrów, zwracany typ i ciało metody.
+
+{% scalafiddle %}
+```tut
+def add(x: Int, y: Int): Int = x + y
+println(add(1, 2)) // 3
+```
+{% endscalafiddle %}
+
+Zauważ, że zwracany typ jest zadeklarowany _po_ liście parametrów i dwukropku `: Int`.
+
+Metody mogą mieć wiele list parametrów.
+
+{% scalafiddle %}
+```tut
+def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier
+println(addThenMultiply(1, 2)(3)) // 9
+```
+{% endscalafiddle %}
+
+Mogą również wcale ich nie posiadać.
+
+{% scalafiddle %}
+```tut
+def name: String = System.getProperty("user.name")
+println("Hello, " + name + "!")
+```
+{% endscalafiddle %}
+
+Od funkcji odróżnia je jeszcze kilka innych rzeczy, ale na razie możesz o nich myśleć jak o bardzo podobnych do funkcji.
+
+Metody mogą zawierać również wyrażenia wielowierszowe.
+
+```tut
+def getSquareString(input: Double): String = {
+  val square = input * input
+  square.toString
+}
+```
+
+Ostatnie wyrażenie w ciele metody jest wartością, jaką zwraca cała metoda.
+Scala posiada słowo kluczowe `return`, ale jest ono wykorzystywane bardzo rzadko.
+
+## Klasy
+
+Klasy są definiowane za pomocą słowa kluczowego `class`, po którym następuje nazwa klasy i parametry konstruktora.
+
+{% scalafiddle %}
+```tut
+class Greeter(prefix: String, suffix: String) {
+  def greet(name: String): Unit =
+    println(prefix + name + suffix)
+}
+```
+
+Metoda `greet` zwraca typ `Unit` - oznacza to, że nie ma nic znaczącego do zwrócenia.
+`Unit` jest używany podobnie jak `void` w językach Java i C.
+Różnica polega na tym, że w Scali każde wyrażenie musi zwracać jakąś wartosć, tak naprawdę istnieje [obiekt singleton](singleton-objects.html) typu `Unit` - nie niesie on ze sobą żadnej znaczącej informacji.
+
+Nowe instancje klasy tworzy się za pomocą słowa kluczowego `new`.
+
+```tut
+val greeter = new Greeter("Hello, ", "!")
+greeter.greet("Scala developer") // Hello, Scala developer!
+```
+{% endscalafiddle %}
+
+Klasy zostaną szerzej omówione w [dalszej części](classes.html) tego przewodnika.
+
+## Klasy przypadku (case classes)
+
+W Scali istnieje spacjalny typ klasy - klasa "przypadku" (case class).
+Klasy przypadku są domyślnie niezmienne i porównywane przez wartości.
+Klasy te można definiować używająć słów kluczowych `case class`.
+
+{% scalafiddle %}
+```tut
+case class Point(x: Int, y: Int)
+```
+
+Do utworzenia nowej instacji klasy przypadku nie jest konieczne używanie słowa kluczowego `new`.
+
+```tut
+val point = Point(1, 2)
+val anotherPoint = Point(1, 2)
+val yetAnotherPoint = Point(2, 2)
+```
+
+Są one porównywane przez wartości - _nie_ przez referencje.
+
+```tut
+if (point == anotherPoint) {
+  println(point + " i " + anotherPoint + " są jednakowe.")
+} else {
+  println(point + " i " + anotherPoint + " są inne.")
+} // Point(1,2) i Point(1,2) są jednakowe.
+
+if (point == yetAnotherPoint) {
+  println(point + " i " + yetAnotherPoint + " są jednakowe.")
+} else {
+  println(point + " i " + yetAnotherPoint + " są inne.")
+} // Point(1,2) i Point(2,2) są inne.
+```
+{% endscalafiddle %}
+
+Klasy przypadków to dużo szerszy temat, do zapoznania z którym bardzo zachęcamy. Jesteśmy pewni, że Ci się spodoba!
+Jest on dokładnie omówiony w [późniejszym rozdziale](case-classes.html).
+
+## Obiekty
+
+Obiekty to pojedyncze wystąpienia ich definicji.
+Można o nich myśleć jak o instancjach ich własnych klas - singletonach.
+
+Objekty definiuje się z użyciem słowa kluczowego `object`.
+
+{% scalafiddle %}
+```tut
+object IdFactory {
+  private var counter = 0
+  def create(): Int = {
+    counter += 1
+    counter
+  }
+}
+```
+
+Aby uzyskać dostęp do obiektu używa się jego nazwy.
+
+```tut
+val newId: Int = IdFactory.create()
+println(newId) // 1
+val newerId: Int = IdFactory.create()
+println(newerId) // 2
+```
+{% endscalafiddle %}
+
+Obiekty zostaną szerzej omówione [później](singleton-objects.html).
+
+## Cechy (traits)
+
+Cechy to typy zawierające pewne pola i metody.
+Wiele cech może być łączonych.
+
+Cechę (trait) można zdefiniować używając słowa kluczowego `trait`.
+
+```tut
+trait Greeter {
+  def greet(name: String): Unit
+}
+```
+
+Cechy mogą zawierać domyślną implementację.
+
+{% scalafiddle %}
+```tut
+trait Greeter {
+  def greet(name: String): Unit =
+    println("Hello, " + name + "!")
+}
+```
+
+Cechy można rozszerzać używając słowa kluczowego `extends` i nadpisać implementację z użyciem `override`.
+
+```tut
+class DefaultGreeter extends Greeter
+
+class CustomizableGreeter(prefix: String, postfix: String) extends Greeter {
+  override def greet(name: String): Unit = {
+    println(prefix + name + postfix)
+  }
+}
+
+val greeter = new DefaultGreeter()
+greeter.greet("Scala developer") // Hello, Scala developer!
+
+val customGreeter = new CustomizableGreeter("How are you, ", "?")
+customGreeter.greet("Scala developer") // How are you, Scala developer?
+```
+{% endscalafiddle %}
+
+W tym przykładzie `DefaultGreeter` rozszerza tylko jedną cechę (trait), ale równie dobrze może rozszerzać ich wiele.
+
+Cechy zostały dokładniej opisane w jednym z [kolejnych](traits.html) rozdziałów.
+
+## Metoda Main
+
+Metoda `main` to punkt wejścia do programu.
+Maszyna Wirtalna Javy (Java Virtual Machine / JVM) wymaga, aby metoda ta nazywała się "main" i posiadała jeden arguemnt - tablicę ciągów znaków.
+
+Z użyciem obiektu można zdefiniować metodę `main` w następujący sposób:
+
+```tut
+object Main {
+  def main(args: Array[String]): Unit =
+    println("Hello, Scala developer!")
+}
+```

_pl/tour/mixin-class-composition.md

@@ -6,7 +6,7 @@ discourse: false
 
 partof: scala-tour
 
-num: 5
+num: 6
 language: pl
 next-page: higher-order-functions
 previous-page: tuples