Skip to content

← Späť na FP Labs

Cvičenie 7 – Vstup, výstup a monády

Useful Files

Riešenia úloh 2–5 sú v main.hs (spustenie: runghc main.hs values.txt), úloha 1 v hello.hs, úloha 6 v guess/app/Main.hs (balík guess.zip, spustenie: cd guess && cabal run).

  1. Základné pojmy
  2. Krok 1 – Spustiteľný program
  3. Krok 2 – Vstup a výstup
  4. Krok 3 – Validácia vstupu
  5. Krok 4 – Dotazník
  6. Krok 5 – Práca so súbormi
  7. Krok 6 – Balík a závislosti
  8. Prehľad príkazov

1. Základné pojmy

pojem význam
IO a akcia, ktorá komunikuje so svetom (klávesnica, obrazovka, súbor) a vráti hodnotu typu a
IO () akcia, ktorá nič užitočné nevracia (napr. putStrLn)
main :: IO () vstupný bod programu, spustí sa po štarte
do zápis akcií pod seba, vykonajú sa v poradí
x <- akcia vykoná akciu a jej výsledok uloží do x
let x = ... obyčajná (čistá) hodnota v do bloku, nič sa nevykonáva
pure x / return x akcia, ktorá nič nerobí, len vráti x

Čisté funkcie vs. IO:

  • čistá funkcia (String -> Int) pre rovnaký vstup vráti vždy to isté
  • getLine :: IO String vráti zakaždým niečo iné, preto je to akcia typu IO
  • hodnotu z IO vieš „vybaliť“ len vo vnútri inej IO akcie (cez <-)

Monáda (zjednodušene): typ, ktorého hodnoty sa dajú reťaziť operátorom >>=. IO je monáda a do je len krajší zápis >>=. Monády sú aj Maybe a zoznam.

operátor typ význam
>>= IO a -> (a -> IO b) -> IO b výsledok prvej akcie pošle do funkcie
>> IO a -> IO b -> IO b vykoná prvú akciu, výsledok zahodí, potom druhú

2. Krok 1 – Spustiteľný program

Úloha 1.1

Vytvorte hello.hs s funkciou main a skompilujte ho.

main :: IO ()
main = putStrLn "Hello world!"
$ ghc hello.hs        # vytvorí hello.exe (+ pomocné hello.o, hello.hi)
$ ./hello
Hello world!
  • ghc = kompilácia do spustiteľného súboru
  • runghc hello.hs = spustenie bez kompilácie (rýchle skúšanie)
  • ghci hello.hs = interaktívne, :r načíta zmeny

3. Krok 2 – Vstup a výstup

Úloha 2.1

Program sa opýta na meno a mesto a vypíše „Hello, <meno> from <mesto>!“. Použite getLine, putStrLn a let.

greetingV2 :: IO ()
greetingV2 = do
    putStrLn "Hello, what is your name?"
    name <- getLine
    putStrLn "Where do you live?"
    city <- getLine
    let greeting = "Hello, " ++ name ++ " from " ++ city ++ "!"
    putStrLn greeting
  • name <- getLine – prečíta riadok a uloží ho do name
  • let greeting = ... – zloží reťazec (čistý výpočet, preto let, nie <-)
  • v do bloku sa let píše bez in
Hello, what is your name?
Kamil
Where do you live?
Kosice
Hello, Kamil from Kosice!

Úloha 2.2

Prepíšte kód z do-notácie na operátor >>= (alebo naopak).

greetingV1 :: IO ()
greetingV1 = putStrLn "Hello, what is your name?"
      >> getLine
      >>= \name -> putStrLn "Where do you live?"
      >> getLine
      >>= \city ->
        let greeting = "Hello, " ++ name ++ " from " ++ city ++ "!"
        in putStrLn greeting
do >>=
putStrLn "..." (bez výsledku) putStrLn "..." >>
name <- getLine getLine >>= \name ->
let x = ... let x = ... in ...

Výstup je rovnaký ako pri 2.1. Lambda \name -> ... siaha až na koniec výrazu, preto name vidno aj v poslednom riadku.


4. Krok 3 – Validácia vstupu

Úloha 3.1

Implementujte getInt :: IO Int, ktorá sa pýta na celé číslo, kým nedostane platný vstup. Použite readMaybe z Text.Read.

import Text.Read (readMaybe)

getInt :: IO Int
getInt = do
    putStrLn "Hello, enter an Integer value:"
    line <- getLine
    case readMaybe line of
      Just number -> do
        putStrLn ("You entered Integer with value of " ++ show number)
        pure number
      Nothing -> do
        putStrLn "Invalid input! Please enter a valid number."
        getInt
  • readMaybe :: Read a => String -> Maybe a – Just číslo, alebo Nothing pri neplatnom vstupe (na rozdiel od read, ktorý spadne)
  • typ Int si readMaybe odvodí z typu getInt :: IO Int
  • Nothing → getInt zavolá samu seba = opakovanie (rekurzia namiesto cyklu)
  • pure number – zabalí Int do IO Int
Hello, enter an Integer value:
abc
Invalid input! Please enter a valid number.
Hello, enter an Integer value:
42
You entered Integer with value of 42

Kratšia verzia cez >>=:

getIntV2 :: IO Int
getIntV2 = putStrLn "Enter an int:" >> getLine >>= maybe getIntV2 pure . readMaybe
  • maybe náhrada f m – pri Nothing vráti náhrada (znova sa pýta), pri Just x vráti f x (pure x)
  • maybe getIntV2 pure . readMaybe – najprv readMaybe, potom maybe ... (skladanie .)

5. Krok 4 – Dotazník

Úloha 4.1

Definujte ask (opýta sa otázku, vráti odpoveď) a askAll (opýta sa všetky otázky, vráti zoznam odpovedí). Skúste rekurziu aj mapM.

questions :: [String]
questions =
    [ "What is your name?"
    , "What is your favourite language?"
    , "What would you like to build?"
    ]

ask :: String -> IO String
ask q = do
  putStrLn q
  getLine                     -- výsledok getLine je výsledok ask

Rekurzia:

askAllV2 :: [String] -> IO [String]
askAllV2 [] = pure []
askAllV2 (q:qs) = do
    ans  <- ask q
    rest <- askAllV2 qs
    pure (ans : rest)

Rovnaký vzor ako rekurzia nad zoznamom, len každý krok je IO akcia: opýtaj sa prvú, potom zvyšok, a spoj odpovede.

mapM:

askAll :: [String] -> IO [String]
askAll = mapM ask

mapM f xs = ako map, ale f vracia akciu. Akcie vykoná postupne a výsledky zozbiera do zoznamu.

What is your name?
Kamil
What is your favourite language?
Haskell
What would you like to build?
hru
["Kamil","Haskell","hru"]
funkcia typ výsledok
map ask questions [IO String] zoznam akcií, nič sa nevykoná
mapM ask questions IO [String] akcie sa vykonajú, výsledok sú odpovede
mapM_ putStrLn xs IO () vykoná, výsledky zahodí (na výpis)

6. Krok 5 – Práca so súbormi

Úloha 5.1

Upravte program na histogram tak, aby čítal čísla zo súboru zadaného ako argument príkazového riadku. Použite getArgs z System.Environment.

import System.Environment

loadValuesFromFile :: IO [Int]
loadValuesFromFile = do
    args <- getArgs
    case args of
        [fileName] -> do
            content <- readFile fileName
            let values = map read (words [if c == ',' then ' ' else c | c <- content]) :: [Int]
            pure values
        _ -> do
            putStrLn "Usage: runghc main.hs <filename>"
            pure []

main :: IO ()
main = do
    values <- loadValuesFromFile
    putStr (histogram values)
  • getArgs :: IO [String] – argumenty príkazového riadku (runghc main.hs values.txt → ["values.txt"])
  • [fileName] – vzor: práve jeden argument; _ – čokoľvek iné (žiadny alebo viac)
  • readFile :: FilePath -> IO String – celý obsah súboru ako reťazec
  • čiarky → medzery, words rozdelí na kúsky, map read ich prevedie na Int

Súbor values.txt: 6,2,12,10,7,3,0,12,...

$ runghc main.hs values.txt
10                     |
                     | |
                 |   | |
...
   0         5        10        15

Pozor – chyba v counts: rozsah [0 .. maximum nums - 1] vynechá najväčšie číslo (v values.txt je raz 18 a v histograme chýba):

> counts [0,1,1,3]
[1,2,0]                 -- chýba počet trojok

-- oprava:
counts nums = [length (filter (== d) nums) | d <- [0 .. maximum nums]]

> counts [0,1,1,3]
[1,2,0,1]

7. Krok 6 – Balík a závislosti

Úloha 6.1

Hra na hádanie čísla: počítač si myslí číslo, používateľ háda, po zlom odhade počítač povie „väčšie“ alebo „menšie“. Použite knižnicu random v cabal projekte.

Projekt:

mkdir guess && cd guess
cabal init                 # všetko predvolené

V guess.cabal:

    build-depends:    base ^>=4.20.2.0,
                      random
cabal update               # stiahne zoznam balíkov (stačí raz)
cabal run                  # skompiluje a spustí

Kód (guess/app/Main.hs):

module Main where
import System.Random
import Text.Read (readMaybe)

guess :: IO Int
guess = putStrLn "Enter an guessed number:" >> getLine >>= maybe guess pure . readMaybe

loop :: Int -> IO ()
loop sec = do
  ans <- guess
  case compare ans sec of
    LT -> do
        putStrLn "The number I'm thinking of is LARGER!"
        loop sec
    GT -> do
        putStrLn "The number I'm thinking of is SMALLER!"
        loop sec
    EQ -> putStrLn "YOU DID IT!"

main :: IO ()
main = do
    number <- randNumber 1 10
    loop number

randNumber :: Int -> Int -> IO Int
randNumber a b = getStdGen >>= \gen -> return (fst (randomR (a, b) gen))
  • guess – rovnaký vzor ako getIntV2 (pýta sa, kým nedostane číslo)
  • compare ans sec → LT / GT / EQ (z triedy Ord)
  • loop volá samu seba, kým sa netrafíš (rekurzia = cyklus)
  • randomR (a, b) gen – náhodné číslo z intervalu, vráti dvojicu (číslo, nový generátor); fst zoberie číslo
  • getStdGen – generátor je IO, lebo náhoda nie je čistá funkcia
Enter an guessed number:
5
The number I'm thinking of is LARGER!
Enter an guessed number:
8
The number I'm thinking of is SMALLER!
Enter an guessed number:
7
YOU DID IT!

8. Prehľad príkazov

príkaz čo robí príklad výstup
putStrLn vypíše reťazec + nový riadok putStrLn "ahoj" ahoj
putStr vypíše reťazec bez nového riadku putStr "ahoj" ahoj
print vypíše hodnotu cez show print [1,2] [1,2]
getLine prečíta riadok name <- getLine "Kamil"
<- vybalí výsledok akcie x <- getLine –
let (v do) čistá hodnota let s = "a" ++ "b" –
pure / return zabalí hodnotu do IO pure 5 5
>>= pošle výsledok ďalej getLine >>= putStrLn zopakuje vstup
>> reťazí, výsledok zahodí putStr "a" >> putStr "b" ab
readMaybe bezpečný prevod z reťazca readMaybe "42" :: Maybe Int Just 42
readMaybe "x" :: Maybe Int Nothing
read prevod z reťazca (pri chybe spadne) read "42" :: Int 42
maybe spracuje Maybe maybe 0 (+1) (Just 5) 6
mapM map pre akcie, zbiera výsledky mapM ask questions ["...", ...]
mapM_ map pre akcie, výsledky zahodí mapM_ print [1,2] 1 2
getArgs argumenty programu args <- getArgs ["values.txt"]
readFile obsah súboru readFile "values.txt" "6,2,12,..."
writeFile zapíše reťazec do súboru writeFile "a.txt" "ahoj" –
words rozdelí podľa medzier words "1 2 3" ["1","2","3"]
lines / unlines rozdelí / spojí riadky unlines ["a","b"] "a\nb\n"
compare porovnanie compare 3 7 LT
randomR náhodné číslo z intervalu randomR (1,10) gen (7, gen')

Top