Skip to content

← Späť na Docs - FP

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.

maximum [3, 7, 2, 9, 4] = 9

reverse

reverse :: [a] -> [a]

Otočí poradie prvkov v zozname.

reverse [1, 2, 3] = [3, 2, 1]

concat

concat :: [[a]] -> [a]

Zoberie zoznam zoznamov a spojí ich do jedného zoznamu.

concat [[1, 2], [3, 4], [5]] = [1, 2, 3, 4, 5]

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.

concatMap (\x -> [x, x]) [1, 2, 3] = [1, 1, 2, 2, 3, 3]

replicate

replicate :: Int -> a -> [a]

Vytvorí zoznam, kde sa daná hodnota zopakuje n-krát.

replicate 3 '*' = "***"

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.

zipWith (+) [1, 2, 3] [10, 20, 30] = [11, 22, 33]

unlines

unlines :: [String] -> String

Spojí zoznam reťazcov do jedného textu, kde je za každým pridaný znak nového riadku (\n).

unlines ["prvy", "druhy", "treti"]
-- vypíše:
-- prvy
-- druhy
-- treti

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

show 42 = "42"
show [1, 2, 3] = "[1,2,3]"

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.

10 `mod` 2 = 0    -- párne
7  `mod` 2 = 1    -- nepárne

Nájdenie všetkých párnych čísel zo zoznamu:

filter (\x -> x `mod` 2 == 0) [1..10] = [2, 4, 6, 8, 10]

Haskell má na to aj priamo vstavané funkcie even/odd, ktoré robia presne toto (interne používajú mod):

filter even [1..10] = [2, 4, 6, 8, 10]
filter odd  [1..10] = [1, 3, 5, 7, 9]

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ú:
    map (\x -> digitToInt x) xs   -- zbytočne
    map digitToInt xs             -- lepšie
    
  • 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"):
    map (\x -> x * 2) xs   -- funguje
    map (* 2) xs           -- kratšie a bežnejšie
    

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

[x * x | x <- [1..5]] = [1, 4, 9, 16, 25]

Čítaj to takto: "pre každé x zo zoznamu [1..5] vypočítaj x * x".

Môžeš pridať aj podmienku (filter) za čiarkou:

[x | x <- [1..20], x `mod` 3 == 0] = [3, 6, 9, 12, 15, 18]

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

[x + y | x <- [1, 2], y <- [10, 20]] = [11, 21, 12, 22]

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

[c | c <- "Haskell", c `elem` "aeiou"] = "ae"

putStr — histogram

putStr :: String -> IO ()

Vypíše text na obrazovku bez nového riadku na konci (na rozdiel od putStrLn, ktorý riadok automaticky odriadkuje).

putStr "ahoj"
putStr " svet"
-- vypíše: ahoj svet   (na jednom riadku)

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.

True && True = True
True && False = False
(3 > 1) && (5 > 2) = 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]).

[] :: [Int]

++ (spájanie zoznamov)

(++) :: [a] -> [a] -> [a]

Spojí dva zoznamy za sebou do jedného.

[1, 2] ++ [3, 4] = [1, 2, 3, 4]

!! (indexovanie)

(!!) :: [a] -> Int -> a

Vráti prvok zoznamu na danej pozícii (indexované od 0). Na indexe mimo rozsahu spadne s chybou.

[10, 20, 30] !! 1 = 20

head :: [a] -> a

Vráti prvý prvok zoznamu. Na prázdnom zozname spadne s chybou (partial function).

head [1, 2, 3] = 1

tail

tail :: [a] -> [a]

Vráti zoznam bez prvého prvku. Na prázdnom zozname spadne s chybou (partial function).

tail [1, 2, 3] = [2, 3]

last

last :: [a] -> a

Vráti posledný prvok zoznamu. Na prázdnom zozname spadne s chybou (partial function).

last [1, 2, 3] = 3

init

init :: [a] -> [a]

Vráti zoznam bez posledného prvku. Na prázdnom zozname spadne s chybou (partial function).

init [1, 2, 3] = [1, 2]

length

length :: [a] -> Int

Vráti počet prvkov zoznamu.

length [1, 2, 3, 4] = 4

null

null :: [a] -> Bool

Zistí, či je zoznam prázdny. Rýchlejšie ako length xs == 0, pretože nemusí prejsť celý zoznam.

null [] = True
null [1] = False

reverse

reverse :: [a] -> [a]

Otočí poradie prvkov v zozname.

reverse [1, 2, 3] = [3, 2, 1]

drop

drop :: Int -> [a] -> [a]

Zahodí prvých n prvkov zoznamu a vráti zvyšok. Opak take.

drop 2 [1, 2, 3, 4, 5] = [3, 4, 5]

elem

elem :: Eq a => a -> [a] -> Bool

Zistí, či sa daný prvok nachádza v zozname.

elem 3 [1, 2, 3] = True
elem 9 [1, 2, 3] = False

filter

filter :: (a -> Bool) -> [a] -> [a]

Vráti nový zoznam obsahujúci iba prvky, pre ktoré daná podmienka (predikát) vráti True.

filter even [1, 2, 3, 4, 5, 6] = [2, 4, 6]

fst

fst :: (a, b) -> a

Vráti prvý prvok dvojice (tuple).

fst (1, "a") = 1

snd

snd :: (a, b) -> b

Vráti druhý prvok dvojice (tuple).

snd (1, "a") = "a"

map

map :: (a -> b) -> [a] -> [b]

Aplikuje zadanú funkciu na každý prvok zoznamu a vráti zoznam výsledkov.

map (*2) [1, 2, 3] = [2, 4, 6]

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.

lookup "b" [("a", 1), ("b", 2)] = Just 2
lookup "c" [("a", 1), ("b", 2)] = Nothing

words

words :: String -> [String]

Rozdelí reťazec na zoznam slov podľa medzier (whitespace).

words "ahoj ako sa mas" = ["ahoj", "ako", "sa", "mas"]

unwords

unwords :: [String] -> String

Spojí zoznam slov späť do jedného reťazca, oddelené medzerou (opak words).

unwords ["nieco", "nieco", "nieco"] = "nieco nieco nieco"

: (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 : [].

1 : [2, 3] = [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).

(show . (+1)) 5 = "6"
-- (+1) 5 = 6, potom show 6 = "6"

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.

foldr (+) 0 [1, 2, 3] = 6

Ako sa to počíta, krok po kroku na foldr (&&) True [True, False, True]:

  1. Najprv vezme posledný prvok (True) a počiatočnú hodnotu (True): True && True = True
  2. Potom vezme druhý prvok (False) a výsledok z kroku 1: False && True = False
  3. 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.

foldl (+) 0 [1, 2, 3] = 6

Ako sa to počíta, krok po kroku na foldl (&&) True [True, False, True]:

  1. Počiatočná hodnota (True) + prvý prvok (True): True && True = True
  2. Výsledok z kroku 1 + druhý prvok (False): True && False = False
  3. 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).

takeWhile (< 5) [1, 2, 3, 4, 5, 6, 1, 2] = [1, 2, 3, 4]

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

dropWhile (< 5) [1, 2, 3, 4, 5, 6, 1, 2] = [5, 6, 1, 2]

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.

take 5 [1..] = [1, 2, 3, 4, 5]
take 5 (repeat 7) = [7, 7, 7, 7, 7]
take 10 (cycle [1, 2, 3]) = [1, 2, 3, 1, 2, 3, 1, 2, 3, 1]

Top