From c3fb66cd6dfe79d9c8357e6f65230c750f78b3a7 Mon Sep 17 00:00:00 2001
From: Remigiusz Suwalski <remigiusz-suwalski@users.noreply.github.com>
Date: Tue, 10 Jan 2017 09:45:11 +0100
Subject: Initial commit

---
 pl-pl/haskell-pl.html.markdown | 450 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 450 insertions(+)
 create mode 100644 pl-pl/haskell-pl.html.markdown

(limited to 'pl-pl')

diff --git a/pl-pl/haskell-pl.html.markdown b/pl-pl/haskell-pl.html.markdown
new file mode 100644
index 00000000..196ad9a6
--- /dev/null
+++ b/pl-pl/haskell-pl.html.markdown
@@ -0,0 +1,450 @@
+---
+language: Haskell
+lang: pl-pl
+contributors:
+    - ["Remigiusz Suwalski", "https://github.com/remigiusz-suwalski"]
+---
+
+Haskell został zaprojektowany jako praktyczy, czysto funkcyjny język 
+programowania. Jest znany przede wszystkim ze względu na jego monady oraz system
+typów, ale ja lubię do niego wracać przez jego elegancję. Sprawił on, że 
+programowanie jest prawdziwą przyjemnością.
+
+```haskell
+-- Komentarze jednolinijkowe zaczynają się od dwóch myślników
+{- Komentarze wielolinijkowe należy 
+zamykać w bloki klamrami.
+-}
+
+----------------------------------------------------
+-- 1. Primitive Datatypes and Operators
+----------------------------------------------------
+
+-- You have numbers
+3 -- 3
+
+-- Math is what you would expect
+1 + 1 -- 2
+8 - 1 -- 7
+10 * 2 -- 20
+35 / 5 -- 7.0
+
+-- Division is not integer division by default
+35 / 4 -- 8.75
+
+-- integer division
+35 `div` 4 -- 8
+
+-- Boolean values are primitives
+True
+False
+
+-- Boolean operations
+not True -- False
+not False -- True
+1 == 1 -- True
+1 /= 1 -- False
+1 < 10 -- True
+
+-- In the above examples, `not` is a function that takes one value.
+-- Haskell doesn't need parentheses for function calls...all the arguments
+-- are just listed after the function. So the general pattern is:
+-- func arg1 arg2 arg3...
+-- See the section on functions for information on how to write your own.
+
+-- Strings and characters
+"This is a string."
+'a' -- character
+'You cant use single quotes for strings.' -- error!
+
+-- Strings can be concatenated
+"Hello " ++ "world!" -- "Hello world!"
+
+-- A string is a list of characters
+['H', 'e', 'l', 'l', 'o'] -- "Hello"
+"This is a string" !! 0 -- 'T'
+
+
+----------------------------------------------------
+-- Lists and Tuples
+----------------------------------------------------
+
+-- Every element in a list must have the same type.
+-- These two lists are the same:
+[1, 2, 3, 4, 5]
+[1..5]
+
+-- Ranges are versatile.
+['A'..'F'] -- "ABCDEF"
+
+-- You can create a step in a range.
+[0,2..10] -- [0, 2, 4, 6, 8, 10]
+[5..1] -- This doesn't work because Haskell defaults to incrementing.
+[5,4..1] -- [5, 4, 3, 2, 1]
+
+-- indexing into a list
+[1..10] !! 3 -- 4
+
+-- You can also have infinite lists in Haskell!
+[1..] -- a list of all the natural numbers
+
+-- Infinite lists work because Haskell has "lazy evaluation". This means
+-- that Haskell only evaluates things when it needs to. So you can ask for
+-- the 1000th element of your list and Haskell will give it to you:
+
+[1..] !! 999 -- 1000
+
+-- And now Haskell has evaluated elements 1 - 1000 of this list...but the
+-- rest of the elements of this "infinite" list don't exist yet! Haskell won't
+-- actually evaluate them until it needs to.
+
+-- joining two lists
+[1..5] ++ [6..10]
+
+-- adding to the head of a list
+0:[1..5] -- [0, 1, 2, 3, 4, 5]
+
+-- more list operations
+head [1..5] -- 1
+tail [1..5] -- [2, 3, 4, 5]
+init [1..5] -- [1, 2, 3, 4]
+last [1..5] -- 5
+
+-- list comprehensions
+[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10]
+
+-- with a conditional
+[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10]
+
+-- Every element in a tuple can be a different type, but a tuple has a
+-- fixed length.
+-- A tuple:
+("haskell", 1)
+
+-- accessing elements of a pair (i.e. a tuple of length 2)
+fst ("haskell", 1) -- "haskell"
+snd ("haskell", 1) -- 1
+
+----------------------------------------------------
+-- 3. Functions
+----------------------------------------------------
+-- A simple function that takes two variables
+add a b = a + b
+
+-- Note that if you are using ghci (the Haskell interpreter)
+-- You'll need to use `let`, i.e.
+-- let add a b = a + b
+
+-- Using the function
+add 1 2 -- 3
+
+-- You can also put the function name between the two arguments
+-- with backticks:
+1 `add` 2 -- 3
+
+-- You can also define functions that have no letters! This lets
+-- you define your own operators! Here's an operator that does
+-- integer division
+(//) a b = a `div` b
+35 // 4 -- 8
+
+-- Guards: an easy way to do branching in functions
+fib x
+  | x < 2 = 1
+  | otherwise = fib (x - 1) + fib (x - 2)
+
+-- Pattern matching is similar. Here we have given three different
+-- definitions for fib. Haskell will automatically call the first
+-- function that matches the pattern of the value.
+fib 1 = 1
+fib 2 = 2
+fib x = fib (x - 1) + fib (x - 2)
+
+-- Pattern matching on tuples:
+foo (x, y) = (x + 1, y + 2)
+
+-- Pattern matching on lists. Here `x` is the first element
+-- in the list, and `xs` is the rest of the list. We can write
+-- our own map function:
+myMap func [] = []
+myMap func (x:xs) = func x:(myMap func xs)
+
+-- Anonymous functions are created with a backslash followed by
+-- all the arguments.
+myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7]
+
+-- using fold (called `inject` in some languages) with an anonymous
+-- function. foldl1 means fold left, and use the first value in the
+-- list as the initial value for the accumulator.
+foldl1 (\acc x -> acc + x) [1..5] -- 15
+
+----------------------------------------------------
+-- 4. More functions
+----------------------------------------------------
+
+-- partial application: if you don't pass in all the arguments to a function,
+-- it gets "partially applied". That means it returns a function that takes the
+-- rest of the arguments.
+
+add a b = a + b
+foo = add 10 -- foo is now a function that takes a number and adds 10 to it
+foo 5 -- 15
+
+-- Another way to write the same thing
+foo = (10+)
+foo 5 -- 15
+
+-- function composition
+-- the operator `.` chains functions together.
+-- For example, here foo is a function that takes a value. It adds 10 to it,
+-- multiplies the result of that by 4, and then returns the final value.
+foo = (4*) . (10+)
+
+-- 4*(10 + 5) = 60
+foo 5 -- 60
+
+-- fixing precedence
+-- Haskell has another operator called `$`. This operator applies a function 
+-- to a given parameter. In contrast to standard function application, which 
+-- has highest possible priority of 10 and is left-associative, the `$` operator 
+-- has priority of 0 and is right-associative. Such a low priority means that
+-- the expression on its right is applied as the parameter to the function on its left.
+
+-- before
+even (fib 7) -- false
+
+-- equivalently
+even $ fib 7 -- false
+
+-- composing functions
+even . fib $ 7 -- false
+
+
+----------------------------------------------------
+-- 5. Type signatures
+----------------------------------------------------
+
+-- Haskell has a very strong type system, and every valid expression has a type. 
+
+-- Some basic types:
+5 :: Integer
+"hello" :: String
+True :: Bool
+
+-- Functions have types too.
+-- `not` takes a boolean and returns a boolean:
+-- not :: Bool -> Bool
+
+-- Here's a function that takes two arguments:
+-- add :: Integer -> Integer -> Integer
+
+-- When you define a value, it's good practice to write its type above it:
+double :: Integer -> Integer
+double x = x * 2
+
+----------------------------------------------------
+-- 6. Control Flow and If Expressions
+----------------------------------------------------
+
+-- if expressions
+haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome"
+
+-- if expressions can be on multiple lines too, indentation is important
+haskell = if 1 == 1
+            then "awesome"
+            else "awful"
+
+-- case expressions: Here's how you could parse command line arguments
+case args of
+  "help" -> printHelp
+  "start" -> startProgram
+  _ -> putStrLn "bad args"
+
+-- Haskell doesn't have loops; it uses recursion instead.
+-- map applies a function over every element in a list
+
+map (*2) [1..5] -- [2, 4, 6, 8, 10]
+
+-- you can make a for function using map
+for array func = map func array
+
+-- and then use it
+for [0..5] $ \i -> show i
+
+-- we could've written that like this too:
+for [0..5] show
+
+-- You can use foldl or foldr to reduce a list
+-- foldl <fn> <initial value> <list>
+foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43
+
+-- This is the same as
+(2 * (2 * (2 * 4 + 1) + 2) + 3)
+
+-- foldl is left-handed, foldr is right-handed
+foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16
+
+-- This is now the same as
+(2 * 1 + (2 * 2 + (2 * 3 + 4)))
+
+----------------------------------------------------
+-- 7. Data Types
+----------------------------------------------------
+
+-- Here's how you make your own data type in Haskell
+
+data Color = Red | Blue | Green
+
+-- Now you can use it in a function:
+
+
+say :: Color -> String
+say Red = "You are Red!"
+say Blue = "You are Blue!"
+say Green =  "You are Green!"
+
+-- Your data types can have parameters too:
+
+data Maybe a = Nothing | Just a
+
+-- These are all of type Maybe
+Just "hello"    -- of type `Maybe String`
+Just 1          -- of type `Maybe Int`
+Nothing         -- of type `Maybe a` for any `a`
+
+----------------------------------------------------
+-- 8. Haskell IO
+----------------------------------------------------
+
+-- While IO can't be explained fully without explaining monads,
+-- it is not hard to explain enough to get going.
+
+-- When a Haskell program is executed, `main` is
+-- called. It must return a value of type `IO a` for some type `a`. For example:
+
+main :: IO ()
+main = putStrLn $ "Hello, sky! " ++ (say Blue)
+-- putStrLn has type String -> IO ()
+
+-- It is easiest to do IO if you can implement your program as
+-- a function from String to String. The function
+--    interact :: (String -> String) -> IO ()
+-- inputs some text, runs a function on it, and prints out the
+-- output.
+
+countLines :: String -> String
+countLines = show . length . lines
+
+main' = interact countLines
+
+-- You can think of a value of type `IO ()` as representing a
+-- sequence of actions for the computer to do, much like a
+-- computer program written in an imperative language. We can use
+-- the `do` notation to chain actions together. For example:
+
+sayHello :: IO ()
+sayHello = do
+   putStrLn "What is your name?"
+   name <- getLine -- this gets a line and gives it the name "name"
+   putStrLn $ "Hello, " ++ name
+
+-- Exercise: write your own version of `interact` that only reads
+--           one line of input.
+
+-- The code in `sayHello` will never be executed, however. The only
+-- action that ever gets executed is the value of `main`.
+-- To run `sayHello` comment out the above definition of `main`
+-- and replace it with:
+--   main = sayHello
+
+-- Let's understand better how the function `getLine` we just
+-- used works. Its type is:
+--    getLine :: IO String
+-- You can think of a value of type `IO a` as representing a
+-- computer program that will generate a value of type `a`
+-- when executed (in addition to anything else it does). We can
+-- name and reuse this value using `<-`. We can also
+-- make our own action of type `IO String`:
+
+action :: IO String
+action = do
+   putStrLn "This is a line. Duh"
+   input1 <- getLine
+   input2 <- getLine
+   -- The type of the `do` statement is that of its last line.
+   -- `return` is not a keyword, but merely a function
+   return (input1 ++ "\n" ++ input2) -- return :: String -> IO String
+
+-- We can use this just like we used `getLine`:
+
+main'' = do
+    putStrLn "I will echo two lines!"
+    result <- action
+    putStrLn result
+    putStrLn "This was all, folks!"
+
+-- The type `IO` is an example of a "monad". The way Haskell uses a monad to
+-- do IO allows it to be a purely functional language. Any function that
+-- interacts with the outside world (i.e. does IO) gets marked as `IO` in its
+-- type signature. This lets us reason about what functions are "pure" (don't
+-- interact with the outside world or modify state) and what functions aren't.
+
+-- This is a powerful feature, because it's easy to run pure functions
+-- concurrently; so, concurrency in Haskell is very easy.
+
+
+----------------------------------------------------
+-- 9. The Haskell REPL
+----------------------------------------------------
+
+-- Start the repl by typing `ghci`.
+-- Now you can type in Haskell code. Any new values
+-- need to be created with `let`:
+
+let foo = 5
+
+-- You can see the type of any value or expression with `:t`:
+
+> :t foo
+foo :: Integer
+
+-- Operators, such as `+`, `:` and `$`, are functions.
+-- Their type can be inspected by putting the operator in parentheses:
+
+> :t (:)
+(:) :: a -> [a] -> [a]
+
+-- You can get additional information on any `name` using `:i`:
+
+> :i (+)
+class Num a where
+  (+) :: a -> a -> a
+  ...
+    -- Defined in ‘GHC.Num’
+infixl 6 +
+
+-- You can also run any action of type `IO ()`
+
+> sayHello
+What is your name?
+Friend!
+Hello, Friend!
+
+```
+
+There's a lot more to Haskell, including typeclasses and monads. These are the
+big ideas that make Haskell such fun to code in. I'll leave you with one final
+Haskell example: an implementation of a quicksort variant in Haskell:
+
+```haskell
+qsort [] = []
+qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
+    where lesser  = filter (< p) xs
+          greater = filter (>= p) xs
+```
+
+There are two popular ways to install Haskell: The traditional [Cabal-based installation](http://www.haskell.org/platform/), and the newer [Stack-based process](https://www.stackage.org/install).
+
+You can find a much gentler introduction from the excellent
+[Learn you a Haskell](http://learnyouahaskell.com/) or
+[Real World Haskell](http://book.realworldhaskell.org/).
-- 
cgit v1.2.3


From fb5dac4b3cbc92abd16187974eb7bb0608f3e9be Mon Sep 17 00:00:00 2001
From: Remigiusz Suwalski <remigiusz-suwalski@users.noreply.github.com>
Date: Tue, 10 Jan 2017 09:58:12 +0100
Subject: Lists and tuples

---
 pl-pl/haskell-pl.html.markdown | 46 +++++++++++++++++++++---------------------
 1 file changed, 23 insertions(+), 23 deletions(-)

(limited to 'pl-pl')

diff --git a/pl-pl/haskell-pl.html.markdown b/pl-pl/haskell-pl.html.markdown
index 196ad9a6..cc65be27 100644
--- a/pl-pl/haskell-pl.html.markdown
+++ b/pl-pl/haskell-pl.html.markdown
@@ -66,45 +66,46 @@ not False -- True
 
 
 ----------------------------------------------------
--- Lists and Tuples
+-- Listy oraz krotki
 ----------------------------------------------------
 
--- Every element in a list must have the same type.
--- These two lists are the same:
+-- Wszystkie elementy listy muszą być tego samego typu.
+-- Poniższe dwie listy są identyczne:
 [1, 2, 3, 4, 5]
 [1..5]
 
--- Ranges are versatile.
+-- Zakresy są uniwersalne.
 ['A'..'F'] -- "ABCDEF"
 
--- You can create a step in a range.
+-- Przy tworzeniu zakresów można określić krok.
 [0,2..10] -- [0, 2, 4, 6, 8, 10]
-[5..1] -- This doesn't work because Haskell defaults to incrementing.
+[5..1] -- To nie zadziała, gdyż w Haskellu zakresy tworzone są domyślnie rosnąco
 [5,4..1] -- [5, 4, 3, 2, 1]
 
--- indexing into a list
+-- indeksowanie listy od zera
 [1..10] !! 3 -- 4
 
--- You can also have infinite lists in Haskell!
-[1..] -- a list of all the natural numbers
+-- Można nawet tworzyć listy nieskończone!
+[1..] -- lista wszystkich liczb naturalnych
 
--- Infinite lists work because Haskell has "lazy evaluation". This means
--- that Haskell only evaluates things when it needs to. So you can ask for
--- the 1000th element of your list and Haskell will give it to you:
+-- Nieskończone listy mają prawo działać, ponieważ Haskell cechuje się leniwym 
+-- wartościowaniem. To oznacza, że obliczane są jedynie te elementy listy, 
+-- których istotnie potrzebujemy. Możemy poprosić o tysiączny element i 
+-- dostaniemy go:
 
 [1..] !! 999 -- 1000
 
--- And now Haskell has evaluated elements 1 - 1000 of this list...but the
--- rest of the elements of this "infinite" list don't exist yet! Haskell won't
--- actually evaluate them until it needs to.
+-- Haskell wyznaczył pierwsze tysiąc elementów listy, ale cała jej reszta 
+-- jeszcze nie istnieje! Nie zostanie obliczona ich wartość, póki nie zajdzie
+-- taka potrzeba.
 
--- joining two lists
+-- łączenie dwóch list
 [1..5] ++ [6..10]
 
--- adding to the head of a list
+-- dodawanie pojedynczego elementu na początek listy
 0:[1..5] -- [0, 1, 2, 3, 4, 5]
 
--- more list operations
+-- więcej operacji na listach
 head [1..5] -- 1
 tail [1..5] -- [2, 3, 4, 5]
 init [1..5] -- [1, 2, 3, 4]
@@ -113,15 +114,14 @@ last [1..5] -- 5
 -- list comprehensions
 [x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10]
 
--- with a conditional
+-- z dodatkowym warunkiem
 [x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10]
 
--- Every element in a tuple can be a different type, but a tuple has a
--- fixed length.
--- A tuple:
+-- każdy element krotki może być innego typu, jednak sama krotka musi być stałej 
+-- długości. Przykładowo:
 ("haskell", 1)
 
--- accessing elements of a pair (i.e. a tuple of length 2)
+-- dostęp do elementów pary (krotki długości 2):
 fst ("haskell", 1) -- "haskell"
 snd ("haskell", 1) -- 1
 
-- 
cgit v1.2.3


From 7e3b7a5326c948ec80e79c687e462d62538fe319 Mon Sep 17 00:00:00 2001
From: Remigiusz Suwalski <remigiusz-suwalski@users.noreply.github.com>
Date: Tue, 10 Jan 2017 10:04:14 +0100
Subject: Translate functions

---
 pl-pl/haskell-pl.html.markdown | 39 +++++++++++++++++++--------------------
 1 file changed, 19 insertions(+), 20 deletions(-)

(limited to 'pl-pl')

diff --git a/pl-pl/haskell-pl.html.markdown b/pl-pl/haskell-pl.html.markdown
index cc65be27..b747ebb3 100644
--- a/pl-pl/haskell-pl.html.markdown
+++ b/pl-pl/haskell-pl.html.markdown
@@ -17,53 +17,52 @@ zamykać w bloki klamrami.
 -}
 
 ----------------------------------------------------
--- 1. Primitive Datatypes and Operators
+-- 1. Podstawowe typy danych oraz operatory
 ----------------------------------------------------
 
--- You have numbers
+-- Mamy liczby
 3 -- 3
 
--- Math is what you would expect
+-- Podstawowe działania działają tak, jak powinny
 1 + 1 -- 2
 8 - 1 -- 7
 10 * 2 -- 20
 35 / 5 -- 7.0
 
--- Division is not integer division by default
+-- dzielenie domyślnie zwraca ,,dokładny'' wynik
 35 / 4 -- 8.75
 
--- integer division
+-- dzielenie całkowitoliczbowe
 35 `div` 4 -- 8
 
--- Boolean values are primitives
+-- wartości logiczne także są podstawowym typem danych:
 True
 False
 
--- Boolean operations
+-- operacje logiczne: negacja oraz porównania
 not True -- False
 not False -- True
 1 == 1 -- True
 1 /= 1 -- False
 1 < 10 -- True
 
--- In the above examples, `not` is a function that takes one value.
--- Haskell doesn't need parentheses for function calls...all the arguments
--- are just listed after the function. So the general pattern is:
--- func arg1 arg2 arg3...
--- See the section on functions for information on how to write your own.
+-- W powyższych przykładach, `not` jest funkcją przyjmującą jeden argument.
+-- Haskell nie potrzebuje nawiasów, by wywołać funkcję: argumenty są po prostu
+-- wypisywane jeden za drugim. Ogólnie wygląda to tak:
+-- funkcja arg1 arg2 arg3...
+-- Sekcja poświęcona funkcjom zawiera informacje, jak stworzyć własne.
 
--- Strings and characters
-"This is a string."
-'a' -- character
-'You cant use single quotes for strings.' -- error!
+-- Łańcuchy znaków (stringi) i pojedyncze znaki:
+"To jest lancuch."
+'a' -- znak
+'Nie mozna laczyc apostrofow z lancuchami.' -- błąd!
 
--- Strings can be concatenated
+-- Łańcuchy można sklejać
 "Hello " ++ "world!" -- "Hello world!"
 
--- A string is a list of characters
+-- Łańcuch jest listą własnych znaków
 ['H', 'e', 'l', 'l', 'o'] -- "Hello"
-"This is a string" !! 0 -- 'T'
-
+"To jest lancuch" !! 0 -- 'T'
 
 ----------------------------------------------------
 -- Listy oraz krotki
-- 
cgit v1.2.3


From cc0bd98aeed7bb0b03b78422c63c382907eced77 Mon Sep 17 00:00:00 2001
From: Remigiusz Suwalski <remigiusz-suwalski@users.noreply.github.com>
Date: Tue, 10 Jan 2017 10:06:27 +0100
Subject: Translate data types

---
 pl-pl/haskell-pl.html.markdown | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

(limited to 'pl-pl')

diff --git a/pl-pl/haskell-pl.html.markdown b/pl-pl/haskell-pl.html.markdown
index b747ebb3..ae44cd9a 100644
--- a/pl-pl/haskell-pl.html.markdown
+++ b/pl-pl/haskell-pl.html.markdown
@@ -287,29 +287,28 @@ foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16
 (2 * 1 + (2 * 2 + (2 * 3 + 4)))
 
 ----------------------------------------------------
--- 7. Data Types
+-- 7. Typy danych
 ----------------------------------------------------
 
--- Here's how you make your own data type in Haskell
+-- Oto jak tworzy się nowe typy danych w Haskellu:
 
 data Color = Red | Blue | Green
 
--- Now you can use it in a function:
-
+-- Teraz można używać ich we własnych funkcjach:
 
 say :: Color -> String
 say Red = "You are Red!"
 say Blue = "You are Blue!"
 say Green =  "You are Green!"
 
--- Your data types can have parameters too:
+-- Twoje typy danych mogą posiadać nawet parametry:
 
 data Maybe a = Nothing | Just a
 
--- These are all of type Maybe
-Just "hello"    -- of type `Maybe String`
-Just 1          -- of type `Maybe Int`
-Nothing         -- of type `Maybe a` for any `a`
+-- Wszystkie poniższe są typu Maybe
+Just "hello"    -- typu `Maybe String`
+Just 1          -- typu `Maybe Int`
+Nothing         -- typu `Maybe a` for any `a`
 
 ----------------------------------------------------
 -- 8. Haskell IO
-- 
cgit v1.2.3


From fd89a692838344ab3776334984a7afced5defe93 Mon Sep 17 00:00:00 2001
From: Remigiusz Suwalski <remigiusz-suwalski@users.noreply.github.com>
Date: Tue, 10 Jan 2017 10:10:04 +0100
Subject: Translate type signatures

---
 pl-pl/haskell-pl.html.markdown | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

(limited to 'pl-pl')

diff --git a/pl-pl/haskell-pl.html.markdown b/pl-pl/haskell-pl.html.markdown
index ae44cd9a..a3c2d187 100644
--- a/pl-pl/haskell-pl.html.markdown
+++ b/pl-pl/haskell-pl.html.markdown
@@ -220,24 +220,26 @@ even . fib $ 7 -- false
 
 
 ----------------------------------------------------
--- 5. Type signatures
+-- 5. Sygnatury typów
 ----------------------------------------------------
 
--- Haskell has a very strong type system, and every valid expression has a type. 
+-- Haskell posiada wyjątkowo silny system typów, w którym każde poprawne 
+-- wyrażenie ma swój typ.
 
--- Some basic types:
+-- Kilka podstawowych typów:
 5 :: Integer
 "hello" :: String
 True :: Bool
 
--- Functions have types too.
--- `not` takes a boolean and returns a boolean:
+-- Funkcje też są określonego typu.
+-- `not` przyjmuje wartość logiczną i taką też zwraca:
 -- not :: Bool -> Bool
 
--- Here's a function that takes two arguments:
+-- Przykład funkcji przyjmującej dwa argumenty
 -- add :: Integer -> Integer -> Integer
 
--- When you define a value, it's good practice to write its type above it:
+-- Dobrą praktyką podczas definiowania wartości jest napisanie nad nią
+-- także jej typu:
 double :: Integer -> Integer
 double x = x * 2
 
-- 
cgit v1.2.3


From 6fa14954a506717535f29c3ff97d9703a80ddca5 Mon Sep 17 00:00:00 2001
From: Remigiusz Suwalski <remigiusz-suwalski@users.noreply.github.com>
Date: Tue, 10 Jan 2017 18:29:33 +0100
Subject: Translate Flow control

---
 pl-pl/haskell-pl.html.markdown | 33 +++++++++++++++++----------------
 1 file changed, 17 insertions(+), 16 deletions(-)

(limited to 'pl-pl')

diff --git a/pl-pl/haskell-pl.html.markdown b/pl-pl/haskell-pl.html.markdown
index a3c2d187..59fc090e 100644
--- a/pl-pl/haskell-pl.html.markdown
+++ b/pl-pl/haskell-pl.html.markdown
@@ -244,48 +244,49 @@ double :: Integer -> Integer
 double x = x * 2
 
 ----------------------------------------------------
--- 6. Control Flow and If Expressions
+-- 6. Wyrażenia warunkowe
 ----------------------------------------------------
 
--- if expressions
-haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome"
+-- wyrażenie warunkowe
+haskell = if 1 == 1 then "wspaniale" else "paskudnie" -- haskell = "wspaniale"
 
--- if expressions can be on multiple lines too, indentation is important
+-- wyrażenie warunkowe można rozbić na wiele linii, 
+-- ale trzeba uważać na wcięcia w kodzie
 haskell = if 1 == 1
-            then "awesome"
-            else "awful"
+            then "wspaniale"
+            else "paskudnie"
 
--- case expressions: Here's how you could parse command line arguments
+-- rozpatrywanie przypadków: oto jak można parsować argumenty z linii poleceń:
 case args of
   "help" -> printHelp
   "start" -> startProgram
   _ -> putStrLn "bad args"
 
--- Haskell doesn't have loops; it uses recursion instead.
--- map applies a function over every element in a list
+-- Haskell zastępuje pętle (których nie ma) rekurencyjnymi wywołaniami funkcji.
+-- map aplikuje funkcję do każdego elementu listy:
 
 map (*2) [1..5] -- [2, 4, 6, 8, 10]
 
--- you can make a for function using map
+-- możesz zdefiniować funkcję for przy użyciu map:
 for array func = map func array
 
--- and then use it
+-- a następnie użyć jej:
 for [0..5] $ \i -> show i
 
--- we could've written that like this too:
+-- mogliśmy użyć krótszego zapisu bez zmiany działania funkcji for:
 for [0..5] show
 
--- You can use foldl or foldr to reduce a list
+-- Do redukcji listy służy polecenie foldl (foldr):
 -- foldl <fn> <initial value> <list>
 foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43
 
--- This is the same as
+-- Jest to równoważne z:
 (2 * (2 * (2 * 4 + 1) + 2) + 3)
 
--- foldl is left-handed, foldr is right-handed
+-- foldl składa od od lewej strony, foldr od prawej
 foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16
 
--- This is now the same as
+-- To zaś równoważne jest:
 (2 * 1 + (2 * 2 + (2 * 3 + 4)))
 
 ----------------------------------------------------
-- 
cgit v1.2.3


From b80c70b4a3e4646c15f21f1c86fed9242ddbd793 Mon Sep 17 00:00:00 2001
From: Remigiusz Suwalski <remigiusz-suwalski@users.noreply.github.com>
Date: Wed, 11 Jan 2017 10:21:38 +0100
Subject: Translate REPL

---
 pl-pl/haskell-pl.html.markdown | 32 +++++++++++++++++---------------
 1 file changed, 17 insertions(+), 15 deletions(-)

(limited to 'pl-pl')

diff --git a/pl-pl/haskell-pl.html.markdown b/pl-pl/haskell-pl.html.markdown
index 59fc090e..f2c31bb4 100644
--- a/pl-pl/haskell-pl.html.markdown
+++ b/pl-pl/haskell-pl.html.markdown
@@ -395,27 +395,27 @@ main'' = do
 
 
 ----------------------------------------------------
--- 9. The Haskell REPL
+-- 9. Interaktywne środowisko programowania
 ----------------------------------------------------
 
--- Start the repl by typing `ghci`.
--- Now you can type in Haskell code. Any new values
--- need to be created with `let`:
+-- Aby uruchomić repl (read-eval-print loop, interaktywne środowisko), należy
+-- wpisać `ghci`. Można już programować. Do definiowania nowych wartości służy
+-- słowo kluczowe `let`:
 
 let foo = 5
 
--- You can see the type of any value or expression with `:t`:
+-- Do sprawdzania typów dowolnej wartości (wyrażenia) wykorzystuje się `:t`:
 
 > :t foo
 foo :: Integer
 
--- Operators, such as `+`, `:` and `$`, are functions.
--- Their type can be inspected by putting the operator in parentheses:
+-- Działania takie jak `+`, `:` czy `$`, są funkcjami.
+-- Przed sprawdzeniem ich typu należy otoczyć je nawiasami:
 
 > :t (:)
 (:) :: a -> [a] -> [a]
 
--- You can get additional information on any `name` using `:i`:
+-- Dodatkowych informacji dostarcza `:i`:
 
 > :i (+)
 class Num a where
@@ -424,7 +424,7 @@ class Num a where
     -- Defined in ‘GHC.Num’
 infixl 6 +
 
--- You can also run any action of type `IO ()`
+-- Można nawet wykonywać akcje typu `IO ()`!
 
 > sayHello
 What is your name?
@@ -433,9 +433,9 @@ Hello, Friend!
 
 ```
 
-There's a lot more to Haskell, including typeclasses and monads. These are the
-big ideas that make Haskell such fun to code in. I'll leave you with one final
-Haskell example: an implementation of a quicksort variant in Haskell:
+Pominęliśmy wiele aspektów Haskella, wliczając w to monady. To właśnie one 
+sprawiają, że programowanie w Haskellu sprawia tyle frajdy. Na zakończenie
+pokażę Tobie implementację algorytmu quicksort w Haskellu:
 
 ```haskell
 qsort [] = []
@@ -444,8 +444,10 @@ qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
           greater = filter (>= p) xs
 ```
 
-There are two popular ways to install Haskell: The traditional [Cabal-based installation](http://www.haskell.org/platform/), and the newer [Stack-based process](https://www.stackage.org/install).
+Haskell może zostać zainstalowany na co najmniej dwa sposoby:
+ - tradycyjnie [przy użyciu Cabala](http://www.haskell.org/platform/),
+ - nowocześnie [z pomocą Stack](https://www.stackage.org/install).
 
-You can find a much gentler introduction from the excellent
-[Learn you a Haskell](http://learnyouahaskell.com/) or
+Godnymi poleceniami wprowadzeniami są wspaniałe
+[Learn you a Haskell](http://learnyouahaskell.com/) albo
 [Real World Haskell](http://book.realworldhaskell.org/).
-- 
cgit v1.2.3


From ac680b6a7fe84e55c5ee5ae77034150603f4a028 Mon Sep 17 00:00:00 2001
From: Remigiusz Suwalski <remigiusz-suwalski@users.noreply.github.com>
Date: Fri, 13 Jan 2017 10:10:10 +0100
Subject: Translate Haskell IO

---
 pl-pl/haskell-pl.html.markdown | 62 +++++++++++++++++++-----------------------
 1 file changed, 28 insertions(+), 34 deletions(-)

(limited to 'pl-pl')

diff --git a/pl-pl/haskell-pl.html.markdown b/pl-pl/haskell-pl.html.markdown
index f2c31bb4..23de1949 100644
--- a/pl-pl/haskell-pl.html.markdown
+++ b/pl-pl/haskell-pl.html.markdown
@@ -317,31 +317,29 @@ Nothing         -- typu `Maybe a` for any `a`
 -- 8. Haskell IO
 ----------------------------------------------------
 
--- While IO can't be explained fully without explaining monads,
--- it is not hard to explain enough to get going.
+-- Chociaż obsługa wejścia i wyjścia nie może zostać wyjaśniona przez poznaniem
+-- monad, spróbujemy zrobić to częściowo
 
--- When a Haskell program is executed, `main` is
--- called. It must return a value of type `IO a` for some type `a`. For example:
+-- Wykonanie programu napisanego w Haskellu wywołuje funkcję `main` 
+-- Musi zwrócić wartość typu `IO a` dla pewnego `a`. Przykład:
 
 main :: IO ()
 main = putStrLn $ "Hello, sky! " ++ (say Blue)
 -- putStrLn has type String -> IO ()
 
--- It is easiest to do IO if you can implement your program as
--- a function from String to String. The function
+-- Najłatwiej obsłużyć wejście i wyjście, kiedy program zostanie 
+-- zaimplementowany jako funkcja String -> String. Funkcja
 --    interact :: (String -> String) -> IO ()
--- inputs some text, runs a function on it, and prints out the
--- output.
+-- pobiera pewien tekst, wykonuje na nim operacje, po czym wypisuje wynik.
 
 countLines :: String -> String
 countLines = show . length . lines
 
 main' = interact countLines
 
--- You can think of a value of type `IO ()` as representing a
--- sequence of actions for the computer to do, much like a
--- computer program written in an imperative language. We can use
--- the `do` notation to chain actions together. For example:
+-- Możesz myśleć o wartości typu `IO ()` jako reprezentującej ciąg czynności,
+-- które komputer ma wykonać, zupełnie niczym program komputerowy w imperatywnym
+-- języku programowania. Akcje można łączyć przy użyciu notacji `do`:
 
 sayHello :: IO ()
 sayHello = do
@@ -349,23 +347,20 @@ sayHello = do
    name <- getLine -- this gets a line and gives it the name "name"
    putStrLn $ "Hello, " ++ name
 
--- Exercise: write your own version of `interact` that only reads
---           one line of input.
+-- Ćwiczenie: napisz własną wersję `interact`, 
+-- która czyta tylko jedną linię wejścia.
 
--- The code in `sayHello` will never be executed, however. The only
--- action that ever gets executed is the value of `main`.
--- To run `sayHello` comment out the above definition of `main`
--- and replace it with:
+-- Kod w `sayHello` nigdy się nie wykona. Jedyną akcją, która zostanie 
+-- uruchomiona, jest wartość `main`.
+-- Aby uruchomić `sayHello`, należy zastąpić poprzednią definicję `main` przez
 --   main = sayHello
 
--- Let's understand better how the function `getLine` we just
--- used works. Its type is:
+-- Spróbujmy lepiej zrozumieć, jak działa funkcja `getLine`, której właśnie
+-- użyliśmy. Jej typem jest
 --    getLine :: IO String
--- You can think of a value of type `IO a` as representing a
--- computer program that will generate a value of type `a`
--- when executed (in addition to anything else it does). We can
--- name and reuse this value using `<-`. We can also
--- make our own action of type `IO String`:
+-- Możesz myśleć o wartości typu `IO a` jako reprezentującej program, który
+-- wygeneruje wartość typu `a`, poza wszystkim innym, co jeszcze zrobi.
+-- Możemy także tworzyć własne akcje typu `IO String`:
 
 action :: IO String
 action = do
@@ -376,7 +371,7 @@ action = do
    -- `return` is not a keyword, but merely a function
    return (input1 ++ "\n" ++ input2) -- return :: String -> IO String
 
--- We can use this just like we used `getLine`:
+-- Możemy użyć tego tak jak używaliśmy `getLine`:
 
 main'' = do
     putStrLn "I will echo two lines!"
@@ -384,15 +379,14 @@ main'' = do
     putStrLn result
     putStrLn "This was all, folks!"
 
--- The type `IO` is an example of a "monad". The way Haskell uses a monad to
--- do IO allows it to be a purely functional language. Any function that
--- interacts with the outside world (i.e. does IO) gets marked as `IO` in its
--- type signature. This lets us reason about what functions are "pure" (don't
--- interact with the outside world or modify state) and what functions aren't.
-
--- This is a powerful feature, because it's easy to run pure functions
--- concurrently; so, concurrency in Haskell is very easy.
+-- Typ `IO` jest przykładem monady. Sposób w jakim Haskell używa monad do 
+-- obsługi wejścia i wyjścia pozwala mu być czysto funkcyjnym językiem.
+-- Każda funkcja, która wchodzi w interakcje ze światem zewnętrznym, oznaczana
+-- jest jako `IO` w jej sygnaturze typu, co umożliwia odróżnianie funkcji
+-- czystych od zależnych od świata lub modyfikujących stan.
 
+-- To naprawdę użyteczna własność, dzięki której jesteśmy w stanie uruchamiać
+-- czyste funkcje jednocześnie.
 
 ----------------------------------------------------
 -- 9. Interaktywne środowisko programowania
-- 
cgit v1.2.3


From ca0d124a8e26dc0e9de2534395708ccd6bead7f2 Mon Sep 17 00:00:00 2001
From: Remigiusz Suwalski <remigiusz-suwalski@users.noreply.github.com>
Date: Fri, 13 Jan 2017 10:31:24 +0100
Subject: Translate more functions

---
 pl-pl/haskell-pl.html.markdown | 44 +++++++++++++++++++++---------------------
 1 file changed, 22 insertions(+), 22 deletions(-)

(limited to 'pl-pl')

diff --git a/pl-pl/haskell-pl.html.markdown b/pl-pl/haskell-pl.html.markdown
index 23de1949..4de76281 100644
--- a/pl-pl/haskell-pl.html.markdown
+++ b/pl-pl/haskell-pl.html.markdown
@@ -178,45 +178,45 @@ myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7]
 foldl1 (\acc x -> acc + x) [1..5] -- 15
 
 ----------------------------------------------------
--- 4. More functions
+-- 4. Więcej funkcji
 ----------------------------------------------------
 
--- partial application: if you don't pass in all the arguments to a function,
--- it gets "partially applied". That means it returns a function that takes the
--- rest of the arguments.
+-- częściowe nakładanie: jeśli funkcja nie otrzyma wszystkich swoich argumentów, 
+-- zostaje cześciowo nałożona - zwraca funkcję, która przyjmuje pozostałe,
+-- brakujące argumenty.
 
 add a b = a + b
-foo = add 10 -- foo is now a function that takes a number and adds 10 to it
+foo = add 10 -- foo jest teraz funkcją, która przyjmuje liczbę, zwiększa ją o 10
 foo 5 -- 15
 
--- Another way to write the same thing
+-- Inny sposób na zapisanie tego samego:
 foo = (10+)
 foo 5 -- 15
 
--- function composition
--- the operator `.` chains functions together.
--- For example, here foo is a function that takes a value. It adds 10 to it,
--- multiplies the result of that by 4, and then returns the final value.
+-- składanie funkcji:
+-- operator `.` składa wiele funkcji w jedną.
+-- Dla przykładu, foo jest funkcją, która powiększa swój argument o 10, mnoży 
+-- tak uzyskaną liczbę przez 4 i zwraca wynik:
 foo = (4*) . (10+)
 
 -- 4*(10 + 5) = 60
 foo 5 -- 60
 
--- fixing precedence
--- Haskell has another operator called `$`. This operator applies a function 
--- to a given parameter. In contrast to standard function application, which 
--- has highest possible priority of 10 and is left-associative, the `$` operator 
--- has priority of 0 and is right-associative. Such a low priority means that
--- the expression on its right is applied as the parameter to the function on its left.
+-- ustalanie kolejności
+-- Haskell posiada inny operator, `$`, który nakłada funkcję do podanego
+-- parametru. W przeciwieństwie do zwykłego lewostronnie łącznego nakładania 
+-- funkcji, którego priorytet jest najwyższy (10), operator `$` posiada
+-- priorytet 0 i jest prawostronnie łączny. Tak niski priorytet oznacza, że
+-- wyrażenie po prawej traktowane jest jako parametr funkcji po lewej
 
--- before
-even (fib 7) -- false
+-- wcześniej
+even (fib 7) -- fałsz
 
--- equivalently
-even $ fib 7 -- false
+-- równoważnie
+even $ fib 7 -- fałsz
 
--- composing functions
-even . fib $ 7 -- false
+-- składanie funkcji
+even . fib $ 7 -- fałsz
 
 
 ----------------------------------------------------
-- 
cgit v1.2.3


From 5a1df9e1dabda88d1fd83aaa2fc8e6209dd275e0 Mon Sep 17 00:00:00 2001
From: Remigiusz Suwalski <remigiusz-suwalski@users.noreply.github.com>
Date: Fri, 13 Jan 2017 10:47:08 +0100
Subject: Translate functions

---
 pl-pl/haskell-pl.html.markdown | 43 ++++++++++++++++++++----------------------
 1 file changed, 20 insertions(+), 23 deletions(-)

(limited to 'pl-pl')

diff --git a/pl-pl/haskell-pl.html.markdown b/pl-pl/haskell-pl.html.markdown
index 4de76281..4c6b0243 100644
--- a/pl-pl/haskell-pl.html.markdown
+++ b/pl-pl/haskell-pl.html.markdown
@@ -125,56 +125,53 @@ fst ("haskell", 1) -- "haskell"
 snd ("haskell", 1) -- 1
 
 ----------------------------------------------------
--- 3. Functions
+-- 3. Funkcje
 ----------------------------------------------------
--- A simple function that takes two variables
+-- Prosta funkcja przyjmująca dwa argumenty
 add a b = a + b
 
--- Note that if you are using ghci (the Haskell interpreter)
--- You'll need to use `let`, i.e.
+-- Pamiętaj, że podczas stosowania ghci, interpretera Haskella, wszelkie 
+-- definicje muszą zostać poprzedzone słowem `let`, na przykład:
 -- let add a b = a + b
 
--- Using the function
+-- Używanie funkcji:
 add 1 2 -- 3
 
--- You can also put the function name between the two arguments
--- with backticks:
+-- Nazwę funkcji można podać między dwoma argumentami, ale wtedy musi zostać
+-- otoczona grawisami:
 1 `add` 2 -- 3
 
--- You can also define functions that have no letters! This lets
--- you define your own operators! Here's an operator that does
--- integer division
+-- Nazwa funkcji nie musi zawierać żadnych liter, przykładem czego jest 
+-- operator dzielenia:
 (//) a b = a `div` b
 35 // 4 -- 8
 
--- Guards: an easy way to do branching in functions
+-- Strażnicy: prosty sposób na rozbijanie funkcji na przypadki
 fib x
   | x < 2 = 1
   | otherwise = fib (x - 1) + fib (x - 2)
 
--- Pattern matching is similar. Here we have given three different
--- definitions for fib. Haskell will automatically call the first
--- function that matches the pattern of the value.
+-- Dopasowanie wzorca jest podobne. Haskell sam automatycznie wybierze, która
+-- z poniższych definicji fib powinna zostać użyta:
 fib 1 = 1
 fib 2 = 2
 fib x = fib (x - 1) + fib (x - 2)
 
--- Pattern matching on tuples:
+-- Dopasowanie z krotkami:
 foo (x, y) = (x + 1, y + 2)
 
--- Pattern matching on lists. Here `x` is the first element
--- in the list, and `xs` is the rest of the list. We can write
--- our own map function:
+-- Dopasowanie z listami. Tutaj `x` jest pierwszym elementem listy, 
+-- natomiast `xs` to jej reszta (ogon). Poniższa funkcja nakłada funkcję
+-- na każdy z elementów listy:
 myMap func [] = []
 myMap func (x:xs) = func x:(myMap func xs)
 
--- Anonymous functions are created with a backslash followed by
--- all the arguments.
+-- Funkcje anonimowe tworzone są przy użyciu w-tył-ciachu, po którym następują
+-- wszystkie argumenty:
 myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7]
 
--- using fold (called `inject` in some languages) with an anonymous
--- function. foldl1 means fold left, and use the first value in the
--- list as the initial value for the accumulator.
+-- używanie zwijania z anonimowymi funkcjami: foldl1 zwija z lewej strony,
+-- przyjmując jako wartość początkową zbieracza pierwszy element listy.
 foldl1 (\acc x -> acc + x) [1..5] -- 15
 
 ----------------------------------------------------
-- 
cgit v1.2.3


From 5ef6b1074930c552b1dd4a30e556f4e3ffd0e396 Mon Sep 17 00:00:00 2001
From: Remigiusz Suwalski <remigiusz-suwalski@users.noreply.github.com>
Date: Fri, 13 Jan 2017 18:05:03 +0100
Subject: Add a missing letter

---
 pl-pl/haskell-pl.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pl-pl')

diff --git a/pl-pl/haskell-pl.html.markdown b/pl-pl/haskell-pl.html.markdown
index 4c6b0243..5eb68e2e 100644
--- a/pl-pl/haskell-pl.html.markdown
+++ b/pl-pl/haskell-pl.html.markdown
@@ -5,7 +5,7 @@ contributors:
     - ["Remigiusz Suwalski", "https://github.com/remigiusz-suwalski"]
 ---
 
-Haskell został zaprojektowany jako praktyczy, czysto funkcyjny język 
+Haskell został zaprojektowany jako praktyczny, czysto funkcyjny język 
 programowania. Jest znany przede wszystkim ze względu na jego monady oraz system
 typów, ale ja lubię do niego wracać przez jego elegancję. Sprawił on, że 
 programowanie jest prawdziwą przyjemnością.
-- 
cgit v1.2.3


From 63a6eb1182205389388e13b680962199ac9b3ffb Mon Sep 17 00:00:00 2001
From: Andy <andys8@users.noreply.github.com>
Date: Sat, 1 Apr 2017 22:19:58 +0200
Subject: [haskell] Updating second headline (#2695)

* Haskell: Updating second headline

* Haskell: Updating second headline (es)

* Haskell: Updating second headline (fr)

* Haskell: Updating second headline (pl)

* Haskell: Updating second headline (pt)

* Haskell: Updating second headline (ro)

* Haskell: Updating second headline (ru)

* Haskell: Updating second headline (cn)
---
 pl-pl/haskell-pl.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pl-pl')

diff --git a/pl-pl/haskell-pl.html.markdown b/pl-pl/haskell-pl.html.markdown
index 5eb68e2e..3a51ade5 100644
--- a/pl-pl/haskell-pl.html.markdown
+++ b/pl-pl/haskell-pl.html.markdown
@@ -65,7 +65,7 @@ not False -- True
 "To jest lancuch" !! 0 -- 'T'
 
 ----------------------------------------------------
--- Listy oraz krotki
+-- 2. Listy oraz krotki
 ----------------------------------------------------
 
 -- Wszystkie elementy listy muszą być tego samego typu.
-- 
cgit v1.2.3


From a2ee84b2010691d7a54a9b335b12e92b366c7eae Mon Sep 17 00:00:00 2001
From: Yan Zhang <Eskibear@users.noreply.github.com>
Date: Thu, 1 Jun 2017 17:31:14 +0800
Subject: fix broken URL for vim (#2744)

---
 pl-pl/vim-pl.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pl-pl')

diff --git a/pl-pl/vim-pl.html.markdown b/pl-pl/vim-pl.html.markdown
index 21c8c152..8ac2df56 100644
--- a/pl-pl/vim-pl.html.markdown
+++ b/pl-pl/vim-pl.html.markdown
@@ -10,7 +10,7 @@ filename: LearnVim-pl.txt
 ---
 
 
-[Vim](www.vim.org)
+[Vim](http://www.vim.org)
 (Vi IMproved) jest klonem popularnego edytora vi dla systemów Unix. 
 Zaprojektowany z myślą o prędkości edycji i zwiększeniu produktywności jest 
 wszechobecny na systemach UNIXopodobnych. Posiada wiele skrótów klawiszowych 
-- 
cgit v1.2.3


From 3a0d915f808b07d6a42158352b530e467d0ac8cf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andre=20Polykanine=20A=2EK=2EA=2E=20Menelion=20Elens=C3=BA?=
 =?UTF-8?q?l=C3=AB?= <andre@oire.org>
Date: Wed, 23 Aug 2017 00:10:14 +0300
Subject: Attempted to fix the messed-up frontmatter for Polish. See #2829.

---
 pl-pl/bf-pl.html.markdown      | 2 ++
 pl-pl/haskell-pl.html.markdown | 6 +++++-
 pl-pl/json-pl.html.markdown    | 3 ++-
 pl-pl/perl-pl.html.markdown    | 4 +++-
 4 files changed, 12 insertions(+), 3 deletions(-)

(limited to 'pl-pl')

diff --git a/pl-pl/bf-pl.html.markdown b/pl-pl/bf-pl.html.markdown
index 801f1a9a..c7e1633a 100644
--- a/pl-pl/bf-pl.html.markdown
+++ b/pl-pl/bf-pl.html.markdown
@@ -1,4 +1,5 @@
 ---
+category: language
 language: bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
@@ -6,6 +7,7 @@ contributors:
 translators:
     - ["Jakub Młokosiewicz", "https://github.com/hckr"]
 lang: pl-pl
+filename: bf-pl.html
 ---
 
 Brainfuck (pisane małymi literami, za wyjątkiem początku zdania) jest bardzo 
diff --git a/pl-pl/haskell-pl.html.markdown b/pl-pl/haskell-pl.html.markdown
index 3a51ade5..034189f5 100644
--- a/pl-pl/haskell-pl.html.markdown
+++ b/pl-pl/haskell-pl.html.markdown
@@ -1,8 +1,12 @@
 ---
+category: language
 language: Haskell
-lang: pl-pl
 contributors:
+    - ["Adit Bhargava", "http://adit.io"]
+translators:
     - ["Remigiusz Suwalski", "https://github.com/remigiusz-suwalski"]
+lang: pl-pl
+filename: haskell-pl.hs
 ---
 
 Haskell został zaprojektowany jako praktyczny, czysto funkcyjny język 
diff --git a/pl-pl/json-pl.html.markdown b/pl-pl/json-pl.html.markdown
index 872455de..edd059bf 100644
--- a/pl-pl/json-pl.html.markdown
+++ b/pl-pl/json-pl.html.markdown
@@ -1,6 +1,6 @@
 ---
+category: language
 language: json
-filename: learnjson-pl.json
 contributors:
   - ["Anna Harren", "https://github.com/iirelu"]
   - ["Marco Scannadinari", "https://github.com/marcoms"]
@@ -9,6 +9,7 @@ contributors:
 translators:
   - ["Michał Mitrosz", "https://github.com/Voltinus"]
 lang: pl-pl
+filename: learnjson-pl.json
 ---
 
 JSON to bardzo prosty format wymiany danych. Jak jest napisane na [json.org](http://json.org), jest łatwy do pisania i czytania dla ludzi i do parsowania i generowania dla maszyn.
diff --git a/pl-pl/perl-pl.html.markdown b/pl-pl/perl-pl.html.markdown
index 029ca006..3bac1cbb 100644
--- a/pl-pl/perl-pl.html.markdown
+++ b/pl-pl/perl-pl.html.markdown
@@ -2,11 +2,13 @@
 name: perl
 category: language
 language: perl
-filename: learnperl.pl
 contributors:
     - ["Korjavin Ivan", "http://github.com/korjavin"]
+    - ["Dan Book", "http://github.com/Grinnz"]
+translators:
     - ["Michał Kupczyński", "http://github.com/ukoms"]
 lang: pl-pl
+filename: learnperl-pl.pl
 ---
 
 Perl 5 jest wysoce użytecznym, bogatym w wiele opcji językiem programowania
-- 
cgit v1.2.3


From 9df9387dbeff9393dd26eb0b50966177b34ed9ce Mon Sep 17 00:00:00 2001
From: Pratik Karki <prertik@outlook.com>
Date: Fri, 25 Aug 2017 13:53:25 +0545
Subject: Add filename(#2832)

---
 pl-pl/bf-pl.html.markdown | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'pl-pl')

diff --git a/pl-pl/bf-pl.html.markdown b/pl-pl/bf-pl.html.markdown
index c7e1633a..88f928cf 100644
--- a/pl-pl/bf-pl.html.markdown
+++ b/pl-pl/bf-pl.html.markdown
@@ -1,13 +1,14 @@
 ---
 category: language
 language: bf
+filename: learnbf-pl.bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
 translators:
     - ["Jakub Młokosiewicz", "https://github.com/hckr"]
 lang: pl-pl
-filename: bf-pl.html
+
 ---
 
 Brainfuck (pisane małymi literami, za wyjątkiem początku zdania) jest bardzo 
-- 
cgit v1.2.3


From c0cde322a9dfd18ab45b116bbab6cbc2d1c492e5 Mon Sep 17 00:00:00 2001
From: Pratik Karki <prertik@outlook.com>
Date: Fri, 25 Aug 2017 13:54:01 +0545
Subject: Add filename(#2832)

---
 pl-pl/haskell-pl.html.markdown | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'pl-pl')

diff --git a/pl-pl/haskell-pl.html.markdown b/pl-pl/haskell-pl.html.markdown
index 034189f5..236b8958 100644
--- a/pl-pl/haskell-pl.html.markdown
+++ b/pl-pl/haskell-pl.html.markdown
@@ -1,12 +1,13 @@
 ---
 category: language
+filename: haskell-pl.hs
 language: Haskell
 contributors:
     - ["Adit Bhargava", "http://adit.io"]
 translators:
     - ["Remigiusz Suwalski", "https://github.com/remigiusz-suwalski"]
 lang: pl-pl
-filename: haskell-pl.hs
+
 ---
 
 Haskell został zaprojektowany jako praktyczny, czysto funkcyjny język 
-- 
cgit v1.2.3


From 153083a2013710d63aafb91b0362b04352d9ff96 Mon Sep 17 00:00:00 2001
From: Pratik Karki <prertik@outlook.com>
Date: Fri, 25 Aug 2017 13:55:25 +0545
Subject: Add language code suffix(#2832)

---
 pl-pl/perl-pl.html.markdown | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'pl-pl')

diff --git a/pl-pl/perl-pl.html.markdown b/pl-pl/perl-pl.html.markdown
index 3bac1cbb..3e27cc4f 100644
--- a/pl-pl/perl-pl.html.markdown
+++ b/pl-pl/perl-pl.html.markdown
@@ -2,13 +2,14 @@
 name: perl
 category: language
 language: perl
+filename: learnperl-pl.pm
 contributors:
     - ["Korjavin Ivan", "http://github.com/korjavin"]
     - ["Dan Book", "http://github.com/Grinnz"]
 translators:
     - ["Michał Kupczyński", "http://github.com/ukoms"]
 lang: pl-pl
-filename: learnperl-pl.pl
+
 ---
 
 Perl 5 jest wysoce użytecznym, bogatym w wiele opcji językiem programowania
-- 
cgit v1.2.3


From 9b5b5f6d31b64be55e64c5f45084e45115f2f350 Mon Sep 17 00:00:00 2001
From: Anindya Srivastava <pro.anindya@gmail.com>
Date: Wed, 6 Feb 2019 07:26:25 +0530
Subject: Type correction for the output of math.sqrt() propagated across
 versions and languages

---
 pl-pl/python-pl.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pl-pl')

diff --git a/pl-pl/python-pl.html.markdown b/pl-pl/python-pl.html.markdown
index 023c3e6b..222f753f 100644
--- a/pl-pl/python-pl.html.markdown
+++ b/pl-pl/python-pl.html.markdown
@@ -532,7 +532,7 @@ Czlowiek.grunt()   # => "*grunt*"
 
 # Tak importuje się moduły:
 import math
-print(math.sqrt(16))  # => 4
+print(math.sqrt(16))  # => 4.0
 
 # Można podać konkretne funkcje, np. ceil, floor z modułu math
 from math import ceil, floor
-- 
cgit v1.2.3


From 8e54561b476a37edf26e3d716e280ae72a6adcce Mon Sep 17 00:00:00 2001
From: jacekwachowiak <jacekwachowiak94@gmail.com>
Date: Sat, 16 Mar 2019 06:10:06 +0100
Subject: Java translation to Polish v1

---
 pl-pl/java-pl.html.markdown | 1025 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1025 insertions(+)
 create mode 100644 pl-pl/java-pl.html.markdown

(limited to 'pl-pl')

diff --git a/pl-pl/java-pl.html.markdown b/pl-pl/java-pl.html.markdown
new file mode 100644
index 00000000..91feaf2f
--- /dev/null
+++ b/pl-pl/java-pl.html.markdown
@@ -0,0 +1,1025 @@
+---
+language: java
+contributors:
+    - ["Jake Prather", "https://github.com/JakeHP"]
+    - ["Jakukyo Friel", "https://weakish.github.io"]
+    - ["Madison Dickson", "https://github.com/mix3d"]
+    - ["Simon Morgan", "https://sjm.io/"]
+    - ["Zachary Ferguson", "https://github.com/zfergus2"]
+    - ["Cameron Schermerhorn", "https://github.com/cschermerhorn"]
+    - ["Rachel Stiyer", "https://github.com/rstiyer"]
+    - ["Michael Dähnert", "https://github.com/JaXt0r"]
+    - ["Rob Rose", "https://github.com/RobRoseKnows"]
+    - ["Sean Nam", "https://github.com/seannam"]
+    - ["Shawn M. Hanes", "https://github.com/smhanes15"]
+filename: LearnJava.java
+translators:
+    - ["Jacek Wachowiak", "https://github.com/jacekwachowiak"]
+lang: pl-pl
+---
+
+Java jest współbieżnym, opartym na klasach, obiektowym językiem programowania
+ogólnego zastosowania.
+[Tu znajdziesz więcej informacji po angielsku.]
+(https://docs.oracle.com/javase/tutorial/java/)
+
+```java
+// Pojedyncze komentarze oznaczamy //
+
+/*
+Komentarze wieloliniowe wyglądają tak
+*/
+
+/**
+ * Komentarze JavaDoc wygladają w ten sposób. Używane są do opisu klas lub
+ * różnych właściwości klas.
+ * Główne właściwości:
+ *
+ * @author      Imię i nazwisko (i kontakt np. email) autora.
+ * @version     Aktualna wersja programu.
+ * @since       Kiedy ta część programu została dodana.
+ * @param       Służy do opisu parametrów metody.
+ * @return      Służy do opisu zwracanej wartości.
+ * @deprecated  Służy do oznaczenia nieaktualnego lub niezalecanego kodu.
+ * @see         Linki do innej cześci dokumentacji.
+*/
+
+// Import klasy ArrayList z paczki java.util
+import java.util.ArrayList;
+// Import wszystkich klas z paczki java.security
+import java.security.*;
+
+public class LearnJava {
+
+    // Aby móc uruchomić program w języku java musi on mieć główną metodę jako
+    // punkt wejścia.
+    public static void main(String[] args) {
+
+    ///////////////////////////////////////
+    // Operacje wejścia/wyjścia (input/output)
+    ///////////////////////////////////////
+
+        /*
+        * Wyjście
+        */
+
+        // System.out.println() służy do wyświetlania linii tekstu.
+        System.out.println("Hello World!");
+        System.out.println(
+            "Integer: " + 10 +
+            " Double: " + 3.14 +
+            " Boolean: " + true);
+
+        // Aby wyświetlić  bez nowej linii użyj System.out.print().
+        System.out.print("Hello ");
+        System.out.print("World");
+
+        // System.out.printf() służy do łatwego formatowania wyświetlanego elementu.
+        System.out.printf("pi = %.5f", Math.PI); // => pi = 3.14159
+
+        /*
+         * Wejście
+         */
+
+        // Scanner służy do wczytywania danych
+        // niezbędny jest import java.util.Scanner;
+        Scanner scanner = new Scanner(System.in);
+
+        // zczytaj string (tekst)
+        String name = scanner.next();
+
+        // zczytaj zmienną typu bajt
+        byte numByte = scanner.nextByte();
+
+        // zczytaj zmienną typu integer - liczba całkowita
+        int numInt = scanner.nextInt();
+
+        // zczytaj zmienną typu float - liczba zmiennoprzecinkowa
+        float numFloat = scanner.nextFloat();
+
+        // zczytaj zmienna typu double -liczba zmiennoprzecinkowa
+        double numDouble = scanner.nextDouble();
+
+        // zczytaj zmienną typu boolowskiego -
+        boolean bool = scanner.nextBoolean();
+
+        ///////////////////////////////////////
+        // Zmienne
+        ///////////////////////////////////////
+
+        /*
+        *  Deklaracja zmiennych
+        */
+        // Zmienną deklaruje się poprzez <rodzaj> <nazwa>
+        int fooInt;
+        // Dozwolona jest deklaracja wielu zmiennych tego samego typu na raz
+        // rodzaj <nazwa1>, <nazwa2>, <nazwa3>
+        int fooInt1, fooInt2, fooInt3;
+
+        /*
+        *  Inicjalizacja zmiennych
+        */
+
+        // Zmienną inicjalizuje się poprzez <rodzaj> <nazwa> = <wartość>
+        int barInt = 1;
+        // Możliwe jest zainicjalizowanie wielu zmiennych tego samego typu tą samą wartością
+        // rodzaj <nazwa1>, <nazwa2>, <nazwa3>
+        // <nazwa1> = <nazwa2> = <nazwa3> = <wartość>
+        int barInt1, barInt2, barInt3;
+        barInt1 = barInt2 = barInt3 = 1;
+
+        /*
+        *  Rodzaje zmiennych
+        */
+        // Bajt - 8-bitowa, zawierająca ujemne wartości zmienna w dwójkowym
+        // systemie pozycyjnym
+        // (-128 <= byte <= 127)
+        byte fooByte = 100;
+
+        // Jeśli chcemy zinterpretować bajt jako zmienną typu unsigned integer
+        // - liczbę całkowitą z wartościami ujemnymi ta operacja może pomóc:
+        int unsignedIntLessThan256 = 0xff & fooByte;
+        // jako kontrast operacja zmiany typu która może zwrócić wartość ujemną.
+        int signedInt = (int) fooByte;
+
+        // Short - 16-bitowa, zawierająca ujemne wartości zmienna w dwójkowym
+        // systemie pozycyjnym (-32,768 <= short <= 32,767)
+        short fooShort = 10000;
+
+        // Integer - 32-bitowa, zawierająca ujemne wartości zmienna w dwójkowym systemie pozycyjnym
+        // (-2,147,483,648 <= int <= 2,147,483,647)
+        int bazInt = 1;
+
+        // Long - 64-bitowa, zawierająca ujemne wartości zmienna w dwójkowym
+        // systemie pozycyjnym
+        // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+        long fooLong = 100000L;
+        // L jest używane do zaznaczenia, że wartość zmiennej jest typu Long;
+        // bez L wszystko inne będzie traktowane z założenia jako integer.
+
+        // Uwaga: byte, short, int and long zawierają ujemne wartości.
+        // Nie istnieją odpowiedniki z jedynie pozytywnymi wartościami.
+        // Jedynie char jest 16-bitowym typem zmiennej, który akceptuje tylko
+        // wartości nieujemne.
+
+        // Float - 32-bitowy typ zmiennoprzecinkowy zgodnie z IEEE 754
+        // Floating Point 2^-149 <= float <= (2-2^-23) * 2^127
+        float fooFloat = 234.5f;
+        // f or F jest używane aby zaznaczyć, że dana zmienna jest typu float;
+        // w przeciwnym razie będzie ona traktowana jako double.
+
+        // Double -  64-bitowy typ zmiennoprzecinkowy zgodnie z IEEE 754
+        // Floating Point 2^-1074 <= x <= (2-2^-52) * 2^1023
+        double fooDouble = 123.4;
+
+        // Typ boolowski - true/prawda & false/fałsz
+        boolean fooBoolean = true;
+        boolean barBoolean = false;
+
+        // Char - pojedynczy 16-bitowy symbol Unicode
+        char fooChar = 'A';
+
+        // zmienne zadeklarowane z użyciem final nie mogą być edytowane,
+        final int HOURS_I_WORK_PER_WEEK = 9001;
+        // ale możliwa jest późniejsza inicjalizacja.
+        final double E;
+        E = 2.71828;
+
+        // BigInteger - Nieedytowalny typ zmiennej o nieograniczonej długości
+        // dla liczb całkowitych
+        //
+        // BigInteger jest typem zmiennej, który pozwala na operacje na liczbach całkowitych dłuższych niż 64 bity.
+        // Liczby są przechowywane jako tablica bajtów
+        // i modyfikowane za pomocą funkcji wbudowanych w BigInteger
+        //
+        // BigInteger może być zainicjalizowany za pomocą tablicy bajtów lub jako string.
+        BigInteger fooBigInteger = new BigInteger(fooByteArray);
+
+        // BigDecimal - Nieedytowalny typ zmiennej o nieograniczonej długości dla
+        // liczb zmiennoprzecinkowych
+        //
+        // BigDecimal zaiwera 2 części: typ integer o arbitralnej precyzji bez skalowania
+        // oraz 32-bitową skalę
+        //
+        // BigDecimal pozwala programiście na całkowitą kontrolę zaokrąglenia dziesiętnego.
+        // Zalecane jest używanie BigDecimal z wartościami walut.
+        // oraz tam, gdzie absolutna dokładność jest niezbędna.
+        //
+        // BigDecimal można zainicjalizowac używając int, long, double or String
+        // a także inicjalizując nieprzeskalowaną wartość (BigInteger) i skalę (int).
+        BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt);
+
+        // Uwaga na konstruktor, który przyjmuje float lub double jako, że
+        // niedokładność float/double będzie przeniesiona do BigDecimal.
+        // Zalecane jest uzywanie konstruktora typu String gdy konieczne jest
+        // uzyskanie absolutnej precyzji.
+        BigDecimal tenCents = new BigDecimal("0.1");
+
+        // String - zmienna tekstowa
+        String fooString = "Tutaj jest mój string!";
+
+        // \n jest symbolem karetki, która rozpoczyna nową linę
+        String barString = "Wyświetlanie w nowej linii?\nNie ma problemu!";
+        // \t jest symbolem tabulatora, który dodaje odstęp.
+        String bazString = "Chesz dodać tabulator?\tBez problemu!";
+        System.out.println(fooString);
+        System.out.println(barString);
+        System.out.println(bazString);
+
+        // Budowanie Stringów
+        // #1 - za pomocą operatora dodawania
+        // To jest podstawowy sposób (zoptymalizowany)
+        String plusConcatenated = "Stringi mogą " + "być łączone " + "operatorem +.";
+        System.out.println(plusConcatenated);
+        // Wyjście: Stringi będą połączone operatorem +.
+
+        // #2 - za pomocą StringBuilder
+        // Ten sposób nie tworzy żadnych pośrednich stringów, jedynie zachowuje
+        // części i wiąże je po kolei gdy wywołane jest toString().
+        // Wskazówka: Ta klasa nie jest bezpieczna z punktu widzenia wątków.
+        // Bezpieczną alternatywą jest (wiążąca się ze spadkiem wydajności)
+        // StringBuffer.
+        StringBuilder builderConcatenated = new StringBuilder();
+        builderConcatenated.append("Możesz ");
+        builderConcatenated.append("użyć ");
+        builderConcatenated.append("klasy StringBuilder.");
+        System.out.println(builderConcatenated.toString()); // dopiero tutaj
+        //budowany jest string
+        // Wyjście: Używany jest StringBuilder.
+
+        // StringBuilder jest wydajny, gdy połączony string nie jest używany aż do końcowego przetworzenia.
+        StringBuilder stringBuilder = new StringBuilder();
+        String inefficientString = "";
+        for (int i = 0 ; i < 10; i++) {
+            stringBuilder.append(i).append(" ");
+            inefficientString += i + " ";
+        }
+        System.out.println(inefficientString);
+        System.out.println(stringBuilder.toString());
+        // inefficientString wymaga dużo więcej pracy przy stworzeniu ponieważ
+        // tworzy string przy każdej iteracji.
+        // Proste łączenie za pomocą + jest kompilowane do StringBuilder i
+        // toString(). Unikaj łączenia stringów w pętlach.
+
+        // #3 - za pomocą String formatter
+        // Inna możliwość, szybka i czytelna.
+        String.format("%s wolisz %s.", "A może", "String.format()");
+        // Wyjście: Być może wolisz String.format().
+
+        // Tablice
+        // Rozmiar tablicy musi być określony przy stworzeniu.
+        // Podane poniżej sposoby są dozwolone prz deklaracji tablicy
+        // <rodzaj>[] <nazwa> = new <rodzaj>[<rozmiar>];
+        // <rodzaj> <nazwa>[] = new <rodzaj>[<rozmiar>];
+        int[] intArray = new int[10];
+        String[] stringArray = new String[1];
+        boolean boolArray[] = new boolean[100];
+
+        // Inny sposób deklaracji i inicjalizacji tablicy
+        int[] y = {9000, 1000, 1337};
+        String names[] = {"Bob", "John", "Fred", "Juan Pedro"};
+        boolean bools[] = {true, false, false};
+
+        // Indeksowanie tablicy - dostęp do elementów
+        System.out.println("intArray @ 0: " + intArray[0]);
+
+        // Tablice zaczynają się z indeksem 0 i są edytowalne.
+        intArray[1] = 1;
+        System.out.println("intArray @ 1: " + intArray[1]); // => 1
+
+        // Inny typ zmiennej, z którymi warto się zapoznać
+        // ArrayLists - Tablice z większą funkcjonalnością
+        //              i zmiennym rozmiarem.
+        // LinkedLists - Dwustronnie połączone listy. Wszystkie operacje
+        //               na listach zaimpllementowane.
+        // Maps - Mapy zawierające klucz i wartość. Mapa jest interfejsem
+        //        i nie może zostać zainicjalizowana.
+        //        Rodzaj klucza i wartości dla mapy musi zostać określony
+        //        przy inicjalizacji implementującej mapę klasy
+        //        Każdy klucz przypisany jest do tylko jednej wartości,
+        //        każdy klucz może wystąpić tylko raz (brak duplikatów).
+        // HashMaps - Używa tablicy hashów do implementacji interfejsu mapy
+        //            Pozwala to na użycie podstawowych operacji, jak
+        //            get i insert, które pozostają niezmiennie wydajne
+        //            czasowo nawet dla dużych zestawów danych
+        // TreeMap - Mapa posortowana przez klucze. Każda modyfikacja
+        //           utrzymuje sortowanie, zdefiniowane przez komparator
+        //           dodany przy inicjalizacji lub porównanie każdego obiektu
+        //           jeśli zaimplementowany jest interfejs Comparable.
+        //           Niepowodzenie kluczy wimplemntacji Comparable połączone
+        //           z niepowodzeniem dostarczenia komparatora spowoduje
+        //           ClassCastExceptions.
+        //           Dodawanie i usuwanie kosztuje O(log(n)) czasu,
+        //           zalecane jest nieużywanie tego typu jeżeli sortowanie
+        //           nie jest przydatne.
+
+        ///////////////////////////////////////
+        // Operatory
+        ///////////////////////////////////////
+        System.out.println("\n->Operatory");
+
+        int i1 = 1, i2 = 2; // Skrót dla wielokrotnych deklaracji
+
+        // Arytmetyka jest prosta
+        System.out.println("1+2 = " + (i1 + i2)); // => 3
+        System.out.println("2-1 = " + (i2 - i1)); // => 1
+        System.out.println("2*1 = " + (i2 * i1)); // => 2
+        System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int zwraca int)
+        System.out.println("1/2.0 = " + (i1 / (double)i2)); // => 0.5
+
+        // Modulo
+        System.out.println("11%3 = "+(11 % 3)); // => 2
+
+        // Porównania
+        System.out.println("3 == 2? " + (3 == 2)); // => false
+        System.out.println("3 != 2? " + (3 != 2)); // => true
+        System.out.println("3 > 2? " + (3 > 2)); // => true
+        System.out.println("3 < 2? " + (3 < 2)); // => false
+        System.out.println("2 <= 2? " + (2 <= 2)); // => true
+        System.out.println("2 >= 2? " + (2 >= 2)); // => true
+
+        // Operacje boolowskie
+        System.out.println("3 > 2 && 2 > 3? " + ((3 > 2) && (2 > 3))); // => false
+        System.out.println("3 > 2 || 2 > 3? " + ((3 > 2) || (2 > 3))); // => true
+        System.out.println("!(3 == 2)? " + (!(3 == 2))); // => true
+
+        // Operacje na bitach!
+        /*
+        ~      Odwrócenie bitów
+        <<     Przesunięcie w lewo
+        >>     Przesunięcie w prawo, arytmetyczne/dla wartości ujemnych -signed
+        >>>    Przesunięcie w prawo, logiczne/dla wartości dodatnich - unsigned
+        &      Bitowe AND
+        ^      Bitowe XOR
+        |      Bitowe OR
+        */
+
+        // Operatory inkrementacji
+        int i = 0;
+        System.out.println("\n->In/De-krementacja");
+        // Operatory ++ i -- zwiększają lub zmniejszają o 1 daną wartość.
+        // Jeżeli używane są przed zmienną, wykonywane są przed powrotem zmiennej.
+        // Użyte po zmiennej najpierw zwracają zmienną a następnie dokonują
+        // zmiany wartości.
+        System.out.println(i++); // i = 1, wyświetli 0 (post-increment)
+        System.out.println(++i); // i = 2, wyświetli 2 (pre-increment)
+        System.out.println(i--); // i = 1, wyświetli 2 (post-decrement)
+        System.out.println(--i); // i = 0, wyświetli 0 (pre-decrement)
+
+        ///////////////////////////////////////
+        // Przepływ sterowania
+        ///////////////////////////////////////
+        System.out.println("\n->Przepływ sterowania");
+
+        // Instrukcja if wygląda jak w c
+        int j = 10;
+        if (j == 10) {
+            System.out.println("Wyświetlam się");
+        } else if (j > 10) {
+            System.out.println("A ja nie");
+        } else {
+            System.out.println("Ja też nie");
+        }
+
+        // Pętla while
+        int fooWhile = 0;
+        while(fooWhile < 100) {
+            System.out.println(fooWhile);
+            // Licznik jest zwiększany
+            // Iteruje 100 razy, fooWhile 0,1,2...99
+            fooWhile++;
+        }
+        System.out.println("Wartość fooWhile: " + fooWhile);
+
+        // Pętla do while
+        int fooDoWhile = 0;
+        do {
+            System.out.println(fooDoWhile);
+            // Licznik jest zwiększany
+            // Iteruje 99 razy, fooDoWhile 0->99
+            fooDoWhile++;
+        } while(fooDoWhile < 100);
+        System.out.println("Wartość fooDoWhile: " + fooDoWhile);
+
+        // Pętla for
+        // struktura pętli for => for(<początek>; <warunek>; <krok>)
+        for (int fooFor = 0; fooFor < 10; fooFor++) {
+            System.out.println(fooFor);
+            // Iteruje 10 razy, fooFor 0->9
+        }
+        System.out.println("Wartość fooFor: " + fooFor);
+
+        // Wyjście z zagnieżdżonej, oznaczonej pętli for
+        outer:
+        for (int i = 0; i < 10; i++) {
+          for (int j = 0; j < 10; j++) {
+            if (i == 5 && j ==5) {
+              break outer;
+              // wychodzi z zewnętrznej pętli zamiast jednynie z aktualnej z
+              // powodu oznaczenia
+            }
+          }
+        }
+
+        // Pętla for each
+        // Pętla for each może iterować tablice jak i obiekty
+        // które implementują interfejs Iterable.
+        int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+        // Struktura for each => for (<element> : <obiekt iterowany>)
+        // należy rozumieć jako: dla każdego elementu w obiekcie iterowanym
+        // uwaga: typ zdefiniowango elementu musi się zgadzać z typem w
+        //obiekcie iterowanym.
+        for (int bar : fooList) {
+            System.out.println(bar);
+            //Iteruje 9 razy i wyświetla 1-9 w nowych liniach
+        }
+
+        // Switch Case
+        // Switch (przełącznik) działa z zmiennymi typu byte, short, char, int.
+        // Działa również z enumeratorami (zobacz typ Enum),
+        // klasą String, i kilkoma specjalnymi klasami które zawierają typy
+        // podstawowe: Character, Byte, Short, and Integer.
+        // Z wersją Java 7 i wyższymi możliwe jest użycie typu String.
+        // Uwagga: Pamiętaj, że nie dodając "break" na końcu danego case
+        // spowoduje przejście do następnego (jeżeli spełniony jest warunek).
+        int month = 3;
+        String monthString;
+        switch (month) {
+            case 1: monthString = "Styczeń";
+                    break;
+            case 2: monthString = "Luty";
+                    break;
+            case 3: monthString = "Marzec";
+                    break;
+            default: monthString = "Inny miesiąc";
+                     break;
+        }
+        System.out.println("Wynik Switch Case : " + monthString);
+
+
+        // Try-with-resources (Java 7+)
+        // Try-catch-finally działa zgodnie z oczekiwaniami jednakże w Java 7+
+        // dodatkowo jest dostępny try-with-resources statement.
+        // Try-with-resources upraszcza try-catch-finally automatycznie
+        // usuwając zasoby.
+
+        // Aby użyć try-with-resources, użyj instancji klasy
+        // w części "try". Klasa musi implementować java.lang.AutoCloseable.
+        try (BufferedReader br = new BufferedReader(new FileReader("foo.txt"))) {
+            // Tutaj możesz spróbować wywołac wyjątek.
+            System.out.println(br.readLine());
+            // W Java 7 zasoby będą zawsze usuwane nawet jeśli nastąpi wyjątek.
+        } catch (Exception ex) {
+            // Zasób będzie usunięty zanim wykona się catch.
+            System.out.println("readLine() nie powiódł się.");
+        }
+        // Nie ma potrzeby używać sekcji "finally", jako że BufferedReader
+        // został już zamknięty. Ten sposób może zostać użyty aby uniknąć
+        // pewnych wartości brzegowych gdzie "finally" nie zostałoby wywołane
+        // Więcej na ten temat po angielsku:
+        // https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html
+
+
+        // Skrócone instrukcje warunkowe
+        // Dozwolone jest użycie operatora '?' aby szybko sprawdzić warunek
+        // logiczny. Rozumiane jest to jako "Jeśli (warunek) jest spełniony, użyj
+        // <pierwszej wartości>, inaczej, użyj <drugiej wartości>"
+        int foo = 5;
+        String bar = (foo < 10) ? "A" : "B";
+        System.out.println("bar : " + bar); // Wyśwletli "bar : A", poineważ
+        // warunke jest spełniony.
+        // Lub prościej
+        System.out.println("bar : " + (foo < 10 ? "A" : "B"));
+
+
+        ////////////////////////////////////////
+        // Konwersja typów danych
+        ////////////////////////////////////////
+
+        // Konwersja danych
+
+        // Konwersja String do Integer
+        Integer.parseInt("123");//zwraca zmienna typu Integer o wartości "123"
+
+        // Konwersja Integer do String
+        Integer.toString(123);//zwraca zmienną typu String o wartości 123
+
+        // Inne konwersje możesz sprawdzić dla klas:
+        // Double
+        // Long
+        // String
+
+        ///////////////////////////////////////
+        // Klasy i funkcje
+        ///////////////////////////////////////
+
+        System.out.println("\n->Klasy & Funkcje");
+
+        // (definicja klasy Rower nieco niżej)
+
+        // Użyj new aby zainstancjonować klasę
+        Rower trek = new Rower();
+
+        // Wywoływanie metod klasy
+        trek.predkoscUp(3); // Zawsze używaj settera i gettera jako metod
+        trek.setCadence(100);
+
+        // toString zwraca reprezentację typu String tego obiektu.
+        System.out.println("trek info: " + trek.toString());
+
+        // Inicjalizacja za pomocą podwójnego nawiasu
+        // Język Java nie zawiera możliwości stworzenia statycznej kolekcji
+        // Dlatego zwykle odbywa się to w ten sposób:
+        private static final Set<String> KRAJE = new HashSet<String>();
+        static {
+           COUNTRIES.add("DANIA");
+           COUNTRIES.add("SZWECJA");
+           COUNTRIES.add("FINLANDIA");
+        }
+
+        // Jest jednak sprytny sposób aby łatwiej osiągnąc ten sam efekt
+        // używając czegoś nazywanego Double Brace Initialization -
+        // inicjalizacja za pomocą podwójnego nawiasu.
+        private static final Set<String> KRAJE = new HashSet<String>() {{
+            add("DANIA");
+            add("SZWECJA");
+            add("FINLANDIA");
+        }}
+
+        // Pierwszy nawias tworzy nową klasę AnonymousInnerClass,
+        // drugi deklaruje instancję bloku inicjalizacji. Blok ten
+        // jest wywoływany gdy wewnętrzna, anonimowa klasa jest tworzona.
+        // Dany sposób działa nie tylko dla kolekcji, ale również dla
+        // wszystkich nie-finalnych klas.
+
+    } // Koniec metody main
+} // Koniec klasy LearnJava
+
+// Możesz zawrzeć inne, niepubliczne, zewnętrzne klasy w pliku .java,
+// jednak nie jest to zalecane. Zalecane jest dzielenie klas na osobne pliki.
+
+// Składnia deklaracji klasy:
+// <public/private/protected> class <nazwa klasy> {
+//    // pola danych, konstruktory, funkcje.
+//    // w jężyku Java funkcje są wywoływane jako metody.
+// }
+
+class Rower {
+
+    // Zmienne klasy
+    public int pedalowanie; // Public: Dostępne wszędzie
+    private int predkosc;  // Private: Dostępne tylko w klasie
+    protected int przerzutka; // Protected: Dostępne w klasie i podklasach
+    String nazwa; // domyślnie: Dostępne tlyko w danej paczce
+    static String nazwaKlasy; // Zmienna statyczna
+
+    // Blok statyczny
+    // Java nie posiada implemntacji konstruktorów staycznych, ale
+    // posiada blok stayczny, który może  być użyty aby zainicjalizować
+    // statyczne zmienne klasy
+    // Ten blok będzie wywołane gdy klasa jest ładowana.
+    static {
+        nazwaKlasy = "Rower";
+    }
+
+    // Konstruktory służą do stworzenia instancji klas
+    // Too jest konstruktor
+    public Rower() {
+        // Możesz wywołać także  inny konstruktor:
+        // this(1, 50, 5, "Bontrager");
+        przerzutka = 1;
+        pedalowanie = 50;
+        predkosc = 5;
+        nazwa = "Bontrager";
+    }
+    // To jest konstruktor, który przyjmuje argumenty
+        public Rower(int poczatkowePedalowanie, int poczatkowaPredkosc, int początkowaPrzerzutka,
+        String nazwa) {
+        this.przerzutka = początkowaPrzerzutka;
+        this.pedalowanie = poczatkowePedalowanie;
+        this.predkosc = poczatkowaPredkosc;
+        this.nazwa = nazwa;
+    }
+
+    // Składnia metod:
+    // <public/private/protected> <zwracany rodzaj> <nazwa funkcji>(<argumenty>)
+
+    // Klasy często implementują metody getter i setter dla danych wewnątrz
+
+    // Składnia deklaracji metody:
+    // <dostępność> <zwracany rodzaj> <nawa metody>(<argumenty>)
+    public int getPedalowanie() {
+        return pedalowanie;
+    }
+
+    // metody void nie wymagają słowa kluczowego return, nic nie zwracają
+    public void setPedalowanie(int newValue) {
+        pedalowanie = newValue;
+    }
+    public void setPrzerzutka(int newValue) {
+        przerzutka = newValue;
+    }
+    public void predkoscZwieksz(int inkrement) {
+        predkosc += inkrement;
+    }
+    public void predkoscZmniejsz(int dekrement) {
+        predkosc -= dekrement;
+    }
+    public void nadajNazwe(String nowaNazwa) {
+        nazwa = nowaNazwa;
+    }
+    public String zwrocNazwe() {
+        return nazwa;
+    }
+
+    // Metoda do wyświetlenia wartości atrybutów danego obiektu.
+    @Override // Dziedziczy z klasy obiektu.
+    public String toString() {
+        return "przerzutka: " + przerzutka + " pedalowanie: " + pedalowanie + " predkosc: " + predkosc +
+            " nazwa: " + nazwa;
+    }
+} // koniec klasy Rower
+
+// PennyFarthing jest podklasą klasy Rower
+class PennyFarthing extends Rower {
+    // (Penny Farthing to rower z wielkim przednim kołem.
+    // Nie ma przerzutek.)
+
+    public PennyFarthing(int poczatkowePedalowanie, int poczatkowaPredkosc) {
+        // Wywołanie kostruktora klasy z której dziedziczymy za pomocą super
+        super(poczatkowePedalowanie, poczatkowaPredkosc, 0, "PennyFarthing");
+    }
+
+    // Używamy annotacji @annotation przy przeciążaniu metod.
+    // Aby dowiedzieć się więcej o annotacjach przydatne jest przejrzenie
+    // (w języku angielskim):
+    // http://docs.oracle.com/javase/tutorial/java/annotations/
+    @Override
+    public void setGear(int przerzutka) {
+        this.przerzutka = 0;
+    }
+}
+
+// Rzutowanie
+// Jako, że  klasa PennyFarthing dziedziczy z klasy Rower, możemy uznać, że
+// instancja PennyFarthing jest typu Rower i napisać :
+// Rower rower = new PennyFarthing();
+// Dana operacja jest rzutowaniem obiektu, gdzie jego domyślna klasa jest inna niż docelowa.
+// Więcej szczegółów i przykładów oraz ciekawych konceptów (po angielsku):
+// https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
+
+// Interfejsy
+// Składnia deklaracji interfejsu
+// <dostępność> interface <nazwa interfejsu> extends <super-interfaces> {
+//     // Zmienne typu constant
+//     // Deklaracje metod
+// }
+
+// Przykład - Jedzenie:
+public interface Jadalne {
+    public void jedz(); // Każda klasa która implemetuje ten interfejs musi
+    // implementować tę metodę.
+}
+
+public interface Przetrawialne {
+    public void przetrawiaj();
+    // Wraz z Java 8, interfejsy mogą mieć metodę domyślną.
+    public default void defaultMethod() {
+        System.out.println("Hej z metody domyślnej ...");
+    }
+}
+
+// Teraz stworzymy klasę, która zaimplementuje oba interfejsy.
+public class Owoc implements Jadalne, Przetrawialne {
+    @Override
+    public void jedz() {
+        // ...
+    }
+
+    @Override
+    public void przetrawiaj() {
+        // ...
+    }
+}
+
+// W Javie możesz dziedziczyć jedynie z jednej klasy, jednak implementować
+// wiele interfejsów. Na przykład:
+public class Przyklad extends Przodek implements Interfejs1,
+    Interfejs2 {
+    @Override
+    public void Interfejs1Metoda() {
+    }
+
+    @Override
+    public void Interfejs2Metoda() {
+    }
+
+}
+
+// Klasy abstrakcyjne
+
+// Składnia deklaracji klasy abstrakcyjnej
+// <dostępność> abstract class <nawa klasy abstrakcyjnej> extends
+// <superklasy, z których dziedziczy> {
+//     // Zmienne i stałe
+//     // Deklaracje metod
+// }
+
+// Klasy abstrakcyjne nie mogą posiadać instancji.
+// Klasy abstrakcyjne mogą definiować  metody abstrakcyjne.
+// Metody abstrakcyjne nie mają ciała funkcji i są oznaczone jako abstrakcyjne.
+// Nieabstrakcyjne klasy-dzieci muszą przeciążać wszystkie abstrakcyjne metody
+// superklasy.
+// Klasy abstrakcyjne są użyteczne gdy wymagana jest powtarzalna logika działania,
+// jednak należy zaauważyć, że jako, że wymagają dziedziczenia, łamią
+// zasadę "Composition over inheritance". Rozważ inne podejścia używając
+// kompozycji. https://en.wikipedia.org/wiki/Composition_over_inheritance
+
+public abstract class Zwierze
+{
+    private int wiek;
+
+    public abstract void dajGlos();
+
+    // Metody mogą mieć ciało
+    public void jedz()
+    {
+        System.out.println("Jestem zwierzeciem i jem.");
+        // Uwaga: Możliwy jest dostęp do zmiennych prywatnych.
+        wiek = 30;
+    }
+
+    public void wyswietlWiek()
+    {
+        System.out.println(wiek);
+    }
+
+    // Klasy abstrakcyjne mogą mieć metodę główną.
+    public static void main(String[] args)
+    {
+        System.out.println("Jestem abstrakcyjna");
+    }
+}
+
+class Pies extends Zwierze
+{
+    // Musimy przeciążyć wszystkie abstrakcyjne metody z klasy abstrakcyjnej
+    @Override
+    public void dajGlos()
+    {
+        System.out.println("Hau");
+        // wiek = 30;    ==> BLAD!    wiek jest typu private dla Zwierze
+    }
+
+    // NOTE: Wystąpi błąd jeżeli użyto annotacji @Override jako, że Java
+    // nie pozwala na przeciążanie metod statycznych.
+    // Występuje tutaj METHOD HIDING - ukrywanie metod.
+    // Więcej w poście na SO: http://stackoverflow.com/questions/16313649/
+    public static void main(String[] args)
+    {
+        Dog pluto = new Dog();
+        pluto.makeSound();
+        pluto.eat();
+        pluto.printAge();
+    }
+}
+
+// Klasy finalne
+
+// Składnia deklaracji klasy finalnej
+// <dostępność> final <nazwa klasy finalnej> {
+//     // Zmienne i stałe
+//     // Deklaracje Metody
+// }
+
+// Klasy finalne są klasami, które nie mogą być użyte do dziedziczenia, są więc
+// z założenia ostatnim elementem dziedziczenia. W ten sposób są przeciwnością
+// klas abstrakcyjnych, które z założenia muszą być dziedziczone.
+public final class TygrysSzablozebny extends Zwierze
+{
+    // Nadal musimy przeciążyć metody abstrakcyjne klasy abstrakcyjnej Zwierze
+    @Override
+    public void dajGlos()
+    {
+        System.out.println("Roar");
+    }
+}
+
+// Metody finalne
+public abstract class Ssak()
+{
+    // Składnia metody finalnej:
+    // <dostępność> final <zwracany rodzaj> <nazwa funkcji>(<argumenty>)
+
+    // Metody finalne, jak klasy finalne nie mogą być przeciążane
+    // i są w ten sposób ostatecznymi implementacjami danej metody.
+    public final boolean jestStalocieplny()
+    {
+        return true;
+    }
+}
+
+// Enumeratory
+//
+// Enumerator jest specjalnym tyme danej, która pozwala zmiennej na bycie
+// zestawem wcześniej zdefiniowanych stałych. Zmienna musi być równa jednej z
+// wartości wcześniej zdefiniowanych. Jako, że są to stałe, nazwy pól typu enum
+// są pisane wielkimi literami. W języku Java typ enum definiujemy przez użycie
+// słowa enum. Na przykład aby zdefiniować dni tygodnia:
+public enum dzielenie {
+    PONIEDZIALEK, WTOREK, SRODA, CZWARTEK,
+    PIATEK, SOBOTA, NIEDZIELA
+}
+
+// We can use our enum Day like that:
+public class EnumTest {
+    // Zmienna typu enum
+    Dzien dzien;
+
+    public EnumTest(Dzien dzien) {
+        this.dzien = dzien;
+    }
+
+    public void opiszDzien() {
+        switch (dzien) {
+            case PONIEDZIALEK:
+                System.out.println("Nie lubię poniedziałku!");
+                break;
+            case PIATEK:
+                System.out.println("Piątki są dużo lepsze.");
+                break;
+            case SOBOTA:
+            case NIEDZIELA:
+                System.out.println("Weekendy są najlepsze.");
+                break;
+            default:
+                System.out.println("Środek tygodnia jest taki sobie.");
+                break;
+        }
+    }
+
+    public static void main(String[] args) {
+        EnumTest pierwszyDzien = new EnumTest(Day.PONIEDZIALEK);
+        pierwszyDzien.opiszDzien(); // => Nie lubię poniedziałku!
+        EnumTest trzeciDzien = new EnumTest(Day.SRODA);
+        trzeciDzien.opiszDzien(); // => Środek tygodnia jest taki sobie.
+    }
+}
+
+// Typ enum jest bardziej wszechstronny niż powyższa demostracja.
+// Ciało typu enum może zawierać metody i inne pola.
+// Rzuć okiem na (angielski) https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
+
+// Wprowadzenie do wyrażeń lambda
+//
+// Nowe w Javie 8 są wyrażenia lambda. Lambdy znajdujemy zwykle w funkcyjnych
+// językach programowania, co oznacza, że są metodami, które potrafią być
+// stowrzone bez klasy i przekazywane jak gdyby były obiektem oraz wykonywane
+// gdy zajdzie potrzeba.
+//
+// Ostatnia uwaga - lambdy muszą implementować funcjonalny interfejs.
+// Interfels funkcjonalny to taki, który ma jedynie jedną zadeklarowaną metodę
+// abstrakcyjną, ale może mieć dowolną ilość domyślnych metod. Wyrażenia lambda
+// mogą być używane jako instancje tego interfejsu. Każdy inteferjs, który
+// spełnia wymagania jest traktowany jako funkcjonalny. Więcej o interfejsach
+// znajdziesz powyżej, w odpowiedniej sekcji.
+//
+import java.util.Map;
+import java.util.HashMap;
+import java.util.function.*;
+import java.security.SecureRandom;
+
+public class Lambdas {
+    public static void main(String[] args) {
+        // Składnia deklaracji lambdy:
+	    // <zero lub więcej parametrów> -> <ciało wyrażenia lub blok instrukcji>
+
+        // Poniżej w przykładzie użyjemy tablicy z hashowaniem.
+        Map<String, String> planety = new HashMap<>();
+            planety.put("Merkury", "87.969");
+            planety.put("Wenus", "224.7");
+            planety.put("Ziemia", "365.2564");
+            planety.put("Mars", "687");
+            planety.put("Jowisz", "4,332.59");
+            planety.put("Saturn", "10,759");
+            planety.put("Uran", "30,688.5");
+            planety.put("Neptun", "60,182");
+
+        // Lambda z zerową liczbą parametrów używając funkcjonalnego interfejsu
+        // Supplier z java.util.function.Supplier. Faktyczną lambdą jest częśc
+        // po numPlanets =.
+        Supplier<String> numPlanety = () -> Integer.toString(planety.size());
+        System.out.format("Liczba planet: %s\n\n", numPlanety.get());
+
+        // Lambda z jednym parametrem używająca funkcjonalnego interfejsu
+        // Consumer z java.util.function.Consumer.planety jest mapą, która
+        // wimplementuje Collection jak i Iterable. Użyty forEach pochodzi z
+        // Iterable i jest użyty w lambdzie na każdym elemencie kolekcji
+        // Domyślna implementacja forEach wygląda tak:
+        /*
+            for (T t : this)
+                action.accept(t);
+        */
+
+        // Faktyczna lambda jest parametrem przekazywanym do forEach.
+        planety.keySet().forEach((p) -> System.out.format("%s\n", p));
+
+        // Jeżeli przekazujemy tyklo pojedynczy argumentpowyższy zapis możemy
+        // przekształcić do (zauważ brak nawiasów dookoła p):
+        planety.keySet().forEach(p -> System.out.format("%s\n", p));
+
+        // Śledząc powyższe widzimy, że planety jest typu HashMap, a keySet()
+        // zwraca zestaw kluczy, forEach stosuje o każdego elementu lambdę:
+        // (parameter p) -> System.out.format("%s\n", p). Za każdym razem
+        // element jest uznawany jako  "konsumowany" i wyrażenie (wyrażenia)
+        // w lambdzie są wykonywane. Pamiętaj, że ciało lambdy to część po
+        // symbolu ->.
+
+        // Powyższy przykład bez użycia lambdy wyglądałby tradycyjnie tak:
+        for (String planeta : planety.keySet()) {
+            System.out.format("%s\n", planeta);
+        }
+
+        // Poniższy przykład różni się od powyższego sposobem implementacji
+        // forEach:  forEach użyty w klasie HashMap implementuje intefejs Map.
+        // Poniższy forEach przyjmuje BiConsumer, który ogólnie ujmując jest
+        // wymyślnym sposobem stwierdzenia, że zajmuje się zestawem par
+        // klucz-wartość Key -> Value dla każdego klucza. Ta domyślna
+        // implementacja działa jak:
+        /*
+            for (Map.Entry<K, V> entry : map.entrySet())
+                action.accept(entry.getKey(), entry.getValue());
+        */
+
+        // Faktyczna lambda jest parametrem przekazywanym do forEach.
+        String orbity = "%s okrąża Słońce w %s dni.\n";
+        planety.forEach((K, V) -> System.out.format(orbity, K, V));
+
+        // Powyższe bez użycia lambdy wyglądałoby tradycyjnie tak:
+        for (String planet : planety.keySet()) {
+            System.out.format(orbits, planet, planety.get(planet));
+        }
+
+        // Lub jeżeli postępujemy zgodnie ze specyfikacją domyślnej implementacji:
+        for (Map.Entry<String, String> planeta : planety.entrySet()) {
+            System.out.format(orbits, planeta.getKey(), planeta.getValue());
+        }
+
+        // Podane przykłady pokrywają jedynie podstawowe zastosowanie wyrażeń
+        // lambda. Być może wydają się one niezbyt przydatne, jednak należy
+        // pamiętać, że lambdy można stworzyć jako obiekty, które nastepnie mogą
+        // zostać przekazane jako parametry do innych metod.
+    }
+}
+```
+
+## Dalsze materiały
+
+Linki zamieszczone poniżej służą pomocą w zrozumieniu wybranego tematu, w razie braku rozwiązania wyszukanie w Google zwykle służy pomocą
+
+**Oficjalne poradniki Oracle po angielsku**:
+
+* [Tutorial w Javie od Sun / Oracle](https://docs.oracle.com/javase/tutorial/index.html)
+
+* [Modyfikacje poziomu dostępu w Java](https://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
+
+* [Koncepty programowania obiektowego](https://docs.oracle.com/javase/tutorial/java/concepts/index.html):
+    * [Dziedziczenie](https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
+    * [Polimorfizm](https://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
+    * [Abstrakcja](https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
+
+* [Wyjątki](https://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
+
+* [Interfejsy](https://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
+
+* [Uogólnianie](https://docs.oracle.com/javase/tutorial/java/generics/index.html)
+
+* [Konwencja kodu Java](https://www.oracle.com/technetwork/java/codeconvtoc-136057.html)
+
+* Nowości z Java 8:
+    * [Funkcje Lambda (programowanie funkcyjne)](https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html)
+    * [Data y czas API (java.time package)](http://www.oracle.com/technetwork/articles/java/jf14-date-time-2125367.html)
+
+**Kursy po polsku**
+
+* [PJWSTK - Podstawy programowania w języku Java](http://edu.pjwstk.edu.pl/wyklady/ppj/scb/)
+
+* [PJWSTK - Programowanie obiektowe w języku Java](http://edu.pjwstk.edu.pl/wyklady/poj/scb/)
+
+**Tutoriale i ćwiczenia online po angielsku**
+
+* [Learneroo.com - Learn Java](http://www.learneroo.com)
+
+* [Codingbat.com](http://codingbat.com/java)
+
+* [Codewars - Java Katas](https://www.codewars.com/?language=java)
+
+**Książki po angielsku**:
+
+* [Head First Java](http://www.headfirstlabs.com/books/hfjava/)
+
+* [Thinking in Java](http://www.mindview.net/Books/TIJ/)
+
+* [Objects First with Java](https://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660)
+
+* [Java The Complete Reference](https://www.amazon.com/gp/product/0071606300)
-- 
cgit v1.2.3


From b340c706ee598b8b0b619fddf38ee439fc509ba7 Mon Sep 17 00:00:00 2001
From: jacekwachowiak <jacekwachowiak94@gmail.com>
Date: Sat, 16 Mar 2019 06:58:21 +0100
Subject: Proofreading

---
 pl-pl/java-pl.html.markdown | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

(limited to 'pl-pl')

diff --git a/pl-pl/java-pl.html.markdown b/pl-pl/java-pl.html.markdown
index 91feaf2f..03fdf48d 100644
--- a/pl-pl/java-pl.html.markdown
+++ b/pl-pl/java-pl.html.markdown
@@ -521,8 +521,8 @@ public class LearnJava {
         Rower trek = new Rower();
 
         // Wywoływanie metod klasy
-        trek.predkoscUp(3); // Zawsze używaj settera i gettera jako metod
-        trek.setCadence(100);
+        trek.predkoscZwieksz(3); // Zawsze używaj settera i gettera jako metod
+        trek.setPedalowanie(100);
 
         // toString zwraca reprezentację typu String tego obiektu.
         System.out.println("trek info: " + trek.toString());
@@ -532,9 +532,9 @@ public class LearnJava {
         // Dlatego zwykle odbywa się to w ten sposób:
         private static final Set<String> KRAJE = new HashSet<String>();
         static {
-           COUNTRIES.add("DANIA");
-           COUNTRIES.add("SZWECJA");
-           COUNTRIES.add("FINLANDIA");
+           KRAJE.add("DANIA");
+           KRAJE.add("SZWECJA");
+           KRAJE.add("FINLANDIA");
         }
 
         // Jest jednak sprytny sposób aby łatwiej osiągnąc ten sam efekt
@@ -655,7 +655,7 @@ class PennyFarthing extends Rower {
     // (w języku angielskim):
     // http://docs.oracle.com/javase/tutorial/java/annotations/
     @Override
-    public void setGear(int przerzutka) {
+    public void setPrzerzutka(int przerzutka) {
         this.przerzutka = 0;
     }
 }
@@ -777,10 +777,10 @@ class Pies extends Zwierze
     // Więcej w poście na SO: http://stackoverflow.com/questions/16313649/
     public static void main(String[] args)
     {
-        Dog pluto = new Dog();
-        pluto.makeSound();
-        pluto.eat();
-        pluto.printAge();
+        Pies pluto = new Pies();
+        pluto.dajGLos();
+        pluto.jedz();
+        pluto.wyswietlWiek();
     }
 }
 
@@ -806,7 +806,7 @@ public final class TygrysSzablozebny extends Zwierze
 }
 
 // Metody finalne
-public abstract class Ssak()
+public abstract class Ssak
 {
     // Składnia metody finalnej:
     // <dostępność> final <zwracany rodzaj> <nazwa funkcji>(<argumenty>)
@@ -826,7 +826,7 @@ public abstract class Ssak()
 // wartości wcześniej zdefiniowanych. Jako, że są to stałe, nazwy pól typu enum
 // są pisane wielkimi literami. W języku Java typ enum definiujemy przez użycie
 // słowa enum. Na przykład aby zdefiniować dni tygodnia:
-public enum dzielenie {
+public enum Dzien {
     PONIEDZIALEK, WTOREK, SRODA, CZWARTEK,
     PIATEK, SOBOTA, NIEDZIELA
 }
@@ -859,9 +859,9 @@ public class EnumTest {
     }
 
     public static void main(String[] args) {
-        EnumTest pierwszyDzien = new EnumTest(Day.PONIEDZIALEK);
+        EnumTest pierwszyDzien = new EnumTest(Dzien.PONIEDZIALEK);
         pierwszyDzien.opiszDzien(); // => Nie lubię poniedziałku!
-        EnumTest trzeciDzien = new EnumTest(Day.SRODA);
+        EnumTest trzeciDzien = new EnumTest(Dzien.SRODA);
         trzeciDzien.opiszDzien(); // => Środek tygodnia jest taki sobie.
     }
 }
@@ -957,12 +957,12 @@ public class Lambdas {
 
         // Powyższe bez użycia lambdy wyglądałoby tradycyjnie tak:
         for (String planet : planety.keySet()) {
-            System.out.format(orbits, planet, planety.get(planet));
+            System.out.format(orbity, planet, planety.get(planet));
         }
 
         // Lub jeżeli postępujemy zgodnie ze specyfikacją domyślnej implementacji:
         for (Map.Entry<String, String> planeta : planety.entrySet()) {
-            System.out.format(orbits, planeta.getKey(), planeta.getValue());
+            System.out.format(orbity, planeta.getKey(), planeta.getValue());
         }
 
         // Podane przykłady pokrywają jedynie podstawowe zastosowanie wyrażeń
-- 
cgit v1.2.3


From 67220bdbcc0ff2196b83d7f8a43990d9a018a710 Mon Sep 17 00:00:00 2001
From: jacekwachowiak <jacekwachowiak94@gmail.com>
Date: Sat, 16 Mar 2019 07:35:09 +0100
Subject: Adding the file option

---
 pl-pl/java-pl.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'pl-pl')

diff --git a/pl-pl/java-pl.html.markdown b/pl-pl/java-pl.html.markdown
index 03fdf48d..0da449c5 100644
--- a/pl-pl/java-pl.html.markdown
+++ b/pl-pl/java-pl.html.markdown
@@ -1,5 +1,6 @@
 ---
 language: java
+filename: LearnJavaPl.java
 contributors:
     - ["Jake Prather", "https://github.com/JakeHP"]
     - ["Jakukyo Friel", "https://weakish.github.io"]
-- 
cgit v1.2.3


From 1b7ef9c3dfc6c87148d1fdb8428da00c579d0616 Mon Sep 17 00:00:00 2001
From: Mateusz Burniak <mateusz@burniak.pl>
Date: Thu, 3 Oct 2019 19:03:47 +0200
Subject: Fix typos

---
 pl-pl/bf-pl.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'pl-pl')

diff --git a/pl-pl/bf-pl.html.markdown b/pl-pl/bf-pl.html.markdown
index 88f928cf..6747f8da 100644
--- a/pl-pl/bf-pl.html.markdown
+++ b/pl-pl/bf-pl.html.markdown
@@ -32,9 +32,9 @@ Oto osiem poleceń brainfucka:
 . : wyświetla wartość bieżącej komórki (w formie znaku ASCII, np. 65 = 'A')
 , : wczytuje (jeden) znak z wejścia do bieżącej komórki
     (konkretnie jego numer z tabeli ASCII)
-[ : jeśli wartość w bieżącej komórce jest rózna zero, przechodzi do
+[ : jeśli wartość w bieżącej komórce jest różna zero, przechodzi do
     odpowiadającego ]; w przeciwnym wypdaku przechodzi do następnej instrukcji
-] : Jeśli wartość w bieżącej komórce jest rózna od zera, przechodzi do
+] : Jeśli wartość w bieżącej komórce jest różna od zera, przechodzi do
     następnej instrukcji; w przeciwnym wypdaku przechodzi do odpowiadającego [
 
 [ i ] oznaczają pętlę while. Oczywiście każda pętla rozpoczęta [
-- 
cgit v1.2.3


From 4dc019f923b50bbaeff6fcad31e9a0f6087a742b Mon Sep 17 00:00:00 2001
From: Mateusz Burniak <mateusz@burniak.pl>
Date: Thu, 3 Oct 2019 19:15:23 +0200
Subject: Fix translation

---
 pl-pl/bf-pl.html.markdown | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'pl-pl')

diff --git a/pl-pl/bf-pl.html.markdown b/pl-pl/bf-pl.html.markdown
index 6747f8da..54772961 100644
--- a/pl-pl/bf-pl.html.markdown
+++ b/pl-pl/bf-pl.html.markdown
@@ -7,6 +7,7 @@ contributors:
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
 translators:
     - ["Jakub Młokosiewicz", "https://github.com/hckr"]
+    - ["Mateusz Burniak", "https://gitbub.com/matbur"]
 lang: pl-pl
 
 ---
@@ -32,9 +33,9 @@ Oto osiem poleceń brainfucka:
 . : wyświetla wartość bieżącej komórki (w formie znaku ASCII, np. 65 = 'A')
 , : wczytuje (jeden) znak z wejścia do bieżącej komórki
     (konkretnie jego numer z tabeli ASCII)
-[ : jeśli wartość w bieżącej komórce jest różna zero, przechodzi do
+[ : jeśli wartość w bieżącej komórce jest równa zeru, przechodzi do
     odpowiadającego ]; w przeciwnym wypdaku przechodzi do następnej instrukcji
-] : Jeśli wartość w bieżącej komórce jest różna od zera, przechodzi do
+] : Jeśli wartość w bieżącej komórce jest równa zeru, przechodzi do
     następnej instrukcji; w przeciwnym wypdaku przechodzi do odpowiadającego [
 
 [ i ] oznaczają pętlę while. Oczywiście każda pętla rozpoczęta [
-- 
cgit v1.2.3


From 2afee25faf822439b6c3aaa621cc8fde55925282 Mon Sep 17 00:00:00 2001
From: Mateusz Burniak <mateusz@burniak.pl>
Date: Thu, 3 Oct 2019 22:45:27 +0200
Subject: [bf/pl-pl] Fix typo in url

---
 pl-pl/bf-pl.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pl-pl')

diff --git a/pl-pl/bf-pl.html.markdown b/pl-pl/bf-pl.html.markdown
index 54772961..09c85362 100644
--- a/pl-pl/bf-pl.html.markdown
+++ b/pl-pl/bf-pl.html.markdown
@@ -7,7 +7,7 @@ contributors:
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
 translators:
     - ["Jakub Młokosiewicz", "https://github.com/hckr"]
-    - ["Mateusz Burniak", "https://gitbub.com/matbur"]
+    - ["Mateusz Burniak", "https://github.com/matbur"]
 lang: pl-pl
 
 ---
-- 
cgit v1.2.3


From 1adab9bc3f80d82123987ff34083568030735db7 Mon Sep 17 00:00:00 2001
From: Simon Shine <shreddedglory@gmail.com>
Date: Wed, 12 Feb 2020 04:49:56 +0100
Subject: Rename Python 2 markdown files into 'pythonlegacy'

```
for f in $(find . -iname "*python*" | grep -vE 'python3|git|statcomp'); do
  flegacy=$(echo "$f" | sed 's/python/pythonlegacy/')
  git mv "$f" "$flegacy"
done
```
---
 pl-pl/python-pl.html.markdown       | 640 ------------------------------------
 pl-pl/pythonlegacy-pl.html.markdown | 640 ++++++++++++++++++++++++++++++++++++
 2 files changed, 640 insertions(+), 640 deletions(-)
 delete mode 100644 pl-pl/python-pl.html.markdown
 create mode 100644 pl-pl/pythonlegacy-pl.html.markdown

(limited to 'pl-pl')

diff --git a/pl-pl/python-pl.html.markdown b/pl-pl/python-pl.html.markdown
deleted file mode 100644
index 222f753f..00000000
--- a/pl-pl/python-pl.html.markdown
+++ /dev/null
@@ -1,640 +0,0 @@
----
-name: python
-category: language
-language: python
-filename: learnpython-pl.py
-contributors:
-    - ["Louie Dinh", "http://ldinh.ca"]
-    - ["Amin Bandali", "http://aminbandali.com"]
-    - ["Andre Polykanine", "https://github.com/Oire"]
-translators:
-    - ["Dominik Krzemiński", "https://github.com/dokato"]
-lang: pl-pl
----
-
-Python został opracowany przez Guido Van Rossuma na początku lat 90-tych.
-Obecnie jest jednym z najbardziej popularnych języków programowania.
-Zakochałem się w Pythonie dzięki porządkowi, jaki utrzymywany jest w kodzie.
-To po prostu wykonywalny pseudokod.
-
-Zapraszam do kontaktu. Złapiecie nas na:
-- kontakt polski: raymon92 [at] [google's email service]
-- kontakt angielski: [@louiedinh](http://twitter.com/louiedinh) lub louiedinh [at] [google's email service]
-
-Uwaga: Ten artykuł odnosi się do wersji Pythona 2.7, ale powinien
-działać w wersjach 2.x. Dla wersji 3.x znajdziesz odpowiedni artykuł na stronie głównej.
-
-```python
-# -*- coding: utf-8 -*-
-
-# Pojedyncze komentarze oznaczamy takim symbolem.
-
-""" Wielolinijkowe napisy zapisywane są przy użyciu
-    potrójnych cudzysłowów i często
-    wykorzystywane są jako komentarze.
-"""
-
-####################################################
-## 1. Podstawowe typy danych i operatory
-####################################################
-
-# Liczby to liczby
-3  # => 3
-
-# Matematyka jest intuicyjna
-1 + 1  # => 2
-8 - 1  # => 7
-10 * 2  # => 20
-35 / 5  # => 7
-
-# Dzielenie może być kłopotliwe. Poniższe działanie to dzielenie
-# całkowitoliczbowe(int) i wynik jest automatycznie zaokrąglany.
-5 / 2  # => 2
-
-# Aby to naprawić, musimy powiedzieć nieco o liczbach zmiennoprzecinkowych.
-2.0     # To liczba zmiennoprzecinkowa, tzw. float
-11.0 / 4.0  # => 2.75 ahhh...znacznie lepiej
-
-# Wynik dzielenia całkowitoliczbowego jest obcinany dla liczb
-# dodatnich i ujemnych.
-5 // 3     # => 1
-5.0 // 3.0 # => 1.0 # działa też na floatach
--5 // 3  # => -2
--5.0 // 3.0 # => -2.0
-
-# Operator modulo - wyznaczanie reszty z dzielenia
-7 % 3 # => 1
-
-# Potęgowanie (x do potęgi y-tej)
-2**4 # => 16
-
-# Wymuszanie pierwszeństwa w nawiasach
-(1 + 3) * 2  # => 8
-
-# Operacje logiczne
-# Zauważ, że przy "and" i "or" trzeba zwracać uwagę na rozmiar liter
-True and False #=> False  # Fałsz
-False or True #=> True   # Prawda
-
-# Zauważ, że operatorów logicznych można używać z intami
-0 and 2 #=> 0
--5 or 0 #=> -5
-0 == False #=> True
-2 == True #=> False
-k1 == True #=> True
-
-# aby zanegować, użyj "not"
-not True  # => False
-not False  # => True
-
-# Równość ==
-1 == 1  # => True
-2 == 1  # => False
-
-# Nierówność !=
-1 != 1  # => False
-2 != 1  # => True
-
-# Więcej porównań
-1 < 10  # => True
-1 > 10  # => False
-2 <= 2  # => True
-2 >= 2  # => True
-
-# Porównania można układać w łańcuch!
-1 < 2 < 3  # => True
-2 < 3 < 2  # => False
-
-# Napisy (typ string) tworzone są przy użyciu cudzysłowów " lub '
-"Jestem napisem."
-'Ja też jestem napisem.'
-
-# Napisy można dodawać!
-"Witaj " + "świecie!"  # => "Witaj świecie!"
-
-# ... a nawet mnożyć
-"Hej" * 3  # => "HejHejHej"
-
-# Napis może być traktowany jako lista znaków
-"To napis"[0]  # => 'T'
-
-# % może być używane do formatowania napisów:
-"%s są %s" % ("napisy", "fajne")
-
-# Jednak nowszym sposobem formatowania jest metoda "format".
-# Ta metoda jest obecnie polecana:
-"{0} są {1}".format("napisy", "fajne")
-# Jeśli nie chce ci się liczyć, użyj słów kluczowych.
-"{imie} chce zjeść {jadlo}".format(imie="Bob", jadlo="makaron")
-
-# None jest obiektem
-None  # => None
-
-# Nie używaj "==" w celu porównania obiektów z None
-# Zamiast tego użyj "is"
-"etc" is None  # => False
-None is None  # => True
-
-# Operator 'is' testuje identyczność obiektów. Nie jest to zbyt 
-# pożyteczne, gdy działamy tylko na prostych wartościach,
-# ale przydaje się, gdy mamy do czynienia z obiektami.
-
-# None, 0 i pusty napis "" są odpowiednikami logicznego False.
-# Wszystkie inne wartości są uznawane za prawdę (True)
-bool(0)  # => False
-bool("")  # => False
-
-
-####################################################
-## 2. Zmienne i zbiory danych
-####################################################
-
-# Python ma instrukcję wypisującą "print" we wszystkich wersjach 2.x, ale
-# została ona usunięta z wersji 3.
-print "Jestem Python. Miło Cię poznać!"
-# Python ma też funkcję "print" dostępną w wersjach 2.7 i 3...
-# ale w 2.7 musisz dodać import (odkomentuj):
-# from __future__ import print_function
-print("Ja też jestem Python! ")
-
-# Nie trzeba deklarować zmiennych przed przypisaniem.
-jakas_zmienna = 5    # Konwencja mówi: używaj małych liter i znaków podkreślenia _
-jakas_zmienna  # => 5
-
-# Próba dostępu do niezadeklarowanej zmiennej da błąd.
-# Przejdź do sekcji Obsługa wyjątków, aby dowiedzieć się więcej...
-inna_zmienna  # Wyrzuca nazwę błędu
-
-# "if" może być użyte jako wyrażenie
-"huraaa!" if 3 > 2 else 2  # => "huraaa!"
-
-# Listy:
-li = []
-# Możesz zacząć od wypełnionej listy
-inna_li = [4, 5, 6]
-
-# Dodaj na koniec, używając "append"
-li.append(1)    # li to teraz [1]
-li.append(2)    # li to teraz [1, 2]
-li.append(4)    # li to teraz [1, 2, 4]
-li.append(3)    # li to teraz [1, 2, 4, 3]
-# Usuwanie z konca da "pop"
-li.pop()        # => 3 a li stanie się [1, 2, 4]
-# Dodajmy ponownie
-li.append(3)    # li to znowu [1, 2, 4, 3].
-
-# Dostęp do list jak do każdej tablicy
-li[0]  # => 1
-# Aby nadpisać wcześniej wypełnione miejsca w liście, użyj znaku =
-li[0] = 42
-li[0]  # => 42
-li[0] = 1  # Uwaga: ustawiamy starą wartość
-# Tak podglądamy ostatni element
-li[-1]  # => 3
-
-# Jeżeli wyjdziesz poza zakres...
-li[4]  # ... zobaczysz IndexError
-
-# Możesz też tworzyć wycinki.
-li[1:3]  # => [2, 4]
-# Bez początku
-li[2:]  # => [4, 3]
-# Omijamy koniec
-li[:3]  # => [1, 2, 4]
-# Wybierz co drugi
-li[::2]   # =>[1, 4]
-# Odwróć listę
-li[::-1]   # => [3, 4, 2, 1]
-# Użyj kombinacji powyższych aby tworzyć bardziej skomplikowane wycinki
-# li[poczatek:koniec:krok]
-
-# Usuń element używając "del"
-del li[2]   # li to teraz [1, 2, 3]
-
-# Listy można dodawać
-li + inna_li   # => [1, 2, 3, 4, 5, 6]
-# Uwaga: wartości oryginalnych list li i inna_li się nie zmieniają.
-
-# Do łączenia list użyj "extend()"
-li.extend(other_li)   # li to teraz [1, 2, 3, 4, 5, 6]
-
-# Sprawdź, czy element jest w liście używając "in"
-1 in li   # => True
-
-# "len()" pokazuje długość listy
-len(li)   # => 6
-
-
-# Krotki (tuple) są jak listy, ale nie można ich modyfikować.
-tup = (1, 2, 3)
-tup[0]   # => 1
-tup[0] = 3  # wyrzuci TypeError
-
-# Ale wielu akcji dla list możesz używać przy krotkach
-len(tup)   # => 3
-tup + (4, 5, 6)   # => (1, 2, 3, 4, 5, 6)
-tup[:2]   # => (1, 2)
-2 in tup   # => True
-
-# Można rozpakować krotki i listy do poszczególych zmiennych
-a, b, c = (1, 2, 3)     # a to teraz 1, b jest 2, a c to 3
-# Jeżeli zapomnisz nawiasów, automatycznie tworzone są krotki
-d, e, f = 4, 5, 6
-# Popatrz jak prosto zamienić wartości
-e, d = d, e     # d to teraz 5 a e to 4
-
-
-# Słowniki są również pożyteczne
-pusty_slownik = {}
-# Tu tworzymy wypełniony:
-pelen_slownik = {"raz": 1, "dwa": 2, "trzy": 3}
-
-# Podglądany wartość
-pelen_slownik["one"]   # => 1
-
-# Wypisz wszystkie klucze, używając "keys()"
-pelen_slownik.keys()   # => ["trzy", "dwa", "raz"]
-# Uwaga: słowniki nie zapamiętują kolejności kluczy.
-
-# A teraz wszystkie wartości "values()"
-pelen_slownik.values()   # => [3, 2, 1]
-# Uwaga: to samo dotyczy wartości.
-
-# Sprawdzanie czy klucz występuje w słowniku za pomocą "in"
-"raz" in pelen_slownik   # => True
-1 in pelen_slownik   # => False
-
-# Próba dobrania się do nieistniejącego klucza da KeyError
-pelen_slownik["cztery"]   # KeyError
-
-# Użyj metody "get()", aby uniknąć błędu KeyError
-pelen_slownik.get("raz")   # => 1
-pelen_slownik.get("cztery")   # => None
-# Metoda get zwraca domyślną wartość gdy brakuje klucza
-pelen_slownik.get("one", 4)   # => 1
-pelen_slownik.get("cztery", 4)   # => 4
-# zauważ, że pelen_slownik.get("cztery") wciąż zwraca => None
-# (get nie ustawia wartości słownika)
-
-# przypisz wartość do klucza podobnie jak w listach
-pelen_slownik["cztery"] = 4  # teraz: pelen_slownik["cztery"] => 4
-
-# "setdefault()" wstawia do słownika tylko jeśli nie było klucza
-pelen_slownik.setdefault("piec", 5)  # pelen_slownik["piec"] daje 5
-pelen_slownik.setdefault("piec", 6)  # pelen_slownik["piec"] to wciąż 5
-
-
-# Teraz zbiory (set) - działają jak zwykłe listy, ale bez potórzeń
-pusty_zbior = set()
-# Inicjalizujemy "set()" pewnymi wartościami
-jakis_zbior = set([1, 2, 2, 3, 4])   # jakis_zbior to teraz set([1, 2, 3, 4])
-
-# kolejność nie jest zachowana, nawet gdy wydaje się posortowane
-inny_zbior = set([4, 3, 2, 2, 1])  # inny_zbior to set([1, 2, 3, 4])
-
-# Od Pythona 2.7 nawiasy klamrowe {} mogą być użyte do deklarowania zbioru
-pelen_zbior = {1, 2, 2, 3, 4}   # => {1, 2, 3, 4}
-
-# Dodaj więcej elementów przez "add()"
-pelen_zbior.add(5)   # pelen_zbior is now {1, 2, 3, 4, 5}
-
-# Znajdź przecięcie (część wspólną) zbiorów, używając &
-inny_zbior = {3, 4, 5, 6}
-pelen_zbior & other_set   # => {3, 4, 5}
-
-# Suma zbiorów |  
-pelen_zbior | other_set   # => {1, 2, 3, 4, 5, 6}
-
-# Różnicę zbiorów da znak -
-{1, 2, 3, 4} - {2, 3, 5}   # => {1, 4}
-
-# Sprawdzanie obecności w zbiorze: "in".
-2 in pelen_zbior   # => True
-10 in pelen_zbior   # => False
-
-
-####################################################
-## 3. Kontrola przepływu
-####################################################
-
-# Tworzymy zmienną jakas_zm
-jakas_zm = 5
-
-# Tutaj widzisz wyrażenie warunkowe "if". Wcięcia w Pythonie są ważne!
-# Poniższy kod wypisze "jakas_zm jest mniejsza niż 10"
-if jakas_zm > 10:
-    print("jakas_zm jest wieksza niż 10")
-elif some_var < 10:    # Opcjonalna klauzula elif
-    print("jakas_zm jest mniejsza niż 10")
-else:           # Również opcjonalna klauzula else
-    print("jakas_zm jest równa 10")
-
-
-"""
-Pętla for iteruje po elementach listy, wypisując:
-    pies to ssak
-    kot to ssak
-    mysz to ssak
-"""
-for zwierze in ["pies", "kot", "mysz"]:
-    # Użyj metody format, aby umieścić wartość zmiennej w ciągu
-    print("{0} to ssak".format(zwierze))
-
-"""
-"range(liczba)" zwraca listę liczb
-z przedziału od zera do wskazanej liczby (bez niej):
-    0
-    1
-    2
-    3
-"""
-for i in range(4):
-    print(i)
-
-"""
-While to pętla, która jest wykonywana, dopóki spełniony jest warunek:
-    0
-    1
-    2
-    3
-"""
-x = 0
-while x < 4:
-    print(x)
-    x += 1  # Skrót od x = x + 1
-
-# Wyjątki wyłapujemy, używając try i except
-
-# Działa w Pythonie 2.6 i wyższych:
-try:
-    # Użyj "raise" aby wyrzucić wyjątek
-    raise IndexError("To błąd indeksu")
-except IndexError as e:
-    pass    # Pass to brak reakcji na błąd. Zwykle opisujesz tutaj, jak program ma się zachować w przypadku błędu.
-except (TypeError, NameError):
-    pass    # kilka wyjątków można przechwycić jednocześnie.
-else:   # Opcjonalna część bloku try/except. Musi wystąpić na końcu
-    print "Wszystko ok!"   # Zadziała tylko, gdy program nie napotka wyjatku.
-
-
-####################################################
-## 4. Funkcje
-####################################################
-
-# Użyj "def", aby stworzyć nową funkcję
-def dodaj(x, y):
-    print("x to %s, a y to %s" % (x, y))
-    return x + y    # słowo kluczowe return zwraca wynik działania
-
-# Tak wywołuje się funkcję z parametrami:
-dodaj(5, 6)   # => wypisze "x to 5, a y to 6" i zwróci 11
-
-# Innym sposobem jest wywołanie z parametrami nazwanymi.
-dodaj(y=6, x=5)   # tutaj kolejność podania nie ma znaczenia.
-
-
-# Można też stworzyć funkcję, które przyjmują zmienną liczbę parametrów pozycyjnych,
-# które zostaną przekazana jako krotka, pisząc w definicji funkcji "*args"
-def varargs(*args):
-    return args
-
-varargs(1, 2, 3)   # => (1, 2, 3)
-
-
-# Można też stworzyć funkcję, które przyjmują zmienną liczbę parametrów
-# nazwanych kwargs, które zostaną przekazane jako słownik, pisząc w definicji funkcji "**kwargs"
-def keyword_args(**kwargs):
-    return kwargs
-
-# Wywołajmy to i sprawdźmy co się dzieje
-keyword_args(wielka="stopa", loch="ness")   # => {"wielka": "stopa", "loch": "ness"}
-
-
-# Możesz też przyjmować jednocześnie zmienną liczbę parametrów pozycyjnych i nazwanych
-def all_the_args(*args, **kwargs):
-    print(args)
-    print(kwargs)
-"""
-all_the_args(1, 2, a=3, b=4) wypisze:
-    (1, 2)
-    {"a": 3, "b": 4}
-"""
-
-# Użyj * aby rozwinąć parametry z krotki args
-# i użyj ** aby rozwinąć parametry nazwane ze słownika kwargs.
-args = (1, 2, 3, 4)
-kwargs = {"a": 3, "b": 4}
-all_the_args(*args)   # odpowiednik foo(1, 2, 3, 4)
-all_the_args(**kwargs)   # odpowiednik foo(a=3, b=4)
-all_the_args(*args, **kwargs)   # odpowiednik foo(1, 2, 3, 4, a=3, b=4)
-
-# Możesz podać parametry args i kwargs do funkcji równocześnie
-# przez rozwinięcie odpowiednio * i **
-def pass_all_the_args(*args, **kwargs):
-    all_the_args(*args, **kwargs)
-    print varargs(*args)
-    print keyword_args(**kwargs)
-
-# Zasięg zmiennych
-x = 5
-
-def setX(num):
-    # Lokalna zmienna x nie jest tym samym co zmienna x
-    x = num # => 43
-    print x # => 43
-    
-def setGlobalX(num):
-    global x
-    print x # => 5
-    x = num # globalna zmienna to teraz 6
-    print x # => 6
-
-setX(43)
-setGlobalX(6)
-
-# Można tworzyć funkcje wewnętrzne i zwrócić je jako wynik
-def rob_dodawacz(x):
-    def dodawacz(y):
-        return x + y
-    return dodawacz
-
-dodaj_10 = rob_dodawacz(10)
-dodaj_10(3)   # => 13
-
-# Są również funkcje anonimowe "lambda"
-(lambda x: x > 2)(3)   # => True
-
-# Python ma też wbudowane funkcje wyższego rzędu (przyjmujące inną funkcje jako parametr)
-map(add_10, [1, 2, 3])   # => [11, 12, 13]
-filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
-
-# Można używać wyrażeń listowych (list comprehensions) do mapowania i filtrowania
-[add_10(i) for i in [1, 2, 3]]  # => [11, 12, 13]
-[x for x in [3, 4, 5, 6, 7] if x > 5]   # => [6, 7]
-
-
-####################################################
-## 5. Klasy
-####################################################
-
-# Wszystkie klasy są podklasą object
-class Czlowiek(object):
-
-    # Atrybut klasy. Występuje we wszystkich instancjach klasy.
-    gatunek = "H. sapiens"
-    
-    # Podstawowa inicjalizacja - wywoływana podczas tworzenia instacji.
-    # Zauważ, że podwójne podkreślenia przed i za nazwą oznaczają
-    # specjalne obiekty lub atrybuty wykorzystywane wewnętrznie przez Pythona.
-    # Nie używaj ich we własnych metodach.
-    def __init__(self, nazwa):
-        # przypisz parametr "nazwa" do atrybutu instancji
-        self.nazwa = nazwa
-
-    # Metoda instancji. Wszystkie metody przyjmują "self" jako pierwszy argument
-    def mow(self, wiadomosc):
-        return "%s: %s" % (self.nazwa, wiadomosc)
-
-    # Metoda klasowa współdzielona przez instancje.
-    # Przyjmuje wywołującą klasę jako pierwszy argument.
-    @classmethod
-    def daj_gatunek(cls):
-        return cls.gatunek
-
-    # Metoda statyczna jest wywoływana bez argumentów klasy czy instancji.
-    @staticmethod
-    def grunt():
-        return "*grunt*"
-
-
-# Instancja klasy
-i = Czlowiek(name="Ian")
-print(i.mow("cześć"))     # wypisze "Ian: cześć"
-
-j = Czlowiek("Joel")
-print(j.mow("cześć"))  # wypisze "Joel: cześć"
-
-# Wywołujemy naszą metodę klasową
-i.daj_gatunek()   # => "H. sapiens"
-
-# Zmieniamy wspólny parametr
-Czlowiek.gatunek = "H. neanderthalensis"
-i.daj_gatunek()   # => "H. neanderthalensis"
-j.daj_gatunek()   # => "H. neanderthalensis"
-
-# Wywołanie metody statycznej
-Czlowiek.grunt()   # => "*grunt*"
-
-
-####################################################
-## 6. Moduły
-####################################################
-
-# Tak importuje się moduły:
-import math
-print(math.sqrt(16))  # => 4.0
-
-# Można podać konkretne funkcje, np. ceil, floor z modułu math
-from math import ceil, floor
-print(ceil(3.7))  # => 4.0
-print(floor(3.7))   # => 3.0
-
-# Można zaimportować wszystkie funkcje z danego modułu.
-# Uwaga: nie jest to polecane, bo później w kodzie trudno połapać się,
-# która funkcja pochodzi z którego modułu.
-from math import *
-
-# Można skracać nazwy modułów.
-import math as m
-math.sqrt(16) == m.sqrt(16)   # => True
-# sprawdźmy czy funkcje są równoważne
-from math import sqrt
-math.sqrt == m.sqrt == sqrt  # => True
-
-# Moduły Pythona to zwykłe skrypty napisane w tym języku. Możesz
-# pisać własne i importować je. Nazwa modułu to nazwa pliku.
-
-# W ten sposób sprawdzisz jakie funkcje wchodzą w skład modułu.
-import math
-dir(math)
-
-
-####################################################
-## 7. Zaawansowane
-####################################################
-
-# Generatory pomagają tworzyć tzw. "leniwy kod"
-def podwojne_liczby(iterowalne):
-    for i in iterowalne:
-        yield i + i
-
-# Generatory tworzą wartości w locie.
-# Zamiast generować wartości raz i zapisywać je (np. w liście), 
-# generator tworzy je na bieżąco, w wyniku iteracji. To oznacza,
-# że w poniższym przykładzie wartości większe niż 15 nie będą przetworzone 
-# w funkcji "podwojne_liczby".
-# Zauważ, że xrange to generator, który wykonuje tę samą operację co range.
-# Stworzenie listy od 1 do 900000000 zajęłoby sporo czasu i pamięci,
-# a xrange tworzy obiekt generatora zamiast budować całą listę jak range.
-
-# Aby odróżnić nazwę zmiennej od nazwy zarezerwowanej w Pythonie, używamy
-# zwykle na końcu znaku podkreślenia
-xrange_ = xrange(1, 900000000)
-
-# poniższa pętla będzie podwajać liczby aż do 30 
-for i in podwojne_liczby(xrange_):
-    print(i)
-    if i >= 30:
-        break
-
-
-# Dekoratory
-# w tym przykładzie "beg" jest nakładką na "say"
-# Beg wywołuje say. Jeśli say_please jest prawdziwe, wtedy zwracana wartość
-# zostanie zmieniona
-
-from functools import wraps
-
-
-def beg(target_function):
-    @wraps(target_function)
-    def wrapper(*args, **kwargs):
-        msg, say_please = target_function(*args, **kwargs)
-        if say_please:
-            return "{} {}".format(msg, "Proszę! Jestem spłukany :(")
-        return msg
-    return wrapper
-
-
-@beg
-def say(say_please=False):
-    msg = "Kupisz mi piwo?"
-    return msg, say_please
-
-
-print(say())  # Kupisz mi piwo?
-print(say(say_please=True))  # Kupisz mi piwo? Proszę! Jestem spłukany :(
-```
-
-## Gotowy na więcej?
-### Polskie
-
-* [Zanurkuj w Pythonie](http://pl.wikibooks.org/wiki/Zanurkuj_w_Pythonie)
-* [LearnPythonPl](http://www.learnpython.org/pl/)
-
-### Angielskie:
-#### Darmowe źródła online
-
-* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
-* [Dive Into Python](http://www.diveintopython.net/)
-* [The Official Docs](http://docs.python.org/2.6/)
-* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
-* [Python Module of the Week](http://pymotw.com/2/)
-* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
-
-#### Inne
-
-* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
-* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
-* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
-
diff --git a/pl-pl/pythonlegacy-pl.html.markdown b/pl-pl/pythonlegacy-pl.html.markdown
new file mode 100644
index 00000000..222f753f
--- /dev/null
+++ b/pl-pl/pythonlegacy-pl.html.markdown
@@ -0,0 +1,640 @@
+---
+name: python
+category: language
+language: python
+filename: learnpython-pl.py
+contributors:
+    - ["Louie Dinh", "http://ldinh.ca"]
+    - ["Amin Bandali", "http://aminbandali.com"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+translators:
+    - ["Dominik Krzemiński", "https://github.com/dokato"]
+lang: pl-pl
+---
+
+Python został opracowany przez Guido Van Rossuma na początku lat 90-tych.
+Obecnie jest jednym z najbardziej popularnych języków programowania.
+Zakochałem się w Pythonie dzięki porządkowi, jaki utrzymywany jest w kodzie.
+To po prostu wykonywalny pseudokod.
+
+Zapraszam do kontaktu. Złapiecie nas na:
+- kontakt polski: raymon92 [at] [google's email service]
+- kontakt angielski: [@louiedinh](http://twitter.com/louiedinh) lub louiedinh [at] [google's email service]
+
+Uwaga: Ten artykuł odnosi się do wersji Pythona 2.7, ale powinien
+działać w wersjach 2.x. Dla wersji 3.x znajdziesz odpowiedni artykuł na stronie głównej.
+
+```python
+# -*- coding: utf-8 -*-
+
+# Pojedyncze komentarze oznaczamy takim symbolem.
+
+""" Wielolinijkowe napisy zapisywane są przy użyciu
+    potrójnych cudzysłowów i często
+    wykorzystywane są jako komentarze.
+"""
+
+####################################################
+## 1. Podstawowe typy danych i operatory
+####################################################
+
+# Liczby to liczby
+3  # => 3
+
+# Matematyka jest intuicyjna
+1 + 1  # => 2
+8 - 1  # => 7
+10 * 2  # => 20
+35 / 5  # => 7
+
+# Dzielenie może być kłopotliwe. Poniższe działanie to dzielenie
+# całkowitoliczbowe(int) i wynik jest automatycznie zaokrąglany.
+5 / 2  # => 2
+
+# Aby to naprawić, musimy powiedzieć nieco o liczbach zmiennoprzecinkowych.
+2.0     # To liczba zmiennoprzecinkowa, tzw. float
+11.0 / 4.0  # => 2.75 ahhh...znacznie lepiej
+
+# Wynik dzielenia całkowitoliczbowego jest obcinany dla liczb
+# dodatnich i ujemnych.
+5 // 3     # => 1
+5.0 // 3.0 # => 1.0 # działa też na floatach
+-5 // 3  # => -2
+-5.0 // 3.0 # => -2.0
+
+# Operator modulo - wyznaczanie reszty z dzielenia
+7 % 3 # => 1
+
+# Potęgowanie (x do potęgi y-tej)
+2**4 # => 16
+
+# Wymuszanie pierwszeństwa w nawiasach
+(1 + 3) * 2  # => 8
+
+# Operacje logiczne
+# Zauważ, że przy "and" i "or" trzeba zwracać uwagę na rozmiar liter
+True and False #=> False  # Fałsz
+False or True #=> True   # Prawda
+
+# Zauważ, że operatorów logicznych można używać z intami
+0 and 2 #=> 0
+-5 or 0 #=> -5
+0 == False #=> True
+2 == True #=> False
+k1 == True #=> True
+
+# aby zanegować, użyj "not"
+not True  # => False
+not False  # => True
+
+# Równość ==
+1 == 1  # => True
+2 == 1  # => False
+
+# Nierówność !=
+1 != 1  # => False
+2 != 1  # => True
+
+# Więcej porównań
+1 < 10  # => True
+1 > 10  # => False
+2 <= 2  # => True
+2 >= 2  # => True
+
+# Porównania można układać w łańcuch!
+1 < 2 < 3  # => True
+2 < 3 < 2  # => False
+
+# Napisy (typ string) tworzone są przy użyciu cudzysłowów " lub '
+"Jestem napisem."
+'Ja też jestem napisem.'
+
+# Napisy można dodawać!
+"Witaj " + "świecie!"  # => "Witaj świecie!"
+
+# ... a nawet mnożyć
+"Hej" * 3  # => "HejHejHej"
+
+# Napis może być traktowany jako lista znaków
+"To napis"[0]  # => 'T'
+
+# % może być używane do formatowania napisów:
+"%s są %s" % ("napisy", "fajne")
+
+# Jednak nowszym sposobem formatowania jest metoda "format".
+# Ta metoda jest obecnie polecana:
+"{0} są {1}".format("napisy", "fajne")
+# Jeśli nie chce ci się liczyć, użyj słów kluczowych.
+"{imie} chce zjeść {jadlo}".format(imie="Bob", jadlo="makaron")
+
+# None jest obiektem
+None  # => None
+
+# Nie używaj "==" w celu porównania obiektów z None
+# Zamiast tego użyj "is"
+"etc" is None  # => False
+None is None  # => True
+
+# Operator 'is' testuje identyczność obiektów. Nie jest to zbyt 
+# pożyteczne, gdy działamy tylko na prostych wartościach,
+# ale przydaje się, gdy mamy do czynienia z obiektami.
+
+# None, 0 i pusty napis "" są odpowiednikami logicznego False.
+# Wszystkie inne wartości są uznawane za prawdę (True)
+bool(0)  # => False
+bool("")  # => False
+
+
+####################################################
+## 2. Zmienne i zbiory danych
+####################################################
+
+# Python ma instrukcję wypisującą "print" we wszystkich wersjach 2.x, ale
+# została ona usunięta z wersji 3.
+print "Jestem Python. Miło Cię poznać!"
+# Python ma też funkcję "print" dostępną w wersjach 2.7 i 3...
+# ale w 2.7 musisz dodać import (odkomentuj):
+# from __future__ import print_function
+print("Ja też jestem Python! ")
+
+# Nie trzeba deklarować zmiennych przed przypisaniem.
+jakas_zmienna = 5    # Konwencja mówi: używaj małych liter i znaków podkreślenia _
+jakas_zmienna  # => 5
+
+# Próba dostępu do niezadeklarowanej zmiennej da błąd.
+# Przejdź do sekcji Obsługa wyjątków, aby dowiedzieć się więcej...
+inna_zmienna  # Wyrzuca nazwę błędu
+
+# "if" może być użyte jako wyrażenie
+"huraaa!" if 3 > 2 else 2  # => "huraaa!"
+
+# Listy:
+li = []
+# Możesz zacząć od wypełnionej listy
+inna_li = [4, 5, 6]
+
+# Dodaj na koniec, używając "append"
+li.append(1)    # li to teraz [1]
+li.append(2)    # li to teraz [1, 2]
+li.append(4)    # li to teraz [1, 2, 4]
+li.append(3)    # li to teraz [1, 2, 4, 3]
+# Usuwanie z konca da "pop"
+li.pop()        # => 3 a li stanie się [1, 2, 4]
+# Dodajmy ponownie
+li.append(3)    # li to znowu [1, 2, 4, 3].
+
+# Dostęp do list jak do każdej tablicy
+li[0]  # => 1
+# Aby nadpisać wcześniej wypełnione miejsca w liście, użyj znaku =
+li[0] = 42
+li[0]  # => 42
+li[0] = 1  # Uwaga: ustawiamy starą wartość
+# Tak podglądamy ostatni element
+li[-1]  # => 3
+
+# Jeżeli wyjdziesz poza zakres...
+li[4]  # ... zobaczysz IndexError
+
+# Możesz też tworzyć wycinki.
+li[1:3]  # => [2, 4]
+# Bez początku
+li[2:]  # => [4, 3]
+# Omijamy koniec
+li[:3]  # => [1, 2, 4]
+# Wybierz co drugi
+li[::2]   # =>[1, 4]
+# Odwróć listę
+li[::-1]   # => [3, 4, 2, 1]
+# Użyj kombinacji powyższych aby tworzyć bardziej skomplikowane wycinki
+# li[poczatek:koniec:krok]
+
+# Usuń element używając "del"
+del li[2]   # li to teraz [1, 2, 3]
+
+# Listy można dodawać
+li + inna_li   # => [1, 2, 3, 4, 5, 6]
+# Uwaga: wartości oryginalnych list li i inna_li się nie zmieniają.
+
+# Do łączenia list użyj "extend()"
+li.extend(other_li)   # li to teraz [1, 2, 3, 4, 5, 6]
+
+# Sprawdź, czy element jest w liście używając "in"
+1 in li   # => True
+
+# "len()" pokazuje długość listy
+len(li)   # => 6
+
+
+# Krotki (tuple) są jak listy, ale nie można ich modyfikować.
+tup = (1, 2, 3)
+tup[0]   # => 1
+tup[0] = 3  # wyrzuci TypeError
+
+# Ale wielu akcji dla list możesz używać przy krotkach
+len(tup)   # => 3
+tup + (4, 5, 6)   # => (1, 2, 3, 4, 5, 6)
+tup[:2]   # => (1, 2)
+2 in tup   # => True
+
+# Można rozpakować krotki i listy do poszczególych zmiennych
+a, b, c = (1, 2, 3)     # a to teraz 1, b jest 2, a c to 3
+# Jeżeli zapomnisz nawiasów, automatycznie tworzone są krotki
+d, e, f = 4, 5, 6
+# Popatrz jak prosto zamienić wartości
+e, d = d, e     # d to teraz 5 a e to 4
+
+
+# Słowniki są również pożyteczne
+pusty_slownik = {}
+# Tu tworzymy wypełniony:
+pelen_slownik = {"raz": 1, "dwa": 2, "trzy": 3}
+
+# Podglądany wartość
+pelen_slownik["one"]   # => 1
+
+# Wypisz wszystkie klucze, używając "keys()"
+pelen_slownik.keys()   # => ["trzy", "dwa", "raz"]
+# Uwaga: słowniki nie zapamiętują kolejności kluczy.
+
+# A teraz wszystkie wartości "values()"
+pelen_slownik.values()   # => [3, 2, 1]
+# Uwaga: to samo dotyczy wartości.
+
+# Sprawdzanie czy klucz występuje w słowniku za pomocą "in"
+"raz" in pelen_slownik   # => True
+1 in pelen_slownik   # => False
+
+# Próba dobrania się do nieistniejącego klucza da KeyError
+pelen_slownik["cztery"]   # KeyError
+
+# Użyj metody "get()", aby uniknąć błędu KeyError
+pelen_slownik.get("raz")   # => 1
+pelen_slownik.get("cztery")   # => None
+# Metoda get zwraca domyślną wartość gdy brakuje klucza
+pelen_slownik.get("one", 4)   # => 1
+pelen_slownik.get("cztery", 4)   # => 4
+# zauważ, że pelen_slownik.get("cztery") wciąż zwraca => None
+# (get nie ustawia wartości słownika)
+
+# przypisz wartość do klucza podobnie jak w listach
+pelen_slownik["cztery"] = 4  # teraz: pelen_slownik["cztery"] => 4
+
+# "setdefault()" wstawia do słownika tylko jeśli nie było klucza
+pelen_slownik.setdefault("piec", 5)  # pelen_slownik["piec"] daje 5
+pelen_slownik.setdefault("piec", 6)  # pelen_slownik["piec"] to wciąż 5
+
+
+# Teraz zbiory (set) - działają jak zwykłe listy, ale bez potórzeń
+pusty_zbior = set()
+# Inicjalizujemy "set()" pewnymi wartościami
+jakis_zbior = set([1, 2, 2, 3, 4])   # jakis_zbior to teraz set([1, 2, 3, 4])
+
+# kolejność nie jest zachowana, nawet gdy wydaje się posortowane
+inny_zbior = set([4, 3, 2, 2, 1])  # inny_zbior to set([1, 2, 3, 4])
+
+# Od Pythona 2.7 nawiasy klamrowe {} mogą być użyte do deklarowania zbioru
+pelen_zbior = {1, 2, 2, 3, 4}   # => {1, 2, 3, 4}
+
+# Dodaj więcej elementów przez "add()"
+pelen_zbior.add(5)   # pelen_zbior is now {1, 2, 3, 4, 5}
+
+# Znajdź przecięcie (część wspólną) zbiorów, używając &
+inny_zbior = {3, 4, 5, 6}
+pelen_zbior & other_set   # => {3, 4, 5}
+
+# Suma zbiorów |  
+pelen_zbior | other_set   # => {1, 2, 3, 4, 5, 6}
+
+# Różnicę zbiorów da znak -
+{1, 2, 3, 4} - {2, 3, 5}   # => {1, 4}
+
+# Sprawdzanie obecności w zbiorze: "in".
+2 in pelen_zbior   # => True
+10 in pelen_zbior   # => False
+
+
+####################################################
+## 3. Kontrola przepływu
+####################################################
+
+# Tworzymy zmienną jakas_zm
+jakas_zm = 5
+
+# Tutaj widzisz wyrażenie warunkowe "if". Wcięcia w Pythonie są ważne!
+# Poniższy kod wypisze "jakas_zm jest mniejsza niż 10"
+if jakas_zm > 10:
+    print("jakas_zm jest wieksza niż 10")
+elif some_var < 10:    # Opcjonalna klauzula elif
+    print("jakas_zm jest mniejsza niż 10")
+else:           # Również opcjonalna klauzula else
+    print("jakas_zm jest równa 10")
+
+
+"""
+Pętla for iteruje po elementach listy, wypisując:
+    pies to ssak
+    kot to ssak
+    mysz to ssak
+"""
+for zwierze in ["pies", "kot", "mysz"]:
+    # Użyj metody format, aby umieścić wartość zmiennej w ciągu
+    print("{0} to ssak".format(zwierze))
+
+"""
+"range(liczba)" zwraca listę liczb
+z przedziału od zera do wskazanej liczby (bez niej):
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print(i)
+
+"""
+While to pętla, która jest wykonywana, dopóki spełniony jest warunek:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print(x)
+    x += 1  # Skrót od x = x + 1
+
+# Wyjątki wyłapujemy, używając try i except
+
+# Działa w Pythonie 2.6 i wyższych:
+try:
+    # Użyj "raise" aby wyrzucić wyjątek
+    raise IndexError("To błąd indeksu")
+except IndexError as e:
+    pass    # Pass to brak reakcji na błąd. Zwykle opisujesz tutaj, jak program ma się zachować w przypadku błędu.
+except (TypeError, NameError):
+    pass    # kilka wyjątków można przechwycić jednocześnie.
+else:   # Opcjonalna część bloku try/except. Musi wystąpić na końcu
+    print "Wszystko ok!"   # Zadziała tylko, gdy program nie napotka wyjatku.
+
+
+####################################################
+## 4. Funkcje
+####################################################
+
+# Użyj "def", aby stworzyć nową funkcję
+def dodaj(x, y):
+    print("x to %s, a y to %s" % (x, y))
+    return x + y    # słowo kluczowe return zwraca wynik działania
+
+# Tak wywołuje się funkcję z parametrami:
+dodaj(5, 6)   # => wypisze "x to 5, a y to 6" i zwróci 11
+
+# Innym sposobem jest wywołanie z parametrami nazwanymi.
+dodaj(y=6, x=5)   # tutaj kolejność podania nie ma znaczenia.
+
+
+# Można też stworzyć funkcję, które przyjmują zmienną liczbę parametrów pozycyjnych,
+# które zostaną przekazana jako krotka, pisząc w definicji funkcji "*args"
+def varargs(*args):
+    return args
+
+varargs(1, 2, 3)   # => (1, 2, 3)
+
+
+# Można też stworzyć funkcję, które przyjmują zmienną liczbę parametrów
+# nazwanych kwargs, które zostaną przekazane jako słownik, pisząc w definicji funkcji "**kwargs"
+def keyword_args(**kwargs):
+    return kwargs
+
+# Wywołajmy to i sprawdźmy co się dzieje
+keyword_args(wielka="stopa", loch="ness")   # => {"wielka": "stopa", "loch": "ness"}
+
+
+# Możesz też przyjmować jednocześnie zmienną liczbę parametrów pozycyjnych i nazwanych
+def all_the_args(*args, **kwargs):
+    print(args)
+    print(kwargs)
+"""
+all_the_args(1, 2, a=3, b=4) wypisze:
+    (1, 2)
+    {"a": 3, "b": 4}
+"""
+
+# Użyj * aby rozwinąć parametry z krotki args
+# i użyj ** aby rozwinąć parametry nazwane ze słownika kwargs.
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args)   # odpowiednik foo(1, 2, 3, 4)
+all_the_args(**kwargs)   # odpowiednik foo(a=3, b=4)
+all_the_args(*args, **kwargs)   # odpowiednik foo(1, 2, 3, 4, a=3, b=4)
+
+# Możesz podać parametry args i kwargs do funkcji równocześnie
+# przez rozwinięcie odpowiednio * i **
+def pass_all_the_args(*args, **kwargs):
+    all_the_args(*args, **kwargs)
+    print varargs(*args)
+    print keyword_args(**kwargs)
+
+# Zasięg zmiennych
+x = 5
+
+def setX(num):
+    # Lokalna zmienna x nie jest tym samym co zmienna x
+    x = num # => 43
+    print x # => 43
+    
+def setGlobalX(num):
+    global x
+    print x # => 5
+    x = num # globalna zmienna to teraz 6
+    print x # => 6
+
+setX(43)
+setGlobalX(6)
+
+# Można tworzyć funkcje wewnętrzne i zwrócić je jako wynik
+def rob_dodawacz(x):
+    def dodawacz(y):
+        return x + y
+    return dodawacz
+
+dodaj_10 = rob_dodawacz(10)
+dodaj_10(3)   # => 13
+
+# Są również funkcje anonimowe "lambda"
+(lambda x: x > 2)(3)   # => True
+
+# Python ma też wbudowane funkcje wyższego rzędu (przyjmujące inną funkcje jako parametr)
+map(add_10, [1, 2, 3])   # => [11, 12, 13]
+filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
+
+# Można używać wyrażeń listowych (list comprehensions) do mapowania i filtrowania
+[add_10(i) for i in [1, 2, 3]]  # => [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5]   # => [6, 7]
+
+
+####################################################
+## 5. Klasy
+####################################################
+
+# Wszystkie klasy są podklasą object
+class Czlowiek(object):
+
+    # Atrybut klasy. Występuje we wszystkich instancjach klasy.
+    gatunek = "H. sapiens"
+    
+    # Podstawowa inicjalizacja - wywoływana podczas tworzenia instacji.
+    # Zauważ, że podwójne podkreślenia przed i za nazwą oznaczają
+    # specjalne obiekty lub atrybuty wykorzystywane wewnętrznie przez Pythona.
+    # Nie używaj ich we własnych metodach.
+    def __init__(self, nazwa):
+        # przypisz parametr "nazwa" do atrybutu instancji
+        self.nazwa = nazwa
+
+    # Metoda instancji. Wszystkie metody przyjmują "self" jako pierwszy argument
+    def mow(self, wiadomosc):
+        return "%s: %s" % (self.nazwa, wiadomosc)
+
+    # Metoda klasowa współdzielona przez instancje.
+    # Przyjmuje wywołującą klasę jako pierwszy argument.
+    @classmethod
+    def daj_gatunek(cls):
+        return cls.gatunek
+
+    # Metoda statyczna jest wywoływana bez argumentów klasy czy instancji.
+    @staticmethod
+    def grunt():
+        return "*grunt*"
+
+
+# Instancja klasy
+i = Czlowiek(name="Ian")
+print(i.mow("cześć"))     # wypisze "Ian: cześć"
+
+j = Czlowiek("Joel")
+print(j.mow("cześć"))  # wypisze "Joel: cześć"
+
+# Wywołujemy naszą metodę klasową
+i.daj_gatunek()   # => "H. sapiens"
+
+# Zmieniamy wspólny parametr
+Czlowiek.gatunek = "H. neanderthalensis"
+i.daj_gatunek()   # => "H. neanderthalensis"
+j.daj_gatunek()   # => "H. neanderthalensis"
+
+# Wywołanie metody statycznej
+Czlowiek.grunt()   # => "*grunt*"
+
+
+####################################################
+## 6. Moduły
+####################################################
+
+# Tak importuje się moduły:
+import math
+print(math.sqrt(16))  # => 4.0
+
+# Można podać konkretne funkcje, np. ceil, floor z modułu math
+from math import ceil, floor
+print(ceil(3.7))  # => 4.0
+print(floor(3.7))   # => 3.0
+
+# Można zaimportować wszystkie funkcje z danego modułu.
+# Uwaga: nie jest to polecane, bo później w kodzie trudno połapać się,
+# która funkcja pochodzi z którego modułu.
+from math import *
+
+# Można skracać nazwy modułów.
+import math as m
+math.sqrt(16) == m.sqrt(16)   # => True
+# sprawdźmy czy funkcje są równoważne
+from math import sqrt
+math.sqrt == m.sqrt == sqrt  # => True
+
+# Moduły Pythona to zwykłe skrypty napisane w tym języku. Możesz
+# pisać własne i importować je. Nazwa modułu to nazwa pliku.
+
+# W ten sposób sprawdzisz jakie funkcje wchodzą w skład modułu.
+import math
+dir(math)
+
+
+####################################################
+## 7. Zaawansowane
+####################################################
+
+# Generatory pomagają tworzyć tzw. "leniwy kod"
+def podwojne_liczby(iterowalne):
+    for i in iterowalne:
+        yield i + i
+
+# Generatory tworzą wartości w locie.
+# Zamiast generować wartości raz i zapisywać je (np. w liście), 
+# generator tworzy je na bieżąco, w wyniku iteracji. To oznacza,
+# że w poniższym przykładzie wartości większe niż 15 nie będą przetworzone 
+# w funkcji "podwojne_liczby".
+# Zauważ, że xrange to generator, który wykonuje tę samą operację co range.
+# Stworzenie listy od 1 do 900000000 zajęłoby sporo czasu i pamięci,
+# a xrange tworzy obiekt generatora zamiast budować całą listę jak range.
+
+# Aby odróżnić nazwę zmiennej od nazwy zarezerwowanej w Pythonie, używamy
+# zwykle na końcu znaku podkreślenia
+xrange_ = xrange(1, 900000000)
+
+# poniższa pętla będzie podwajać liczby aż do 30 
+for i in podwojne_liczby(xrange_):
+    print(i)
+    if i >= 30:
+        break
+
+
+# Dekoratory
+# w tym przykładzie "beg" jest nakładką na "say"
+# Beg wywołuje say. Jeśli say_please jest prawdziwe, wtedy zwracana wartość
+# zostanie zmieniona
+
+from functools import wraps
+
+
+def beg(target_function):
+    @wraps(target_function)
+    def wrapper(*args, **kwargs):
+        msg, say_please = target_function(*args, **kwargs)
+        if say_please:
+            return "{} {}".format(msg, "Proszę! Jestem spłukany :(")
+        return msg
+    return wrapper
+
+
+@beg
+def say(say_please=False):
+    msg = "Kupisz mi piwo?"
+    return msg, say_please
+
+
+print(say())  # Kupisz mi piwo?
+print(say(say_please=True))  # Kupisz mi piwo? Proszę! Jestem spłukany :(
+```
+
+## Gotowy na więcej?
+### Polskie
+
+* [Zanurkuj w Pythonie](http://pl.wikibooks.org/wiki/Zanurkuj_w_Pythonie)
+* [LearnPythonPl](http://www.learnpython.org/pl/)
+
+### Angielskie:
+#### Darmowe źródła online
+
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [The Official Docs](http://docs.python.org/2.6/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [Python Module of the Week](http://pymotw.com/2/)
+* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
+
+#### Inne
+
+* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
+* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
+
-- 
cgit v1.2.3


From 95c8b24ebf8b8e0ed02923787a9f793bdf295200 Mon Sep 17 00:00:00 2001
From: Simon Shine <shreddedglory@gmail.com>
Date: Wed, 12 Feb 2020 05:09:13 +0100
Subject: Python 2 'language': Python 2 (legacy)

Instead of listing 'language: python' for Python 2, use

    language: Python 2 (legacy)

```
find . -iname "*pythonlegacy*" -exec \
  sed -i 's/^language: .*/language: Python 2 (legacy)/' {} \;
```
---
 pl-pl/pythonlegacy-pl.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pl-pl')

diff --git a/pl-pl/pythonlegacy-pl.html.markdown b/pl-pl/pythonlegacy-pl.html.markdown
index 222f753f..e620fffb 100644
--- a/pl-pl/pythonlegacy-pl.html.markdown
+++ b/pl-pl/pythonlegacy-pl.html.markdown
@@ -1,7 +1,7 @@
 ---
 name: python
 category: language
-language: python
+language: Python 2 (legacy)
 filename: learnpython-pl.py
 contributors:
     - ["Louie Dinh", "http://ldinh.ca"]
-- 
cgit v1.2.3


From 887cbee8af080034177734b528819491e73a7a16 Mon Sep 17 00:00:00 2001
From: Simon Shine <shreddedglory@gmail.com>
Date: Wed, 12 Feb 2020 05:50:44 +0100
Subject: Change 'filename:' for Python 2 (legacy)

Before renaming, all Python 2 filenames were 'learnpython-*.py'.

This commit renames them to 'learnpythonlegacy-*.py'.

To verify that the filenames were named consistently across
translations prior to this commit, and to change this:

```
find . -name "pythonlegacy*.markdown" -exec ack filename: {} \;

find . -name "pythonlegacy*.markdown" -exec \
  sed -i 's/^filename: learnpython/filename: learnpythonlegacy/' {} \;
```
---
 pl-pl/pythonlegacy-pl.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pl-pl')

diff --git a/pl-pl/pythonlegacy-pl.html.markdown b/pl-pl/pythonlegacy-pl.html.markdown
index e620fffb..9e322658 100644
--- a/pl-pl/pythonlegacy-pl.html.markdown
+++ b/pl-pl/pythonlegacy-pl.html.markdown
@@ -2,7 +2,7 @@
 name: python
 category: language
 language: Python 2 (legacy)
-filename: learnpython-pl.py
+filename: learnpythonlegacy-pl.py
 contributors:
     - ["Louie Dinh", "http://ldinh.ca"]
     - ["Amin Bandali", "http://aminbandali.com"]
-- 
cgit v1.2.3


From 1a06a3512b4c748372d8aebfdf97ddb07dbfaa54 Mon Sep 17 00:00:00 2001
From: Adam Bard <adam@adambard.com>
Date: Thu, 13 Feb 2020 22:09:07 -0800
Subject: fix pl pythonlegacy

---
 pl-pl/pythonlegacy-pl.html.markdown | 2 --
 1 file changed, 2 deletions(-)

(limited to 'pl-pl')

diff --git a/pl-pl/pythonlegacy-pl.html.markdown b/pl-pl/pythonlegacy-pl.html.markdown
index 9e322658..2b35ce90 100644
--- a/pl-pl/pythonlegacy-pl.html.markdown
+++ b/pl-pl/pythonlegacy-pl.html.markdown
@@ -1,6 +1,4 @@
 ---
-name: python
-category: language
 language: Python 2 (legacy)
 filename: learnpythonlegacy-pl.py
 contributors:
-- 
cgit v1.2.3


From 0ecb8264293d852f2ef586279885848b621668d1 Mon Sep 17 00:00:00 2001
From: sumanstats <suman81765@gmail.com>
Date: Wed, 10 Jun 2020 16:33:01 +0545
Subject: Perl6 to Raku and many more

+ As the Perl 6 is renamed to raku, it is good to reflect that https://github.com/Raku/problem-solving/blob/master/solutions/language/Path-to-Raku.md

+ perl6.org is now raku.org
+ change references of perl 6 to raku
+ rename file perl6-pod.html.markdown to raku-pod.html.markdown
+ Perl refers to Perl 5, there is no ambiguity after rename of Perl6 to
  Raku, use Perl only to refer to Perl 5
+ fix links inside raku.html.markdown
---
 pl-pl/perl-pl.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'pl-pl')

diff --git a/pl-pl/perl-pl.html.markdown b/pl-pl/perl-pl.html.markdown
index 3e27cc4f..43d68b05 100644
--- a/pl-pl/perl-pl.html.markdown
+++ b/pl-pl/perl-pl.html.markdown
@@ -12,10 +12,10 @@ lang: pl-pl
 
 ---
 
-Perl 5 jest wysoce użytecznym, bogatym w wiele opcji językiem programowania
+Perl jest wysoce użytecznym, bogatym w wiele opcji językiem programowania
 z ponad 25 latami nieustannego rozwoju.
 
-Perl 5 używany jest na ponad 100 różnych platformach (od przenośnych do w
+Perl używany jest na ponad 100 różnych platformach (od przenośnych do w
 pełni stacjonarnych) i nadaje się zarówno do szybkiego prototypowania jak
 i projektów deweloperskich prowadzonych na szeroką skalę.
 
-- 
cgit v1.2.3