Capítulo 5 - Polimorfismo Paramétrico e Classes de Tipos

Polimorfismo Paramétrico

 Definição: É a capacidade de funções e tipos de serem definidos genericamente,

operando sobre qualquer tipo. Isso elimina a necessidade de duplicar código para
diferentes tipos de dados.

 Como funciona:

o Tipos genéricos são definidos usando variáveis de tipo (a, b, etc.).

o O Haskell aplica o tipo correto automaticamente em tempo de compilação.

o Isso promove a reutilização e abstração do código.

 Aplicação: Use funções que não dependem de um tipo específico.

Exemplo 1 - Função identidade:

identidade :: a -> a
identidade x = x
-- Uso:
identidade 5 -- Retorna: 5
identidade "Haskell" -- Retorna: "Haskell"

Exemplo 2 - Reverter listas genéricas:

reverte :: [a] -> [a]

reverte [] = []
reverte (x:xs) = reverte xs ++ [x]
-- Uso:
reverte [1,2,3] -- Retorna: [3,2,1]
reverte "abc" -- Retorna: "cba"

Classes de Tipos

 Definição: São como interfaces que definem um conjunto de operações que podem ser
implementadas por diferentes tipos.

 Mecanismo:

o Declara-se uma classe de tipos com as operações que ela suporta.

o Tipos específicos podem implementar essas operações tornando-se instâncias

da classe.

o Exemplo: Eq é uma classe que define a operação (==) para verificar igualdade.
 Exemplo 3 - Definindo igualdade para um tipo personalizado:

data Cor = Vermelho | Azul | Verde

instance Eq Cor where
Vermelho == Vermelho = True
Azul == Azul = True
Verde == Verde = True
_ == _ = False
-- Uso:
Vermelho == Azul -- Retorna: False
Azul == Azul -- Retorna: True

Polimorfismo por Sobrecarga

 Um tipo pode ser polimórfico, mas restringido a uma classe específica. Por exemplo:

o Uma função pode aceitar qualquer tipo, contanto que ele seja parte da classe
Eq.

Exemplo prático: Função genérica com restrição da classe Show

exibir :: Show a => a -> String

exibir x = "O valor é: " ++ show x
-- Uso:
exibir 42 -- Retorna: "O valor é: 42"
exibir "Haskell" -- Retorna: "O valor é: Haskell"

Exemplo com múltiplas restrições

somaEExibe :: (Num a, Show a) => a -> a -> String

somaEExibe x y = "A soma é: " ++ show (x + y)
-- Uso:
somaEExibe 10 5 -- Retorna: "A soma é: 15"

Monoides

 Definição: Estruturas algébricas que têm:

1. Uma operação binária associativa.

2. Um elemento neutro.

 Monoides são úteis para combinar valores de forma consistente.

Exemplo 4 - Monoide com listas:

instance Monoid [a] where

mempty = []
mappend = (++)
-- Uso:
mappend [1, 2] [3, 4] -- Retorna: [1, 2, 3, 4]
mempty ++ [5] -- Retorna: [5]
Resumo Geral

 Capítulo 5: Introduz polimorfismo e classes de tipos, mostrando como generalizar

código e criar interfaces reutilizáveis.

 Exemplo:
 identidade x = x -- Funciona com números, textos, o que você
quiser!

Capítulo 6 - Teoria das Categorias

Categorias

 Definição: Uma abstração matemática composta por:

1. Objetos (que podem ser pensados como tipos em Haskell).

2. Morfismos (funções que conectam esses objetos/tipos).

 Regras:

1. Todo objeto tem um morfismo identidade que o mapeia para ele mesmo.

2. Os morfismos podem ser compostos para formar novos morfismos.

Identidade

Exemplo 1:

id :: a -> a
id x = x
-- Uso:
id 42 -- Retorna: 42
id "Oi" -- Retorna: "Oi"

Composição

Exemplo 2:
dobro :: Int -> Int
dobro x = 2 * x
triplo :: Int -> Int
triplo x = 3 * x
sextuplo :: Int -> Int
sextuplo = dobro . triplo
-- Uso:
sextuplo 2 -- Retorna: 12

Aplicação em Haskell

 Objetos: Tipos de dados.

 Morfismos: Funções que mapeiam um tipo para outro.

 Propriedades:
 o Identidade: id é a função que retorna o mesmo valor.

o Composição: (.) combina duas funções.

Por que é importante?

 A Teoria das Categorias é a base para abstrações como funtores e mônadas, que
ajudam a estruturar e organizar código de maneira lógica e segura.

Resumo Geral:

 Capítulo 6: Explica a Teoria das Categorias como base para as abstrações do Haskell,
com foco em identidade e composição.

 Exemplo:
 id x = x -- "Você é você mesmo."

Capítulo 7 - Funtores

Definição

 Um funtor é uma estrutura que pode ser mapeada. Ele permite aplicar funções a
valores encapsulados em um contexto (como listas ou tipos opcionais) sem retirar o
valor do contexto.

Como funciona?

 Em Haskell, funtores são representados pela classe Functor, que define a operação
fmap:

o fmap :: (a -> b) -> f a -> f b

o f é o contexto, como uma lista ([a]) ou um Maybe a.

Exemplo 1 - Usando fmap com listas:

fmap (+1) [1, 2, 3] -- Retorna: [2, 3, 4]

Exemplo 2 - Usando fmap com Maybe:

fmap (*2) (Just 3) -- Retorna: Just 6
fmap (*2) Nothing -- Retorna: Nothing

Propriedades

1. Preserva identidade: fmap id é equivalente a id no contexto.

2. Preserva composição: fmap (f . g) é equivalente a fmap f . fmap g.

Exemplo 3 - Criando um Funtor para Caixa:

data Caixa a = Vazia | Contem a

instance Functor Caixa where
fmap _ Vazia = Vazia
fmap f (Contem x) = Contem (f x)
-- Uso:
fmap (+1) (Contem 5) -- Retorna: Contem 6
fmap (+1) Vazia -- Retorna: Vazia

Funtores Aplicativos

 Uma extensão dos funtores, onde funções também podem estar em um contexto. Eles
permitem aplicar funções encapsuladas a valores encapsulados.

Exemplo 4:

pure (+) <*> Just 3 <*> Just 5 -- Retorna: Just 8

pure (+) <*> Nothing <*> Just 5 -- Retorna: Nothing

Funtores Contravariantes

 Variantes de funtores que permitem mapear funções "ao contrário". Em vez de

transformar o valor no contexto, eles transformam a função que será usada.

Exemplo prático: Functor Contravariante para Predicate Um Predicate a é uma função que
retorna um Bool para algum valor do tipo a.
import Data.Functor.Contravariant
newtype Predicate a = Predicate (a -> Bool)
instance Contravariant Predicate where
contramap f (Predicate p) = Predicate (p . f)
-- Uso: Criando um predicado para verificar se um número é par
isEven :: Predicate Int
isEven = Predicate even
-- Ajustando o predicado para trabalhar com o comprimento de strings
lengthIsEven :: Predicate String
lengthIsEven = contramap length isEven
-- Testando
runPredicate :: Predicate a -> a -> Bool
runPredicate (Predicate p) x = p x
runPredicate lengthIsEven "Haskell" -- Retorna: True (comprimento de
"Haskell" é 7, que não é par)
runPredicate lengthIsEven "Fun" -- Retorna: False (comprimento de
"Fun" é 3, que é ímpar)

Explicação:

1. isEven verifica se um número é par.

2. contramap ajusta o predicado para usar o comprimento de uma string como entrada
ao invés de números diretamente.

3. lengthIsEven agora é um predicado para strings, funcionando com base em seus

comprimentos.
Resumo Geral:

 Capítulo 7: Apresenta funtores como estruturas que permitem manipular valores em

contextos, e os estende com funtores aplicativos e contravariantes.

Exemplo:

fmap (*2) (Just 3) -- Multiplica o número dentro da "caixa" e vira Just 6.