Haskell - Modèles de données de base

Haskell est un langage de programmation purement fonctionnel, il est donc beaucoup plus interactif et intelligent que les autres langages de programmation. Dans ce chapitre, nous allons découvrir les modèles de données de base de Haskell qui sont en fait prédéfinis ou décodés intelligemment dans la mémoire de l'ordinateur.

Tout au long de ce tutoriel, nous utiliserons la plateforme en ligne Haskell disponible sur notre site Web (https://www.tutorialspoint.com/codingground.htm).

Nombres

Haskell est assez intelligent pour décoder un certain nombre sous forme de nombre. Par conséquent, vous n'avez pas besoin de mentionner son type en externe comme nous le faisons habituellement dans le cas d'autres langages de programmation. Comme par exemple, allez à votre invite de commande prélude et exécutez simplement "2 + 2" et appuyez sur Entrée.

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

En conséquence, vous recevrez la sortie suivante.

Dans le code ci-dessus, nous venons de passer deux nombres comme arguments au compilateur GHCI sans prédéfinir leur type, mais le compilateur pourrait facilement décoder ces deux entrées sous forme de nombres.

Maintenant, essayons un calcul mathématique un peu plus complexe et voyons si notre compilateur intelligent nous donne la sortie correcte ou non. Essayez avec "15+ (5 * 5) -40"

Prelude> 15+(5*5)-40

L'expression ci-dessus donne "0" selon la sortie attendue.

Personnages

Comme les nombres, Haskell peut identifier intelligemment un caractère donné en entrée. Accédez à votre invite de commande Haskell et tapez n'importe quel caractère avec une citation double ou simple.

Fournissons la ligne suivante comme entrée et vérifions sa sortie.

Prelude> :t "a"

Il produira la sortie suivante -

"a" :: [Char]

N'oubliez pas que vous utilisez (:t) tout en fournissant l'entrée. Dans l'exemple ci-dessus,(:t)consiste à inclure le type spécifique lié aux entrées. Nous en apprendrons plus sur ce type dans les prochains chapitres.

Jetez un œil à l'exemple suivant où nous transmettons une entrée non valide sous forme de caractère, ce qui à son tour conduit à une erreur.

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

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

Par le message d'erreur "<interactif>: 4: 1: Pas dans la portée:` a '", le compilateur Haskell nous avertit qu'il n'est pas capable de reconnaître votre entrée. Haskell est un type de langage où tout est représenté à l'aide d'un nombre.

Haskell suit le style d'encodage ASCII conventionnel. Jetons un coup d'œil à l'exemple suivant pour en comprendre plus -

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

Regardez comment votre entrée est décodée au format ASCII.

Chaîne

UNE stringn'est rien d'autre qu'une collection de personnages. Il n'y a pas de syntaxe spécifique pour l'utilisation de la chaîne, mais Haskell suit le style conventionnel de représentation d'une chaîne avec des guillemets doubles.

Jetez un œil à l'exemple suivant où nous passons la chaîne «Tutorialspoint.com».

Prelude> :t "tutorialspoint.com"

Il produira la sortie suivante à l'écran -

"tutorialspoint.com" :: [Char]

Voyez comment la chaîne entière a été décodée en tant que tableau de Char uniquement. Passons à l'autre type de données et à sa syntaxe. Une fois que nous avons commencé notre pratique réelle, nous serons habitués à tous les types de données et à leur utilisation.

Booléen

Le type de données booléen est également assez simple comme les autres types de données. Regardez l'exemple suivant où nous utiliserons différentes opérations booléennes en utilisant des entrées booléennes telles que "True" ou "False".

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

Dans l'exemple ci-dessus, nous n'avons pas besoin de mentionner que "True" et "False" sont les valeurs booléennes. Haskell lui-même peut le décoder et effectuer les opérations respectives. Modifions nos entrées avec "vrai" ou "faux".

Prelude> true

Il produira la sortie suivante -

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

Dans l'exemple ci-dessus, Haskell ne pouvait pas faire la différence entre «vrai» et une valeur numérique, donc notre entrée «vrai» n'est pas un nombre. Par conséquent, le compilateur Haskell renvoie une erreur indiquant que notre entrée n'est pas sa portée.

Compréhension de listes et de listes

Comme d'autres types de données, Listest également un type de données très utile utilisé dans Haskell. Comme par exemple, [a, b, c] est une liste de caractères, donc, par définition, List est une collection du même type de données séparés par des virgules.

Comme d'autres types de données, vous n'avez pas besoin de déclarer une liste en tant que liste. Haskell est suffisamment intelligent pour décoder votre entrée en regardant la syntaxe utilisée dans l'expression.

Jetez un œil à l'exemple suivant qui montre comment Haskell traite une liste.

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

Il produira la sortie suivante -

[1,2,3,4,5]

Les listes dans Haskell sont de nature homogène, ce qui signifie qu'elles ne vous permettront pas de déclarer une liste de types de données différents. Toute liste comme [1,2,3,4,5, a, b, c, d, e, f] produira une erreur.

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

Ce code produira l'erreur suivante -

<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'

Compréhension de liste

La compréhension de liste est le processus de génération d'une liste à l'aide d'une expression mathématique. Regardez l'exemple suivant où nous générons une liste à l'aide d'une expression mathématique au format [sortie | plage, condition].

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]

Cette méthode de création d'une liste à l'aide d'une expression mathématique est appelée List Comprehension.

Tuple

Haskell fournit une autre façon de déclarer plusieurs valeurs dans un seul type de données. Il est connu commeTuple. Un tuple peut être considéré comme une liste, mais il existe des différences techniques entre un tuple et une liste.

Un Tuple est un type de données immuable, car nous ne pouvons pas modifier le nombre d'éléments à l'exécution, alors qu'un List est un type de données mutable.

D'autre part, List est un type de données homogène, mais Tuple est de nature hétérogène, car un Tuple peut contenir différents types de données.

Les tuples sont représentés par des parenthèses simples. Jetez un œil à l'exemple suivant pour voir comment Haskell traite un Tuple.