drawing

Cours 05 : Créer de nouveaux types¶

Types synonymes¶

La façon la plus simple de déclarer un nouveau nom de type consiste à donner un autre nom à un type existant.

En Haskell, on crée un synonyme de type avec le mot-clé type. Son nom doit commencer par une majuscule.

Par exemple, String est un synonyme de [Char], le type des listes de caractères :

In [1]:
:opt no-lint

type String = [Char]

Un synonyme de type ne crée pas un type distinct : String et [Char] désignent le même type.

In [2]:
type Point = (Float, Float) -- coordonées
type Circle = (Point, Float) -- centre et rayon
In [3]:
perimeter :: Circle -> Float
perimeter (_, radius) = 2 * pi * radius
In [4]:
perimeter ((1,1),3.5)
21.99115
In [5]:
:t ((1,1),3.5)
((1,1),3.5) :: forall b1 a b2. (Fractional b1, Num a, Num b2) => ((a, b2), b1)
In [6]:
:t ((1,1),3.5) :: Circle
((1,1),3.5) :: Circle :: Circle
In [7]:
:k Circle
Circle :: *
In [8]:
distance :: Point -> Point -> Float
distance (x1, y1) (x2, y2) = sqrt ((x2 - x1)^2 + (y2 - y1)^2)

pointInCircle :: Point -> Circle -> Bool
pointInCircle point (center, radius) = radius >= 0 && distance point center <= radius
In [9]:
pointInCircle (2,2) ((1,1),3.5)
pointInCircle (5,5) ((1,1),3.5)
True
False

Les déclarations de types synonymes peuvent être parametrées par d'autre types.

In [10]:
type Trio a = (a, a, a)

allEquals :: Eq a => Trio a -> Bool
allEquals (a,b,c) = a == b && b == c
In [11]:
allEquals ((1,1,1) :: Trio Int)
True

Types de données algébriques (data types)¶

  • En Haskell, on peut déclarer un nouveau type, et non simplement un synonyme d’un type existant, en définissant ses valeurs avec data.
  • Une définition de type algébrique commence par data, suivi du nom du type, du symbole =, puis des constructeurs.
  • Les noms des types et des constructeurs commencent par une majuscule.

Type énumérés¶

Un type énuméré représente un choix entre plusieurs valeurs. Par exemple :

In [12]:
-- type énuméré
data Temperature = Cold | Hot
In [13]:
:t Cold
:t Hot
Cold :: Temperature
Hot :: Temperature

Cold et Hot sont les deux constructeurs de valeurs du type Temperature.

In [14]:
:t Temperature
<interactive>:1:1: error:
    • Data constructor not in scope: Temperature
    • Perhaps you meant variable ‘$tcTemperature’ (<no location info>)
In [61]:
:k Temperature
Temperature :: *

Un autre exemple

In [16]:
data Season = Spring | Summer | Autumn | Winter

Pour définir des fonctions sur des types énumérés, on utilise... du pattern matching, bien sûr !

In [17]:
toString :: Season -> String
toString Spring = "printemps"
toString Summer = "été"
toString Autumn = "automne"
toString Winter = "hiver"
In [18]:
toString Winter
"hiver"
In [19]:
seasonToTemperature :: Season -> Temperature
seasonToTemperature Winter = Cold
seasonToTemperature _      = Hot
In [20]:
seasonToTemperature Summer
<interactive>:1:1: error:
    • No instance for (Show Temperature) arising from a use of ‘print’
    • In a stmt of an interactive GHCi command: print it

🤔

Pour afficher une expression, Haskell exécute la fonction show sur cette valeur pour obtenir une représentation en chaîne de caractères, puis affiche celle-ci dans le terminal.

In [21]:
:i show
type Show :: * -> Constraint
class Show a where
...
show :: a -> IHaskellPrelude.String
...
-- Defined in ‘GHC.Show’

La fonctionshow est déclarée dans la classe de types Show.

In [22]:
:i Show
type Show :: * -> Constraint
class Show a where
showsPrec :: Int -> a -> ShowS
show :: a -> IHaskellPrelude.String
showList :: [a] -> ShowS
{-# MINIMAL showsPrec | show #-}
-- Defined in ‘GHC.Show’
instance (Show a, Show b) => Show (Either a b) -- Defined in ‘Data.Either’
instance Show IHaskellTH.TypeFamilyHead -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Type -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.TyVarBndr -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.TySynEqn -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.TyLit -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Stmt -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.SourceUnpackedness -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.SourceStrictness -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Safety -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.RuleMatch -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.RuleBndr -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Role -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Range -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Pragma -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Phases -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.PatSynDir -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.PatSynArgs -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Pat -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Overlap -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.NameSpace -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Name -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.ModuleInfo -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Match -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Loc -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Lit -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Inline -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.InjectivityAnn -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Info -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Guard -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.FunDep -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Foreign -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.FixityDirection -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Fixity -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.FamilyResultSig -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Exp -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.DerivStrategy -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.DerivClause -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.DecidedStrictness -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Dec -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Con -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Clause -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Callconv -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Body -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.Bang -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.AnnTarget -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellTH.AnnLookup -- Defined in ‘Language.Haskell.TH.Syntax’
instance Show IHaskellSysIO.NewlineMode -- Defined in ‘GHC.IO.Handle.Types’
instance Show IHaskellSysIO.Newline -- Defined in ‘GHC.IO.Handle.Types’
instance Show IHaskellSysIO.Handle -- Defined in ‘GHC.IO.Handle.Types’
instance Show IHaskellSysIO.BufferMode -- Defined in ‘GHC.IO.Handle.Types’
instance Show IHaskellSysIO.HandlePosn -- Defined in ‘GHC.IO.Handle’
instance Show IHaskell.Display.Widget -- Defined in ‘IHaskell.Types’
instance Show IHaskell.Display.Display -- Defined in ‘IHaskell.Types’
instance Show a => Show [a] -- Defined in ‘GHC.Show’
instance Show Word -- Defined in ‘GHC.Show’
instance Show GHC.Types.RuntimeRep -- Defined in ‘GHC.Show’
instance Show Ordering -- Defined in ‘GHC.Show’
instance Show a => Show (Maybe a) -- Defined in ‘GHC.Show’
instance Show Integer -- Defined in ‘GHC.Show’
instance Show Int -- Defined in ‘GHC.Show’
instance Show Char -- Defined in ‘GHC.Show’
instance Show Bool -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n, Show o) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
-- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m) -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l) => Show (a, b, c, d, e, f, g, h, i, j, k, l) -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k) => Show (a, b, c, d, e, f, g, h, i, j, k) -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j) => Show (a, b, c, d, e, f, g, h, i, j) -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i) => Show (a, b, c, d, e, f, g, h, i) -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h) => Show (a, b, c, d, e, f, g, h) -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a, b, c, d, e, f, g) -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f) -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e) -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d) => Show (a, b, c, d) -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c) => Show (a, b, c) -- Defined in ‘GHC.Show’
instance (Show a, Show b) => Show (a, b) -- Defined in ‘GHC.Show’
instance Show () -- Defined in ‘GHC.Show’
instance Show Float -- Defined in ‘GHC.Float’
instance Show Double -- Defined in ‘GHC.Float’

Pour rendre Temperature membre de la classe de types Show, on peut le modifier définir show ainsi :

In [23]:
instance Show Temperature where
    show Hot = "chaud"
    show Cold = "froid"
In [24]:
Hot
chaud

Ou encore plus simplement, avec la version "par défaut" :

In [25]:
data Season = Spring | Summer | Autumn | Winter deriving Show
In [26]:
Winter
Winter

Types produits¶

Un type produit regroupe plusieurs valeurs en même temps :

In [5]:
data ColorRGB = RGB Int Int Int

ColorRGB est un constructeur de type et RGB est un constructeur de valeur.

In [6]:
red = RGB 255 0 0
In [7]:
red
<interactive>:1:1: error:
    • No instance for (Show ColorRGB) arising from a use of ‘print’
    • In a stmt of an interactive GHCi command: print it
In [8]:
data ColorRGB = RGB Int Int Int deriving Show
In [9]:
RGB 255 0 0
RGB 255 0 0
In [10]:
data Color = Red | Green | Blue | Purple | Yellow | Orange deriving Show

toRGB :: Color -> ColorRGB
toRGB Red    = RGB 255 0   0
toRGB Green  = RGB 0   255 0
toRGB Blue   = RGB 0   0   255
toRGB Purple = RGB 128 0   128
toRGB Yellow = RGB 255 255 0
toRGB Orange = RGB 255 165 0
In [11]:
toRGB Red
RGB 255 0 0
In [12]:
data Color = Red | Green | Blue | Purple | Yellow | Orange | Undefined deriving Show

fromRGB :: ColorRGB -> Color
fromRGB (RGB 255 0   0)   = Red
fromRGB (RGB 0   255 0)   = Green
fromRGB (RGB 0   0   255) = Blue
fromRGB (RGB 128 0   128) = Purple
fromRGB (RGB 255 255 0)   = Yellow
fromRGB (RGB 255 165 0)   = Orange
fromRGB _                 = Undefined -- bof :(
In [13]:
fromRGB (RGB 255 0 0)
Red
In [14]:
fromRGB (RGB 255 0 1)
Undefined

Le constructeur de valeur peut avoir le même nom que le constructeur de type :

In [15]:
data RGB = RGB Int Int Int -- type produit

Différence avec les types synonymes

In [16]:
type RGB' = (Int, Int, Int) -- type synonyme
In [17]:
:t RGB'
<interactive>:1:1: error:
    • Data constructor not in scope: RGB'
    • Perhaps you meant one of these: ‘Ghci53.RGB’ (imported from Ghci53), ‘Ghci105.RGB’ (imported from Ghci105), ‘RGB’ (line 1)
In [18]:
:t RGB
RGB :: Int -> Int -> Int -> RGB
In [19]:
:t ColorRGB
<interactive>:1:1: error: Data constructor not in scope: ColorRGB

Types somme¶

Un type somme, c'est un peu la combinaison d'un type produit et d'un type énuméré (une énumération de produits) :

In [25]:
data Color = RGB Int Int Int | Hex String deriving (Show,Eq)
In [30]:
lst = [Hex "FF0000", RGB 255 0 0]
lst
:t lst
[Hex "FF0000",RGB 255 0 0]
lst :: [Color]

Là encore, on les manipule au travers du pattern matching

In [31]:
isRed :: Color -> Bool
isRed (Hex "FF0000") = True
isRed (RGB 255 0 0)  = True
isRed _              = False

Avec des paramètres de type¶

Les types de données algébriques peuvent être typés (comme quand on crée ses propres types géneriques en Java).

Par exemple, le type Maybe a, qui correspond (à peu près) aux Optional<A> de Java est défini ainsi :

data Maybe a = Nothing | Just a
In [32]:
:i Maybe
type Maybe :: * -> *
data Maybe a = Nothing | Just a
-- Defined in ‘GHC.Maybe’
instance Show a => Show (Maybe a) -- Defined in ‘GHC.Show’
instance Eq a => Eq (Maybe a) -- Defined in ‘GHC.Maybe’
instance Functor Maybe -- Defined in ‘GHC.Base’
instance Foldable Maybe -- Defined in ‘Data.Foldable’
instance Traversable Maybe -- Defined in ‘Data.Traversable’
instance Ord a => Ord (Maybe a) -- Defined in ‘GHC.Maybe’
instance Semigroup a => Monoid (Maybe a) -- Defined in ‘GHC.Base’
instance Read a => Read (Maybe a) -- Defined in ‘GHC.Read’
instance Semigroup a => Semigroup (Maybe a) -- Defined in ‘GHC.Base’
instance Applicative Maybe -- Defined in ‘GHC.Base’
instance Monad Maybe -- Defined in ‘GHC.Base’
instance MonadFail Maybe -- Defined in ‘Control.Monad.Fail’
In [33]:
Just 1
Just 1
In [34]:
Just "Haskell"
Just "Haskell"
In [35]:
Nothing
Nothing
In [36]:
:t Nothing
Nothing :: forall a. Maybe a
In [37]:
:t Just
Just :: forall a. a -> Maybe a
In [38]:
:t Maybe
<interactive>:1:1: error:
    • Data constructor not in scope: Maybe
    • Perhaps you meant variable ‘maybe’ (imported from Prelude)
In [39]:
:k Maybe
Maybe :: * -> *
In [40]:
:k Maybe Int
Maybe Int :: *
In [41]:
:t Just 1
Just 1 :: forall a. Num a => Maybe a
In [42]:
data RGB = RGB Int Int Int

data Color = Red | Green | Blue deriving Show

fromRGB :: RGB -> Maybe Color
fromRGB (RGB 255 0   0)   = Just Red
fromRGB (RGB 0   255 0)   = Just Green
fromRGB (RGB 0   0   255) = Just Blue
fromRGB _                 = Nothing -- mieux :D
In [43]:
fromRGB (RGB 0 0 0)
Nothing

Éléments de correction du TP¶

In [ ]: