Haskell - Modelos de Dados Básicos

Haskell é uma linguagem de programação puramente funcional, portanto, é muito mais interativa e inteligente do que outras linguagens de programação. Neste capítulo, aprenderemos sobre modelos de dados básicos de Haskell que são predefinidos ou de alguma forma decodificados de forma inteligente na memória do computador.

Ao longo deste tutorial, usaremos a plataforma online Haskell disponível em nosso site ()

Números

Haskell é inteligente o suficiente para decodificar alguns números como números. Portanto, você não precisa mencionar seu tipo externamente, como costumamos fazer no caso de outras linguagens de programação. Como por exemplo, vá para o prompt de comando do prelúdio e apenas execute "2 + 2" e pressione Enter.

sh-4.3$ ghci 
GHCi, version 7.6.3: http://www.haskell.org/ghc/  :? for help 
Loading package ghc-prim ... linking ... done. 
Loading package integer-gmp ... linking ... done. 
Loading package base ... linking ... done. 
Prelude> 2+2

Você receberá a seguinte saída como resultado.

4

No código acima, apenas passamos dois números como argumentos para o compilador GHCI sem predefinir seu tipo, mas o compilador poderia facilmente decodificar essas duas entradas como números.

Agora, vamos tentar cálculos matemáticos um pouco mais complexos e ver se nosso compilador inteligente nos dá a saída correta ou não. Experimente com "15+ (5 * 5) -40"

Prelude> 15+(5*5)-40

A expressão acima produz "0" de acordo com a saída esperada.

0

Personagens

Como os números, Haskell pode identificar de forma inteligente um caractere fornecido como uma entrada para ele. Vá para o prompt de comando Haskell e digite qualquer caractere com aspas duplas ou simples.

Deixe-nos fornecer a seguinte linha como entrada e verificar sua saída.

Prelude> :t "a"

Ele produzirá a seguinte saída -

"a" :: [Char]

Lembre-se de que você usa (:t) ao fornecer a entrada. No exemplo acima,(:t)é incluir o tipo específico relacionado às entradas. Aprenderemos mais sobre esse tipo nos próximos capítulos.

Dê uma olhada no exemplo a seguir, onde passamos alguma entrada inválida como um caractere que, por sua vez, leva a um erro.

Prelude> :t a 
<interactive>:1:1: Not in scope: 'a'  

Prelude> a 
<interactive>:4:1: Not in scope: 'a'

Com a mensagem de erro "<interativo>: 4: 1: Fora do escopo:` a '"o compilador Haskell está nos avisando que não é capaz de reconhecer sua entrada. Haskell é um tipo de linguagem onde tudo é representado por um número.

Haskell segue o estilo de codificação ASCII convencional. Vamos dar uma olhada no exemplo a seguir para entender mais -

Prelude> '\97' 
'a'  
Prelude> '\67' 
'C'

Veja como sua entrada é decodificada no formato ASCII.

Corda

UMA stringnada mais é que uma coleção de personagens. Não existe uma sintaxe específica para usar string, mas Haskell segue o estilo convencional de representar uma string com aspas duplas.

Dê uma olhada no exemplo a seguir, onde estamos passando a string “Tutorialspoint.com”.

Prelude> :t "tutorialspoint.com"

Ele produzirá a seguinte saída na tela -

"tutorialspoint.com" :: [Char]

Veja como a string inteira foi decodificada como uma matriz de Char apenas. Vamos passar para o outro tipo de dados e sua sintaxe. Assim que começarmos nossa prática real, estaremos habituados a todos os tipos de dados e seu uso.

boleano

O tipo de dados booleano também é bastante direto, como outros tipos de dados. Observe o exemplo a seguir, onde usaremos diferentes operações booleanas usando algumas entradas booleanas como "True" ou "False".

Prelude> True && True 
True  
Prelude> True && False 
False   
Prelude> True || True 
True  
Prelude> True || False 
True

No exemplo acima, não precisamos mencionar que "True" e "False" são os valores booleanos. O próprio Haskell pode decodificá-lo e fazer as respectivas operações. Vamos modificar nossas entradas com "verdadeiro" ou "falso".

Prelude> true

Ele produzirá a seguinte saída -

<interactive>:9:1: Not in scope: 'true'

No exemplo acima, Haskell não pôde diferenciar entre "verdadeiro" e um valor numérico, portanto, nossa entrada "verdadeiro" não é um número. Conseqüentemente, o compilador Haskell emite um erro informando que nossa entrada não é seu escopo.

Lista e compreensão da lista

Como outros tipos de dados, Listtambém é um tipo de dados muito útil usado em Haskell. Como por exemplo, [a, b, c] é uma lista de caracteres, portanto, por definição, Lista é uma coleção do mesmo tipo de dados separados por vírgula.

Como outros tipos de dados, você não precisa declarar uma lista como uma lista. Haskell é inteligente o suficiente para decodificar sua entrada observando a sintaxe usada na expressão.

Dê uma olhada no exemplo a seguir, que mostra como Haskell trata uma Lista.

Prelude> [1,2,3,4,5]

Ele produzirá a seguinte saída -

[1,2,3,4,5]

As listas em Haskell são homogêneas por natureza, o que significa que não permitem que você declare uma lista de tipo diferente de dados. Qualquer lista como [1,2,3,4,5, a, b, c, d, e, f] produzirá um erro.

Prelude> [1,2,3,4,5,a,b,c,d,e,f]

Este código produzirá o seguinte erro -

<interactive>:17:12: Not in scope: 'a' 
<interactive>:17:14: Not in scope: 'b' 
<interactive>:17:16: Not in scope: 'c' 
<interactive>:17:18: Not in scope: 'd' 
<interactive>:17:20: Not in scope: 'e' 
<interactive>:17:22: Not in scope: 'f'

Compreensão de lista

Compreensão de lista é o processo de geração de uma lista usando expressão matemática. Veja o exemplo a seguir, em que estamos gerando uma lista usando uma expressão matemática no formato de [saída | intervalo, condição].

Prelude> [x*2| x<-[1..10]] 
[2,4,6,8,10,12,14,16,18,20]  
Prelude> [x*2| x<-[1..5]] 
[2,4,6,8,10]  
Prelude> [x| x<-[1..5]] 
[1,2,3,4,5]

Este método de criação de uma lista usando expressão matemática é chamado de List Comprehension.

Tupla

Haskell fornece outra maneira de declarar vários valores em um único tipo de dados. É conhecido comoTuple. Uma tupla pode ser considerada uma lista, no entanto, existem algumas diferenças técnicas entre uma tupla e uma lista.

Uma Tupla é um tipo de dados imutável, pois não podemos modificar o número de elementos em tempo de execução, enquanto uma Lista é um tipo de dados mutável.

Por outro lado, Lista é um tipo de dados homogêneo, mas Tupla é de natureza heterogênea, porque uma Tupla pode conter diferentes tipos de dados dentro dela.

As tuplas são representadas por parênteses simples. Dê uma olhada no exemplo a seguir para ver como Haskell trata uma tupla.

Prelude> (1,1,'a')

Ele produzirá a seguinte saída -

(1,1,'a')

No exemplo acima, usamos uma Tupla com duas number variáveis ​​de tipo, e um char variável de tipo.