Nome	TextoResumo
1	ALLEF KRISTIAN TAVARES ROCHA	# Resumo Semana 05 ## Semigroup Um tipo 'a' é um Semigroup se fornecer uma função associativa (<>) que permite combinar quaisquer dois valores do tipo 'a' em um, isto é: ( x <> y ) <> z = x <> ( y <> z ) (<>) :: a -> a -> a [mínima] sconcat :: NonEmpty a -> a stimes :: Integral b => b -> a -> a ## Monoid Um tipo 'a' é um Monoid se ele é um Semigroup, e se permite combinar um valor de um tipo 'a' e um elemento neutro (mempty), de modo que: x <> mempty = mempty <> x = a class Semigroup a => Monoid a where mempty :: a [mínima] mappend :: a -> a -> a mconcat :: [a] -> a Alguns tipos de dados podem ser visto como Monoid em mais de uma maneira, como em números (adição e multiplicação). Nesses casos definimos novos tipos e para esses criamos novas intâncias de Monoid (Sum e Product, respectivamente). ## Foldable Essa classe representa uma estrutura de dados que pode ser reduziada a um valor resultante, um elemento por vez. Instâncias podem ser automaticamente deviradas ativando DeriveFoldable, como o exemplo de árvore binária. {-# LANGUAGE DeriveFoldable #-} data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a) deriving Foldable class Foldable (t :: * -> *) where (foldMap :: Monoid m => (a -> m) -> t a -> m | foldr :: (a -> b -> b) -> b -> t a -> b) [mínima] ## Functor O tipo 'f' é um functor se ele provê uma função fmap que, dado quaisquer tipos 'a' e 'b', permite aplicação uma função do tipo (a -> b) para tornar um 'f a' em 'f b', preservando a estrutura de f. class Functor (f :: * -> *) where fmap :: (a -> b) -> f a -> f b [mínima] (<$) :: a -> f b -> f a
2	ANDRE RICCA YOSHIDA	Monoid: - No conceito algébrico, é um conjunto de valores associados a um operador binário - A estrutura básica dos monóides, é um Tipo, Operador e elemento neutro - Deve possuir duas propriedades, o operador é associativo: (a <> b) <> c = a <> (b <> c) - E quando for um monoide comutativo: a <> b = b <> a O Monoid possui alguns parametros nativos, que podem ser utilizados para se adaptar a necessidade do problema: mempty - Elemento neutro mappend - Operador binário associativo mconcat - Aplica sucessivamente operador binário e reduz até que tenha 1 elemento Um monoie livre, possui as propriedades de um monoide e nada além Semigroup: - Um tipo é um Semigroup se permite que uma função associativa (<>) combine quaisquer 2 valores de um tipo "a" em 1. A relação entre monoides e semigroups, é que o monoide espera receber um semigroup. Foldable e Fold: - Recebe um tipo paramétrico, exemplo: árvore, lista, matriz... É um tipo, que espera um outro tipo como parâmetro - A classe Foldable representa estruturas de dados que podem ser reduzidas a um valor de simples, um elemento por vez. - Ao declarar a classe foldable, temos em mãos, por padrão, diversas funções auxiliares, como: lenght, elem, maximum, minimum... - Exemplo utilizando foldmap: foldMap :: Monoid m => (a -> m) -> t a -> m Functors: - Basicamente, é um tipo de representaçõa funcional de diferentes tipos, que podem ser mapeadas. - Transforma o morfismo de um tipo inteiro em outro. - É definido como uma classe de tipos: class Functor f where fmap :: (a -> b) -> f a -> f b
3	ANGELO MAEDA ROJAS	Monoid A classe Monoid é definida como: class Monoid a Where mempty :: a mappend :: a -> a -> a mconcat :: [a] -> a mconcat = fold mappend mempty Onde mempty é a identidade do tipo a, por exemplo: o número 1 é identidade para o tipo int para operador (*). Esse operador é definido no mappend, caso não seja definido ele puxa o (<>) da classe Semigroup, se houver. A importância de Monoid está na generalização em como combinar uma lista de valores de um tipo que pertença a essa classe. Foldable Uma vez que uma classe é instanciada como Monoid pode-se usar funções da classe Foldable. Como, por exemplo, foldmap. foldmap Sum [1,2,3] => fold [Sum 1, Sum 2, Sum 3] => Sum 6 fold :: Monoid a => [a] -> a fold [] = mempty fold (x:xs) = x `mappend` fold xs Functors Functors são funções que fazem com que as funções de um certo tipo sejam aplicáveis a um tipo paramétrico contendo esse tipo. A classe functor é definida como class Functor f where fmap :: (a -> b) -> f a -> f b Ou seja, se eu já tenho uma função g: a -> b, e tenho um tipo paramétrico f, eu posso aplicar a função g em f a para obter f b. fmap obedece duas propriedades 1) fmap id = id 2) fmap f . fmap g = fmap (f.g) Podemos utilizar o operador <$> no lugar do fmap. (+1) <$> [1,2,3] é equivalente a fmap (+1) [1,2,3]
4	ANTONIO DUARTE CANTANHEDE NETO
7	BRUNA ISHIDA	Monoids são classes de tipos que possui as operações mais simples para associações com o conjunto de valores. Dentre essas operações, temos como exemplo: inteiros com o operador e elemento 0 ou strings com o operador ++ e o elemento String vazia: "". Elas tem a capacidade de abranger uma regra ou uma série de necessidades para que uma lista pertença a esta classe. A classe Foldable, pode ser utilizada com os Monoids e podemos utilizar de diversas funções auxiliare, como por exemplo: elem, null, maximum... Functors são funções que realizam alterações dentro de outras funções para que essas possam ser utilizadas por um tipo paramétrico que utiliza esse tipo. Ou seja, representa um tipo que pode sofrer um map. Um functor pode ser associado a um tipo que armazena valores de um outro tipo e que todas podem sofrer a implementação da função sem maiores problemas. É possível criar tipos de functors automaticamente por meios algébricos.
8	BRUNA MIRELLI XAVIER GONCALVES	Monoid São um conjunto de valores que tem um operador binário associativo e um elemento identidade. São definidos por meio de classe e instâncias. Foldable Monoids ajudam a generalizar a combinação de uma lista de valores de monoid. Podemos realizar a dobra de lista de monoids por meio de foldr e similares. Ou criar a classe de estuturas dobráveis "Foldable", que recebe um tipo paramétrico. E esta também declara funções aplicáveis de forma geral para esses tipos, que são definidas nas instâncias de Foldable. -> A classe Foldable possui funções auxiliares definidas por padrão como: null, length, elem, maximum, minimum, sum, product, toList. -> MapReduce: modelo de programação que funciona como o foldMap, realizando o map de forma distribuída e paralela, e o reduce funcionando como o fold. -> FoldMap pode ser usado para flattening, convertendo uma estrutura complexa para uma lista linear. Tipo de Dado Algébrico Fold Permite a simplificação da aplicação de várias funções a estruturas dobráveis. O tipo Fold é paramétrico recebendo o tipo de dado que a estrutura foldable recebida carrega, e também o tipo resultante da aplicação do fold. Functors São funções de alta ordem que recebem uma função de a para b e a faz ser aplicável a a e b enquanto tipos paramétricos. Ou seja, um Functor pode ser definido como um tipo paramétrico f que armazena a e mapeia a->b para f a -> f b por meio de fmap. Definindo Functors automaticamente A maior parte dos tipos paramétricos possuem uma instância de Functor. Aritmética segura com Functor É possível criar um tipo de dado para armazenar valores seguros para operações aritméticas para evitar erros, e generalizar suas aplicações por meio da definição uma instância de Functor para esse tipo.
9	BRUNO STORER FRANCO MARTINS	Essa semana aprendemos primeiramente sobre Monoids, que são estruturas algébricas com única operação binária e com um elemento neutro. Um exemplo seria a estrutura de Monoid para listas, mostrado a abaixo: instance Monoid [a] where mempty = [] mappend = (++) Nela vemos a definição do elemento neutro (lista vazia) e da operação de concatenação, ou seja, a forma que é descrito a operação binária única nesse caso. O Monoid é útil justamente por permitir uma generalização para combinar valores de uma classe, como combinar uma lista de valores da classe. Isso nos permite criar a classe Foldable, com as principais funções que generalizem possiveeis combinações de valores de uma mesma classe, mostrado abaixo com alguns exemplos de funções: class Foldable t where fold :: Monoid a => t a -> a foldMap :: Monoid b => (a -> b) -> t a -> b foldr :: (a -> b -> b) -> b -> t a -> b foldl :: (a -> b -> a) -> a -> t b -> a Existem varias aplicações para Foldable como o uso do mesmo em MapReduce, um algoritmo cuja a lógica é replicada em várias ferramentas de Big Data do mundo. Por fim, Functors são funções que fazem com que certas funções de um tipo possam ser aplicaveis a um tipo parametrico contendo esse tipo. Podemos definir um Functor da seguinte forma: class Functor f where fmap :: (a -> b) -> f a -> f b Através do functor podemos aplicar de maneira generia uma função f em qualquer tipo de dado, no caso utilizando fmap.
10	CAIO ARGENTINO DE OLIVEIRA
11	CAIO CESAR RAMALHO FOLLADOR
6	CAIO HENRIQUE DOS SANTOS RIBEIRO
12	DANIEL ESPINDOLA DA SILVA
14	DIEGO SOUSA SANTOS
54	DIOGO AKIO BALBONI MIYAKE	Monoides: Um monóide é uma operação associativa binária com uma identidade. Esta definição diz muito - se você está acostumado a separar as definições matemáticas. Um monóide é uma função que recebe dois argumentos e segue duas leis: associatividade e identidade. Associatividade significa que os argumentos podem ser reagrupados (ou reenquadrados ou reassociados) em ordens diferentes e dar o mesmo resultado, como adicional. Identidade significa que existe algum valor tal que, quando o passamos como entrada para nossa função, a operação se torna discutível e o outro valor é retornado, como quando adicionamos zero ou multiplicamos por um. Foldable: A classe do tipo Foldable fornece uma generalização da dobradura de lista (foldr e amigos) e operações derivadas dela para estruturas de dados arbitrárias. Além de ser extremamente útil, o Foldable é um ótimo exemplo de como os monoides podem ajudar a formular boas abstrações. Funtors: Functor em Haskell é um tipo de representação funcional de diferentes tipos que podem ser mapeados. É um conceito de alto nível de implementação de polimorfismo. De acordo com os desenvolvedores do Haskell, todos os Tipos, como Lista, Mapa, Árvore, etc., são a instância do Haskell Functor.
15	EDUARDO MACIEL DE SOUZA	Nessa semana aprendemos um pouco mais sobre Semigroup, Monoid, Foldable e Functor. Podemos definir uma instância de Semigroup para o nosso tipo, onde devemos definir a função do operador diamond <>, que deverá agir como uma operador de união entre valore do nosso tipo, assim podemos trabalhar mais facilmente com nosso tipo. Podemos também criar uma instancia de Monoid para nosso tipo, que necessáriamente usará a definição de <>, onde também devemos definir o caso vazio (operador neutro) do nosso tipo. Através dessa abstração podemos realizar funções de agregação do tipo fold muito mais facilmente pelo nosso tipo, além de possibilitar a execução em paralelo dessas operações. (Para o paralelismo, espera-se que a operação definida por <> seja associativa). Mesmo com tal abstração fornecida pelos Monoids, podemos ter dificuldades em realizar soluções mais elaboradas, como foldmaps com muitas condições. Para mais esse nível de abstração podemos criar um instância de Foldable (definindo no mínimo um fold ou foldMap), assim podemos ter várias funções úteis a partir da classe Foldable. Por último vimos sobre Functor, que fornecem mais um nível de abstração para o nosso tipo, permitindo realizar tarefas mais complexas em uma unica "passada" pela estrutura do nosso tipo e garantir um serviço "OK" quanto ao controle de excessões do nosso programa.
16	EUGENIO VERAS MARIA	Monoid Conjunto de valores associados a um operados binario e um elemento identidade Exemplo: instance Monoid Int where mempty = [] mappend x y = x + y mconcat [x] = foldr (+) mempty x Foldable A importancia de Monoid esta em combinar uma lista de valores de uma classe Para isso usamos foldables Functors São funções que fazem com que funcoes de um certo tipo sejam aplicaveis a um tipo contendo esse tipo
17	FABIO DOS SANTOS DE SOUZA
18	FELIPE PONSANO FRANKE
24	GABRIEL ALBANO SANTOS
25	GABRIEL BELLOMI MEALE	Monoid Um Monoid é um conjunto de valores associados a um operador binário associativo e um elemento identidade Para instanciar um novo monoid, basta seguir os padrões da classe: class Monoid a where mempty :: a mappend :: a -> a -> a mconcat :: [a] -> a mconcat = foldr mappend mempty Um monoid sempre é acompanhado de um Semigroup. Quando este não é definido automaticamente pelo tipo de Data criado associado ao Monoid, é necessário instancia-lo também, da seguinte forma: class Semigroup a where (<>) :: a -> a -> a sconcat :: NonEmpty a -> a stimes :: Integral b => b -> a -> a {-# MINIMAL (<>) #-} Foldable Generalização de como combinar uma lista de valores de um tipo que pertença a mesma classe: class Foldable t where fold :: Monoid a => t a -> a foldMap :: Monoid b => (a -> b) -> t a -> b foldr :: (a -> b -> b) -> b -> t a -> b foldl :: (a -> b -> a) -> a -> t b -> a Se o tipo de dado for um Monoid, é possível utilizar as generalizações da função Fold, como foldr. Functors São morfismos que transformam os morgismo de um tipo em outro. class Functor f where fmap :: (a -> b) -> f a -> f b Isto é, para um novo tipo, podemos criar uma nova instância de functors e, com isso, reutilizar funções que antes eram impossíveis. Isso funciona como se fosse um "de-para" de um novo tipo de dado. Além disso: fmap id = id fmap f . fmap g = fmap (f.g) Um caso interessante de se observar é o Maybe: instance Functor Maybe where fmap _ Nothing = Nothing fmap g (Just x) = Just (g x) Graças ao Functor de Maybe, agora é possível operar sobre um tipo de dado Maybe, por exemplo: (+1) <$> (Maybe 3)
19	GABRIEL DE MELLO FIALI	foldr Recebe um operador binário que recebe dois elementos, um valor inicial e uma lista com valores de tipo especificado. Semigroup Deriva dos princípios do foldr, para combinar elementos de um mesmo tipo. Não é possível criar duas instâncias de um mesmo tipo com diferentes operadores. Para contornar isso, pode-se utilizar os tipos Sum e Product, que são newtypes. Algumas instâncias de tipos: Any e All: comportamento similar a || e &&. First e Last: selecionam os valores da concatenação. Max e Min: exigem tipos ordenáveis se selecionam o maior ou menor valor. Monoid Extensão do Seimigroup. Conta com um elemento neutro, específico para cada instância de tipo; um operador binário, com implementação padrão; e um operador para concatenar listas. Respeita as propriedades de identidade, associatividade e pode respeitar a comutatividade dependendo da implementação. Foldable Utilizado também para outras estruturas além de listas (contêineres). Conta com uma implementação fold, foldMap e foldr. Ferramenta mais declarativa. Fold ExistentialQuantification: permite adicionar restrições para os tipos utilizados. Parametrizado em dois tipos, de entrada e saída; e definido em duas funções, uma que transforma a entrada em um monoid e outra, que transforma o mesmo na saída. Permite criar operadores para unir dois Folds, recebendo os mesmos como parâmetros. * uncurry: permite transformar uma função de dois parâmetros e gera uma saída numa função que recebe uma tupla. * Ajuste de precedência: necessário para garantir que o programa funcione corretamente, definindo a preferência de avaliação. Functor Generaliza a função map para outros tipos. Recebe uma função e a converte para o contexto de um tipo paramétrico específicado. Respeita as propriedades de identidade e associatividade na composição. Conta com um operador próprio <$>. Exemplo de uso: tipo SafeNum, para se encarregar de garantir segurança aritmética.
22	GABRIEL MENDONÇA FARIAS	Monoid é uma operação algébrica realizada através de um conjunto de valores associados por um operador binário. No Haskell, é implementado um elemento neutro (mempty), o operador binário assotiativo (mappend) e o mconcat, que aplicará o mappend em pares de elementos de uma lista até retornar um único elemento. Monoids livres, são instâncias que possuem propriedades exclusivamente de um monoid. Classe Foldable, é aplicada como fold, serve para a partir de vários valores, aplicar funções seguindo seus respectivos tipos e retornar um valor final de determinado tipo, o que auxilia na construção de programas e é amplamente associado ao Monoid e a função map. Functors são funções de alta ordem capazes de generalizar funções de forma a permitir que estas sejam aplicadas em outras com um valor de saída de um tipo paramétrico. Permitindo que se pegue um valor a e outro b, e através de uma função f →a retorne outra função f→ b.
23	GABRIEL MURAKAMI ALVES	Uma classe Monoid é composta por um operador binário associativo e uma elemento identidade. Por exemplo para a soma temos o operador (+) e o elemento identidade 0. Da mesma forma que para uma lista podemos ter o operador (++), de concatenação, e o elemento identidade []. A classe Foldable representa estruturas de dados que podem ser reduzidas/compiladas em uma sequência de valores um elemento de cada vez. Logo, podemos perceber a importância dos Monoids nesse caso, que basicamente serão parte da composição de uma classe Foldable. Um Functor é um tipo que dado uma função g: a -> b, e um tipo paramétrico f, eu consigo aplicar g pra f(a) e obter f(b). Por exemplo a função map já possui definido um fmap = map, uma vez que map tem a assinatura (a -> b) -> [a] -> [b]. Dessa forma podemos aplicar funções a um tipo paramétrico que possui o mesmo tipo dessa função.
30	GABRIEL RIOS SOUZA
21	GABRIEL ROSSETTO MIGLIORINI	Na álgebra, monóide é um conjunto de valores associados à um operador binário associativo e que contém um elemento identidade (ou neutro). Exemplos são: ~Conjunto dos Inteiros com operador de soma e o elemento neutro zero. ~Conjunto dos Inteiros com operador de multiplicação e o elemento neutro um. ~Uma string com o operador concatenação e o elemento neutro "". Em haskell, temos mempty, mappend e mconcat, onde: ~mempty declara o elemento neuro. ~mappend declara o operador binário. ~mconcat aplica o operador ao longo de uma lista. Um monoide livre é aquele que possui as propriedades de um monóide e nada além. Monoides são importantes pois definem, de modo geral, como combinar valores de um tipo que pertençam a essa classe. A classe Foldable representa estruturas de dados que podem ser reduzidas a um valor de resumo. As dobras associativas à direita (lazy) são um bom ajuste para dobras que entram em curto após o processamento inicial dos elementos da estrutura. As dobras associativas à esquerda (estritas) são um bom ajuste para redução com espaço eficiente. MapReduce é um modelo de programação, equivalente a função foldMap. Onde, map é realizado de modo paralelo enquanto Reduce equivale ao fold. Para esse modelo, o uso de monoid é obrigatório pois garante um resultado consistente.
28	GEORGE HARRISON ROCHA	• Semigroup (semigrupo) - Conjunto de valores dotado de um operador binário, sendo esse operador fechado para o conjunto; - Pode-se dizer que é um "Super conjunto" dos Monoids; - Em aula foi visto que em Haskell podemos ter instâncias de semigrupo para os tipos: - listas; - Maybe; - Sum; - Product; - Any e All; - First e Last; - Min e Max. • Monoid - Um Semigroup com um elemento neutro; - Para criar uma instância de Monoid precisa necessariamente ter uma instância de Semigroup. • Foldable - Generalização das funções fold; - Class Foldable: - Classe dos "dobráveis" - Define por padrão diversas classes: sum; product; null; length; elem; maximum; minimum; toList. • Functors - São funções que fazem com que as funções de um certo tipo sejam aplicáveis a um tipo paramétrico contendo esse tipo; - Em Haskell, um Functor é definido como um classe de tipos; - O operador fmap deve satisfazer as seguintes propriedades: - fmap id = id - fmap f = fmap g = fmap (f.g) - Em aula vimos os Functors de: - lista; - Maybe; - Árvores. - Podemos utilizar o operador <$> no lugar do fmap; - Em aula foi definido alguns Functors fundamentais, semelhante ao feito na aula sobre Álgebra dos Tipos.
29	GIANCARLO KAMI DELL ARINGA VIANA
58	GIOVANNA NOGUEIRA	• O semigroup é um combinador binário que pode ser aplicado para dois valores do mesmo tipo. • Any faz um papel de OR, enquanto All faz um papel de AND. • StimesMonoid auxilia em casos em que é preciso aplicar uma mesma operação, diversas vezes em um único elemento. • O Monoid é uma extensão do Semigroup que adiciona um elemento. Sua função mempty devolve um elemento neutro; mappend é um operador binário; mconcat que concatena (ou soma) os elementos recebidos. • O Folding nos permite generalizar as funções de agregação de dados para contêineres diversos. • Functors são funções que fazem com que funções de um certo tipo sejam aplicáveis a um tipo paramétrico que contem esse tipo.
27	GIOVANNI ALMEIDA DE SOUSA
32	GUILHERME FERREIRA GALDINO	Semigroup Representa um conjunto com um operacao binaria associativa. (<>) Superclasse dos Monoids. Monoid Conjunto de valores associados a um operador binario associativo (Semigroup) e um elemento identidade. class Monoid a where mempty :: a mappend :: a -> a -> a mconcat :: [a] -> a mconcat = foldr mappend mempty Uma instancia de Monoid precisa implementar o mempty e mappend instance Monoid [a] where mempty = [] mappend = (++) Foldable (Dobraveis) Com o conceito de Monoid, podemos desdobrar uma determinada estrutura utilizando a definicao de combinacao dos valores do tipo com o elemento identidade. fold :: Monoid a => [a] -> a fold [] = mempty fold (x:xs) = x `mappend` fold xs Com isso temos a seguinte classe Foldable class Foldable t where fold :: Monoid a => t a -> a foldMap :: Monoid b => (a -> b) -> t a -> b foldr :: (a -> b -> b) -> b -> t a -> b foldl :: (a -> b -> a) -> a -> t b -> a Exemplo: newtype Sum a = Sum a deriving (Eq, Ord, Show, Read) getSum :: Sum a -> a getSum (Sum x) = x instance Num a => Monoid (Sum a) where mempty = Sum 0 Sum x `mappend` Sum y = Sum (x+y) getSum (foldMap Sum [1..10]) = 55 No exemplo acima, a funcao retorna varios monoides, deixando a funcao foldMap ilegivel. Uma forma de melhorar isso seria criar um tipo de dado Fold. {-# LANGUAGE ExistentialQuantification #-} -- usar o forall data Fold i o = forall m . Monoid m => Fold (i -> m) (m -> o) -- forall garante que todos m sao monoids Temos o Fold formado por duas funcoes: uma que converte um valor para monoid e o outro o inverso. fold :: Fold i o -> [i] -> o fold (Fold toMonoid summarize) is = summarize (foldl' (<>) mempty (map toMonoid is)) Funcao fold que otimiza o processo descrito anteriormente usando o tipo Fold. Exemplo: sum :: Num n => Fold n n sum = Fold Sum getSum fold sum [1..10] = 55 Functor Mapea uma funcao para um determinado tipo parametrico. class Functor f where fmap :: (a -> b) -> (f a -> f b) Deve seguir as seguintes propriedades fmap id = id fmap f . fmap g = fmap (f.g) Exemplo: instance Functor [] where fmap = map Para uma lista, a aplicacao do functor é semelhante ao map Operador Functor O operador (<$>) é a definição de fmap infixa (+1) <$> [1,2,3] = [2,3,4]
33	GUILHERME FUZISAWA DE SA
34	GUSTAVO MATHEUS LIMA SANTOS
26	GaMendes	Nessa semana fomos introduzidos ao conceito de Monoids. Um Monoid é um conjunto de valores associados a um operador binário associativo e um elemento identidade, o conceito é derivado do conceito algébrico visto nos fundamentos da álgebra moderna. Alguns exemplos de Monoids são valores inteiros com o operador + e o elemento 0, valores inteiros com o operador * e o elemento 1 e valores String com o operador ++ e o elemento ''''. Também nessa semana vimos sobre a classe Foldable. A importância dos Monoids está na generalização em como combinar uma lista de valores de um tipo que pertence a essa classe, podemos então criar a classe dos "dobráveis" que resolvem essa necessidade. Após vermos a classe Foldable, aprendemos sobre MapReduce que é um modelo de programação utilizado largamente em clusters. Muitas ferramentas como Apache Hadoop e Apache Spark são baseadas neste modelo. Seguindo no conteúdo fomos apresentados aos Functors, que são funções que fazem com que as funções de um certo tipo sejam aplicáveis a um tipo paramétrico contendo esse tipo. No Haskell um Functor é definido como uma classe de tipos: class Functor f where fmap :: (a -> b) -> f a -> f b Ou seja, se eu já tenho uma função g:a→b, e tenho um tipo paramétrico f, eu posso aplicar a função g em f a para obter f b. Uma outra forma de entender Functor é como um tipo paramétrico f que armazena zero ou mais valores do tipo a, e que toda função a -> b pode ser mapeada para uma função f a -> f b: class Functor f where fmap :: (a -> b) -> (f a -> f b)
5	HEITOR BELLINI	-- Semigrupo (<>) :: a -> a -> a onde <> é operador binário -- Monoide Conjunto de valores que podem ser associados por um operador associativo, além de contem um elemento neutro (valor v, operador <>, neutro e). Exemplo: (Integer, +, 0) - Propriedades/Tipos: Elementro neutro: a <> e = a e <> a = a Associativos: (a <> b) <> c = a <> (b <> c) Comutativos: a <> b = b <> a Monoide é definido como: class Monoid a where mempty :: a mappend :: a -> a -> a mconcat :: [a] -> a mconcat = foldr mappend mempty OBS Monoide livre: possui propriedades de um monoide e nada mais. -- Foldable Todas estruturas que podem ser "dobradas". Definição da classe: class Foldable t where fold :: Monoid a => t a -> a foldMap :: Monoid b => (a -> b) -> t a -> b foldr :: (a -> b -> b) -> b -> t a -> b foldl :: (a -> b -> a) -> a -> t b -> a onde fold: fold :: Monoid a => [a] -> a fold [] = mempty fold (x:xs) = x `mappend` fold xs -- Tipo de Dado Algébrico Fold Para a função exemplo abaixo: average :: Foldable t => t Int -> Int average ns = sum ns `div` length ns Podemos aperfeiçoar, percorrendo uma única vez: average :: Foldable t => t Double -> Double average xs = getSum soma / getSum contagem where (soma, contagem) = foldMap (\x -> (Sum x, Sum 1.0)) xs Em casos que foldMap retorna muitos monoides, a função função fica ilegível. Assim, podemos definir: data Fold i o = forall m . Monoid m => Fold (i -> m) (m -> o) fold :: Fold i o -> [i] -> o fold (Fold toMonoid summarize) is = summarize (foldl' (<>) mempty (map toMonoid is)) -- Functors Funções que fazem outras funções do tipo 'a' sejam aplicadas à tipos parametrizados 'a': class Functor f where fmap :: (a -> b) -> f a -> f b Logo, dado g(a) -> b e tipo parametrico f, então g(f(a)) -> f(b) - Functors Lista: já temos! É map! - Functors Maybe: instance Functor Maybe where fmap _ Nothing = Nothing fmap g (Just x) = Just (g x) - Functors Arvore: instance Functor Tree where fmap g (Leaf x) = Leaf (g x) fmap g (Node l x r) = Node (fmap g l) (g x) (fmap g r) - E seu operador? (<$>) é a definição de fmap infixa!
35	HENRIQUE AUGUSTO DE OLIVEIRA	Um Semigroup representa um estrutura algébrica que consiste de um conjunto e um operador binário. O operador (<>) indica a operação associativa entre dois elementos de um tipo, fazendo com que se resulte em um elemento. Existem alguns recursos que auxiliam na operação entre dois tipos, como o Sum, Product, Min, Max, Any e All, por exemplo. A classe Monoid possui definição semelhante, sendo uma estrutura algébrica que possui associação de valores de um conjunto por um operador associativo, mas possui também um elemento identidade. O monoid possui definição do valor mempty, sendo um elemento neutro. Então, se no problema estivermos trabalhando com um Sum x, o mempty será Sum 0; Se estivermos com o Product x, o mempty seria um Product 1; e assim por diante. Uma outra função é o mappend, que executa uma operação binária, semelhante ao (<>). O mconcat executa uma operações de mappend na lista como todo. A classe Foldable permite com que seja realizado operações de fold em uma estrutura e seja sumarizado em um valor. A classe possui as funções fold, foldMap, foldr e foldl. Fora as quatro funções, a classe Foldable apresenta diversas outras funções para combinar valores em uma estrutura, como o null, lenght, elem, maximum, minimum, sum e product. A ideia da classe Functor é utilizada para mapear cada elemento de um tipo de dado parametrizado. Functors são morfismos que transformam morfismos de uma categoria em morfismo de outra. Como função primitiva, é utilizado o fmap, que pega uma função de tipo a -> b e um tipo com elementos de tipo a e aplica a função, resultando em um tipo de elementos do tipo b.
36	HENRIQUE FANTATO SILVA DE ALBUQUERQUE	Um Monoid é um conjunto de valores que podem ser associados a um operador binário associativo e um elemento identidade. Como exemplo, valores inteiros, o operador de soma, e o elemento 0, formam um monóide. Criamos monoids para generalizar, definindo como combinar uma lista de valores de um tipo dessa classe. Com base nos monoids, podemos definir a classe Foldable, onde podemos pegar uma estrutura, converte-lá em um Monoid, e aplicar uma função qualquer, para obter o resultado esperado. Já os Functors, são funções que podemos utilizar para aplicar uma função f a, num tipo b, obtendo f b. Eles transformam os morfismos de uma categoria em outra. O Functor mais utilizado até o momento atual do curso é o map, que é valido para listas. Com Functors, podemos realizar uma aritmética segura, onde podemos garantir certos limites para o tipo que estamos utilizando, afim de evitar overflow, garantindo o funcionamento correto do nosso código.
71	HENRIQUE MAGRO DE SOUZA
37	IGOR SAWAKI
38	JANUSA MAIA DA SILVA
74	JEAN DA SILVA NEVES
39	JULIO NOVAES DA FONSECA
40	KELVIN ALVES DOS SANTOS
42	LARISSA COPEL ROTHMAN
72	LARISSA RODRIGUES DE ALMEIDA
43	LEANDRO RIBEIRO DE ALMEIDA
44	LEONARDO SANTIAGO HAMPSHIRE
65	LOUIS PHILLIPE SARDA DUBOIS	Semana 5 Monoids são conjuntos de valores associados a um operador binário associativo e um elemento identidade: class Monoid a where mempty :: a mappend :: a -> a -> a mconcat :: [a] -> a mconcat = foldr mappend mempty instance Monoid a => Monoid (Maybe a) where mempty = Nothing Nothing `mappend` my = my mx `mappend` Nothing = mx Just x `mappend` Just y = Just (x `mappend` y) Foldables class Foldable t where fold :: Monoid a => t a -> a foldMap :: Monoid b => (a -> b) -> t a -> b foldr :: (a -> b -> b) -> b -> t a -> b foldl :: (a -> b -> a) -> a -> t b -> a Tipos de dado algébrico Fold data Fold i o = forall m . Monoid m => Fold (i -> m) (m -> o) Combinando dois Fold (<+>) :: Fold i a -> Fold i b -> Fold i (a, b) (<+>) (Fold toMonoidL summarizeL) (Fold toMonoidR summarizeR) = Fold toMonoid summarize where toMonoid x = (toMonoidL x, toMonoidR x) summarize (sL, sR) = (summarizeL sL, summarizeR sR) (<.>) :: (o1 -> o2) -> Fold i o1 -> Fold i o2 (<.>) f (Fold t s) = Fold t (f.s) Functor <$> class Functor f where fmap :: (a -> b) -> f a -> f b por definição, deve obedecer às duas propriedades: fmap id = id fmap f . fmap g = fmap (f.g) Functor Maybe instance Functor Maybe where fmap _ Nothing = Nothing fmap g (Just x) = Just (g x)
47	LUCAS AKIRA HASEGAVA
48	LUCAS DAVID VADILHO	# Semana 5 ## Classes de Tipo Monoid ### Semigrupo - Implementa o operador binário `<> :: a -> a -> a` - Temos diversos tipos, exemplo: `[]`, `Sum` , `Product`, `Any`, `All`, `First`, `Last` , `Min`, `Max` - `import Data.Semigroup` - `stimesMonoid`: otimiza repetições ## Monoid - Extensão de semigrupo. Contém 3 - `mempty :: a` elemento neutro do monoid - `mappend :: a -> a -> a` é o `<>` - `mconcat :: [a] -> a` é `foldr mappend mempty` ### Propriedades - Identidade a direita e esquerda - Associatividade - Comutatividade (não necessário) ## Foldable - `Import Data.Foldable` - Generaliza as funções de agregação de dados para containers diversos ## Tipo de Dado Fold ```haskell {- # LANGUAGE ExistentialQuantification # -} import Data.Monoid import Prelude hiding (sum) import Data.Foldable (foldl') data Fold i o = forall m . Monoid m => Fold (i -> m) (m -> o) foldl' :: Fold i o -> [i] -> o foldl' (Fold toMonoid summariza) is = summarize (foldMap toMonoid is) -- Com foldl' seria mais eficiente (<+>) :: Fold i a -> Fold i b -> Fold i (a, b) Fold toMonoidLeft summarizeLeft <+> Fold toMonoidRight summarizaRight = Fold toMonoid summarize where toMonoid x = (toMonoidLeft x, toMonoidRight x) summarize (x, y) = (summarizaLeft x, summarizeRight y) avg :: Fractional n => Fold n (n, n) avg = sum <+> length uncurry (/) $ fold' avg [1..10] ``` Podemos _simplificar_ (o uso, não a função#) a função `avg` para: ```haskell (<.>) :: (o1 -> o2) -> Fold i o1 -> Fold i o2 f (<.>) Fold toMonoid summarize = Fold toMonoid (f . summarize) infixr 6 <+> -- Op <+> é infixo, com preferência de avaliação pela direita e com precedência 6 infixl 5 <.> -- Op <-> é infixo, com preferência de avaliação pela esquerda e com precedência 5 avg :: Fractional n => Fold n n avg = uncurry (/) <.> sum <+> length fold' avg [1..10] ``` ## Functor Generaliza a função `map` para outras estruturas ```haskell class Functor f where fmap :: (a -> b) -> (f a -> f b)` ``` - Operador fmap `<$>` Propriedades (não verificadas pelo haskell): - `fmap id = id` - `fmap f . fmap g = fmap (f . g)` - `{-# LANGUAGE DeriveFunctor #-}` ghc tenta derivar instância de functor automaticamente
31	LUCAS MAZIM DE SOUSA
46	LUCAS SILVA AMORIM	Monoid: - Álgebra: Conjunto de valores associados a um valor binário associativo, e que contém um elemento neutro. - Possui duas propriedades: Associatividade e elemento neutro e alguns comutatividade - Haskell: Classe de tipo: - mempty: a (Elemento neutro). - mappend: a -> a -> a (Operador binário associativo) - mconcat: [a] -> a (possui implementacao padrado: foldl mappend mempty) - Uso dos monoids: Permitem a generalização para concatenação de valores - mappend === <> Foldable: - Def: Aproveitando a generalização da classe monoid para realizar a operação de fold em diferentes estruturas. - Classe fold: class Foldable t {- tipo parametrico -} where fold :: Monoid a => t a -> a (realiza a operacao de reduce no tipo t) foldMap :: Monoid b => (a -> b) -> t a -> b (nao monoid -> monoid -> fold monoid) fold(l ou r) (A mesma ideia do já conhecido fold, mas para um tipo genérico) - Exemplo: Utilizando foldable no tipo Tree data Tree a = Leaf a | Node (Tree a) (Tree b) instance Foldable Tree where foldMap f (Leaf a) = f a foldMap f (Node l r) = foldMap f l <> foldMap f r $> foldMap Sum tree - Implementando o foldMap para o tipo t, voce já ganha funções com implementacao padrao. Tipo de dados Fold: - Para algumas aplicações (Exemplo função avarage) utilizar as funções da classe Foldable pode não ter uma performance. - O tipo de dados Fold, nos permite combinar diferentes folds. Functors: - Funções que fazem que uma função f de um certo tipo seja aplicado em um contexto de um tipo parametrico t - No haskell, functors sao um classe de tipos, tais que: class Functor f where fmap :: (a -> b) -> (f a -> f b) - Exemplo fmap char (Just 65) --> Just 'A' - Propriedades do fmap: - fmap id = id - fmap f. fmap g = fmap (f.g) - fmap === <$> - A diretiva de compilacao {-# LANGUAGE DeriveFunctor} deriva automaticamente Functor para as intancias desejadas - Aplicação: Aritimetrica segura (Safe num data type).
49	LUCAS YUDI FUKAZAWA CASSIN	Semigroup Classe de tipo. Implementação mínima (<>) :: a -> a -> a -- tipo Sum a = Sum {getSum :: a} || Product a = Product { getProduct :: a } || Any = Any { getAny :: Bool} funcao stimesMonoid, aplica a função (<>) x vezes a um monoid passado. Ex.: stimesMonoid 3 (Sum 10) Monoid Extenção do Semigroup 3 funções mempty (elemento neutro) (mempty <> x = x) mappend = (<>) mconcat :: [a] -> a (foldr mappend mempty a) mconcat [Sum 1, Sum 2, Sum 3] => foldr (+) 0 [Sum 1, Sum 2, Sum 3] = Sum 6 Fodable Generaliza as generalizações de dados para diversos containers foldMap => mconcat $ map f xs (Mapeia a lista passando a função f e depois realiza o mconcat. Ex.: mconcat $ map Sum [1..10] => foldMap Sum [1..10]) Data Fold Tem dois tipos paramétricos (a, b) e recebe no seu container uma função de a para Monoid e uma função de Monoid para b Exemplo de aplicação: fold' (Fold toMonoid fromMonoid) xs = fromMonoid (foldMap toMonoid xs) sum = Fold Sum getSum ==> fold' sum [1..10] = getSum $ foldMap Sum [1..10] É possível combinar folds em tuplas Funtor Classe de tipo. Generaliza função map para outras estruturas Implementação fmap :: (a -> b) -> (f a -> f b) || f é paramétrico Ex.: instancia para Maybe ==> fmap _ Nothing = Nothing fmap f (Just x) = Just (f x) fmap chr (Just 65) = Just 'A' Tem que obedecer que fmap id a = id a e fmap g . fmap h = fmap (g . h) fmap f a = f <$> a Pode-se colocar a diretiva {-# LANGUAGE DeriveFunctor #-} e assim é possível derivar a classe Functor nos dados. Cria-se automaticamente o fmap Com fmap pode-se deixar algumas implementações mais fáceis e legíveis
41	LUCAS ZOCCHIO	É possível generalizar a aplicação da função fold para diferentes tipos de dados, mesmo aqueles definidos por ADT através do conceito de semiGroup, uma classe de tipos que requer a definição de um operador binário associativo <> que combina dois elementos daquele dado tipo. A classe Monoid requer ainda que se defina um elemento neutro "mempty". O "mappend" é o operador associativo e "mconcat", que possui uma implementação padrão, aplica o operador aos pares de elementos do tipo numa lista, reduzindo até retornar um único valor. Para generalizar a função fold para outros tipos, é usada a classe de tipos Foldable. Para instanciar esta classe, é preciso definir uma operação foldMap ou foldr para o dado tipo. A partir disso, a operação foldMap pode ser usada para passar elementos de um tipo para o ADT desejado e realizar o fold. Essa classe ainda possui implementação padrão de funções como null, length, sum, maximum, toList, entre outras. O tipo de dados algébrico Fold pode ser usado para definir diferentes funções dos Monoides. Ele recebe uma função que converte o dado de entrada no tipo Monoid desejado e outro que retorna o valor a partir do Monoid. Como cada tipo Monoid possui seu operador binário, cada tipo realiza uma operação diferente. Dessa forma é possível otimizar o fold para diferentes tipos de dados. Functors permitem usar operações comumns em tipos paramétricos. Usando a função fmap, ou o operador <$>, implementada para a instanciação da classe Functor, pode-se aplicar uma função comum a um tipo a, por exemplo, uma árvore daquele tipo. É possível também derivar Functors automaticamente para um tipo de dado paramétrico utilizando a diretiva DeriveFunctor. Utilizando Functor é possível criar e generalizar operações para diferentes tipos de dados paramétricos que se queira.
50	LUCCA IANAGUIVARA KISANUCKI	Monoid Um conjunto de valores associados a um operador binário associativo e um elemento identidade Valores inteiros com o operador + e o elemento 0 Valores inteiros com o operador * e o elemento 1 Valores String com o operador ++ e o elemento "" Classe Foldable class Foldable t where fold :: Monoid a => t a -> a foldMap :: Monoid b => (a -> b) -> t a -> b foldr :: (a -> b -> b) -> b -> t a -> b foldl :: (a -> b -> a) -> a -> t b -> a Funções auxiliares do Foldable: null, length, elem, maximum, minimum, sum, product, toList MapReduce == foldMap Tipo algebrico Fold data Fold i o = forall m . Monoid m => Fold (i -> m) (m -> o) fold :: Fold i o -> [i] -> o fold (Fold toMonoid summarize) is = summarize (foldl' (<>) mempty (map toMonoid is)) Functors Funções que fazem com que as funções de um certo tipo sejam aplicáveis a um tipo paramétrico contendo esse tipo Functors são morfismos que transformam os morfismos de uma categoria inteira (Tipos) em morfismos de outra ([], Maybe, …) class Functor f where fmap :: (a -> b) -> f a -> f b Functors de lista instance Functor [] where fmap = map Functors de Maybe instance Functor Maybe where fmap _ Nothing = Nothing fmap g (Just x) = Just (g x) Functors de Árvores instance Functor Tree where fmap g (Leaf x) = Leaf (g x) fmap g (Node l x r) = Node (fmap g l) (g x) (fmap g r) Podemos utilizar o operador (<$>) no lugar do fmap (+1) <$> [1,2,3] >>[2,3,4]
51	LUIZ FELIPE LEAL GOMES AZZOLINI	## Semigrupos, Monoides e Foldables Um monoide é um conjunto que simplesmente contem uma operação de associação entre dois elementos e um elemento neutro. Na computação usamos essa estrutura para criar implementações de fundações algébricas, o que se torna muito útil quando utilizamos o paradigma funcional para programar. Quando utilizamos monoides criamos instancias deles para um certo tipo, com isso definimos como combinar uma lista de elementos desse mesmo tipo. Sendo assim, após criar os monoides podemos utiliza-los na classe foldable, que contem muitas funções úteis, como o fold, foldl, foldr e foldMap.
52	MARCELO CECILIO FAGUNDES DA SILVA FILHO	No haskell existem algumas classes que facilitam no uso de operadores. Entre elas estão: Semigroup: Conjunto de tipos que tenham operadores binários, ou seja, que ajam de dois em dois, exemplo soma, produto e etc. Operador padrão é o <> que pode representar qualquer operação binária. Monoid: É uma subclasse do Semigroup e também representa os tipos que tenham operadores binários. Porém um monoid possui 3 operadores sendo o mappend equivalente ao <>. Já o mempty representa o valor padrão do tipo e o mconcat é o operador que aplica um foldr usando mappend e mempty como parametros. Foldable: São tipos capazes de se realizar uma operação entre seus elementos. Isso permite aplicar funções como fold em estruturas que não são listas como por exemplo Árvores. Uma das operações possíveis é o foldMap que executa a função map e em seguida a função fold, permitindo atribuir um tipo a uma estrutura e realizar sua operação. Exemplo foldMap Sum lista, sendo Sum um tipo cuja operação é a soma, aplicamos o tipo soma em todos os elementos da lista e depois os somamos. Functor: É uma classe de funções que aplicam uma função de certo tipo em uma função de outro tipo que contenha o tipo original. Com isso é possível o uso da função fmap que mapeia uma função para os elementos de um determinado tipo. O fmap é parecido com o map que aplicava uma função dentro dos elementos de uma lista, porém mais genérico, permitindo qualquer tipo de estrutura. Exemplo dado a tipo Maybe = Nothing | Just a, se fazermos fmap (+1) Just 5, o resultado será Just 6. O fmap pode ser substituído por <$>. Com o uso da diretiva de compilação DeriveFunctor é possível criar instâncias de Functor automaticamente usando deriving.
59	MARIANA MIWA OKUMA MIYASHIRO	Monoid e Foldable - Monoid: conjunto de valores associados a um binário e um elemento identidade - ex: + e 0, ou ++ e "" - monoid como classe é composta por: - mempty :: a (elemento neutro) - mappend :: a -> a -> a (operador binário) - mconcat :: [a] -> a - mconcat = foldr mappend mempty (implementação padrão) - para listas: instance Monoid [a] where mempty = [] mappend = (++) - propriedades: - identidade à direita e à esquerda - associatividade - comutatividade para algumas operações - Foldable: funções que recebem um callback, aplicando-o a cada elemento de um conjunto - classe dos "dobráveis": - fold, foldMap, foldr, foldl - Fold: tipo de dado algébrico - forma de processar estrutura de dados com alguma operação e retornar um valor - tudo em Data.Monoid pode ser escrito utilizando Fold Functors: funções que fazem com que funções de um tipo sejam aplicados a tipos paramétricos - Em Haskell, Functor é uma classe de tipos: - class Functor f where fmap :: (a -> b) -> f a -> f b - a definição de fmap segue: - fmap id = id - fmap f . fmap g = fmap (f.g) - listas: fmap = map - Maybe: fmap _ Nothing = Nothing fmap g (Just x)= Just (g x) - isso torna possível aplicar funções em valores cuja computação pode falhar - árvores: instance Functor Tree where fmap g (Leaf x) = Lead (g x) fmap g (Node l x r) = Node (fmap g l) (g x) (fmap g r) - <$> no lugar de fmap - Definição automática - construir definições de Functor através de um processo algébrico - definindo um Functor que não armazenada nada usando Const e um com único elemento usando Identity - com isso, criar uma função do tipo Maybe - Aritmética segura - evitar operações inválidas ou overflow, por exemplo - data SafeNum a = NaN | NegInf | PosInf | SafeNum a deriving Show - isso possibilita criação de funções que devolvem uma versão segura do valor - transforma-se SafeNum em um functor e usar fmap para evitar problemas de execução
53	MATHEUS ALEXANDRE DE SENA
55	MIGUEL MIRA FONSECA	Um semigroup é uma estrutura algébrica definida por um par formado por um conjunto de valores e um operador binário associativo sobre esse conjunto. Um monoid é um semigroup com a adição da existência do elemento neutro, que permite a propriedade de identidade a esquerda e a direita. Eventualmente a operação binária do monoid pode ser comutativa, mas nem sempre. O monoid permite generalizar operações, como o folding. Já functors são estruturas algébricas definidas por uma função chamada fmap que recebe uma função e retornam uma função com a aplicação de um tipo paramétrico (contexto) nos parâmetros de entrada e saída. Em teoria de categorias, isso seria equivalente a um morfismo que transforma o morfismo de uma categoria a outra, preservando sua estrutura (objetos) durante a transformação. Temos que quase todo tipo paramétrico é um functor e com isso podemos criar uma álgebra de functors, semelhante a álgebra de tipos. O tipo Const recebe dois parâmetros “a” e “b” porém só guarda um dos parâmetros, no caso o “b”. O Const é equivalente ao tipo Void da álgebra de tipos. E uma forma de ilustrar o uso de functors é através da criação de uma instância SafeNum que permite fazer uma aritmética segura, como evitar divisão por erro e overflows. O que permite detectar erros e fazer o devido tratamento dos mesmos.
57	NATALIA LEITE VARES DE SOUZA	SEMIGROUP O Semigroup representa um conjunto com uma operação binária associativa (<>). Isso torna um Semigroup um superconjunto de monóides. MONOID Monoid é um conjunto de valores associados a um operador binário associativo e um elemento identidade: A importância dos Monoids está na generalização em como combinar uma lista de valores de um tipo que pertença a essa classe. FOLDABLE Foldable representa estruturas de dados que podem ser reduzidas a um valor de resumo, um elemento por vez. Na classe Foldable temos algumas funções pré estabelecidas, como: fold, foldMap, foldr e foldl (vistos em aulas anteriores). Além disso, são definidas diversas funções auxiliares (null, elem, length, sum, product, etc) FUNCTORS Functors são funções que fazem com que as funções de um certo tipo sejam aplicáveis a um tipo paramétrico contendo esse tipo. Dentro da classe functor temos a função fmap, que deve obedecer a duas regras, sendo elas: fmap id = id fmap f . fmap g = fmap (f.g) Assim, deve valer que a propriedade de identidade e a distributiva. Temos implementações de Functor para listas, Maybe e árvores. Também é possível utilizar o operador (<$>) no lugar do fmap, assim teremos o operador functor É possível construir definições de Functor automaticamente através de um processo algébrico.
56	NATHALIA CORREA DOS SANTOS
64	PAULO GABRIEL MASSA
60	PAULO HENRIQUE EIJI HAYASHIDA	classes Semigroup trabalham com funções que recebem argumentos de um mesmo tipo para retornar um resultado também desse mesmo tipo Usando o operador de concatenação <> pode-se juntar duas listas como ["ola "] <> ["mundo"] = ["ola mundo"] Tipo Maybe, que retornar Just se um dos dois argumentos não forem Nothing Nothing <> Just [10] = Just [10] Tipo Sum, retorna a soma Sum 2 <> Sum 10 = Sum 12 Tipo Product, retorna o produto Product 2 <> Product 10 = Product 20 Tipo Any, retorna a operação booleana OR Any True <> Any False = Any True Tipo All, retorna a operação booleana AND All True <> All False = All False Tipo First , retorna o primeiro argumento First 10 <> First 2 = First 10 Tipo Last, retorna o ultimo argumento Last 10 <> Last 2 = Last 2 Tipo Min, retorna o valor minimo Min 10 <> Min 2 = Min 2 Tipo Max, retorna o maior valor Max 10 <> Max 2 = Max 10 stimesMonoid repete uma função f, n vezes, sendo que essa função é otimizada para realizar operações de repetições Sua sintase é stimesMonoid n f, por exemplo stimesMonoid 2 (Product 2) = Product 4 Para uma variavel ser da classe Monoid, ele também deve ser da classe Semigroup. Monoids possuem 3 funções mempty, um elemento neutro de uma função, mappend, o operador de concatenação <>, mconcat, que aplica um fold com a concatenação e o elemento neutro A classes Foldable definem 3 funções que podem ser aplicadas a qualquer container que pode ser uma lista, uma arvore. As funções dessa classe são fold, foldMap, foldr. Redefinindo todos os operadores para aceitarem monoides pode-se criar uma função que converte valores para monoides e transformam os monoides em resultados do tipo desejado novamente Functors transformam funções que convertem valores de a para b, em funções aplicadas em a para funções aplicadas em b.A classes Semigroup trabalham com funções que recebem argumentos de um mesmo tipo para retornar um resultado também desse mesmo tipo Usando o operador de concatenação <> pode-se juntar duas listas como ["ola "] <> ["mundo"] = ["ola mundo"] Tipo Maybe, que retornar Just se um dos dois argumentos não forem Nothing Nothing <> Just [10] = Just [10] Tipo Sum, retorna a soma Sum 2 <> Sum 10 = Sum 12 Tipo Product, retorna o produto Product 2 <> Product 10 = Product 20 Tipo Any, retorna a operação booleana OR Any True <> Any False = Any True Tipo All, retorna a operação booleana AND All True <> All False = All False Tipo First , retorna o primeiro argumento First 10 <> First 2 = First 10 Tipo Last, retorna o ultimo argumento Last 10 <> Last 2 = Last 2 Tipo Min, retorna o valor minimo Min 10 <> Min 2 = Min 2 Tipo Max, retorna o maior valor Max 10 <> Max 2 = Max 10 stimesMonoid repete uma função f, n vezes, sendo que essa função é otimizada para realizar operações de repetições Sua sintase é stimesMonoid n f, por exemplo stimesMonoid 2 (Product 2) = Product 4 Para uma variavel ser da classe Monoid, ele também deve ser da classe Semigroup. Monoids possuem 3 funções mempty, um elemento neutro de uma função, mappend, o operador de concatenação <>, mconcat, que aplica um fold com a concatenação e o elemento neutro A classes Foldable definem 3 funções que podem ser aplicadas a qualquer container que pode ser uma lista, uma arvore. As funções dessa classe são fold, foldMap, foldr. Redefinindo todos os operadores para aceitarem monoides pode-se criar uma função que converte valores para monoides e transformam os monoides em resultados do tipo desejado novamente Functors transformam funções que convertem valores de a para b, em funções aplicadas em a para funções aplicadas em b.
63	PEDRO ANTUNES NEGRÃO
61	PEDRO BRAGA DOS SANTOS BACELLAR
62	PEDRO MACHADO NERY DOS SANTOS	Monoides são estruturas algébricas que contêm um operador binário e um elemento neutro, o que permite a generalização de fold para outras estruturas. Um monoide é um conjunto de valores associados a um operador binário associativo e que contém um elemento neutro: M = (V, <>, e). Exemplo: (Integer, +, 0) O operador deve ser associativo e o elemento neutro pode ser aplicado à esquerda e à direita: (a<>b)<>c = a<>(b<>c) a<>e=a e<>a=a Em Haskell, a classe Monoid existe: class Monoid a where mempty :: a mappend :: a->a->a mconcat :: [a]->a mconcat foldr mappend mempty Também necessário definir instance Semigroup quando se instancia um monoide de uma dada classe a, para definição do operador <> padrão de combinação. Exemplo: data Resultado = Pontuacao Int | Cola deriving (Show, Eq) instance Semigroup Resultado where Pontuacao a <> Pontuacao b = Pontuacao (a+b) _ <> Cola = Cola Cola <> _ = Cola instance Monoid Resultado where mempty = Pontuacao 0 No entanto, mconcat é definido para monoides apenas, de forma que a classe Foldable é definida para outras classes "dobráveis". Permite a concatenação de resultados de folds e consiste num tipo paramétrico t. A classe functor generaliza o map para outras estruturas, tornando funções aplicáveis a certos tipos paramétricos de seu mesmo tipo. Em específico, permite o uso de fmap de forma análoga ao map para listas. Dessa forma, pode-se definir procedimentos a serem realizados sobre tipos paramétricos e inclusive substituir fmap por <$>. Exemplo: (+1) <$> [1,2,3] = [2,3,4]. Maybe é um exemplo de functor. É possível definir functors automaticamente a partir da sentença "deriving Functor" em um tipo construído, utilizando {-# LANGUAGE DeriveFunctor #-}. Por fim, também é possível utilizar functors para construção de aritméticas seguras sobre tipos, tratando casos como NaNs e Infs.
69	PEDRO REGIO SHOJI
66	PIETRO DI CONSOLO GREGORIO	Um Monoid pode ser definido como um conjunto de valores associados à uma operação binária associativa (<> ou mappend) e um elemento identidade (mempty) que não realiza nada quando associado com outros elementos. Por exemplo, o elemento identidade da soma seria o número 0 e do produto o número 1. A classe foldable define uma generalização para classes que podem ser dobradas utilizando as funções fold, foldMap, foldr e foldl. A instância de Monoid para os tipos Sum e Product fazem com que a somatória e a produtória possa ser feita apenas com um foldMap. O MapReduce se trata da função foldMap, onde o map é feito de forma paralela e distribuída e o reduce corresponde ao fold. É possível automatizar o procedimento onde o map do foldMap retorne vários monóides através da criação de um tipo de dados Fold. Funções que fazem com que as funções de um certo tipo sejam aplicáveis a um tipo paramétrico contendo esse tipo são chamadas de Functors, ou seja, ela recebe uma função (a -> b) e transforma ela para uma função (F a -> F b). Um Functor é definido como uma classe de tipo no Haskell, e é definido pela função fmap. Quase qualquer tipo paramétrico é um Functor. Como um exemplo de aplicação, é possível implementar uma aritmética segura de forma mais simples utilizando Functor.
13	RAFAEL BRUNO FERREIRA FIGUEIREDO	stimesMonoid: Função usa as porpriedades dsos monoides para otimizar a aplicação de operações várias vezes. Monoide é uma extensão do semigrupo! mempty -> é o elemento neutro dos tipos. Pra string é "", pra soma é 0 e para produto é 1. mconcat -> Aplica funções definidas na tag do semigrupo Monoides são associativos, o que pode ajudar na implementação de paralelismo! Alguns monoides também sao comutáveis mas não é necessário para classe: [1] <> [2] /= []2 <> [1] mas Sum 10 <> Sum 20 = Sum 20 <> Sum 10 Foldable: Permite generalizar funções de agregação de dados para diversos conteiners. uncurry: transforma uma função que recebe dois tipos e retorna um tipo para uma função que recebe uma tupla dos dois primeiros tipos e retorna o terceiro tipo. Functors: São funções que alteram o contexto das funções. Podem ser utilizados para não travar o programa quando uma execução falha, por exemplo.
67	RAFAEL PAUWELS DE MACEDO	Na primeira seção da aula vimos as classes semigroup, monoid e foldable. A classe semigroup implementa uma combinação binária para cada tipo, possibilitando combinar elementos do mesmo tipo, por exemplo, Sum 2 <> Sum 3 = Sum 5. O monoid é uma extensão da classe semigroup que implementa três operações, mempty, mappend e mconcat, sendo uma característica importante dos monóides a associatividade entre as operações, importante notar que não é necessário que os monóides sejam comutativos, é esperado que [1] ++ [2] seja diferente de [2] ++ [1]. Já na classe foldable é esperado que seja implementado a função foldr ou foldMap, que espera receber um Monoid e retorna um monoid do mesmo tipo. Vimos também a classe Fold e como podemos usar a estrutura do Fold para, por exemplo, converter um elemento i para monoid e aplicar uma função sobre esse novo monoid. Podemos usar essa estrutura para implementar algumas funções do prelude, all por exemplo, é implementado como all p = Fold (All . p) getAll. A segunda seção fala sobre a classe Functor e o functor map (fmap), sendo importante notar que durante a implementação de uma instancia de fmap devemos garantir que fmap f . fmap g seja igual a fmap(f.g) e devemos ter em mente que o compilador não te da a garantia dessa propriedade. Podemos usar o fmap para aplicar uma função dentro de uma estrutura, como por exemplo, uma árvore. Analogamente podemos usar o operador <$>. Ainda no assunto de functor vimos um caso de uso criando funções que realizam operações matemáticas de forma segura, ou seja, respeitando os limites de overflow dos inteiros. Para isso categorizamos os números como NaN, PosInf, NegInf ou (SafeNum x) e cabe a cada operação matemática guards para tratar com todas as possíveis entradas para uma operação.
68	RAPHAEL RAMOS DA SILVA	---------------------------------------------- Semigroup ------------------------------------------------- Semigroup: classe de tipos que admitem um operador binário associativo (aplicado a 2 valores do mesmo tipo). Exemplo: ([a], ++), (Int, +), (Int, *). Podemos definir instâncias de Semigroup para um determinado tipo (definindo o operador binário). Exemplo: instance Semigroup [a] where (<>) = (++). O import Data.Semigroup já carrega algumas instâncias (Ex.: Sum/Product/Any/All/First/Last). Exemplo: Last 10 <> Last 2 (retorna o ultimo elemento: 2). ----------------------------------------------- Monoid ---------------------------------------------------- Monoid: Semigroup (operador representado por `mappend`) + elemento identidade (representado por `mempty'). Exemplos: ([a], ++, []) (Int, + , 0), (Int, *, 1). A graça está na generalização da combinação de uma lista de valores de um tipo (Monoid). Para criar uma instância de Monoid, precisamos definir o elemento mempty (o operador mappend é igual a <>). Exemplo: Para listas, `mappend` = ++ e `mempty` = []. ---------------------------------------------- Foldable -------------------------------------------------- Foldable: generalização das funções fold (foldr e foldl). Principais implementações da classe: - fold :: Monoid m => t m -> m (onde t é um "container" - estrutura qualquer - não necessariamente lista) - foldMap :: Monoid m => (a -> m) -> t a -> m - foldr :: (a -> b -> b) -> b -> t a -> b ---------------------------------------------- TDA Fold -------------------------------------------------- Exemplo da média em uma lista numérica: average xs = sum xs / lenght xs Neste cálculo, a estrutura é percorrida duas vezes. Com foldMap, a estrutura é percorrida apenas uma vez. O Fold é um TDA que permite a automatização dessa estrutura. data Fold i o = forall m . Monoid m => Fold (i -> m) (m -> o) ----------------------------------------------- Functor -------------------------------------------------- Definição: Classe de tipos que generaliza a função map (fmap). functor :: (a -> b) -> (F a -> F b) - onde F é um tipo paramétrico. fmap deve obedecer duas propriedades: - fmap id = id - fmap f . fmap g = fmap (f.g) <$> é a forma infixa de fmap
45	RENAN FERREIRA LIMA	Os temas da semana foram as classes de tipos Monoid e Functor, na primeira destaca-se o Semigroup, Monoid e Foldable, enquanto que na segunda temos uma transformação de tipos paramétricos. Quanto ao Semigroup, este recebe um operador binário e o aplica para dois valores do mesmo tipo. O Semigroup engloba diversas instâncias como: Lista, Maybe, Sum, Product, Min e Max, entre outras. Uma extensão do Semigroup é o Monoid, cuja implementação torna possível simplificar as operações mais comuns do tipo fold, uma vez que é possível defini-las previamente, tornando o código mais conciso. Há algumas propriedades que devem ser obedecidas nos monoids, são elas: identidade e associatividade, alguns ainda possuem a comutatividade. Outra classe de tipo Monoid é a Foldable que permite a generalização das funções de agregação de dados para containers diversos, ampliando dessa forma, as possibilidades abordadas com o fold, as quais são aplicadas à listas. Uma maneira de deixar o código mais claro e com isso auxiliar na implementação é através da definição de um novo tipo de dado para Fold, de modo que possibilite a construção de uma função fold’ utilizando as novas características definidas para o dado, além de viabilizar a redefinição de outras funções já implementadas na biblioteca Monoid como: head, sum, last, entre outras. Quanto aos Functors, em Haskell, são definidos como uma classe de tipos que recebe um tipo paramétrico e possui uma função functor map (fmap). Através do fmap é possível aplicar diversas funções utilizando Functors. Um recurso importante é a implementação do SafeNum para tratar exceções quando for necessário trabalhar funções envolvendo números.
70	RENAN GONCALVES MIRANDA	Monoid Estrutura algébrica que contem um operador binário que combina dois elementos e um elemento neutro, nos permitindo a generalização do conceito de fold para várias outras estruturas através da classe do tipo Foldable. Um exemplo de Monoid na álgebra são os números inteiros com o operador soma e o zero como elemento neutro. O Monoid deve seguir algumas propriedade: Ele deve ser associativo; A aplicação do elemento neutro com qualquer coisa, deve dar qualquer coisa; Ele deve ser comutativo. Foldable Com a classe Foldable, podemos criar a classe dos dobráveis e operações derivadas dela para estruturas de dados arbitrárias. Muito utilizado em big data, o MapReduce nada mais é que uma função foldmap. Classe Functor Generaliza a função map para outras estruturas, permitindo a criação de funções ainda mais genéricas que as funções de alta ordem. Functor são funções que fazem com que as funções de um certo tipo sejam aplicáveis ao um tipo paramétrico que contem esse tipo [f :: (a -> b) -> ( F a -> F b)]. Em teoria das categorias Functor são morfismo que transformam o morfismo de uma categoria em um morfismo de outro categoria. No haskell Functor é uma classe definida como fmap :: (a -> b) -> (f a -> f b). Toda instancia de fmap tem que obedecer algumas propriedades: fmap id = id fmap f . fmap g = fmap (f . g) Quase qualquer tipo paramétrico é um Functor. Aritmética Segura Criação de tipos para armazenamento de valores numéricos que realizam o trabalho de verificação de segurança (exemplos divisão por zero, maxbound, minbound)
73	SAMUEL ESDRAS NAVARRO DA SILVA
75	TAMIRES CHRISTYNE DA SILVA
77	VICTOR LOURENCO BORGES	** Semigrupos ** - Traz a ideia de concatenar elementos (<> :: a -> a -> a) - funcionam como tags em elementos - exemplos: All True <> All False = False // Product 2 <> Product 5 = 10 ** Monoids ** - Extensão do semigroup, com a adição de um elemento: e de um elemento neutro - concatenação = mconcat e elemento neutro = mempty - classes: List (++ e []), Sum (+ e 0), Product (* e 1). All, Any, Min, Max, etc - nem todos são comutativos (a <> b == b <> a) - elemento neutro permite concatenação em lista => fold - exemplos: mconcat [[1], [2]] -> [1, 2] // mconcat [Sum 1, Sum 2] -> 3 - mconcat $ map Sum xs => aplica semigrupo de Sum a cada elemento da lista, e depois usa o mconcat para reduzir a um valor único - mconcat $ map ( Any . even ) xs => aplica Any junto do bool se o número for par na lista. Ao final, com o concat, retornará true caso haja algum Any True - ** Foldables ** - tem método fold, que irá reduzir a lista de elementos (mconcat) - tem método foldMap, que aplica map e depois reduz (mconcat $ map) - tem o foldr, foldl padrões ** Data Fold ** - permite compor uma sequência de Fold - encapsula método toMonoid para tagear uma lista em monoids, e dps o summarize para concatenar e reduzir a lista ** Functors ** - leva uma função e a aplica dentro de um contexto diferente ( a -> b ) -> ( F a -> F b) - exemplo, função (+1) dentro do contexto de Just / Nothing: fmap (+1) Just (5) = Just 6 - ou ainda, aplicar even dentro de uma Tree - pode ser usado de modo infixo: (+1) <$> [1,2] = fmap (+1) [1,2] = [2,3
78	VINICIUS DE OLIVEIRA CAMPOS DOS REIS
79	VINICIUS LOURENCO DA SILVA
0	VITOR MARINI BLASELBAUER
80	VITOR RUBENS SNIQUER LEAO MARTINS
76	VITTORIA ARIEL DOS SANTOS BOROTTO	Algebra consiste em dominio e operacoes(com propriedades) de um dominio, Exemplo: Domain: Natural numbers Operations: Addition Properties: Associativity => Semigroups O que é: um magma associativo. Tipo de classe que consiste em uma operacao que é o Diamond. O dominio do Semigroups é o dominio do tipo que voce ta usando. E o semigrupo que voce quer criar desse dominio tem que ser associativo. Tipos que tem instancia de semigroups: Either e Lista generica Lista generica: funciona como um append[que é associativo] => Monoid O que é: precisa de um semigroup com o elemento identidade, pois é criado a partir de um semigroup, continuamos com a operacao associativa, mas agora a gente precisa de um elemento para o caso de identidade Regras do monoid: Right identity: m <> mempty = x Left identity: m <> x = x Associativity: x <> (y <> z) = (x <> y) <> z Concatenation: mconcat = foldr (<>) mempty >Nem todo tipo tem um monoid, alguns tem mais de um monoid, ou nenhum Inteiros: as operacoes de associacao sao adicao e multiplicacao Normalmente Semigroups e Monoids sao utilizados para deixar implicitas premissas na semantica dos programas, isso pode ser bem util em computacao distribuida com muitos foldings, consegue-se otimizar inferindo a operacao associativa Valores inteiros com o operador + e o elemento 0 Valores inteiros com o operador * e o elemento 1 Valores String com o operador ++ e o elemento '''' Foldable: pode ser definido usando Monoids => Functors O que é: funcoes que fazem funcoes de um certo tipo ser aplicavel a um tipo parametrico contendo esse tipo -são morfismos que transformam os morfismos de uma categoria inteira (Tipos) em morfismos de outra ([], Maybe, …) Funcao que recebe como parametro uma funcao e uma colecao, aplicando a funcao em cada item da colecao
81	WALTER OSCAR TRUJILO
82	WESLEY AXEL DE BARROS	Para esta semana 05, tivemos um topico importante para o estudo de Haskell na disciplina de Paradigmas de Programação. Estudamos o conceito de monoide aplicado na linguagem de progamação funcional Haskell, que acaba sendo importante na hora de simplificar códigos, que possuem o intuito de combinar lista de valores de tipos de uma mesma classe, conforme o exemplo da lista de exercicio. Aonde tivemos que "somar/combinar" diferentes dietas com seu resultado baseado em um conceito de dieta. Verificamos o conceito dos foldables, que são uma classe de funções "foldr", que podem ser derivadas e aplicas em diversas estruturas e listas, como monoides, ou arvores binarias, com o intuito de utilizar uma função "foldr", que com base em um valor inicial, aplica uma função binaria em uma estrutura de dados para se obter um resultado. Também Vimos o "foldMap", que baseado na função "fold", em uma estrutura de dados de monoides, acaba aplicando a função binaria desse monoide na estrutura, para se obter um resultado. Estudamos também o conceito de Functors, que são funções que fazem com que funções baseadas em um tipo, sejam aplicadas a um tipo diferente do original, ou seja, baseado em uma função f:a -> b, se aplica "f" em "a" , para se obter o valor de aplicar "f" em "b". Para isso, analisamos o exemplo de functor aplicado em operações aritmeticas, aonde baseado em um tipo com valores que possam armazenar numeros de maneira segura, conseguimos implementar funções que, caso haja qualquer problema nas operações aritmeticas envolvendo esse tipo, como extrapolação do limite do tipo Int, ou alguma operação de divisão com numero 0, o resultado seja um valor seguro informando o caso, e não um erro na operação de compilação do código.
83	WILLIAM SENA SILVA
84	WILLIAN CORTEZ
20	francesquini