From 5aa692f5f3bbfa7b79224748dcfd8ca5fba7a8bc Mon Sep 17 00:00:00 2001 From: Adam Date: Fri, 12 Feb 2016 11:42:25 -0800 Subject: brainfuck->bf --- pl-pl/bf-pl.html.markdown | 93 ++++++++++++++++++++++++++++++++++++++++ pl-pl/brainfuck-pl.html.markdown | 93 ---------------------------------------- 2 files changed, 93 insertions(+), 93 deletions(-) create mode 100644 pl-pl/bf-pl.html.markdown delete mode 100644 pl-pl/brainfuck-pl.html.markdown (limited to 'pl-pl') diff --git a/pl-pl/bf-pl.html.markdown b/pl-pl/bf-pl.html.markdown new file mode 100644 index 00000000..801f1a9a --- /dev/null +++ b/pl-pl/bf-pl.html.markdown @@ -0,0 +1,93 @@ +--- +language: bf +contributors: + - ["Prajit Ramachandran", "http://prajitr.github.io/"] + - ["Mathias Bynens", "http://mathiasbynens.be/"] +translators: + - ["Jakub Młokosiewicz", "https://github.com/hckr"] +lang: pl-pl +--- + +Brainfuck (pisane małymi literami, za wyjątkiem początku zdania) jest bardzo +minimalistycznym, kompletnym w sensie Turinga, językiem programowania. +Zawiera zaledwie 8 poleceń. + +Możesz przetesotwać brainfucka w swojej przeglądarce, korzystając z narzędzia +[brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/). + +``` +Wszystkie znaki oprócz "><+-.,[]" (wyłączając znaki zapytania) są ignorowane. + +Pamięć w brainfucku jest reprezentowana przez tablicę 30.000 komórek +zainicjalizowanych zerami, ze wskaźnikiem pokazującym na aktualną komórkę. + +Oto osiem poleceń brainfucka: ++ : inkrementuje (zwiększa o jeden) wartość aktualnie wskazywanej komórki +- : dekrementuje (zmniejsza o jeden) wartość aktualnie wskazywanej komórki +> : przesuwa wskaźnik na następną komórkę (w prawo) +< : przesuwa wskaźnik na poprzednią komórkę (w lewo) +. : 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 + 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 + następnej instrukcji; w przeciwnym wypdaku przechodzi do odpowiadającego [ + +[ i ] oznaczają pętlę while. Oczywiście każda pętla rozpoczęta [ +musi być zakończona ]. + +Zobaczmy kilka prostych programów w brainfucku. + + +++++++ [ > ++++++++++ < - ] > +++++ . + +Ten program wypisuje literę 'A'. Najpierw zwiększa wartość komórki #1 do 6. +Komórka #1 będzie wykorzystana w pętli. Następnie program wchodzi w pętlę ([) +i przechodzi do komórki #2. Pętla wykonuje się sześć razy (komórka #1 jest +dekrementowana sześć razy, nim osiągnie wartość zero, kiedy to program +przechodzi do odpowiadającego ] i wykonuje kolejne instrukcje). + +W tym momencie wskaźnik pokazuje na komórkę #1, mającą wartość 0, podczas gdy +komórka #2 ma wartość 60. Przesuwamy wskaźnik na komórkę #2, inkrementujemy ją +pięć razy, uzyskując wartość 65. Następnie wyświetlamy wartość komórki #2. +65 to 'A' w tabeli ASCII, więc właśnie ten znak jest wypisany na konsolę. + + +, [ > + < - ] > . + +Ten program wczytuje znak z wejścia i umieszcza jego kod ASCII w komórce #1. +Następnie zaczyna się pętla, w której znajdują się następujące instrukcje: +przesunięcie wskaźnika na komórkę #2, inkrementacja wartości komóri #2, +powrót do komórki #1 i dekrementacja wartości komórki #1. Instrukcje pętli +wykonują się aż wartość komórki #1 osiągnie zero, a komórka #2 osiągnie +poprednią wartość komórki #1. Ponieważ na końcu pętli wskaźnik pokazuje na +komórkę #1, po pętli następuje instrukcja przejścia do komórki #2 i wysłanie +jej wartości (w formie znaku ASCII) na wyjście. + +Zauważ, że odstępy służą wyłącznie poprawie czytelności. +Równie dobrze można powyższy program zapisać tak: + +,[>+<-]>. + + +Spróbuj odgadnąć, co robi poniższy program: + +,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> + +Ten program pobiera z wejścia dwie liczby i je mnoży. + +Po wczytaniu dwóch wejść (do komórek #1 i #2) następuje pętla zewnętrzna, +warunkowana wartością komórki #1. Następnie program przechodzi do komórki #2 +i rozpoczyna pętlę wewnętrzną z warunkiem zakończenia w komórce #2, +inkrementującą komórkę #3. Tu jednak pojawia się problem: w chwili zakończenia +wewnętrznej pętli komórka #2 ma wartość zero. W takim razie wewętrzna pętla +nie wywoła się następny raz. Aby rozwiązać ten problem, inkrementujemy także +wartość komórki #4, a następnie kopiujemy jej wartość do komórki #2. +Ostatecznie wynik działania znajduje się w komórce #3. +``` + +I to właśnie jest brainfuck. Nie taki trudny, co? W ramach rozrywki możesz +napisać własne programy w brainfucku. Możesz też napisać interpreter brainfucka +w innym języku. Implementacja interpretera to dość proste zadanie. Jeśli +jesteś masochistą, spróbuj napisać interpreter brainfucka w... brainfucku. diff --git a/pl-pl/brainfuck-pl.html.markdown b/pl-pl/brainfuck-pl.html.markdown deleted file mode 100644 index 69d814c4..00000000 --- a/pl-pl/brainfuck-pl.html.markdown +++ /dev/null @@ -1,93 +0,0 @@ ---- -language: brainfuck -contributors: - - ["Prajit Ramachandran", "http://prajitr.github.io/"] - - ["Mathias Bynens", "http://mathiasbynens.be/"] -translators: - - ["Jakub Młokosiewicz", "https://github.com/hckr"] -lang: pl-pl ---- - -Brainfuck (pisane małymi literami, za wyjątkiem początku zdania) jest bardzo -minimalistycznym, kompletnym w sensie Turinga, językiem programowania. -Zawiera zaledwie 8 poleceń. - -Możesz przetesotwać brainfucka w swojej przeglądarce, korzystając z narzędzia -[brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/). - -``` -Wszystkie znaki oprócz "><+-.,[]" (wyłączając znaki zapytania) są ignorowane. - -Pamięć w brainfucku jest reprezentowana przez tablicę 30.000 komórek -zainicjalizowanych zerami, ze wskaźnikiem pokazującym na aktualną komórkę. - -Oto osiem poleceń brainfucka: -+ : inkrementuje (zwiększa o jeden) wartość aktualnie wskazywanej komórki -- : dekrementuje (zmniejsza o jeden) wartość aktualnie wskazywanej komórki -> : przesuwa wskaźnik na następną komórkę (w prawo) -< : przesuwa wskaźnik na poprzednią komórkę (w lewo) -. : 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 - 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 - następnej instrukcji; w przeciwnym wypdaku przechodzi do odpowiadającego [ - -[ i ] oznaczają pętlę while. Oczywiście każda pętla rozpoczęta [ -musi być zakończona ]. - -Zobaczmy kilka prostych programów w brainfucku. - - -++++++ [ > ++++++++++ < - ] > +++++ . - -Ten program wypisuje literę 'A'. Najpierw zwiększa wartość komórki #1 do 6. -Komórka #1 będzie wykorzystana w pętli. Następnie program wchodzi w pętlę ([) -i przechodzi do komórki #2. Pętla wykonuje się sześć razy (komórka #1 jest -dekrementowana sześć razy, nim osiągnie wartość zero, kiedy to program -przechodzi do odpowiadającego ] i wykonuje kolejne instrukcje). - -W tym momencie wskaźnik pokazuje na komórkę #1, mającą wartość 0, podczas gdy -komórka #2 ma wartość 60. Przesuwamy wskaźnik na komórkę #2, inkrementujemy ją -pięć razy, uzyskując wartość 65. Następnie wyświetlamy wartość komórki #2. -65 to 'A' w tabeli ASCII, więc właśnie ten znak jest wypisany na konsolę. - - -, [ > + < - ] > . - -Ten program wczytuje znak z wejścia i umieszcza jego kod ASCII w komórce #1. -Następnie zaczyna się pętla, w której znajdują się następujące instrukcje: -przesunięcie wskaźnika na komórkę #2, inkrementacja wartości komóri #2, -powrót do komórki #1 i dekrementacja wartości komórki #1. Instrukcje pętli -wykonują się aż wartość komórki #1 osiągnie zero, a komórka #2 osiągnie -poprednią wartość komórki #1. Ponieważ na końcu pętli wskaźnik pokazuje na -komórkę #1, po pętli następuje instrukcja przejścia do komórki #2 i wysłanie -jej wartości (w formie znaku ASCII) na wyjście. - -Zauważ, że odstępy służą wyłącznie poprawie czytelności. -Równie dobrze można powyższy program zapisać tak: - -,[>+<-]>. - - -Spróbuj odgadnąć, co robi poniższy program: - -,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> - -Ten program pobiera z wejścia dwie liczby i je mnoży. - -Po wczytaniu dwóch wejść (do komórek #1 i #2) następuje pętla zewnętrzna, -warunkowana wartością komórki #1. Następnie program przechodzi do komórki #2 -i rozpoczyna pętlę wewnętrzną z warunkiem zakończenia w komórce #2, -inkrementującą komórkę #3. Tu jednak pojawia się problem: w chwili zakończenia -wewnętrznej pętli komórka #2 ma wartość zero. W takim razie wewętrzna pętla -nie wywoła się następny raz. Aby rozwiązać ten problem, inkrementujemy także -wartość komórki #4, a następnie kopiujemy jej wartość do komórki #2. -Ostatecznie wynik działania znajduje się w komórce #3. -``` - -I to właśnie jest brainfuck. Nie taki trudny, co? W ramach rozrywki możesz -napisać własne programy w brainfucku. Możesz też napisać interpreter brainfucka -w innym języku. Implementacja interpretera to dość proste zadanie. Jeśli -jesteś masochistą, spróbuj napisać interpreter brainfucka w... brainfucku. -- cgit v1.2.3 From 5068509640591a47a47169687757fc996c88d60a Mon Sep 17 00:00:00 2001 From: Voltinus Date: Sun, 26 Jun 2016 16:24:58 +0300 Subject: [json/pl] Translated JSON tutorial (#2079) * Create json-pl.html.markdown * Update json-pl.html.markdown * Added -pl to file name --- pl-pl/json-pl.html.markdown | 85 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 85 insertions(+) create mode 100644 pl-pl/json-pl.html.markdown (limited to 'pl-pl') diff --git a/pl-pl/json-pl.html.markdown b/pl-pl/json-pl.html.markdown new file mode 100644 index 00000000..872455de --- /dev/null +++ b/pl-pl/json-pl.html.markdown @@ -0,0 +1,85 @@ +--- +language: json +filename: learnjson-pl.json +contributors: + - ["Anna Harren", "https://github.com/iirelu"] + - ["Marco Scannadinari", "https://github.com/marcoms"] + - ["himanshu", "https://github.com/himanshu81494"] + - ["Michael Neth", "https://github.com/infernocloud"] +translators: + - ["Michał Mitrosz", "https://github.com/Voltinus"] +lang: pl-pl +--- + +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. + +Kod JSON musi zawierać któreś z poniższych: +* Zbiór par nazwa/wartość (`{ }`). W różnych językach jest to obiekt, rekord, struktura, słownik, tablica mieszająca, lista z kluczami, lub tablica asocjacyjna. +* Uporządkowana lista wartości (`[ ]`). W różnych językach jest to tablica, wektor, lista, lub sekwencja. + tablica/lista/sekwencja (`[ ]`) lub słownik/obiekt/tablica asocjacyjna (`{ }`). + +JSON w swojej czystej postaci nie ma komentarzy, ale większość parserów akceptuje komentarze w stylu C (`//`, `/* */`). Niektóre parsery pozwalają także na końcowy przecinek (np. przecinek po ostatnim elemencie w tablicy lub po ostatiej własności obiektu), ale powinien on być omijany dla lepszej kompatybilności. + +Dla celów tego poradnika wszystko będzie 100% kodem JSON. Na szczęście, to samo mówi za siebie. + +Wspierane typy danych: + +* Łańcuchy znaków: `"witaj"`, `"\"Cytat.\""`, `"\u0abe"`, `"Nowa linia.\n"` +* Liczby: `23`, `0.11`, `12e10`, `3.141e-10`, `1.23e+4` +* Obiekty: `{ "klucz": "wartość" }` +* Tablice: `["Wartości"]` +* Inne: `true`, `false`, `null` + +```json +{ + "klucz": "wartość", + + "klucze": "muszą być zawsze zamknięte w podwójnych cudzysłowach", + "liczby": 0, + "łańcuchy": "Hellø, wørld. Wszystkie znaki unicode są dozwolone, razem z \"sekwencjami escape\".", + "wartości logiczne?": true, + "nic": null, + + "duża liczba": 1.2e+100, + + "obiekty": { + "komentarz": "Większość twojej struktury będzie zbudowana z obiektów.", + + "tablica": [0, 1, 2, 3, "Tablice mogą mieć wewnątrz cokolwiek", 5], + + "inny obiekt": { + "komentarz": "Elementy mogą się w sobie zawierać, bardzo użyteczne" + } + }, + + "głupota": [ + { + "źródła potasu": ["banany"] + }, + [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, "neo"], + [0, 0, 0, 1] + ] + ], + + "styl alternatywny": { + "komentarz": "sprawdź to!" + , "pozycja przecinka": "nie ma znaczenia, o ile jest przed następnym kluczem, jest poprawnie" + , "następny komentarz": "jak ładnie" + }, + + + + "znaki białe": "nie mają znaczenia", + + + + "to było krótkie": "I gotowe. Wiesz już wszystko o formacie JSON." +} +``` + +## Dalsza lektura + +* [JSON.org](http://json.org) Cały JSON pięknie wytłumaczony na podstawie grafik przypominających schematy blokowe. -- cgit v1.2.3 From 7aef44996c67251272a5d7e6888f88787586cc12 Mon Sep 17 00:00:00 2001 From: ven Date: Thu, 22 Sep 2016 16:25:13 +0200 Subject: fix #2382 --- pl-pl/ruby-pl.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pl-pl') diff --git a/pl-pl/ruby-pl.html.markdown b/pl-pl/ruby-pl.html.markdown index 73b1a7d8..7ab47847 100644 --- a/pl-pl/ruby-pl.html.markdown +++ b/pl-pl/ruby-pl.html.markdown @@ -1,6 +1,6 @@ --- language: ruby -filename: learnruby.rb +filename: learnruby-pl.rb contributors: - ["David Underwood", "http://theflyingdeveloper.com"] - ["Joel Walden", "http://joelwalden.net"] -- cgit v1.2.3 From 844efb460fd0382852774ba5434f1e6c11a699ae Mon Sep 17 00:00:00 2001 From: Adam Bobowski Date: Tue, 1 Nov 2016 02:18:11 +0100 Subject: [vim/pl] Tutorial translation to Polish language (#2544) * Added vim tutorial translation to Polish language * Fixed spelling errors --- pl-pl/vim-pl.html.markdown | 236 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 236 insertions(+) create mode 100644 pl-pl/vim-pl.html.markdown (limited to 'pl-pl') diff --git a/pl-pl/vim-pl.html.markdown b/pl-pl/vim-pl.html.markdown new file mode 100644 index 00000000..8481046f --- /dev/null +++ b/pl-pl/vim-pl.html.markdown @@ -0,0 +1,236 @@ +--- +category: tool +tool: vim +contributors: + - ["RadhikaG", "https://github.com/RadhikaG"] +translators: + - ["Adam Bobowski", "https://github.com/Bobowski"] +lang: pl-pl +filename: LearnVim-pl.txt +--- + + +[Vim](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 +do szybkiej nawigacji do wybranych miejsc w plikach oraz szybkiej edycji +danych fragmentów. + +## Podstawy nawigacji w Vim + +``` + vim # Otwórz w vim + :q # Zamknij vim + :w # Zapisz aktualny plik + :wq # Zapisz i wyjdź z vim + :q! # Wyjdź bez zapisywania + # ! *wymusza* wykonanie :q, dlatego nie wykonuje zapisu + :x # Zapisz i wyjdź, krótszy odpowiednik :wq + + u # Cofnij operację + CTRL+R # Powtórz operację + + h # Przesuń kursor w lewo + j # Przesuń kursor w dół + k # Przesuń kursor w górę + l # Przesuń kursor w prawo + + # Poruszanie w obrębie jednej lini + + 0 # Skocz do początku linii + $ # Skocz do końca linii + ^ # Skocz do pierwszego niebiałego znaku + + # Wyszukiwanie w tekście + + /slowo # Zaznacza wszystkie wystąpienia słowa za kursorem + ?slowo # Zaznacza wszystkie wystąpienia słowa przed kursorem + n # Przemieszcza kursor do następnego wystąpienia słowa + N # Przemieszcza kursor do poprzedniego wystąpenia słowa + + :%s/foo/bar/g # Zamień 'foo' na 'bar' w każdej linii tekstu + :s/foo/bar/g # Zamień 'foo' na 'bar' w aktualnej linii + + # Skoki do znaków + + f # Skocz do przodu i zatrzymaj się na + t # Skocz do przodu i zatrzymaj się przed + + # Na przykład, + f< # Skocz do przodu i zatrzymaj się na < + t< # Skocz do przodu i zatrzymaj się przed < + + # Moving by word + + w # Przesuń kursor do przodu o jedno słowo + b # Przesuń kursor do tyłu o jedno słowo + e # Przesuń kursor do końca aktualnego słowa + + # Inne znaki do przemieszczania się + + gg # Skocz na początek pliku + G # Skocz na koniec pliku + :NUM # Skocz do linii o numerze NUM + H # Skocz na górę ekranu + M # Skocz na środek ekranu + L # Skocz na dół ekranu +``` + +## Tryby: + +Vim oparty jest na koncepcji **trybów**. + +Command Mode - (Tryb komend) vim zaczyna w tym trybie, używany do nawigacji i wpisywania komend +Insert Mode - (Tryb wprowadzania) używany do wprowadzania zmian w pliku +Visual Mode - (Tryb wizualny) używany do zaznaczania tekstu i wykonywania komend na nim +Ex Mode - (Tryb Ex) + +``` + i # Przechodzi to trybu wprowadzania, przed pozycją kursora + a # Przechodzi do trybu wprowadzania, za pozycją kursora + v # Przechodzi do trybu wizualnego + : # Przechodzi do trybu ex + # Wychodzi z dowolnego aktywnego trybu do trybu komend + + # Kopiowanie i wklejanie tekstu + + y # Skopiuj zaznaczony tekst + yy # Skopiuj aktualną linię + d # Usuń zaznaczony tekst + dd # Usuń aktualną linię + p # Wklej skopiowany tekst za kursorem + P # Wklej skopiowany tekst przed kursorem + x # Usuń znak pod kursorem +``` + +## 'Gramatyka' vim'a + +Vim można traktować jako zbiór komend w formacie 'Akcja-Modyfikator-Obiekt', gdzie: + +Akcja - jedna z dostępnych akcji +Modyfikator - w jaki sposób wykonywana jest akcja +Obiekt - obiekt na którym wykonywana jest akcja + +Kilka ważnych przykładów Akcji, Modyfikatorów i Obiektów: + +``` + # 'Akcje' + + d # Usuń + c # Zmień + y # Skopiuj + v # Zaznacz + + # 'Modyfikatory' + + i # W środku + a # Dookoła + NUM # Liczba + f # Szuka czegoś i zatrzymuje się na tym + t # Szuka czegoś i zatrzymuje się przed tym + / # Znajduje napis od kursora naprzód + ? # Znajduje napis przed kursorem + + # 'Obiekty' + + w # Słowo + s # Zdanie + p # Paragraf + b # Blok + + # Przykładowe 'zdania' + + d2w # Usuń 2 słowa + cis # Zmień w zdaniu + yip # Skopiuj paragraf w którym jest kursor + ct< # Zamień na < + d$ # Usuń tekst do końca linii +``` + +## Pewne skróty i triki + + +``` + > # Zrób wcięcie zaznaczonego bloku + < # Usuń wcięcie zaznaczonego bloku + :earlier 15m # Przywróć dokument do stanu z przed 15 minut + :later 15m # Odwróć efekt poprzedniej komendy + ddp # Zamień kolejnością kolejne linie, dd potem p + . # Powtórz poprzenią komendę +``` + +## Makra + +Makra są właściwie nagrywanymi akcjami. Gdy zaczynasz nagrywać makro, nagrywa ono +**każdą** akcję i komendę jaką wykonasz do momentu przerwania nagrywania. +Wywołanie makra wykonuje dokładnie te same operacje w tej samej kolejności. + +``` + qa # Zacznij nagrywać makro 'a' + q # Przerwij nagrywanie + @a # Odtwórz makro 'a' +``` + +### Konfiguracja ~/.vimrc + +Plik .vimrc może być użyty do skonfigurowania Vim'a przy jego starcie + +Poniżej zamieszczono przykładowy plik ~/.vimrc: + +``` +" Przykładowy ~/.vimrc +" 2016.10 + +" Wymagane aby korzystać z opcji iMproved +set nocompatible + +" Na podstawie typu pliku włącza inteligentne wcięcia i inne. +filetype indent plugin on + +" Włącz podkreślanie składni +syntax on + +" Lepsze uzupełnianie składni komend +set wildmenu + +" Wyszukiwanie będzie ignorować wielkość liter poza przypadkami gdy użyjemy wielkich liter +set ignorecase +set smartcase + +" Po otwarciu pliku gdzie nie jest zdefiniowane zachowanie wcięć +" zostanie zachowane wcięcie takie samo jak w aktualnej linii +set autoindent + +" Wyświetlaj numer lini +set number + +" Opcje wcięć, zmień w zależności od osobistych upodobań + +" Szerokość TAB w spacjach +set tabstop=4 + +" Liczba spacji w TAB podczas edycji +set softtabstop=4 + +" Liczba spacji gdy wykonywane są operacje wcięcia (>> i <<) +set shiftwidth=4 + +" Zamieniaj tabulatory na spacje +set expandtab + +" Aktywuj inteligentne tabulatory i spacje do wcięć i wyrównań +set smarttab +``` + +### Odniesienia [ENG] + +[Vim | Home](http://www.vim.org/index.php) + +`$ vimtutor` + +[A vim Tutorial and Primer](https://danielmiessler.com/study/vim/) + +[What are the dark corners of Vim your mom never told you about? (Stack Overflow thread)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about) + +[Arch Linux Wiki](https://wiki.archlinux.org/index.php/Vim) -- cgit v1.2.3 From e5416f2a34c0303dd5928cd26f0673a62b17e8c4 Mon Sep 17 00:00:00 2001 From: Hatsuney Date: Tue, 1 Nov 2016 02:24:51 +0100 Subject: [vim/pl] fixed a typo (#2551) --- 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 8481046f..21c8c152 100644 --- a/pl-pl/vim-pl.html.markdown +++ b/pl-pl/vim-pl.html.markdown @@ -157,7 +157,7 @@ Kilka ważnych przykładów Akcji, Modyfikatorów i Obiektów: :earlier 15m # Przywróć dokument do stanu z przed 15 minut :later 15m # Odwróć efekt poprzedniej komendy ddp # Zamień kolejnością kolejne linie, dd potem p - . # Powtórz poprzenią komendę + . # Powtórz poprzednią komendę ``` ## Makra -- cgit v1.2.3 From c3fb66cd6dfe79d9c8357e6f65230c750f78b3a7 Mon Sep 17 00:00:00 2001 From: Remigiusz Suwalski 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 +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 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 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 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 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 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 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 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 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 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 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 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 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 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