FP / Vstup, výstup a monády

Ako robiť I/O v čistých funkciách?

Príklad

substractInputs :: Int
substractInputs = getInt - getInt
  where
    getInt :: Int
    getInt = read (getLine)

Bude to fungovať?

Ako to vyriešiť?

Nemôžem vrátiť výsledok I/O

Môžem vrátiť samotnú I/O akciu

Myšlienkový experiment

const action1 = putStrLn("Hello,");
const action2 = putStrLn("world!");
const main = () => return [action1, action2];

Vstupy?

const action1 = getLine();
const action2 = putStrLn("Hello, ...!");
const main = () => return [action1, action2];

Lambda

const action1 = getLine();
const action2 = (name) => putStrLn(`Hello, ${name}!`);
const main = () => return [action1, action2];

Spojenie

const action1 = getLine();
const action2 = (name) => putStrLn(`Hello, ${name}!`);
const main = () => action1.then(action2);

Viac vstupov

const action1 = getLine();
const action2 = getLine();
const action3 = (x, y) => {
    const result = parseInt(x) - parseInt(y);
    return putStrLn(`Result: ${result}`);
};
const main = () => action1.then(
    (x) => action2.then((y) => action3(x, y)));

Niečo to pripomína?

Promise

IO

Namiesto vykonania operácie, vrátime ju ako výsledok.

main :: IO ()
main = putStrLn "Hello, world!"

Typ IO a

IO bez hodnoty

putChar :: Char -> IO ()
putStr :: String -> IO ()
putStrLn :: String -> IO ()
print :: Show a => a -> IO ()

Typ ()

• Unit
• Jediná hodnota: ()

IO produkujúce hodnotu

getChar :: IO Char
getLine :: IO String
getContents :: IO String

Príklad

main :: IO ()
main = putStr (histogram values)

Spojiť viacero akcií

(>>) :: IO a -> IO b -> IO b

main = putStrLn "Hello, what is your name?"
      >> getLine
      >> putStrLn ("Hello, world!")

Bind

(>>=) :: IO a -> (a -> IO b) -> IO b

main = putStrLn "Hello, what is your name?"
      >> getLine
      >>= \name -> putStrLn ("Hello, " ++ name ++ "!")

Return

return :: a -> IO a

Príklad

substractInputs :: IO Int
substractInputs =
    getInt
    >>= \ x -> getInt
    >>= \ y -> return (x - y)
  where
    getInt :: IO Int
    getInt = getLine >>= \ line -> return (read line)

do notácia

substractInputs :: IO Int
substractInputs = do
    x <- getInt
    y <- getInt
    return (x - y)
  where
    getInt :: IO Int
    getInt = getLine >>= return . read

main = putStrLn "Hello, what is your name?"
      >> getLine
      >>= \name -> putStrLn ("Hello, " ++ name ++ "!")

main = do
    putStrLn "Hello, what is your name?"
    name <- getLine
    putStrLn ("Hello, " ++ name ++ "!")

main = putStrLn "Hello, what is your name?"
      >> getLine
      >>= \name -> putStrLn ("Hello, " ++ name ++ "!")

main = do {
    putStrLn "Hello, what is your name?";
    name <- getLine;
    putStrLn ("Hello, " ++ name ++ "!")
}

IO a ostatný kód

• Každá funkcia obsahujúca vstupno-výstupné operácie, musí mať typ IO a
• Každá funkcia, ktorá využíva takúto funkciu, musí mať typ IO a

Dizajn aplikácií

• Vstup a výstup iba na vonkajšej úrovni
• Vnútorné úrovne — čisté funkcie
• Clean architecture

Monády

Čo je monáda?

Monáda je monoid v kategórii endofunktorov

Poďme na to inak

Príklad

studentStatus :: String -> String
studentStatus name = lookup status statusNames
  where
    status = lookup id statuses
    id = lookup name studentIDs

Problém: Maybe

Riešenie

studentStatus :: String -> Maybe String
studentStatus name =
    case lookup name studentIDs of
        Just id -> case lookup id statuses of
            Just status -> lookup status statusNames
            Nothing -> Nothing
        Nothing -> Nothing

Ako to zjednodušiť?

>>=
vieme preťažiť!

Použijeme >>=

studentStatus :: String -> Maybe String
studentStatus name =
        lookup name studentIDs
    >>= \ id -> lookup id statuses
    >>= \ status -> lookup readableStatus status

Alebo inak

studentStatus :: String -> Maybe String
studentStatus name = do
    id <- lookup name studentIDs
    status <- lookup id statuses
    lookup readableStatus status

Monáda

• IO je iba špeciálny prípad Monády

class  Monad m  where
    (>>=)   :: m a -> (a -> m b) -> m b
    (>>)    :: m a -> m b -> m b
    return  :: a -> m a

Maybe

instance  Monad Maybe  where
    (Just x) >>= k  = k x
    Nothing  >>= _  = Nothing
    return          = Just

Either

instance Monad (Either e) where
    Left  l >>= _  = Left l
    Right r >>= k  = k r
    return         = Right

• Right — výsledok
• Left — správa o chybe

Zoznamy

instance Monad []  where
    xs >>= f  = concat (map f xs)
    return x  = [x]

• Každý krok môže mať viacero výsledkov
• Výpočet všetkých možností

Ďalšie príklady

• State
• Parsing
• Exceptions

• Operácie nad monádami

Analógia

• Preťažovanie ;

Java

• >>= — flatMap()
• return — of()
• Stream aj Optional

JavaScript

• >>= — then()
• return — Promise.resolve()

Zákony monád

• Ľavá identita: return a >>= h = h a
• Pravá identita: m >>= return = m
• Asociativita: (m >>= g) >>= h = m >>= (\x -> g x >>= h)

Alebo ešte inak

Aplikácia funkcie na hodnotu

square 2
4

Aplikácia funkcie na hodnotu v zozname

map square [2]
[4]

Vieme to zovšeobecniť?

Funktor

fmap square [2]
➜ [4]

fmap square (Just 2)
➜ Just 4

fmap square Nothing
➜ Nothing

Funktor

class Functor f where
    fmap :: (a -> b) -> f a -> f b
    (<$) :: a -> f b -> f a

(<$>) = fmap

Aj funkcia je Funktor

instance Functor ((->) r) where
    fmap f g = f . g

let squareDouble = fmap square (*2)
squareDouble 5
➜ 100

Applicative

• Zabalená hodnota aj funkcia

Just square <*> Just 2
➜ Just 4

 [(*2), (+3)] <*> [1, 2, 3]
➜ [2, 4, 6, 4, 5, 6]

Princíp

• Functor (fmap, <$>) aplikuje funkciu na zabalenú hodnotu
• Applicative (<*>) aplikuje zabalenú funkciu na zabalenú hodnotu
• Monad (>>=) aplikuje funkciu produkujúcu zabalenú hodnotu na zabalenú hodnotu