Functions (FP)¶
Prehľad funkcií¶
Rýchla referencia funkcií a operátorov použitých v main.hs.
maximum¶
maximum :: Ord a => [a] -> a
Vráti najväčší prvok zoznamu.
reverse¶
reverse :: [a] -> [a]
Otočí poradie prvkov v zozname.
concat¶
concat :: [[a]] -> [a]
Zoberie zoznam zoznamov a spojí ich do jedného zoznamu.
concatMap¶
concatMap :: (a -> [b]) -> [a] -> [b]
To isté ako map + concat naraz — na každý prvok aplikuje funkciu (ktorá vráti zoznam) a všetky výsledné zoznamy spojí do jedného.
replicate¶
replicate :: Int -> a -> [a]
Vytvorí zoznam, kde sa daná hodnota zopakuje n-krát.
zipWith¶
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
Spojí dva zoznamy po dvojiciach (prvý s prvým, druhý s druhým, ...) a na každú dvojicu aplikuje danú funkciu.
unlines¶
unlines :: [String] -> String
Spojí zoznam reťazcov do jedného textu, kde je za každým pridaný znak nového riadku (\n).
show¶
show :: Show a => a -> String
Prevedie hodnotu na jej textovú reprezentáciu (String). Používa sa napr. keď chceš číslo vložiť do textu cez ++.
mod — párne a nepárne čísla¶
mod :: Int -> Int -> Int
mod vráti zvyšok po delení. Číslo je párne, ak je zvyšok po delení 2 rovný 0; nepárne, ak je zvyšok 1.
Nájdenie všetkých párnych čísel zo zoznamu:
Haskell má na to aj priamo vstavané funkcie even/odd, ktoré robia presne toto (interne používajú mod):
Lambda funkcia (anonymná funkcia)¶
Funkcia bez mena, ktorú napíšeš priamo na mieste, kde ju potrebuješ — zvyčajne ako argument pre map/filter/foldr a podobné. Zápis: \argumenty -> výraz (znak \ pripomína grécke písmeno λ).
map (\x -> x * 2) [1, 2, 3] = [2, 4, 6]
(\x y -> x + y) 3 4 = 7
filter (\x -> x `mod` 2 == 0) [1..10] = [2, 4, 6, 8, 10]
Best practices:
- Lambdu používaj len na krátke, jednorazové výrazy. Ak je logika zložitejšia alebo sa používa viackrát, daj jej meno (bežnou
where/top-level funkciou) — kód sa potom ľahšie čita. - Ak lambda len priamo volá existujúcu funkciu, zbytočná — napíš funkciu samotnú:
- Ak lambda len pomenúva argumenty pre operátor, často sa dá nahradiť zátvorkovým zápisom operátora (pozri sekciu "Aritmetické operátory"):
Lambda s _ (wildcard) vo foldr/foldl: keď funkcia pre foldr/foldl musí brať dva argumenty (prvok a doterajší výsledok), ale na konkrétnej hodnote prvku nezáleží, nahraď ju podtržníkom _:
myLength :: [a] -> Int
myLength xs = foldr (\_ acc -> acc + 1) 0 xs
myLength [1, 2, 3, 4] = 4
myLength "ahoj" = 4
\_ acc -> acc + 1 znamená: "nezáleží mi, aký je prvok (_), len pripočítaj 1 k doterajšiemu výsledku (acc)" — každý prvok zoznamu tak pripočíta 1, výsledkom je dĺžka zoznamu.
Množinové abstrakcie (list comprehensions)¶
Spôsob, ako postaviť zoznam priamo z iného zoznamu — podobne ako v matematike {x² | x ∈ ℕ}. Všeobecný tvar: [výraz | x <- zoznam, podmienky].
Čítaj to takto: "pre každé x zo zoznamu [1..5] vypočítaj x * x".
Môžeš pridať aj podmienku (filter) za čiarkou:
"pre každé x z [1..20], ktoré je deliteľné 3, ponechaj x."
Môžeš použiť aj viac zoznamov naraz — vygenerujú sa všetky kombinácie:
Nahrádza map + filter naraz — výraz pred | je ako map, podmienka za čiarkou je ako filter:
-- cez map + filter:
map (*2) (filter even [1..10]) = [4, 8, 12, 16, 20]
-- to isté cez list comprehension:
[x * 2 | x <- [1..10], even x] = [4, 8, 12, 16, 20]
Funguje aj na reťazcoch (String je zoznam znakov):
putStr — histogram¶
putStr :: String -> IO ()
Vypíše text na obrazovku bez nového riadku na konci (na rozdiel od putStrLn, ktorý riadok automaticky odriadkuje).
Klasický príklad použitia — histogram (pre každé číslo zo zoznamu vypíš toľko hviezdičiek):
printBar :: Int -> IO ()
printBar n = putStrLn (replicate n '*')
histogram :: [Int] -> IO ()
histogram = mapM_ printBar
histogram [3, 1, 5, 2]
-- vypíše:
-- ***
-- *
-- *****
-- **
replicate n '*' vytvorí reťazec z n hviezdičiek (napr. replicate 3 '*' = "***") a mapM_ zavolá printBar na každé číslo v zozname po sebe.
Aritmetické operátory (prefix vs. infix)¶
Operátory ako +, -, * sú v Haskelli bežné funkcie dvoch argumentov — len sa väčšinou zapisujú infixne (medzi argumentmi). Rovnako ich ale môžeš zapísať prefixne, ak ich uzavrieš do zátvoriek — presne naopak ako pri `div` (tam uzatváraš bežnú funkciu do backtickov, aby sa dala písať infixne).
(+) 5 4 = 5 + 4 -- 9
(-) 5 4 = 5 - 4 -- 1
(*) 5 4 = 5 * 4 -- 20
(/) 5 2 = 5 / 2 -- 2.5 (len Fractional, napr. Double)
(^) 2 3 = 2 ^ 3 -- 8 (mocnina)
Funkcie ako div, mod, quot, rem sú naopak zapísané prefixne ako štandard, a infixne sa dajú použiť cez backticky:
div 13 4 = 13 `div` 4 -- 3 (celočíselné delenie, zaokrúhľuje k -∞)
mod 13 4 = 13 `mod` 4 -- 1 (zvyšok po delení)
quot (-13) 4 = -3 -- celočíselné delenie zaokrúhľujúce k 0
rem (-13) 4 = -1 -- zvyšok zodpovedajúci quot
Pozor: div/mod a quot/rem sa pri kladných číslach správajú rovnako, rozdiel je len pri záporných (pozri sekciu quotRem/divMod v cheat-sheet.md).
Kedy nemusíš písať zoznam explicitne¶
Ak je zoznam posledný argument funkcie a na pravej strane ho len odovzdáš ďalej (nič s ním iné nerobíš), nemusíš ho vypisovať ani na ľavej, ani na pravej strane.
-- s explicitným xs
listAnd :: [Bool] -> Bool
listAnd xs = foldr (&&) True xs
-- bez xs — robí presne to isté
listAnd :: [Bool] -> Bool
listAnd = foldr (&&) True
Ďalšie príklady:
wordLengths :: [String] -> [Int]
wordLengths = map length
wordLengths ["ahoj", "ja"] = [4, 2]
double :: [Int] -> [Int]
double = map (*2)
double [1, 2, 3] = [2, 4, 6]
total :: [Int] -> Int
total = foldr (+) 0
total [1, 2, 3] = 6
Kedy to takto nejde: ak so zoznamom robíš ešte niečo navyše (napr. ho použiješ dvakrát, alebo nie je posledný argument), musíš ho napísať:
-- toto NEJDE skrátiť, lebo xs sa použije dvakrát
isEmpty :: [a] -> Bool
isEmpty xs = length xs == 0
&& (a zároveň)¶
(&&) :: Bool -> Bool -> Bool
Vráti True len vtedy, keď sú obe strany True.
[] (prázdny zoznam)¶
[] :: [a]
Konštruktor prázdneho zoznamu. Každý zoznam je buď [], alebo prvok pripojený cez : k ďalšiemu zoznamu (1 : 2 : [] == [1, 2]).
++ (spájanie zoznamov)¶
(++) :: [a] -> [a] -> [a]
Spojí dva zoznamy za sebou do jedného.
!! (indexovanie)¶
(!!) :: [a] -> Int -> a
Vráti prvok zoznamu na danej pozícii (indexované od 0). Na indexe mimo rozsahu spadne s chybou.
head¶
head :: [a] -> a
Vráti prvý prvok zoznamu. Na prázdnom zozname spadne s chybou (partial function).
tail¶
tail :: [a] -> [a]
Vráti zoznam bez prvého prvku. Na prázdnom zozname spadne s chybou (partial function).
last¶
last :: [a] -> a
Vráti posledný prvok zoznamu. Na prázdnom zozname spadne s chybou (partial function).
init¶
init :: [a] -> [a]
Vráti zoznam bez posledného prvku. Na prázdnom zozname spadne s chybou (partial function).
length¶
length :: [a] -> Int
Vráti počet prvkov zoznamu.
null¶
null :: [a] -> Bool
Zistí, či je zoznam prázdny. Rýchlejšie ako length xs == 0, pretože nemusí prejsť celý zoznam.
reverse¶
reverse :: [a] -> [a]
Otočí poradie prvkov v zozname.
drop¶
drop :: Int -> [a] -> [a]
Zahodí prvých n prvkov zoznamu a vráti zvyšok. Opak take.
elem¶
elem :: Eq a => a -> [a] -> Bool
Zistí, či sa daný prvok nachádza v zozname.
filter¶
filter :: (a -> Bool) -> [a] -> [a]
Vráti nový zoznam obsahujúci iba prvky, pre ktoré daná podmienka (predikát) vráti True.
fst¶
fst :: (a, b) -> a
Vráti prvý prvok dvojice (tuple).
snd¶
snd :: (a, b) -> b
Vráti druhý prvok dvojice (tuple).
map¶
map :: (a -> b) -> [a] -> [b]
Aplikuje zadanú funkciu na každý prvok zoznamu a vráti zoznam výsledkov.
lookup¶
lookup :: Eq a => a -> [(a, b)] -> Maybe b
V zozname dvojíc (asociatívny zoznam) vyhľadá hodnotu podľa kľúča. Ak kľúč nájde, vráti Just hodnota, inak Nothing.
words¶
words :: String -> [String]
Rozdelí reťazec na zoznam slov podľa medzier (whitespace).
unwords¶
unwords :: [String] -> String
Spojí zoznam slov späť do jedného reťazca, oddelené medzerou (opak words).
: (cons)¶
(:) :: a -> [a] -> [a]
Pridá prvok na začiatok zoznamu. Dá sa tým aj poskladať celý zoznam: [1, 2, 3] je to isté ako 1 : 2 : 3 : [].
. (kompozícia funkcií)¶
(.) :: (b -> c) -> (a -> b) -> a -> c
Zreťazí dve funkcie do jednej — výsledok pravej funkcie sa stane vstupom ľavej. (f . g) x == f (g x).
case of¶
Výraz, ktorý robí pattern matching priamo vo vnútri výrazu (nielen v hlavičke funkcie). Vyhodnocuje sa zhora dole, použije sa výsledok prvého vzoru, ktorý sedí. _ zachytí všetky ostatné prípady.
describe :: Int -> String
describe n = case n of
1 -> "one"
2 -> "two"
_ -> "other"
describe 1 = "one"
describe 5 = "other"
Často sa používa na rozbalenie Maybe/Either:
classify :: Maybe Int -> String
classify m = case m of
Just x -> "got " ++ show x
Nothing -> "nothing"
classify (Just 5) = "got 5"
classify Nothing = "nothing"
foldr¶
foldr :: (a -> b -> b) -> b -> [a] -> b
Zoberie zoznam a postupne ho "spočíta" do jednej hodnoty, začína sa od konca zoznamu.
Ako sa to počíta, krok po kroku na foldr (&&) True [True, False, True]:
- Najprv vezme posledný prvok (
True) a počiatočnú hodnotu (True):True && True = True - Potom vezme druhý prvok (
False) a výsledok z kroku 1:False && True = False - Potom vezme prvý prvok (
True) a výsledok z kroku 2:True && False = False
Výsledok: False.
foldr jednoducho ide od konca zoznamu k začiatku a v každom kroku skombinuje jeden prvok s doterajším výsledkom.
op (konvencia pre názov parametra)¶
op nie je vstavaná funkcia ani kľúčové slovo — podobne ako go (pozri cheat-sheet.md) je to len zaužívaný názov pre parameter, ktorý je sám funkciou (skratka od "operation"). Používa sa najmä pri funkciách vyššieho rádu, keď chceš parametru dať zmysluplnejšie meno než f.
forEach :: [a] -> (a -> b) -> [b]
forEach (x:xs) op = op x : forEach xs op
forEach [] _ = []
forEach [1, 2, 3] (*2) = [2, 4, 6]
Tu op zastupuje funkciu, ktorú forEach dostane ako druhý argument (v príklade (*2)) a aplikuje ju na každý prvok zoznamu.
acc (konvencia pre názov parametra)¶
acc nie je vstavaná funkcia, ale zaužívaný názov pre medzivýsledok, ktorý sa nesie cez rekurziu (skratka od "accumulator"). Na začiatku dostane počiatočnú hodnotu a v každom kroku rekurzie sa aktualizuje.
sumList :: [Int] -> Int
sumList xs = go 0 xs
where
go acc [] = acc
go acc (x:xs) = go (acc + x) xs
sumList [1, 2, 3, 4] = 10
Krok po kroku: acc začína na 0, potom sa postupne pripočítava každý prvok — 0+1=1, 1+2=3, 3+3=6, 6+4=10 — a keď dôjde na koniec zoznamu ([]), vráti sa jeho finálna hodnota.
foldl¶
foldl :: (b -> a -> b) -> b -> [a] -> b
To isté ako foldr, len začína od začiatku zoznamu.
Ako sa to počíta, krok po kroku na foldl (&&) True [True, False, True]:
- Počiatočná hodnota (
True) + prvý prvok (True):True && True = True - Výsledok z kroku 1 + druhý prvok (
False):True && False = False - Výsledok z kroku 2 + tretí prvok (
True):False && True = False
Výsledok: False (tu to vyšlo rovnako ako pri foldr, pretože && nezáleží na poradí).
Prečo na poradí niekedy záleží: skús to isté s - namiesto &&, na [1, 2, 3]:
foldr (-) 0 [1, 2, 3] = 2 -- začína od konca: 3, 2, 1
foldl (-) 0 [1, 2, 3] = -6 -- začína od začiatku: 1, 2, 3
Iné poradie spracovania prvkov → iný výsledok, keď operácia nie je komutatívna (ako -).
takeWhile¶
takeWhile :: (a -> Bool) -> [a] -> [a]
Berie prvky zo začiatku zoznamu, pokiaľ podmienka platí; skončí pri prvom prvku, kde podmienka nesedí (aj keby ďalšie prvky sedeli).
dropWhile¶
dropWhile :: (a -> Bool) -> [a] -> [a]
Opak takeWhile — zahodí prvky zo začiatku, pokiaľ podmienka platí, a vráti zvyšok (vrátane prvku, na ktorom sa podmienka prvýkrát nesplnila).
Quicksort¶
Klasická rekurzívna implementácia pomocou filter a pattern matchingu — nie vstavaná funkcia, ale typický príklad rekurzie nad zoznamami.
quicksort :: Ord a => [a] -> [a]
quicksort [] = []
quicksort (p:xs) = quicksort smaller ++ [p] ++ quicksort larger
where
smaller = filter (< p) xs
larger = filter (>= p) xs
quicksort [3, 1, 4, 1, 5, 9, 2, 6] = [1, 1, 2, 3, 4, 5, 6, 9]
take + nekonečné zoznamy¶
take :: Int -> [a] -> [a]
Haskell je lazy — zoznam ako [1..] (nekonečná postupnosť), repeat x (nekonečné opakovanie) alebo cycle xs (nekonečné opakovanie zoznamu) sa nevyhodnotí celý naraz. take n z neho vyberie len prvých n prvkov, a to je presne to, čo sa reálne vypočíta.