Programowanie funkcyjne

Tomasz Brengos

Wykład 4

Basics/Lecture04.hs

Przypomnienie definicji z teorii kategorii. Trójkę

(m, join, return)

nazywamy monadą, jeśli m jest funktorem oraz:

join   :: m (m a)   -> m a
return ::  a        -> m a

spełniają znane aksjomaty dla mnożenia i jedności monady:

join . (fmap join)   = join . join
join . (fmap return) = join . return = id

W Haskellu bardziej przydatne jest składanie w kategorii Kleisli dla danej monady:

(>=>) :: (Monad m) => (a -> m b) -> (b -> m c) -> a -> m c

Wyraźmy >=> za pomocą join!

f >=> g = join. fmap g . f

Okazuje się, że częściej W Haskellu używana jest operacji bind:

(>>=) :: (Monad m) => m a -> (a -> m b) -> m b

Definicja instancji Monad zawiera:

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

f >=> g = \x -> ( f x >>= g )

x >>= g = (const x >=> g) ()

Definicja instancji monady Maybe:

instance Monad Maybe where
  Nothing >>= _ = Nothing
  Just x  >>= f = f x

  return = Just

Pobawmy się kodem. Funkcje head i tail w Haskellu są częściowe. Możemy je poprawić:

head' :: [a] -> Maybe a
head' []     = Nothing
head' (x:xs) = Just x

tail' :: [a] -> Maybe [a]
tail' []     = Nothing
tail' (x:xs) = Just xs

Używając head' i tail' napisać funkcję która zwraca 3ci element z wejściowej listy:

third :: [a] -> Maybe a