Tipo Haskell vs Construtor de Dados

Estou aprendendo Haskell em learnyouahaskell.com . Estou tendo problemas para entender construtores de tipo e construtores de dados. Por exemplo, eu realmente não entendo a diferença entre isso:

data Car = Car { company :: String  
               , model :: String  
               , year :: Int  
               } deriving (Show) 

e isto:

data Car a b c = Car { company :: a  
                     , model :: b  
                     , year :: c   
                     } deriving (Show)  

Entendo que o primeiro é simplesmente usar um construtor ( Car) para criar dados do tipo Car. Eu realmente não entendo o segundo.

Além disso, como os tipos de dados são definidos assim:

data Color = Blue | Green | Red

se encaixam em tudo isso?

Pelo que eu entendo, o terceiro exemplo ( Color) é um tipo que pode ser em três estados: Blue, Greenou Red. Mas isso entra em conflito com a forma como entendo os dois primeiros exemplos: será que o tipo Carpode estar apenas em um estado Car, que pode levar vários parâmetros para criar? Se sim, como o segundo exemplo se encaixa?

Essencialmente, estou procurando uma explicação que unifique os três exemplos / construções de código acima.

Em uma datadeclaração, um construtor de tipo é a coisa do lado esquerdo do sinal de igual. O (s) construtor (es) de dados são os itens do lado direito do sinal de igual. Você usa construtores de tipo onde um tipo é esperado e usa construtores de dados onde um valor é esperado.

Construtores de dados

Para simplificar, podemos começar com um exemplo de um tipo que representa uma cor.

data Colour = Red | Green | Blue

Aqui, temos três construtores de dados. Colouré um tipo, e Greené um construtor que contém um valor de tipo Colour. Da mesma forma, Rede Bluesão ambos construtores que constroem valores do tipo Colour. Poderíamos imaginar apimentá-lo embora!

data Colour = RGB Int Int Int

Ainda temos apenas o tipo Colour, mas RGBnão é um valor - é uma função que leva três Ints e retorna um valor! RGBtem o tipo

RGB :: Int -> Int -> Int -> Colour

RGBé um construtor de dados que é uma função que aceita alguns valores como argumentos e os usa para construir um novo valor. Se você fez alguma programação orientada a objetos, deve reconhecer isso. No OOP, os construtores também recebem alguns valores como argumentos e retornam um novo valor!

Nesse caso, se aplicarmos RGBa três valores, obteremos um valor de cor!

Prelude> RGB 12 92 27
#0c5c1b

Temos construído um valor do tipo Colouraplicando o construtor de dados. Um construtor de dados contém um valor como uma variável ou aceita outros valores como argumento e cria um novo valor . Se você já fez a programação anterior, esse conceito não deve ser muito estranho para você.

Intervalo

Se você deseja construir uma árvore binária para armazenar Strings, você pode imaginar fazer algo como

data SBTree = Leaf String
            | Branch String SBTree SBTree

O que vemos aqui é um tipo SBTreeque contém dois construtores de dados. Em outras palavras, existem duas funções (a saber Leafe Branch) que construirão valores do SBTreetipo. Se você não estiver familiarizado com o funcionamento das árvores binárias, aguarde um pouco. Na verdade, você não precisa saber como as árvores binárias funcionam, apenas que essa armazena Strings de alguma maneira.

Também vemos que os dois construtores de dados usam um Stringargumento - essa é a String que eles armazenam na árvore.

Mas! E se nós também quiséssemos armazenar Bool, teríamos que criar uma nova árvore binária. Pode ser algo como isto:

data BBTree = Leaf Bool
            | Branch Bool BBTree BBTree

Tipo construtores

Ambos SBTreee BBTreesão construtores de tipo. Mas há um problema evidente. Você vê como eles são semelhantes? Isso é um sinal de que você realmente deseja um parâmetro em algum lugar.

Para que possamos fazer isso:

data BTree a = Leaf a
             | Branch a (BTree a) (BTree a)

Agora, introduzimos uma variável de tipo a como parâmetro no construtor de tipos. Nesta declaração, BTreetornou-se uma função. Ele aceita um tipo como argumento e retorna um novo tipo .

É importante considerar aqui a diferença entre um tipo concreto (exemplos incluem Int, [Char]e Maybe Bool), que é um tipo que pode ser atribuído a um valor em seu programa e uma função construtora de tipo que você precisa alimentar um tipo para poder ser atribuído a um valor. Um valor nunca pode ser do tipo "lista", porque precisa ser uma "lista de algo ". No mesmo espírito, um valor nunca pode ser do tipo "árvore binária", porque precisa ser uma "árvore binária que armazena algo ".

Se passarmos, digamos, Boolcomo argumento para BTree, ele retornará o tipo BTree Bool, que é uma árvore binária que armazena Bools. Substitua todas as ocorrências da variável type apelo tipo Boole você pode ver por si mesmo como é verdade.

Se desejar, você pode visualizar BTreecomo uma função do tipo

BTree :: * -> *

Tipos são semelhantes aos tipos - *indica um tipo concreto, por isso dizemos que BTreeé de um tipo concreto para um tipo concreto.

Empacotando

Volte aqui um momento e tome nota das semelhanças.

• Um construtor de dados é uma "função" que recebe 0 ou mais valores e retorna um novo valor.

• Um construtor de tipos é uma "função" que recebe 0 ou mais tipos e devolve um novo tipo.

Construtores de dados com parâmetros são legais se queremos pequenas variações em nossos valores - colocamos essas variações nos parâmetros e deixamos o cara que cria o valor decidir em quais argumentos eles serão inseridos. No mesmo sentido, digite construtores com parâmetros como legais se queremos pequenas variações em nossos tipos! Colocamos essas variações como parâmetros e deixamos o cara que cria o tipo decidir em quais argumentos eles irão colocar.

Um estudo de caso

Como o trecho da casa aqui, podemos considerar o Maybe atipo. Sua definição é

data Maybe a = Nothing
             | Just a

Aqui Maybeestá um construtor de tipos que retorna um tipo concreto. Justé um construtor de dados que retorna um valor. Nothingé um construtor de dados que contém um valor. Se olharmos para o tipo de Just, vemos que

Just :: a -> Maybe a

Em outras palavras, Justpega um valor do tipo ae retorna um valor do tipo Maybe a. Se olharmos para o tipo de coisa Maybe, vemos que

Maybe :: * -> *

Em outras palavras, Maybepega um tipo concreto e retorna um tipo concreto.

De novo! A diferença entre um tipo concreto e uma função construtora de tipo. Você não pode criar uma lista de Maybes - se tentar executar

[] :: [Maybe]

você receberá um erro. No entanto, você pode criar uma lista de Maybe Int, ou Maybe a. Isso Maybeocorre porque é uma função construtora de tipo, mas uma lista precisa conter valores de um tipo concreto. Maybe Inte Maybe asão tipos concretos (ou, se desejar, chamadas para digitar funções construtoras que retornam tipos concretos.)

Haskell possui tipos de dados algébricos , que poucas outras línguas possuem. Talvez seja isso que o confunda.

Em outros idiomas, geralmente você pode criar um "registro", "estrutura" ou similar, que possui vários campos nomeados que contêm vários tipos diferentes de dados. Você também pode, por vezes, fazer um "enumeração", que tem um conjunto (pequeno) de valores fixos possíveis (por exemplo, o seu Red, Greene Blue).

No Haskell, você pode combinar os dois ao mesmo tempo. Estranho, mas é verdade!

Por que é chamado de "algébrico"? Bem, os nerds falam sobre "tipos de soma" e "tipos de produto". Por exemplo:

data Eg1 = One Int | Two String

Um Eg1valor é basicamente quer um inteiro ou uma string. Portanto, o conjunto de todos os Eg1valores possíveis é a "soma" do conjunto de todos os possíveis valores inteiros e todos os possíveis valores de sequência. Assim, os nerds se referem Eg1como um "tipo de soma". Por outro lado:

data Eg2 = Pair Int String

Cada Eg2valor consiste em ambos um inteiro e uma string. Portanto, o conjunto de todos os Eg2valores possíveis é o produto cartesiano do conjunto de todos os números inteiros e o conjunto de todas as cadeias. Os dois conjuntos são "multiplicados" juntos, então esse é um "tipo de produto".

Os tipos algébricos de Haskell são tipos de soma de tipos de produtos . Você fornece a um construtor vários campos para criar um tipo de produto e possui vários construtores para fazer uma soma (de produtos).

Como um exemplo de por que isso pode ser útil, suponha que você tenha algo que produz dados como XML ou JSON e seja necessário um registro de configuração - mas, obviamente, as definições de configuração para XML e JSON são totalmente diferentes. Então você pode fazer algo assim:

data Config = XML_Config {...} | JSON_Config {...}

(Com alguns campos adequados, obviamente.) Você não pode fazer coisas assim em linguagens de programação normais, e é por isso que a maioria das pessoas não está acostumada.

Comece com o caso mais simples:

data Color = Blue | Green | Red

Isso define um "construtor de tipos" Colorque não aceita argumentos - e possui três "construtores de dados" Blue, Greene Red. Nenhum dos construtores de dados aceita argumentos. Isto significa que existem três tipo Color: Blue, Greene Red.

Um construtor de dados é usado quando você precisa criar um valor de algum tipo. Gostar:

myFavoriteColor :: Color
myFavoriteColor = Green

cria um valor myFavoriteColorusando o Greenconstrutor de dados - e myFavoriteColorserá do tipo, Colorpois esse é o tipo de valores produzido pelo construtor de dados.

Um construtor de tipo é usado quando você precisa criar um tipo de algum tipo. Geralmente, esse é o caso ao escrever assinaturas:

isFavoriteColor :: Color -> Bool

Nesse caso, você está chamando o Colorconstrutor de tipos (que não aceita argumentos).

Ainda comigo?

Agora, imagine que você não apenas queria criar valores de vermelho / verde / azul, mas também queria especificar uma "intensidade". Como, um valor entre 0 e 256. Você pode fazer isso adicionando um argumento a cada um dos construtores de dados, para terminar com:

data Color = Blue Int | Green Int | Red Int

Agora, cada um dos três construtores de dados leva um argumento do tipo Int. O construtor de tipo ( Color) ainda não aceita argumentos. Então, minha cor favorita é um verde escuro, eu poderia escrever

    myFavoriteColor :: Color
    myFavoriteColor = Green 50

E, novamente, ele chama o Greenconstrutor de dados e eu recebo um valor do tipo Color.

Imagine se você não quiser ditar como as pessoas expressam a intensidade de uma cor. Alguns podem querer um valor numérico como acabamos de fazer. Outros podem ficar bem com apenas um booleano indicando "brilhante" ou "não tão brilhante". A solução para isso é não codificar Intnos construtores de dados, mas usar uma variável de tipo:

data Color a = Blue a | Green a | Red a

Agora, nosso construtor de tipos aceita um argumento (outro tipo que acabamos de chamar a!) E todos os construtores de dados aceitam um argumento (um valor!) Desse tipo a. Então você poderia ter

myFavoriteColor :: Color Bool
myFavoriteColor = Green False

ou

myFavoriteColor :: Color Int
myFavoriteColor = Green 50

Observe como chamamos o Colorconstrutor de tipos com um argumento (outro tipo) para obter o tipo "efetivo" que será retornado pelos construtores de dados. Isso toca o conceito de tipos que você pode querer ler sobre uma ou duas xícaras de café.

Agora descobrimos o que são os construtores de dados e os construtores de tipos e como os construtores de dados podem assumir outros valores como argumentos e os construtores de tipos podem usar outros tipos como argumentos. HTH.

Como outros apontaram, o polimorfismo não é tão útil aqui. Vejamos outro exemplo com o qual você provavelmente já está familiarizado:

Maybe a = Just a | Nothing

Este tipo possui dois construtores de dados. Nothingé um pouco chato, não contém dados úteis. Por outro lado, Justcontém um valor de a- qualquer que seja o tipo a. Vamos escrever uma função que use esse tipo, por exemplo, obter o cabeçalho de uma Intlista, se houver alguma (espero que você concorde que isso seja mais útil do que gerar um erro):

maybeHead :: [Int] -> Maybe Int
maybeHead [] = Nothing
maybeHead (x:_) = Just x

> maybeHead [1,2,3]    -- Just 1
> maybeHead []         -- None

Portanto, neste caso, aé um Int, mas funcionaria bem para qualquer outro tipo. De fato, você pode fazer nossa função funcionar para todos os tipos de lista (mesmo sem alterar a implementação):

maybeHead :: [t] -> Maybe t
maybeHead [] = Nothing
maybeHead (x:_) = Just x

Por outro lado, você pode escrever funções que aceitam apenas um certo tipo de Maybe , por exemplo,

doubleMaybe :: Maybe Int -> Maybe Int
doubleMaybe Just x = Just (2*x)
doubleMaybe Nothing= Nothing

Para encurtar a história, com o polimorfismo, você oferece ao seu tipo a flexibilidade de trabalhar com valores de outros tipos diferentes.

No seu exemplo, você pode decidir em algum momento que Stringnão é suficiente para identificar a empresa, mas ela precisa ter seu próprio tipo Company(que contém dados adicionais como país, endereço, contas bancárias etc.). Sua primeira implementação Carprecisaria ser alterada para ser usada em Companyvez do Stringprimeiro valor. Sua segunda implementação está ótima, você a usa como antes Car Company String Inte funcionaria como antes (é claro que as funções de acesso aos dados da empresa precisam ser alteradas).

O segundo tem a noção de "polimorfismo".

O a b cpode ser de qualquer tipo. Por exemplo, apode ser um [String], bpode ser [Int] e cpode ser [Char].

Enquanto o primeiro tipo é fixo: empresa é a String, modelo é a Stringe ano é Int.

O exemplo Car pode não mostrar o significado do uso de polimorfismo. Mas imagine que seus dados são do tipo lista. Uma lista pode conter String, Char, Int ...Nessas situações, você precisará da segunda maneira de definir seus dados.

Quanto à terceira maneira, acho que não precisa se encaixar no tipo anterior. É apenas uma outra maneira de definir dados no Haskell.

Esta é a minha humilde opinião como iniciante.

Btw: Certifique-se de treinar bem o seu cérebro e se sentir confortável com isso. É a chave para entender o Monad mais tarde.

É sobre tipos : no primeiro caso, você define os tipos String(por empresa e modelo) e Intpor ano. No segundo caso, você é mais genérico. a,, be cpodem ser os mesmos tipos do primeiro exemplo ou algo completamente diferente. Por exemplo, pode ser útil fornecer o ano como string em vez de inteiro. E se você quiser, você pode até usar seu Colortipo.