import Data.List ((!?)) -- Úloha 1.1 -- Definujte funkcie pre bezpečnú prácu s zoznamami: safeHead :: [a] -> Maybe a safeHead [] = Nothing safeHead (x:_) = Just x safeIndex :: [a] -> Int -> Maybe a safeIndex xs i = xs !? i -- V prípade, že zoznam je prázdny, alebo index je mimo rozsahu zoznamu, výsledok funkcií bude Nothing. -- Poznámka -- V knižnici Data.Maybe už existuje funkcia listToMaybe zodpovedajúca safeHead, a v Data.List je definovaný operátor !? zodpovedajúci safeIndex. -- Úloha 1.2 -- Rozšírte riešenie úlohy z minulého cvičenia o ďalšie funkcie: data LoanStatus = Available | Borrowed String -- meno osoby, ktorá si knihu požičala deriving (Eq, Show) data Book = Book { title :: String , author :: String , loanStatus :: LoanStatus } deriving (Eq, Show) library :: [Book] library = [ Book "Duna" "Frank Herbert" Available , Book "1984" "George Orwell" (Borrowed "Jana") , Book "Hobit" "J. R. R. Tolkien" (Borrowed "Peter") ] findBook :: String -> [Book] -> Maybe Book findBook t books = safeHead (filter hasTitle books) where hasTitle b = title b == t borrowerOf :: String -> [Book] -> Maybe String borrowerOf t books = case findBook t books of Nothing -> Nothing Just book -> case loanStatus book of Available -> Nothing Borrowed person -> Just person -- Úloha 1.3 -- Vieme pri borrowerOf rozlíšiť prípad, že kniha nie je v databáze alebo nie je vypožičaná? -- Nie. borrowerOf vráti Nothing v oboch prípadoch: keď kniha v databáze nie je, -- aj keď je dostupná. Rozlíšiť sa to dá cez Either: borrowerOf' :: String -> [Book] -> Either String String borrowerOf' t books = case findBook t books of Nothing -> Left "kniha neexistuje" Just book -> case loanStatus book of Available -> Left "kniha nie je vypozicana" Borrowed person -> Right person -- Uloha 2 -- Buď, alebo cieľ 1 -- Majme definované nasledovné typy reprezentujúce používateľský účet a rôzne dôvody zlyhania vytvárania účtu. data Account = Account { username :: String , password :: String } deriving (Eq, Show) data RegistrationError = EmptyUsername | PasswordTooShort Int | PasswordMismatch deriving (Eq, Show) -- Úloha 2.1 -- Definujte funkciu register pre registráciu používateľa. Funkcia dostane používateľské meno, heslo a zopakované heslo. Jej výsledkom bude buď vytvorený účet, alebo typ chyby pri jeho vytváraní. -- Nech pre účty platia tieto podmienky: -- používateľské meno nesmie byť prázdne, -- heslo musí mať aspoň 8 znakov, -- heslo a zopakované heslo sa musia zhodovať. register :: String -> String -> String -> Either RegistrationError Account register username passcode repeatedPasscode | null username = Left EmptyUsername | length passcode < 8 = Left (PasswordTooShort (length passcode)) | passcode /= repeatedPasscode = Left PasswordMismatch | otherwise = Right (Account username passcode) -- Uloha 3 -- Strom aritmetických výrazov -- Úloha 3.1 -- Definujte dátový typ pre reprezentáciu stromu aritmetických výrazov s operátormi +, - *, /, unárnym mínus, a číslami typu Double. data Expr = Num Double | Add Expr Expr | Sub Expr Expr | Mul Expr Expr | Div Expr Expr | Neg Expr deriving Show myExp = Add (Mul (Num 1) (Num 2)) (Sub (Num 3) (Num 4)) -- Úloha 3.2 -- Definujte funkciu pretty, ktorá vytvori textovú reprezentáciu výrazu (so zátvorkami). pretty :: Expr -> String pretty (Num n) = showNum n pretty (Neg n) = "(-" ++ pretty n ++ ")" pretty (Add a b) = "(" ++ pretty a ++ " + " ++ pretty b ++ ")" pretty (Sub a b) = "(" ++ pretty a ++ " - " ++ pretty b ++ ")" pretty (Mul a b) = "(" ++ pretty a ++ " * " ++ pretty b ++ ")" pretty (Div a b) = "(" ++ pretty a ++ " / " ++ pretty b ++ ")" -- celé čísla vypíše bez .0 (1.0 -> "1") showNum :: Double -> String showNum x | x == fromIntegral (round x :: Integer) = show (round x :: Integer) | otherwise = show x -- Príklad -- > pretty myExp -- "((1 * 2) + (3 - 4))" -- Úloha 3.3 -- Definujte funkciu eval, ktorá vypočíta zadaný výraz. eval :: Expr -> Double eval (Num x) = x eval (Add a b) = eval a + eval b eval (Sub a b) = eval a - eval b eval (Mul a b) = eval a * eval b eval (Div a b) = eval a / eval b eval (Neg a) = negate (eval a) -- Príklad -- > eval myExp -- 1.0 -- 4. Rekurzívne typy cieľ 2 -- Úloha 4.1 -- Definujte typ pre binárny strom, kde každý list stromu môže obsahovať hodnotu ľubovoľného typu. Ten je ale rovnaký pre všetky listy. data BTree a = Leaf a | Branch (BTree a) (BTree a) deriving Show myLittleTree = Branch (Branch (Leaf 1) (Branch (Leaf 2) (Leaf 3))) (Leaf 4) -- Poznámka -- Príklad podobného typu sme mali aj na prednáške. Ako sa odlišuje od typu definovaného tu? -- Na prednáške mal strom hodnoty v uzloch a prázdny list. -- Tu sú hodnoty iba v listoch (Leaf) a vetva (Branch) hodnotu nemá. -- Úloha 4.2 -- Definujte funkcie pre prácu s takýmto stromom: leafCount :: BTree a -> Int leafCount (Leaf _) = 1 leafCount (Branch l r) = leafCount l + leafCount r contains :: Eq a => a -> BTree a -> Bool contains y (Leaf x) = x == y contains y (Branch l r) = contains y l || contains y r -- v zadaní je Tree a, má byť BTree a mapTree :: (a -> b) -> BTree a -> BTree b mapTree f (Leaf x) = Leaf (f x) mapTree f (Branch l r) = Branch (mapTree f l) (mapTree f r) -- Úloha 4.3 -- Definujte funkciu sumBTree pre výpočet súčtu hodnôt uložených v strome. sumBTree :: BTree Integer -> Integer sumBTree (Leaf x) = x sumBTree (Branch l r) = sumBTree l + sumBTree r -- Príklad -- > sumBTree myLittleTree -- 10 -- Úloha 4.4 -- Definujte funkciu foldBtree, ktorá používa zadanú binárnu funkciu na výpočet hodnoty z údajov uložených v strome: foldBTree :: (a -> a -> a) -> BTree a -> a foldBTree _ (Leaf x) = x foldBTree f (Branch l r) = f (foldBTree f l) (foldBTree f r) -- Príklad -- > foldBTree (+) myLittleTree -- 10 ---------------------------------------------- -- main main :: IO () main = do putStrLn "--- 1.1: ---" print (safeHead [1,2,3]) print (safeIndex [1,2,3] 2) putStrLn "--- 1.2: ---" print (findBook "Duna" library) print (findBook "Dune" library) print (borrowerOf "1984" library) print (borrowerOf "Duna" library) putStrLn "--- 1.3: ---" print (borrowerOf' "1984" library) print (borrowerOf' "Duna" library) print (borrowerOf' "Dune" library) putStrLn "--- 2.1: ---" print (register "Jakub" "Janok123" "Janok123") print (register "" "Janok123" "Janok123") print (register "Jakub" "abc" "abc") print (register "Jakub" "Janok123" "Janok124") putStrLn "--- 3.1: ---" print myExp putStrLn "--- 3.2: ---" putStrLn (pretty myExp) putStrLn "--- 3.3: ---" print (eval myExp) putStrLn "--- 4.2: ---" print (leafCount myLittleTree) print (contains 3 myLittleTree) print (contains 7 myLittleTree) print (mapTree (*10) myLittleTree) putStrLn "--- 4.3: ---" print (sumBTree myLittleTree) putStrLn "--- 4.4: ---" print (foldBTree (+) myLittleTree)