Fiche de TP no. 4 1

Master 1 Informatique 2015-2016
Programmation Fonctionnelle, p. 1
Fiche de TP no. 4 1
Objectifs : Nous avons aujourd’hui ces objectifs :
1. Comprendre comment on définit des types et comment on utilise les types récursifs.
2. Comprendre comment on instancie un type à une classe, et comment on utilise un module.
3. Écrire un simple analyseur syntaxique (un parseur) en Haskell.
4. Discuter avec les chargés de TP le projet.
Distribuez vos énergies et temps de façon égalitaire entre ces objectifs.
Caveats : le temps passe vite ! Si, après vingt minutes vous êtes encore au premier exercice, cela est un bon
indice que vous ne vous donnez pas les moyens d’apprendre la programmation fonctionnelle.
Exercice 1. Téléchargez le module Parser.hs (ci-dessous) depuis la page web du cours
http://pageperso.lif.univ-mrs.fr/~luigi.santocanale/teaching/PF/code/TP4/Parser.hs
1
2
3
4
5
6
7
module Parser (
Parser ( MkParser ) ,
caractere ,
parse ,
(|||)
)
where
9
10
type Resultat a = Maybe (a , String )
newtype Parser a = MkParser ( String -> Resultat a )
12
13
echoue :: Parser a
echoue = MkParser (\ _ -> Nothing )
15
16
retourne :: a -> Parser a
retourne v = MkParser (\ s -> Just (v , s ))
18
19
20
21
caractere :: Parser Char
caractere = MkParser (\ s -> case s of
""
-> Nothing
( c : cs ) -> Just (c , cs ))
23
24
parse :: Parser a -> String -> Resultat a
parse ( MkParser p ) = p
26
27
28
29
(|||) :: Parser a -> Parser a -> Parser
p ||| p ’ = MkParser (\ s -> case parse p
Nothing ->
r
->
31
32
33
34
( > > >) :: Parser a -> ( a -> Parser b ) -> Parser b
p >>> pf = MkParser (\ s -> case parse p s of
Nothing
-> Nothing
Just (a , s ’) -> parse ( pf a ) s ’)
36
37
38
39
instance Monad Parser where
( > >=) = ( > > >)
return = retourne
fail _ = echoue
a
s of
parse p ’ s
r)
Question 2. Expliquez la définition du type Parser, la définition du parseur caractere, la définition des
opérateurs ||| et >>>.
Question 3. Expliquez ce qui se passe avec les mots clés module et instance.
1. Ce TP est basé sur le TD4 de Samuel Hym http://www.fil.univ-lille1.fr/~hym/e/pf/tdtp/td4.pdf
Master 1 Informatique 2015-2016
Programmation Fonctionnelle, p. 2
Chargez depuis ghci ce module.
Question 4. Evaluez les expressions suivantes et en expliquez l’évaluation :
parse
parse
parse
parse
parse
parse
parse
parse
parse
parse
echoue " haskell "
( retourne 5) " haskell "
caractere " haskell "
( echoue ||| retourne 5) " haskell "
( retourne 5 ||| echoue ) " haskell "
( echoue >>> \ _ -> retourne 5) " haskell "
( fail """ > >= \ _ -> return 5) " haskell "
( do { fail "" ; return 5 }) " haskell "
( do { return 5 ; fail ""}) " haskell "
( caractere > >= \ c -> caractere > >= \ d -> return [d , c ]) " haskell "
Exercice 5. Ajoutez au module Parser une fonction parserChars :: String -> Parser Char qui construit,
à partir d’une liste de caractères, un parseur qui vérifie si le premier caractère d’un flot appartient à la liste
et dans ce cas il retourne ce caractère ; sinon, le parseur retournera Nothing.
Exercice 6. On représente des arbres binaires (non-étiquetés) sous forme textuelle de la façon suivante : f
est une feuille ; (f,(f,f)) est un arbre ayant une feuille f pour sous-arbre gauche et (f,f) pour sous-arbre
droit ; . . . et ainsi de suite.
Dans un script nommé ABin.hs—différent de Parser.hs mais qui importera Parser.hs—définissez
1. une type de données récursif ABin adapté à représenter les arbres binaire non étiquetés ;
2. un parseur parserABin :: Parser ABin, qui construira un arbre binaire à partir de sa représentation
textuelle.
Exercice 7. Ajoutez au module Parser.hs une fonction unOuPLus :: Parser a -> Parser [a] qui étant
donné un parseur, reconnaît une chaîne de caractères qui est la concaténation non-vide de chaînes reconnues
par le parseur passé en paramètre.
Ajoutez aussi une fonction zeroOuPLus :: Parser a -> Parser [a] qui reconnaît la concaténation possiblement vide de chaînes reconnues par le parseur passé en paramètre.
Exercice 8. Améliorez le code du parseur parserABin de façon qu’il soit possible écrire des expressions
d’arbre binaire avec des espaces où des blancs. Par exemple, ( f, (f, f)) sera reconnue par le parseur au
même titre que (f,(f, f)).
Appendice : le projet
Ce travail sur les parseurs est propédeutique au projet, dont vous devez avoir déjà pris connaissance du
texte :
http://pageperso.lif.univ-mrs.fr/~luigi.santocanale/teaching/PF/projet2015.pdf
Objectif 9. Posez vos questions, autour du projet, à votre encadrant de TP, afin d’éclaircir au maximum
ce qui est demandé par ce travail.
Objectif 10. Choisissez votre partenaire de binôme et communiquez son nom à votre encadrant.