Az előző rész tartalmából...

Transcription

1 Az előző rész tartalmából...

2 [2..26]

3 Programozás burritokkal [3..26]

4 Programozás monádokkal programstruktúrálás type IO a = World -> (a, World) -- putstr :: String -> IO () -- getline :: IO String (>>=) :: IO a -> (a -> IO b) -> IO b (f >>= g) w = (g x) w where (x, w ) = f w (>>) :: IO a -> IO b -> IO b f >> g = f >>= \_ -> g main :: IO () main = putstr "Provide me a word> " >> getline >>= \s -> if (s == reverse s) then putstr "A palindrome." else putstr "Not a palindrome." [4..26]

5 Programozás monádokkal a Monad típusosztály {-# LANGUAGE KindSignatures #-} -- Control.Monad class Monad (m :: * -> *) where return :: a -> m a (>>=) :: m a -> (a -> m b) -> m b (>>) :: m a -> m b -> m b x >> f = x >>= \_ -> f fail :: String -> m a fail s = error s (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> (a -> m c) f >=> g = \x -> f x >>= g Monádtörvények: return >=> f === f f >=> return === f (f >=> g) >=> h === f >=> (g >=> h) + run függvény [5..26]

6 Programozás monádokkal a do szintaktika Átírási szabályok: do { e1; e2 } --> e1 >> do { e2 } do { p <- e1; e2 } --> e1 >>= \x -> case x of p -> do { e2 } _ -> fail "error" do { let p = e1; e2 } --> let p = e1 in do { e2 } do { e } --> e Például: do { do x <- f; x <- f f >>= \x -> y <- g; y <- g g >>= \y -> z <- h; --> z <- h --> h >>= \z -> let t = (x,y,z); let t = (x,y,z) let t = (x,y,z) in return t return t return t } [6..26]

7 Intermezzo

8 Applicative...?! Prelude> :load Identity.hs [1 of 1] Compiling Main ( Identity.hs, interpreted ) Identity.hs:6:10: Warning: Identity is an instance of Monad but not Applicative - this will become an error in GHC 7.10, under the Applicative-Monad Proposal. Ok, modules loaded: Main. Minden Monad ideális esetben Applicative Functor: class Functor (f :: * -> *) where -- Data.Functor fmap :: (a -> b) -> f a -> f b -- Control.Applicative class (Functor f) => Applicative (f :: * -> *) where pure :: a -> f a (<*>) :: f (a -> b) -> f a -> f b instance (Monad m) => Functor m where f fmap x = pure f <*> x instance (Monad m) => Applicative m where pure x = return x af <*> ax = do { f <- af; x <- ax; return (f x) } [8..26]

9 Következő felvonás

10 A State monád (intuíció) type State s a = s -> (a, s) -- (s -> (a, s)) -> (a -> (s -> (b, s))) -> (s -> (b, s)) (>>=) :: State s a -> (a -> State s b) -> State s b (x >>= f) s = (f x ) s where (x, s ) = x s -- a -> (s -> (a, s)) return :: a -> State s a (return x) s = (x, s) -- s -> (s, s) get :: State s s (get) s = (s, s) -- s -> ((), s) put :: s -> State s () (put x) s = ((), x) -- (s -> (a, s)) -> s -> (a, s)) runstate :: State s a -> s -> (a, s)) runstate f s = f s [10..26]

11 A State monád (definíció) -- Control.Monad.State data State s a = S (s -> (a, s)) runstate :: State s a -> s -> (a, s) runstate (S f) x = f x instance Monad (State s) where return x = S (\s -> (x,s)) x >>= f = S (\s -> let (x, s ) = runstate x s in runstate (f x ) s ) get :: State s s get = S (\s -> (s, s)) put :: s -> State s () put x = S (\_ -> ((), x)) [11..26]

12 A State monád (példa) data Tree a = Node a (Tree a) (Tree a) Leaf deriving Show numbertree :: (Eq a) => Tree a -> Tree Int numbertree t = fst (runstate (numbertreem t) []) numbertreem :: (Eq a) => Tree a -> State [a] (Tree Int) numbertreem Leaf = return Leaf numbertreem (Node x lt rt) = do table <- get let (table, pos) = case (Data.List.findIndex (== x) table) of put table lt <- numbertreem lt rt <- numbertreem rt return (Node pos lt rt ) Just i -> (table, i) _ -> (table ++ [x], length table) [12..26]

13 A Writer monád (egyszerűsített) -- Control.Monad.Writer data Writer w a = W (a, w) runwriter :: (Monoid w) => Writer w a -> (a, w) runwriter (W (x, w)) = (x, w) instance (Monoid w) => Monad (Writer w) where return x = W (x, mempty) x >>= f = W (let (x, w) = runwriter x in let (x, w ) = runwriter (f x ) in (x, w <> w )) tell :: (Monoid w) => w -> Writer w () tell x = W ((), x) censor :: (Monoid w) => (w -> w) -> Writer w a -> Writer w a censor f (W (x, w)) = W (x, f w) [13..26]

14 A Writer monád (Monoid) -- Data.Monoid class Monoid (a :: *) where mempty :: a mappend :: a -> a -> a (<>) :: (Monoid a) => a -> a -> a -- GHC 7.6+ (<>) = mappend Monoidtörvények: mempty <> x === x x <> mempty === x x <> (y <> z) === (x <> y) <> z mconcat === foldr (<>) mempty Például: instance Monoid [a] where mempty = [] mappend = (++) -- data Sum a = Sum a instance (Num a) => Monoid (Sum a) where mempty = Sum 0 (Sum x) mappend (Sum y) = Sum (x + y) [14..26]

15 A Writer monád (példa) gcdwithlog :: Int -> Int -> (Int, [String]) gcdwithlog x y = runwriter (censor reverse (gcdwithlogm x y)) gcdwithlogm :: Int -> Int -> Writer [String] Int gcdwithlogm x y y == 0 = do tell ["Finished with " ++ show x] return x gcdwithlogm x y = do result <- gcdwithlogm y (x mod y) let msg = show x ++ " mod " ++ show y ++ " = " ++ show (x mod y) tell [msg] return result [15..26]

16 Monádtranszformátorok

17 Motiváció Monádok kombinációja countentries :: FilePath -> K () countentries path = f path 0 where f p n = do deepestreached <- get when (deepestreached < n) (put n) c <- liftio (System.Directory.getDirectoryContents p) let contents = filter ( notelem [".", ".."]) c tell [(p, length contents)] form_ contents (\name -> do let newname = p ++ "/" ++ name isdir <- liftio (System.Directory.doesDirectoryExist newname) maxdepth <- ask when (isdir && (n < maxdepth)) (f newname (n + 1))) type S = Int type C = Int type K = ReaderT C (StateT S (WriterT [(FilePath,Int)] IO)) runstack :: K a -> Int -> IO ((a,s),[(filepath,int)]) runstack k max = runwritert (runstatet (runreadert k c) s) where (s, c) = (0, max) [17..26]

18 Monádok rétegelése (stacking) [18..26]

19 Részletek A MonadTrans és MonadIO osztályok -- Control.Monad.Trans class MonadTrans (t :: (* -> *) -> * -> *) where lift :: Monad m => m a -> t m a Transzformátortörvények: lift. return === return lift (x >>= f) === lift x >>= (lift. f) Az IO esetén ellenben: -- Control.Monad.IO.Class class Monad m => MonadIO (m :: * -> *) where liftio :: IO a -> m a instance MonadIO IO where liftio m = m Adaptált törvények: liftio. return === return liftio (x >>= f) === liftio x >>= (liftio. f) [19..26]

20 A ReaderT transzformátor (egyszerűsített) {-# LANGUAGE KindSignatures, TypeFamilies, FlexibleContexts #-} class (Monad m) => MonadReader (m :: * -> *) where type EnvType m -- "associated type (synonym)" ask :: m (EnvType m) data ReaderT e m a = RT (e -> m a) runreadert :: ReaderT e m a -> e -> m a runreadert (RT t) e = t e type Reader e = ReaderT e Identity runreader :: Reader e a -> e -> a runreader m x = runidentity (runreadert m x) instance (Monad m) => Monad (ReaderT e m) where return x = lift (return x) x >>= f = RT (\e -> do x <- runreadert x e runreadert (f x ) e) [20..26]

21 A ReaderT transzformátor (egyszerűsített, folytatás) instance MonadTrans (ReaderT e) where lift m = RT (\e -> m) instance (Monad m) => MonadReader (ReaderT e m) where type EnvType (ReaderT e m) = e -- ask :: (ReaderT e m) e ask = RT (\e -> return e) instance (MonadState m) => MonadState (ReaderT e m) where type StateType (ReaderT e m) = StateType m -- get :: m (StateType m) get = lift get -- put :: (StateType m) -> m () put s = lift (put s) instance (MonadWriter m) => MonadWriter (ReaderT e m) where type WriterType (ReaderT e m) = WriterType m -- tell :: (WriterType m) -> m () tell w = lift (tell w) -- censor :: (WriterType m -> WriterType m) -> m a -> m a censor f m = RT (\e -> do let m = runreadert m e censor f m ) instance (MonadIO m) => MonadIO (ReaderT e m) where liftio m = lift (liftio m) [21..26]

22 A StateT transzformátor (egyszerűsített) class (Monad m) => MonadState m where type StateType m get :: m (StateType m) put :: (StateType m) -> m () data StateT s m a = ST (s -> m (a, s)) runstatet :: StateT s m a -> s -> m (a, s) runstatet (ST t) s = t s type State s = StateT s Identity runstate :: State s a -> s -> (a, s) runstate m x = runidentity (runstatet m x) instance (Monad m) => Monad (StateT s m) where return x = ST (\s -> return (x, s)) x >>= f = ST (\s -> do (x, s ) <- runstatet x s runstatet (f x ) s ) [22..26]

23 A StateT transzformátor (egyszerűsített, folytatás) instance MonadTrans (StateT s) where lift m = ST (\s -> do x <- m return (x, s)) instance (Monad m) => MonadState (StateT s m) where type StateType (StateT s m) = s get = ST (\s -> return (s,s)) put s = ST (\_ -> return ((),s)) instance (MonadReader m) => MonadReader (StateT s m) where type EnvType (StateT s m) = EnvType m ask = lift ask instance (MonadWriter m) => MonadWriter (StateT s m) where type WriterType (StateT s m) = WriterType m tell w = lift (tell w) censor f m = ST (\s -> do let m = runstatet m s censor f m ) instance (MonadIO m) => MonadIO (StateT s m) where liftio m = lift (liftio m) [23..26]

24 A WriterT transzformátor (egyszerűsített) class (Monoid (WriterType m), Monad m) => MonadWriter m where type WriterType m tell :: (WriterType m) -> m () censor :: (WriterType m -> WriterType m) -> m a -> m a data WriterT w m a = WT (m (a,w)) runwritert :: WriterT w m a -> m (a, w) runwritert (WT m) = m type Writer a = WriterT a Identity runwriter :: Writer w a -> (a, w) runwriter m = runidentity (runwritert m) instance (Monoid w, Monad m) => Monad (WriterT w m) where return x = WT (return (x, mempty)) x >>= f = WT (do (x, w) <- runwritert x (x, w ) <- runwritert (f x ) return (x, w <> w )) [24..26]

25 A WriterT transzformátor (egyszerűsített, folytatás) instance (Monoid w) => MonadTrans (WriterT w) where lift m = WT (do x <- m return (x, mempty)) instance (Monoid w, MonadState m) => MonadState (WriterT w m) where type StateType (WriterT w m) = StateType m get = lift get put s = lift (put s) instance (Monoid w, MonadReader m) => MonadReader (WriterT w m) where type EnvType (WriterT w m) = EnvType m ask = lift ask instance (Monoid w, Monad m) => MonadWriter (WriterT w m) where type WriterType (WriterT w m) = w tell w = WT (return ((), w)) censor f m = WT (do (x, w) <- runwritert m return (x, f w)) instance (Monoid w, MonadIO m) => MonadIO (WriterT w m) where liftio m = lift (liftio m) [25..26]

26 A monádrétegek sorrendje (példa) stack :: (MonadState Int m, MonadWriter [String] m, MonadError String m) => m () stack = do r <- get tell ["Hello!"] throwerror "Error!" tell ["Value: " ++ show r] put (r + 1) type A = ErrorT String (WriterT [String] (State Int)) type B = StateT Int (WriterT [String] (Either String)) stacka :: A () stacka = stack stackb :: B () stackb = stack runa = runstate (runwritert (runerrort stacka)) 0 runb = runwritert (runstatet stackb 0) [26..26]