Haskel - Cheat Sheet¶
Zdroj: pages.kpi.fei.tuke.sk/kpi/fp/lecture-notes/cheat-sheet.html
Navigation¶
- 1.1 Základy
- 1.1.1 Komentáre
- 1.1.2 Konštanty
- 1.1.3 Použitie operátorov a funkcií
- 1.1.4 Základné operátory a funkcie
- 1.1.5 Importy modulov
- 1.2 Definícia funkcie
- 1.2.1 Definícia funkcie viacerými rovnicami
- 1.2.2 Podmienené výrazy (strážcovia)
- 1.2.3 Lokálne funkcie
- 1.2.4 Viac rovníc vs. strážcovia
- 1.2.5 Pomocná funkcia
go - 1.2.6 Výraz
case - 1.3 Typy
- 1.4 Funkcie pre prácu so znakmi
- 1.5 N-tice
- 1.6 Zoznamy
- 1.6.1 Základné funkcie pre prácu s zoznamami
- 1.7 Porovnávanie vzorov (pattern matching)
- 1.8 Funkcie vyššieho rádu
- 1.8.1 Anonymne funkcie
- 1.8.2 Kompozícia funkcií
- 1.8.3 Funkcie vyššieho rádu pre prácu s zoznamami
- 1.8.4 Generovanie zoznamu:
unfoldr - 1.9 Ďalšie operácie nad zoznamami
- 1.10 Množinové abstrakcie
- 1.11 Vlastné údajové typy
- 1.12 Typové synonyma
- 1.13 Typové triedy
- 1.14 Vstupno-výstupné operácie
- 1.15 Spracovanie chýb
- 1.16 Príklad:
sumDigitstromi spôsobmi
1.1 Základy¶
1.1.1 Komentáre¶
1.1.2 Konštanty¶
Čísla: 1``3.14``-42
Znaky: 'a'
Reťazce: "Hello\n"
Pravdivostné hodnoty: True``False
1.1.3 Použitie operátorov a funkcií¶
Infixné operátory:
Aplikácia funkcie je zapisovaná v prefixnom tváre pričom argumenty sú oddelené len medzerami. Ak sú argumenty tiež výrazmi, môže byť potrebné uzavrieť ich do zátvoriek.
Aplikácia funkcie má vyššiu prioritu ako operátory, takže:
Funkciu s dvoma argumentmi je možné zapísať infixne, ak jej názov uzavrieme do spätných apostrofov (backtickov):
Záporné číslo ako argument funkcie musí byť v zátvorkách, inak ho Haskell chápe ako odčítanie:
1.1.4 Základné operátory a funkcie¶
Aritmetické: +``-``*``/``div (celočíselné delenie) mod (modulo) abs (absolútna hodnota) signum (znamienko)
Reláčne: >``<``==``>=``<=``/= (nerovnosť) min``max
Logické: &&``||``not
Ďalšie: even``odd``truncate``round``sqrt
Podiel a zvyšok naraz – výsledkom je dvojica (podiel, zvyšok):
quotRem :: Integral a => a -> a -> (a, a)
divMod :: Integral a => a -> a -> (a, a)
(q, r) = 123 `quotRem` 10 -- q = 12 (číslo bez poslednej cifry)
-- r = 3 (posledná cifra)
Rozdiel sa prejaví iba pri záporných číslach: quot/rem zaokrúhľujú k nule, div/mod smerom dole.
1.1.5 Importy modulov¶
Funkcie mimo štandardného Prelude je potrebné importovať. Všetky import musia byť na začiatku súboru, pred akoukoľvek definíciou (inak parse error on input 'import').
import Data.Char (digitToInt, toUpper) -- len vybrané funkcie
import Data.List (unfoldr)
import Control.Exception (throwIO)
import Data.List -- celý modul
1.2 Definícia funkcie¶
Vo všeobecnosti:
Názvy parametrov sú oddelené iba medzerami. Príklad:
Názvy funkcií, premenných a parametrov musia začínať malými písmenami.
1.2.1 Definícia funkcie viacerými rovnicami¶
Funkcia môže byť definovaná viacerými rovnicami. Pritom ak namiesto mena parametra dáme konkrétnu hodnotu, daná rovnica sa použije iba pre zadanú hodnotu parametra. Rovnice sa prechádzajú zhora dole až kým sa nenájde taká, ktoré sa môže použiť (teda buď je tam rovnaká hodnota alebo meno premennej).
1.2.2 Podmienené výrazy (strážcovia)¶
Rôzny spôsob výpočtu hodnoty funkcie v závislosti od splnenia podmienky. Podmienky sú vyhodnocované zhora dole a výraz, ktorý zodpovedá prvej splnenej podmienke sa použije na výpočet výsledku. Špeciálna konštanta otherwise má hodnotu True a predstavuje podmienku, ktorá je vždy splnená.
1.2.3 Lokálne funkcie¶
Lokálne funkcie môžu byť definované vo vnútri inej funkcie a môžu byť použité pre rozdelenie výpočtu na časti.
Pomocou let je možné definovať lokálne funkcie aj vo výraze.
1.2.4 Viac rovníc vs. strážcovia¶
Oba zápisy môžu robiť to isté, ale fungujú inak:
-- Viac rovníc (pattern matching) – porovnáva priamo hodnotu/štruktúru argumentu
safeDivide :: Int -> Int -> Maybe Int
safeDivide _ 0 = Nothing
safeDivide x y = Just (x `div` y)
-- Strážcovia (|) – vyhodnocujú logické podmienky (True/False)
safeDivide :: Int -> Int -> Maybe Int
safeDivide x y
| y == 0 = Nothing
| otherwise = Just (x `div` y)
- Viac rovníc – keď testuješ konkrétne hodnoty (
0,[],Nothing,Just x) alebo rozkladáš štruktúru. - Strážcovia – keď potrebuješ zložitejšie podmienky (
y < 0,x > y,even x).
Pozor na pokrytie všetkých prípadov – napr. pri | n > 0 = ... | otherwise = 0 padnú aj záporné čísla do otherwise:
sumDigits :: Int -> Int
sumDigits n | n < 0 = sumDigits (-n)
| n > 0 = n `mod` 10 + sumDigits (n `div` 10)
| otherwise = 0
1.2.5 Pomocná funkcia go¶
go nie je kľúčové slovo, ale zaužívaný názov lokálnej (väčšinou rekurzívnej) pomocnej funkcie. Hlavná funkcia pripraví vstup a go robí samotnú rekurziu.
1.2.6 Výraz case¶
Pattern matching priamo vo výraze (nie len v hlavičke funkcie).
describe :: Maybe Int -> String
describe m = case m of
Nothing -> "nic"
Just x -> "hodnota " ++ show x
1.3 Typy¶
Každá hodnota a funkcia má priradený typ, ktorý sa používa pri kontrole správnosti programu. Pritom typ väčšinou nie je nutné zadávať explicitne v kóde, lebo prekladač Haskellu ho dokáže odvodiť automaticky.
Na zistenie typu hodnoty alebo funkcie je možné použiť špeciálny príkaz v interaktívnom interpretátore (typy jednotlivých parametrov funkcie a výsledku sú oddelené operátorom ->).
ghci> :t 'a'
'a' :: Char
ghci> :t not
not :: Bool -> Bool
ghci> :t (&&)
(&&) :: Bool -> Bool -> Bool
Typová definícia funkcie má tvar názov :: typ a uvádza sa zvyčajne pred definíciou hodnoty funkcie:
Názvy typov vždy začínajú veľkými písmenami.
Typ funkcie môže tiež obsahovať typové premenné, ktoré môžu zodpovedať ľubovoľnému typu. Napríklad výsledkom funkcie id je jej argument, pričom typ výsledku je rovnaký ako typ argumentu.
Názvy typových premenných musia začínať malými písmenami. Definícia môže tiež obsahovať obmedzenie určujúce, že typová premenná môže zodpovedať len typom z určitej triedy, napríklad numerickým typom (trieda Num), typom, pre ktoré je definovaná rovnosť (trieda Eq), alebo usporiadanie (trieda Ord).
ghci> :t (+)
(+) :: Num a => a -> a -> a
ghci> :t min
min :: Ord a => a -> a -> a
ghci> :t (==)
(==) :: Eq a => a -> a -> Bool
1.4 Funkcie pre prácu so znakmi¶
ord :: Char -> Int -- ASCII kód
chr :: Int -> Char
isSpace, isAlpha, isDigit :: Char -> Bool
isUpper, isLower :: Char -> Bool
digitToInt :: Char -> Int
intToDigit :: Int -> Char
toUpper, toLower :: Char -> Char
1.5 N-tice¶
Jednoduchá údajová štruktúra spájajúca n hodnôt, ktoré môžu byť rôznych typov. Hodnoty sú uvedené v zátvorkách a oddelené čiarkami.
Typ n-tice má podobný zápis:
Pre 𝑛=2, teda pre dvojice, existujú funkcie pre prístup k jednotlivým hodnotám:
1.6 Zoznamy¶
Zoznam môže obsahovať ľubovoľný počet prvkov rovnakého typu. Syntax: [1, 2, 3]. Zoznam je možné skonštruovať pomocou prázdneho zoznamu ( nil) [] a operátoru cons:, ktorý slúži na pripojenie prvku k zoznamu:
Tieto dva výrazy ([] a :) sú dvoma konštruktormi typu zoznam.
1.6.1 Základné funkcie pre prácu s zoznamami¶
head :: [a] -> a -- Prvý prvok zoznamu
tail :: [a] -> [a] -- Všetko okrem prvého
length :: [a] -> Int -- Dlžka zoznamu
null :: [a] -> Bool -- Je zoznam prázdny?
(++) :: [a] -> [a] -> [a] -- Spájanie
(!!) :: [a] -> Int -> a -- n-tý prvok
take :: Int -> [a] -> [a]
drop :: Int -> [a] -> [a]
elem :: Eq a => a -> [a] -> Bool
last :: [a] -> a
init :: [a] -> [a]
reverse :: [a] -> [a]
1.7 Porovnávanie vzorov (pattern matching)¶
Namiesto názvu parametra funkcie môže byť uvedený jeho konštruktor, kde jednotlivé zložky sú označené premennými alebo sú znovu konštruktormi.
To znamená, že rovnaký zápis má na pravej strane rovnice význam konštrukcie štruktúry z jednotlivých hodnôt alebo výrazov a na ľavej strane naopak rozloženie štruktúry na jednotlivé zložky. Zároveň sa kontroluje či štruktúra aktuálneho argumentu funkcie zodpovedá vzoru štruktúry v zozname parametrov. Ak štruktúra nezodpovedá, prejde sa na ďalšiu rovnicu.
Napríklad zoznam má dva konštruktory, takže funkcie spracovávajúce zoznamy je prirodzené definovať pomocou dvoch rovníc.
Zložky štruktúry, ktoré nie sú používané na pravej strane rovnice je možné označiť pomocou _.
1.8 Funkcie vyššieho rádu¶
Funkcia vyššieho rádu je funkcia, ktorej parameter alebo výsledok je iná funkcia. V typovej definícii sa typ funkcie parameteru zapisuje v zátvorkách. V zozname parametrov sa zapisuje jednoducho meno parametra, ktoré je možne na pravej strane definície používať ako funkciu.
Pri aplikácií sa názov funkcie použije ako argument.
1.8.1 Anonymne funkcie¶
Anonymná funkcia (nazývaná tiež lambda) je funkcia definovaná ako súčasť výrazu. Všeobecná tvar:
Napríklad:
Použitie vo výraze:
1.8.2 Kompozícia funkcií¶
Operátor kompozície funkcií:
Kompozícia sa číta sprava doľava a umožňuje point-free zápis – bez uvedenia parametra:
-- s parametrom
sumDigits n = sum (map digitToInt (show (abs n)))
-- point-free: abs -> show -> map digitToInt -> sum
sumDigits = sum . map digitToInt . show . abs
-- -123 -> 123 -> "123" -> [1,2,3] -> 6
1.8.3 Funkcie vyššieho rádu pre prácu s zoznamami¶
map :: (a -> b) -> [a] -> [b]
filter :: (a -> Bool) -> [a] -> [a]
foldr :: (a -> b -> b) -> b -> [a] -> b
foldl :: (a -> b -> a) -> a -> [b] -> a
takeWhile :: (a -> Bool) -> [a] -> [a]
dropWhile :: (a -> Bool) -> [a] -> [a]
zip :: [a] -> [b] -> [(a,b)]
zipWith :: (a -> b -> c) -> [a] -> [b]
-> [c]
1.8.4 Generovanie zoznamu: unfoldr¶
Opak foldr – z počiatočného stavu vygeneruje zoznam. Funkcia kroku vracia Just (prvok, novýStav) (pokračuj) alebo Nothing (koniec).
digits :: Int -> [Int]
digits = unfoldr step
where
step 0 = Nothing -- STOP
step x = Just (r, q) -- pridaj r, pokračuj s q
where (q, r) = x `quotRem` 10
-- digits 123 == [3, 2, 1]
1.9 Ďalšie operácie nad zoznamami¶
-- Logické
and, or :: [Bool] -> Bool
any, all :: (a -> Bool) -> [a] -> Bool
-- Aritmetické
sum, product :: Num a => [a] -> a
-- Spájanie
concat :: [[a]] -> [a]
-- Reťazce
lines, words :: String -> [String]
unlines, unwords :: [String] -> String
1.10 Množinové abstrakcie¶
Jazyková konštrukcia pre definovanie zoznamov vychádzajúca z matematického zápisu pre zoznamy, napríklad:
{𝑥|𝑥∈ℕ,𝑥>1,𝑥≤20}
Všeobecný tvár:
Príklady:
Výsledkom použitia viacerých generátorov je vygenerovanie všetkých kombinácií.
1.11 Vlastné údajové typy¶
Štruktúra
Konštruktor sa môže používať na ľavej strane rovností pre získanie zložiek štruktúry a tiež na pravej strane pre konštruovanie štruktúry.
distance :: Point -> Point -> Float
distance (Point x1 y1) (Point x2 y2) = sqrt (abs (x2-x1) + abs (y2-y1))
1.11.1 Algebraický údajový typ¶
Údajový typ môže mať niekoľko konštruktorov.
data Bool = True | False
data Shape = Rectangle Double Double
| Square Double
| RTriangle Double Double
| Circle Double
1.11.2 Rekurzívne typy¶
1.11.3 Parametrizované údajové typy¶
-- Binárny strom s hodnotami ľubovoľného (rovnakého) typu
data Btree a = Leaf a
| Branch (Btree a) (Btree a)
1.11.4 Typ Maybe (hodnota, ktorá nemusí existovať)¶
V Haskelli neexistuje null. Namiesto toho sa používa štandardný typ:
Just x– výsledok existuje a je toxNothing– výsledok neexistuje
safeDivide :: Int -> Int -> Maybe Int
safeDivide _ 0 = Nothing
safeDivide x y = Just (x `div` y)
-- safeDivide 10 2 == Just 5
-- safeDivide 10 0 == Nothing
1.11.5 Typ Either (výsledok alebo chyba)¶
Podobné ako Maybe, ale namiesto Nothing nesie informáciu o chybe.
Left chyba– zlyhanie (napr. chybová správa)Right výsledok– úspech
divideSafe :: Int -> Int -> Either String Int
divideSafe _ 0 = Left "Delenie nulou!"
divideSafe x y = Right (x `div` y)
1.12 Typové synonyma¶
Zavedenie nového názvu pre typ.
type String = [Char]
type Point3D = (Double, Double, Double)
type Year = Int
type Amount = Int
type Record = (Year, Amount)
1.13 Typové triedy¶
Typová trieda definujú množinu funkcií, ktoré musia byť realizované pre typ, ak daný typ je inštanciou triedy. To umožňuje vytvárať funkcie, ktoré nie sú obmedzené na konkrétne typy, ale pracujú s celou triedou typov.
Definícia typovej triedy obsahuje typové definície funkcií. Môže tiež obsahovať aj štandardné realizácie týchto funkcií.
class Eq a where
-- Ak typ a je inštanciou triedy Eq
-- musia preň byť definované funkcie
(==) :: a -> a -> Bool
(/=) :: a -> a -> Bool
x /= y = not (x == y)
x == y = not (x /= y)
Inštancia typovej triedy je realizácia funkcií triedy pre konkrétny typ.
data Color = RGB Int Int Int
instance Eq Color where
(RGB r g b) == (RGB r' g' b') =
(r == r') && (g == g') && (b == b')
Dedičnosť inštancií:
data BStree a = Tip
| Bin a (BStree a) (BStree a)
-- Ak a je v triede Eq, potom (BStree a) je v Eq
instance Eq a => Eq (BStree a) where
Tip == Tip = True
(Bin x1 l1 r1) == (Bin x2 l2 r2) =
(x1 == x2) && (l1 == l2) && (r1 == r2)
Dedičnosť typových tried:
-- Typ a musí byť v Eq aby mohol byť v Ord
class Eq a => Ord a where
compare :: a -> a -> Ordering
(<), (<=), (>=), (>) :: a -> a -> Bool
max, min :: a -> a -> a
Uvedené príklady typových tried sú definované v štandardnej knižnici. Ďalšie štandardné typové triedy:
Num(aritmetické operácie+,-,*, …)Integral(celé číslaInt,Integer; operáciediv,mod,quotRem, …)Show(funkciashowpre prevod hodnoty na reťazec)
1.13.1 Automatické odvodenie inštancie¶
Pre niektoré štandardné typové triedy je možné inštanciu triedy odvodiť automaticky.
1.14 Vstupno-výstupné operácie¶
Vstupno výstupné operácie majú špeciálny typ IO a, ktorý znemožňuje ich miešanie s čisto funkcionálnym kódom.
putChar :: Char -> IO ()
putStr :: String -> IO ()
putStrLn :: String -> IO ()
print :: Show a => a -> IO () -- vypíše ľubovoľnú hodnotu (== putStrLn . show)
1.14.1 Funkcia main¶
Vstupný bod programu. Pomocou do sa píše viac IO operácií za sebou, let v do bloku definuje premenné (bez in).
main :: IO ()
main = do
let a = 3
b = 4
print (hypotenuse a b)
putStrLn ("Sucet cifier: " ++ show (sumDigits 123))
Spustenie (mimo GHCi, v termináli): runghc subor.hs
1.14.2 Vstup od používateľa¶
getLine :: IO String -- načíta jeden riadok ako text
read :: Read a => String -> a -- prevedie text na hodnotu (Int, Double, ...)
readLn :: Read a => IO a -- getLine + read v jednom
x <- akcia– vyberie výsledok z IO akcie (napr. to, čo používateľ napísal)let x = výraz– obyčajná (čistá) hodnota, bez IO- pri
read/readLntreba povedať typ (:: Int), inak Haskell nevie, na čo prevádzať
main :: IO ()
main = do
-- text
putStrLn "Zadaj meno:"
meno <- getLine
putStrLn ("Ahoj " ++ meno)
-- jedno číslo: getLine + read
putStrLn "Zadaj cislo:"
riadok <- getLine
let n = read riadok :: Int
print (sumDigits n)
-- jedno číslo: readLn (kratšie)
putStrLn "Zadaj rok:"
rok <- readLn :: IO Int
print (isLeapYear rok)
-- viac čísel na jednom riadku, napr. "3 4"
putStrLn "Zadaj dve cisla oddelene medzerou:"
riadok2 <- getLine
let [a, b] = map read (words riadok2) :: [Double]
print (hypotenuse a b)
Ak chceš výzvu a vstup na tom istom riadku (putStr namiesto putStrLn), treba vypísať buffer, inak sa text zobrazí až po zadaní vstupu:
import System.IO (hFlush, stdout)
main = do
putStr "Zadaj cislo: "
hFlush stdout
n <- readLn :: IO Int
print (n * 2)
1.15 Spracovanie chýb¶
1.15.1 Okamžitý pád programu: error¶
Ekvivalent throw new Error(...) bez try/catch. Kompilátor o chybe nevie, preto sa v čistom kóde používa len výnimočne.
divide :: Int -> Int -> Int
divide _ 0 = error "Delenie nulou nie je povolene!"
divide x y = x `div` y
-- divide 10 0 => *** Exception: Delenie nulou nie je povolene!
1.15.2 Chyba v návratovom type: Maybe / Either¶
Idiomatický spôsob – volajúci je nútený ošetriť oba prípady (pozri 1.11.4, 1.11.5):
main :: IO ()
main = case divideSafe 10 0 of
Left err -> putStrLn ("Chyba: " ++ err)
Right res -> putStrLn ("Vysledok: " ++ show res)
1.15.3 Výnimky v IO¶
Pri práci so súbormi, sieťou a pod. Výnimku je možné neskôr odchytiť cez catch alebo try.
import Control.Exception (throwIO)
loadData :: FilePath -> IO String
loadData path =
if null path
then throwIO (userError "Cesta nesmie byt prazdna!")
else readFile path
1.16 Príklad: sumDigits tromi spôsobmi¶
-- 1. Explicitná rekurzia (div / mod)
sumDigits :: Int -> Int
sumDigits n = go (abs n)
where
go 0 = 0
go x = x `mod` 10 + go (x `div` 10)
-- 2. Cez reťazec (show + digitToInt), point-free
import Data.Char (digitToInt)
sumDigits :: Int -> Int
sumDigits = sum . map digitToInt . show . abs
-- 3. Cez unfoldr + quotRem (bez prevodu na reťazec)
import Data.List (unfoldr)
sumDigits :: Int -> Int
sumDigits = sum . unfoldr step . abs
where
step 0 = Nothing
step x = Just (r, q)
where (q, r) = x `quotRem` 10