drawing

Cours03 : le système de types¶

In [ ]:
-- commentaire : directive pour le compilateur ghc 
:opt no-lint

Rappel : Haskell est fortement typé¶

In [ ]:
"2" + 3

La commande :t peut s'appliquer à n'importe quelle expression Haskell, c'est-à-dire à tout ce que l'on peut évaluer (une valeur, une lettre, un calcul, un if-then-else, une fonction, etc.).

Elle va répondre en donnant:

  • soit un type explicite, si c'est le seul possible, par exemple :
In [ ]:
:t 'a'
  • soit un type polymorphe, qui est un type qui contient une ou plusieurs variables de type
In [ ]:
:t []

Ici, le type signifie : une liste d'éléments de n'importe quel type que l'on nomme a. Tous les éléments de liste sont du même type. C'est similaire aux types génériques de Java (par exemple List<A>).

  • soit en indiquant une contrainte de classe, la plus générale possible. Par exemple :
In [ ]:
:t 1

Ici, le type signifie : n'importe quel type que l'on nomme p, tel que p est membre de la classe Num (c'est la contrainte de classe). Autrement dit, l'expression peut avoir n'importe quel type, à condition que ce type soit "un nombre".

Ces notions seront détaillées dans les sections suivantes.

Les types explicites (ou concrets)¶

  • Bool — Valeurs logiques.
  • Char — Caractères individuels.
  • Int — Entiers à précision fixe.
  • Integer — Entiers à précision arbitraire.
  • Float — Nombres à virgule flottante à simple précision.
  • Double — Nombres à virgule flottante à double précision.
  • String — Chaînes de caractères (équivalent de [Char]).
  • les tuples et listes de types explicites
  • les fonctions dont les paramètres/types de retour sont explicites
In [ ]:
:t "Ab"
:t ['A','b']
In [ ]:
:t (True, 'a', "cat")
In [ ]:
:t ["True", "'a'", "cat"]
In [ ]:
-- avec une annotation de type
:t ["True", "'a'", "cat"] :: [String]

Deux types d'entiers¶

In [ ]:
x = 304140932017133780436126081660 :: Int
In [ ]:
x
In [ ]:
x = 304140932017133780436126081660 :: Integer
In [ ]:
x
In [ ]:
:t 304140932017133780436126081660

Type vs. expression¶

Int n'est pas une expression :

In [ ]:
:t Int

C'est un type, on peut donc demander de quelle sorte (kind) de type il s'agit :

In [ ]:
:k Int

Ici, * signifie que c'est un type explicite.

Les variables de type¶

C'est l'équivalent des paramètres de type (type parameter) en Java, c'est-à-dire les lettres entre <>.

In [ ]:
-- quel est le type de la fonction head (pour les listes) ?
:t head

Ici, le type signifie : pour n'importe quel type que l'on nomme a, la fonction head prend en paramètre une liste d'éléments de type a et renvoie une valeur de type a.

Une même variable de type désigne le même type dans toute la signature.

In [ ]:
:t fst

Ici, le type signifie : pour n'importe quels types que l'on nomme a et b, la fonction fst prend en paramètre un couple d'éléments de type (a,b) et renvoie une valeur de type a.

Les classes de type¶

Une classe de type, c'est (grosso modo) l'équivalent d'une interface en Java. C'est une façon de spécialiser une variable de type pour indiquer quel est le comportement qu'elle implémente.

In [ ]:
-- quel est le type de la fonction (==) ?
:t (==)

Ici, le type signifie : pour n'importe quel type que l'on nomme a, tel que a est membre de la classe de type Eq, la fonction (==) prend deux expressions de type a en paramètre et renvoie un booléen.

In [ ]:
-- quel est le type de la fonction (+) ?
:t (+)

Ici, le type signifie : pour n'importe quel type que l'on nomme a, tel que a est membre de la classe de type Num, la fonction (+) prend deux expressions de type a en paramètre et renvoie un nombre de même type.

Num n'est pas une expression :

In [ ]:
:t Num

C'est un type, on peut donc demander de quelle sorte (kind) de type il s'agit :

In [ ]:
:k Num

Ici, * -> Constraint signifie que Num est une classe applicable à un type et qui produit une contrainte.

In [ ]:
-- type explicite vs. classe de type :
:k Int
:k Num

L'analogie avec les interfaces Java ne s'arrête pas là. Une classe de types définit un comportement : additionner, tester l’égalité, comparer l’ordre, énumérer, ...

Les types qui implémentent ce comportement sont des instances de cette classe.

La commande :i permet d'avoir toutes ces informations pour une classe de type.

In [ ]:
:i Num
In [ ]:
-- quel est le type de la fonction (==) ?
:t (==)

Eq est une classe de type. Eq a est une contrainte sur le type de a utlisé dans la signature de la fonction (==). Et forall a. quantifie la variable de type.

In [ ]:
:i Eq
In [ ]:
-- quel est le type de la fonction (<) ?
:t (<)
In [ ]:
:i Ord

La commande :i permet également de savoir, pour un type explicite donné, de quelles classes il est une instance.

In [ ]:
:i Int

Les principales classes de type, leurs dépendances et les types explicites qui les implémentent.¶

drawing
In [ ]:
-- quel est le type de la fonction sqrt ?
:t sqrt

Ici, le type signifie : pour n'importe quel type de flottant (on a vu Float et Double, par exemple) que l'on nomme a, la fonction sqrt prend en paramètre une valeur de type a et renvoie une valeur de type a.

In [ ]:
-- quel est le type de la fonction even ?
:t even
In [ ]:
-- quel est le type de la fonction (^) ?
:t (^)
In [ ]:
3 ^ 4
In [ ]:
3.4 ^ 5
In [ ]:
3 ^ 4.5
In [ ]:
3 ^ (-4)

Documentation de la fonction :

(^) :: (Num a, Integral b) => a -> b -> a 
raise a number to a non-negative integral power

⚠ Le fait de ne pas pouvoir passer un paramètre négatif n'est pas une contrainte de type. Les classes de type définissent un ensemble de fonctions qui doivent être implémentées, pas des propriétés.

Exemple de variations sur le typage¶

In [ ]:
fac :: Int -> Int
fac n = product [1..n]
In [ ]:
fac 10
In [ ]:
fac 30
In [ ]:
fac2 :: Integer -> Integer
fac2 n = product [1..n]
In [ ]:
fac2 100
In [ ]:
:t fac2
In [ ]:
fac3 :: Int -> Integer
fac3 n = product [1..fromIntegral n]
In [ ]:
fac3 30
In [ ]:
fac4 n = product [1..n]
In [ ]:
fac4 30
In [ ]:
:t fac4
In [ ]:
fac5 0 = 1
fac5 n = n * fac5 (n-1)
In [ ]:
fac5 30
In [ ]:
:t fac5

Éléments de correction du TP¶

In [ ]:
-- correction de contains
-- contains :: String -> String -> Bool

Résultat attendu:

λ> contains "askell" "Haskell"
True
λ> contains "Hsk" "Haskell"
False
λ> contains "hello" "Hello"
False
λ> contains "" "Haskell"
True
λ> contains "Haskell" ""
False
In [ ]: