GHC

GHC reconnaît les formats d'entrées suivants:

Les fichiers .cabal

Cabal et Stack

if

Une clause if est une expression, pas une structure de contrôle. La syntaxe est if a then b else c, où a est une expression de type Bool, b et c des expressions d'un type quelconque. Si a est vraie, l'expression vaut b, sinon c.

Comme c'est une expression, on peut affecter son résultat directement à une variable:

a = if even x then "pair" else "impair"

Que if soit une primitive du compilateur n'est justifié que par le gain de clarté qu'il apporte. L'implémenter en Haskell directement est trivial:

if' :: Bool -> a -> a
if' True a _ = a
if' _ _ b = b

case

Polymorphisme paramétrique

N'importe quelle fonction ou type peut accepter des paramètres d'un type non défini. Sa signature remplace dans ce cas le nom d'un type par un paramètre de type, qui commence par une minuscule.

ghci> :type Just 3
Just 3 :: Num a => Maybe a
ghci> :type Just "Une chaîne"
Just "Une chaîne" :: Maybe [Char]
ghci> :type Nothing
Nothing :: Maybe a

third :: [a] -> Maybe a
third (_:_:x:_) = Just x
third _ = Nothing

Polymorphisme ad hoc

Écrire un module

Un module a le même nom que le fichier .hs qui le contient, et ce nom commence par une majuscule. La déclaration de module a la syntaxe suivante:

-- MyModule.hs
module Mod ( x, y, z ) where -- code

Cette déclaration exporte les identifiants x, y et z du code qui la suit. On exporterait la totalité des noms en enlevant la parenthèse, et aucun en la laissant vide.

TODO exporter un type mais pas ses constructeurs.

Importation de modules

-- Commande -- Importé
import Mod                        -- x, y, z, Mod.x, Mod.y, Mod.z
import Mod ()                     -- Uniquement les instances, voir ci-dessous.
import Mod (x,y)                  -- x, y, Mod.x, Mod.y
import qualified Mod              -- Mod.x, Mod.y, Mod.z
import qualified Mod (x,y)        -- Mod.x, Mod.y
import Mod hiding (x,y)           -- z, Mod.z
import qualified Mod hiding (x,y) -- Mod.z
import Mod as Foo                 -- x, y, z, Foo.x, Foo.y, Foo.z
import Mod as Foo (x,y)           -- x, y, Foo.x, Foo.y
import qualified Mod as Foo       -- Foo.x, Foo.y, Foo.z
import qualified Mod as Foo (x,y) -- Foo.x, Foo.y

Même sans importer aucun nom (c'est le cas de import Mod ()), tout import importe les instances de classes de types définies dans le module importé.

Modules et instances

Les instances de classes de types définies dans un module sont toujours exportées et importées, quels que soient les noms explicitement importés ou exportés, et même s'il n'y en a aucun.

Composition et point-free style

reverseTail, reverseTailPointFree :: [a] -> [a]
reverseTail x = reverse . tail $ x
reverseTailPointFree = reverse . tail

Récursivité

Folds

Les différents folds sont des catamorphismes.

Associatif à droite:

foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b

Associatif à gauche:

foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b

Associatif à gauche, évaluation stricte:

Data.List.foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b

Cette version

Voir le tutorial de .

Nommage des identifiants

En Haskell, la casse du premier caractère d'un identifiant a une importance. Un nom de type ou un constructeur de type commencent toujours par une majuscule, un nom de fonction ou de variable par une minuscule.

Types produits, types sommes, types exponentielles

Si on comprend qu'un type est un ensemble (de valeurs possibles), on voit aisément pourquoi on parle de types produit ou somme:

• Une alternative entre type (data OuBien = Chaine String | Entier Int) a pour cardinal la somme des cardinaux des types qui le constituent.

• Une combinaison de types (data ChaineEtEntier = ChaineEtEntier String Int) a pour cardinal le produit des cardinaux des types qui le constituent.

• Une application de types (TypeA -> TypeB) a pour cardinal le cardinal du type du résultat élevé à la puissance du cardinal du type du paramètre. Le cardinal de a -> b est donc \#b^{\#a}.

(Le cardinal d'un type défini avec data est simplement une somme de produits.)

Types élémentaires

Haskell fournit un grand nombre de types élémentaires, dont les plus importants sont résumés dans ce tableau:

Produits

data Book = NewBook String [String] Int
--                  ^               ^__ Année de publication
--                  |      ^___________ Auteurs
--                  |__________________ Titre

Cette ligne définit un type nommé Book qui fournit un unique constructeur NewBook. Le constructeur NewBook se comporte comme une fonction qui prend trois paramètres et qrenvoie un Book: NewBook :: String -> [String] -> Int -> Book. Pour construire un nouveau Book, on écrit donc book = NewBook "Critique of Pure Reason" ["Immanuel Kant"] 1781. Dans cette syntaxe, les arguments du constructeur sont positionnels et doivent être fournis dans l'ordre de la déclaration.

Sommes

Un type somme présente une alternative en offrant plusieurs constructeurs.

data Bool = True | False
data Maybe a = Nothing | Just a

Syntaxe d'enregistrement

La syntaxe d'enregistrement permet de nommer les champs.

data Book = Book {
  bookTitle :: String, -- bookTitle :: Book -> String
  bookAuthors :: [String], -- bookAuthors :: Book -> [String]
  bookYear :: Int -- bookYear :: Book -> Int
  }

Un type qui utilise cette syntaxe peut être instantié avec des arguments positionnels ou des arguments nommés. Ces derniers peuvent être fournis dans n'importe quel ordre:

crp = Book "Critique de la Raison Pure" ["Immanuel Kant"] 1781
tlp = Book {
  bookYear = 1921,
  bookAuthors = ["Ludwig Wittgenstein"],
  bookTitle = "Tractatus Logico-Philosophicus"
  }

Il définit automatiquement une fonction accesseur pour chacun de ses champs. Le type Book ci-dessus fournit ainsi trois fonctions bookYear :: Book -> Int, bookAuthors :: Book -> [String] et bookTitle :: Book -> String:

ghci>  bookYear tlp 1921

Enfin, il permet de construire une nouvelle valeur à partir des champs d'une valeur existante:

rp = tlp {bookTitle = "Recherches philosophiques", bookYear=1953}

Les types comme contextes

@TODO (On peut considérer un type algébrique comme un contexte sémantique pour un type natif.)

Types récursifs

Un type peut faire référence à lui-même. On peut construire un type liste identique au type natif de la façon suivante:

data List a = Empty | Cons a (List a) list = (Cons 1 (Cons 2 (Cons 3
Empty)))

Un arbre binaire:

data BTree a = Node a (BTree a) (BTree a) | Empty deriving Show

type

type crée un synonyme d'un type existant. Le synonyme et le type auquel ils renvoient sont interchangeables.

type ObjectId = Int16

Les synonymes créés avec type peuvent servir:

• À clarifier le sens des champs dans les types personnalisés sans accesseurs (type ISBN = Int pour un type Book, par exemple):

type Authors = [String]
type Title = String
type ISBN = Int
type Year = Int
data Book2 = Authors Title Year ISBN

• Comme notation abrégée pour des types complexes fréquemment utilisés.

type Weird = (Int -> String) -> (Int -> Int) -> [Int] -> [(Int, String, Int)]

newtype

Le mot-clé newtype permet de dupliquer un type, et crée un type distinct de l'original. Les synonymes créés avec newtype ne sont pas substituables avec le type dont ils sont synonymes. De plus, il n'appartiennent pas automatiquement aux types de classe de ce dernier. Leur syntaxe est très proche de celle de data:

newtype MyType = MyType Int

• Contrairement à data, newtype:

  • n'autorise qu'un seul constructeur et un seul champ.

  • ne conserve pas les informations du type après la compilation. Dans le programme compilé, MyType ci-dessus est traité comme un

  simple Int:

• Contrairement à type,

  • il ne maintient pas la substituabilité du nouveau type et du type dont il est un synonyme. *Alors que type sert à faciliter la lecture, newtype est plutôt utilisé pour masquer l'implémentation*. Il permet notamment de masquer un type sous-jacent sans la perte de performances liée à l'usage de data, par exemple: newtype ResourceHandle = ResourceHandle Int16. Comme il est possible à un module de n'exporter que le type mais pas le constructeur, un programme peut recevoir et transmettre des données de type ResourceHandle sans connaître leur type réel.

  • Il permet aussi, sans perte de performances, de fournir des instances différentes d'une unique classe de type pour un type donné:

    -- Data.Monoid
    
    -- Booléen selon la conjonction
    newtype All = All { getAll :: Bool }
      deriving (Eq, Ord, Read, Show, Bounded)
    instance Monoid All where
      mempty = All True
      mappend (All x) (All y) = All (x && y)
    
    -- Booléen selon la disjonction
    newtype Any = Any { getAny :: Bool }
      deriving (Eq, Ord, Read, Show, Bounded)
    instance Monoid Any where
      mempty = Any False
      mappend (Any x) (Any y) = Any (x || y)

• Enfin, newtype est strict.

Créer une classe de type

class Parsable a where
  parse :: String -> a

Une implémentation par défaut peut être fournie. La classe de type Eq par exemple est définie comme:

class Eq a where
  (==), (/=) :: a -> a -> Bool
  x /= y     =  not (x == y)
  x == y     =  not (x /= y)

Dériver une classe de type

Version triviale:

data CanardLapin = { canard :: Bool, lapin :: Bool }
instance Show CanardLapin where
  show (CanardLapin True False) = "Seulement un canard"
  show (CanardLapin False True) = "Seulement un lapin"
  show _ = "Un canard lapin!"

Plus marrant: dériver un type higher-kinded en fonction de son paramètre:

{-# LANGUAGE FlexibleInstances #-}

class Magique a where
  magie :: a -> a

data CanardLapin' = Canard | Lapin

instance Functor f, Magique m => Magique (f m) where
  magie = fmap magie

instance Magique CanardLapin' where
  magie Canard = Lapin
  magie Lapin = Canard

Dérivation automatique

Les types crées avec data et newtype peuvent dériver automatiquement certaines classes avec le mot clé deriving:

data Something = Something Integer Integer
  deriving (Show)

La dérivation automatique est implémentée au niveau du compilateur, et ne concerne que quelques classes de type du Prélude.

Signature de type

La signature a la forme f :: TypeA -> TypeRet, ce qui signifie que la fonction prend un paramètre de type TypeA et renvoie une valeur de type TypeRet.

Une fonction définie avec plusieurs paramètres a pour signature f :: TypeA -> TypeB -> TypeC -> TypeRet. Cette syntaxe est explicitée fiche . Les fonctions d'ordre supérieur utilisent les parenthèses pour indiquer qu'elles prennent une autre fonction en paramètre. Par exemple, le type map :: (a -> b) -> [a] -> [b] se lit : map prend comme premier paramètre une fonction quelconque x :: a -> b. Une variable ou une fonction sans paramètres a pour type nom :: Type.

Définition de fonctions

Une fonction se définit de la façon suivante:

add :: Int -> Int -> Int -- Signature de type, généralement optionnel.
add a b = a + b

Une fonction infixe se définit en entourant son nom de parenthèses, comme pour l'utiliser en préfixe:

(+/) a b = a + b + a / b

Fonctions préfixes et infixes

Une fonction est dite préfixe si son nom est placé avant ses arguments, et infixe si son nom est placé entre ses arguments. map est une fonction préfixe, + est infixe. La distinction est syntaxique, et se fait au niveau des caractères qui constituent le nom de la fonction.

Fonctions locales

On peut définir des fonctions dont la visibilité est limitée à une fonction. C'est utile pour définir des constantes, ou fournir des fonctions utilitaires qui n'ont pas besoin d'être disponibles au niveau du module. Haskell propose deux syntaxes: let, qui place les variables locales avant le code de la fonction, et where, qui les positionne après.

circLet :: Fractional a => a -> a
circLet radius = let pi = 3.14
         diam = 2 * radius
     in pi * diam

circWhere :: Fractional a => a -> a
circWhere radius = pi * diam
  where pi   = 3.141592653589793
    diam = 2 * radius

• Le choix de l'une ou de l'autre syntaxe est une question de goût et de lisibilité.

• On peut les imbriquer: une fonction locale peut à son tour définir des fonctions locales, etc.

• La visiblité des fonctions locales est limitée à la définition englobante.

Fixité (précédence et associativité)

L'associativité et la précédence sont collectivement nommées «fixité». La fixité d'une fonction infixe (et de n'importe quelle fonction préfixe dans sa forme infixe, comme `elem`) est fixée par une déclaration infixl (associatif à gauche), infixr (associatif à droite) ou infix (non-associatif), suivie de l'ordre de précédence compris entre 0 et 9 et du nom de la fonction:

(+/) :: Num a => a -> a -> a
infixl 9 +/
(+/) a b = a + b + a / b

Il est possible de définir la fixité d'une fonction locale, directement dans la clause let ou where où elle est définie.

Paramètres

toggle :: (a, b) -> a
toggle (x, y) = (y, x)

duplFirst :: (a, b) -> (a, a)
duplFirst (x, \_) = (x, x)

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

suffixes :: [a] -> [[a]] suffixes xs(/:xs') = xs : suffixes xs'
suffixes / = []

Filtrage par motif et gardes

Le filtrage par motifs et l'emploi de gardes permettent de proposer différentes implémentations d'une même fonction selon les paramètres qui y sont passés, de façon similaire à l'emploi de cas en notation mathématique :

f(x) = \begin{cases} f(x-1) + x & \text{si } x > 0 \\ 1 & \text{sinon} \end{cases}

Le filtrage par motifs permet de choisir une implémentation selon le type et dans une certaine mesure la valeur des paramètres, les gardes selon une expression arbitraire.

Filtrage par motifs

Le filtrage par motifs permet de filtrer selon un constructeur ou selon une valeur arbitraire.

maybeIntToStr :: Maybe Int -> String
maybeIntToStr (Just a) = show a
maybeIntToStr Nothing = "NaN"

mySum :: (Num a) => [a] -> a
mySum (x:xs) = x + mySum xs
mySum [] = 0

compte :: String -> String -> Int -> String
compte singulier pluriel 0 = "Aucun(e) " ++ singulier
compte singulier pluriel 1 = "Un(e) " ++ singulier
compte singulier pluriel quantite = show quantite ++ " " ++ pluriel

compte :: String -> String -> Int -> String
compte singulier _ 0 = "Aucun(e) " ++ singulier
compte singulier _ 1 = "Un(e) " ++ singulier
compte _ pluriel quantite = show quantite ++ " " ++ pluriel

Gardes

Un garde est une expression de type Bool. Si l'expression s'évalue à True, l'implémentation qui suit est utilisée.

Leur syntaxe est:

func args | garde = impl

Par exemple, une fonction qui détermine si un nombre est pair, qui s'implémenterait naïvement sous la forme isEven x = if x `mod` 2 == 0 then True else False peut s'écrire plus lisiblement:

isEven x | x mod 2 == 0 = True
isEven _ = False

La partie à gauche du garde peut être omise si elle est identique à celle qui précède (c'est-à-dire si l'éventuel motif est le même):

isEven x | x mod 2 == 0 = True
         | otherwise = False

gardes :: Int -> String gardes a | odd a, a =mod= 5 == 0 = "Impair et/ou
multiple de 5" | even a = "Pair mais pas multiple de 5"

Fonctions spécifiques aux listes

Généralisées aux foncteurs

Lois des monoïdes

Les monoïdes ont deux lois:

1. Loi d'identité:

   x <> mempty = x
   mempty <> x = x

   L'application de mappend sur mempty et une valeur quelconque x retourne toujours x, quel que soit l'ordre des paramètres.

   (Attention, ça n'implique pas qu'un monoïde est nécessairement commutatif! Beaucoup le sont, mais String est un monoïde avec mempty = "" et mappend = (++), et ++ n'est évidemment pas commutatif.)

2. Loi d'associativité:

   (x <> y) <> z = x <> (y <> z)

   Informellement: une série d'applications de `mappend` renvoie le même résultat quel que soit l'ordre d'application.

Lois des Traversable

Fonctions d'entrée

Fonctions de sortie

Manipulation de fichiers ou de répertoires

Les types Maybe et Either

Exceptions

Auteur et mainteneur

Thibault Polge (thibault@thb.lt)

Outils

Ce site est généré avec Hakyll, une librairie de génération de sites statiques écrite en Haskell.

Le thème est compilé avec Sass et utilise Gridle.

Le corps du texte est composé en Open Sans, les titres en Open Sans Condensed.

Les icônes des différentes boîtes proviennent de différentes séries compilées sur IcoMoon

Licence

Pour l'instant, ce travail est mis à disposition sous la (relativement restrictive) [[https://creativecommons.org/licenses/by-nc-sa/2.0/fr/][Licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Partage dans les Mêmes Conditions 2.0 France]].