Aula 9

Maybe no hackage

O Just a é o "valor correto" e Nothing é o valor errado. Eu gostaria de poder continuar processando um Maybe enquanto o valor esta "correto"

fmap (*5) (Just 6)

fmap (*5) Nothing

Um container é um functor se ele implementa a função fmap

:t fmap

:t map

fmap é muito parecido com o map, ou na verdade, o container lista é um functor!!

O fmap aplica uma função que funciona no tipo de interno para dentro do container

Se voce esta definindo o container (tipo), vc precisa definir como o fmap funciona nele. O fmap do maybe é

instance Functor Maybe where
   fmap _ Nothing = Nothing
   fmap f (Just something) = Just (f something)

Containers contem apenas um tipo, mas podem conter múltiplos dados daquele tipo.

Uma lista [a] contem apenas dados do tipo a, mas pode conter muitos desses dados

Um dicionário Map ch v contem apenas dados do tipo ch e v, mas pode ter múltiplos dados desse tipo

o fmap, como o map, tem que aplicar a função de fora em todos os dados de dentro.

data Dic ch v = Vazio | No ch v (Dic ch v) (Dic ch v)
-- dicionario implmentado como uma ABB

instance Functor Dic where
   fmap _ Vazio = Vazio
   fmap f (No ch v ae ad) = No ch  (f v) (fmap f ae) (fmap f ad)

Eu gostaria que:

(Just 7) + (Just 3) ==> Just 10

(Just 7) + Nothing ==> Nothing

Um container é um applicative se ele permite jogar uma função binaria que funciona no tipo interno para dentro do container

(+) <$> (Just 7) <*> (Just 3)

(+) <$> (Just 7) <*> Nothing

o <$> é um operador que combina uma funcao (do tipo interno do container) e um container e retorna "algo" O <*> é outro operador que combina o algo com o container e retorna um container com os elementos internos sendo o resultado da aplicação da função binaria.

A lista é também é um applicative:

(+) <$> [1,2,3,4] <*> [10,100]

[11,101,12,102,13,103,14,104]

Um container é uma monad se ele implementa (entre outras coisas) a função infixa >>= (operador de bind) que remove o dado de um container para aplica-lo em uma função que esta esperando o tipo interno e retorna um container com o resultado

:t (>>=)

(Just 8) >>= (\x -> if odd x then Nothing else (Just (2*x+1)) )

Listas são também monadas,que são combinadas com uma operacao de concatenação

[1,2,3] >>= (\x -> if odd x then [x] else [2*x])
[1,4,3]

Monad define também a função return que coloca um valor dentro do container

mae :: Pessoa -> Maybe Pessoa
pai :: Pessoa -> Maybe Pessoa

avomaternal p = ((return p) >>= mae) >>= pai
avamaternal p =  (return p) >>= mae >>= mae

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

avomaternal p = do m <- mae p
                   pai m

A <- retira o valor da monada. A notação do Parece um programa "tradicional" com o <- como operador de atribuição

filtra f l = do x <- l
                if f x then [x] else []

filtra' f l = [ x | x <- l, f x]

filtra odd [1,2,3,4]
filtra'odd [1,2,3,4]