Projet de Programmation Fonctionnelle

Transcription

1 Projet de Programmation Fonctionnelle L objectif de ce projet est de concevoir, en Objective Caml, un évaluateur pour le langage mini-ml (un sous ensemble du langage Objective Caml). Votre programme devra prendre en paramètre un fichier source contenant des définitions, évaluer ces définitions et afficher le résultat de ces évaluations lorsque cela est possible. Les définitions n étant pas nécessairement bien typées, l évaluation peut échouer et votre programme devra, le cas échéant, produire un message d erreur adapté. Le code réalisant la lecture des définitions depuis le fichier source et leur conversion en expressions Objective Caml sur lesquelles réalisera l évaluation est donné. 1 Le langage mini-ml Le langage mini-ml est un sous ensemble du langage Objective Caml. En particulier, un programme mini-ml étant également un programme Objective Caml, il est possible de tester votre évaluateur en comparant ses résultats à ceux de l évaluateur de ce dernier. Un programme mini-ml est une suite de définitions non récursives et récursives terminant par le symbole ;; (voir exemple ci-dessous). let x = 3;; let rec fact = fun n -> begin match n with 0 -> 1 _ -> n * fact (n-1) end;; let resultat = fact x;; N.B : Comme en Objective Caml, les variables en min-iml sont des chaînes de caractères composées de symboles alphanumériques commençant par une minuscule ou le symbole. Programmes : Plus formellement, les structures des définitions (notées def inition) et des programmes (notés program) sont données par : definition ::= let x = e; ; let rec f = e; ; program ::= def inition def inition program (1) où x et f sont des variables et e est une expression. 1

2 Expressions : La structure des expressions du langage mini-ml (notées e) est données dans la figure 1. Contrairement au langage Objective Caml, le langage mini-ml ne permet pas la définition de nouveaux types. Les types de mini-ml sont : les entiers les booléens les listes les tuples les types fonctionnels int bool τ list où τ est un type τ 1... τ n où τ 1,...,τ n sont des types τ 1 τ 2 où τ 1 et τ 2 sont des types Le langage mini-ml permet : les définitions de fonctions et les liaisons locales (récursives ou non) l application d opérateurs unaires et binaires le filtrage de motifs et le test sur les booléens La définition des expressions s appuie sur les définitions auxiliaires suivantes les constantes (notées c) qui sont les entiers, les booléens et la liste vide les motifs (notés p) les opérateurs unaires et binaires (notés unop et binop) les listes de choix (notées with list) qui permettent de construire les expressions de filtrage. 2 Représentation des programmes en Objective Caml La définition des programmes ((1) et figure 1) de la section précédente concerne les programmes mini-ml tels qu ils apparaissent dans un fichier source. La figure 3 (en annexe) présente la représentation en Objective Caml de ces définitions. Les fonctions C var, C cst, C pat et C exp associent respectivement à une variable, une constante, un motif ou une expression de mini-ml sa représentation en Objective Caml. Le type variable définit les variables comme étant des chaînes de caractères. Une variable x du langage source est représentée par la chaîne de caractères "x" (autrement dit, C var (x) = x ). le type somme constant regroupe les constantes de mini-ml (notées c), chaque type de constante ayant son propre constructeur. Un entier n, un booléen b et la liste vide du langage mini-ml sont respectivement représentés de la manière suivante : C cst (n)=cint n C cst (b)=cbool b C cst ([])=CEmptyList où n (respectivement b) est l entier n (respectivement le booléen b) du langage Objective Caml. Le type pattern représente les motifs de mini-ml dont la traduction est données ci 2

3 c ::= n où n est un entier b où b est un booléen [] liste vide p ::= motif anonyme x où x est une variable c où c est une constante (p,..., p) tuples p :: p listes non vide unop {, not} binop {+,,, /, mod, &&,, <=, >=, <, >, =, <>} e ::= x où x est une variable c où c est une constante (e,..., e) tuples e :: e listes non vide unop e application d un opérateur unaire e binop e application d un opérateur binaire fun x e où x est une variable e e application let x = e in e liaison let rec x = e in e liaison récursive begin match e with with list end filtrage if e then e else e conditionnelle (e) expression parenthésée with list ::= p e (p e with list) Figure 1 Définition du langage mini-ml 3

4 -dessous : C pat ( ) = PWildcard C pat (x) = PVariable C var (x) C pat (c) = PConstant C cst (c) C pat ((p 1,..., p n )) = PTuple [C pat (p 1 );... ; C pat (p n )] C pat (p 1 :: p 2 ) = PConsList (C pat (p 1 ), C pat (p 2 )) A noter ici que les éléments d un tuple sont représentés par une liste ce qui permet de n avoir qu un constructeur pour les paires, les triplets, etc,... A titre d exemple, la traduction du motif mini-ml (1, true, ) est donnée par : C pat ((1, true, )) = PTuple [PConstant(CInt 1); PConstant(CBool true); PWildcard] Les types unop et binop représentent les opérateurs unaires et binaires de mini-ml. La correspondance entre un opérateur et le constructeur utilisé pour le représenter est donnée par les tableaux suivants : opérateurs unaire : Minus not : Not opérateurs binaire + : Add : Sub : Mult / : Div mod : Mod && : And : Or <= : Le >= : Ge < : Lt > : Gt = : Eq <> : NEq Le type expression représente les expressions (notées e) du langage mini-ml. La traduction des expressions de mini-ml en Objective Caml est données ci-dessous, où C unop et C binop sont les constructeurs respectivement associés aux opérateurs unop et binop. A titre d exemple, vous trouverez en Annexe trois représentations d une même expression (mini-ml, Objective Caml et arbre de syntaxe) montrant la relation entre les constructeurs et les noeuds des arbres de syntaxe. De même les parenthéses des expressions parenthésées ont été supprimées. N.B : La gestion de la priorité des opérateurs est effectuée au cours de la génération de la représentation du programme source en Objective Caml. Il n y a donc pas à s en occuper ici (la représentation des expressions correspond aux arbres de syntaxes vus en cours). 4

5 C exp (x) = Variable C var (x) C cst (c) = Constant C cst (c) C exp ((e 1,..., e n )) = Tuple[C exp (e 1 );... ; C exp (e n )] C exp (e 1 :: e 2 ) = ConsList(C exp (e 1 ), C exp (e 2 )) C exp (unop e) = Unop(C unop, C exp (e)) C exp (e 1 binop e 2 ) = Binop(C binop, C exp (e 1 ), C exp (e 2 )) C exp (fun x e) = Fun(C var (x), C exp (e)) C exp (e 1 e 2 ) = Apply(C exp (e 1 ), C exp (e 2 )) C exp (let x = e 0 in e) = LetIn(C var (x), C exp (e 0 ), C exp (e)) C exp (let rec x = e 0 in e) = LetRecIn(C var (x), C exp (e 0 ), C exp (e)) C exp (if e 0 then e 1 else e 2 ) = IfThenElse(C exp (e 0 ), C exp (e 1 ), C exp (e 2 )) C exp (begin match e with p 1 e 1... p n e n end) = Match(C exp (e), [(C pat (p 1 ), C exp (e 1 ));... ; (C pat (p n ), C exp (e n ))]) Finalement, les fonctions C definition et C program qui transforment respectivement une définition et un programme sont respectivement données par C definition (let x = e) = Simple(C var (x), C exp (e 0 )) C definition (let rec f = e 0 e) = Recursive(C var (f), C exp (e 0 )) C program (definition 1... definition n ) = [C definition (definition 1 );... ; C definition (definition n )] 3 Sémantique des programmes mini-ml La sémantique de mini-ml décrit l évaluation des définitions d un programme. Cette description est décomposée en deux étapes l évaluation d une expression en une valeur. l évaluation des définitions successives avec modification de l environnement global. La définition de la sémantique (section 3.2) repose sur les définitions des valeurs et des environnements (section 3.1.1) et sur l opération d unification entre filtres et valeurs (section 3.1.2). 3.1 Valeurs et environnements Valeurs Les valeurs du langage mini-ml (notées v) sont les constantes, les tuples de valeurs, les listes de valeurs et les clôtures (récursives ou non). On distingue deux types de clôtures, récursives et non récursives : [fun x e, E] est la clôture contenant la fonction fun x e et l environnement E 5

6 [fun x e, E] f R est la clôture récursive contenant la fonction fun x e et l environnement E et f est la variable associée à cette fonction dans la liaison récursive ayant généré cette clôture. Un environnement (noté E) est une suite, éventuellement vide, de paires (x, v) où x est une variable et v la valeur associées à x dans cet environnement. On note également (x 1, v 1 ),..., (x n, v n ) l environnement (x 1, v 1 ) ::... :: (x n, v n ) ::. Si E 1 et E 2 sont des environnements, on note E 1 E 2 la concaténation de ces deux environnment. v ::= c (v,..., v) v :: v [fun x e, E] [fun x e, E] f R E ::= environnement vide (x, v) :: E environnement augmenté où x et f sont des variables Unification Le filtrage suppose de déterminer si un motif p et une valeur v correspondent et, le cas échéant, de calculer un nouvel environnement correspondant à l unification de p et v. Considérons l exemple suivant match (1, 2) with (x, y) x + y + z, (z, 3) Pour évaluer la sous-expression x + y + z, il est nécéssaire de générer un nouvel environnement associant x à la valeur 1 et y à la valeur 2, dans lequel cette sous expression peut être évaluée : x + y + z, (x, 1), (y, 2), (z, 3) Le calcul des liaisons à ajouter à l environnement courant est effectué par la fonction filter donnée ci-dessous. filter(, v) = filter(x, v) = (x, v) filter(c 1, c 2 ) = si c 1 = c 2 filter(p 1 :: p 2, v 1 :: v 2 ) = filter(p 1, v 1 ) filter(p 2, v 2 ) filter((p 1,..., p n ), (v 1,..., v n )) = filter(p 1, v 1 )... filter(p n, v n ) La fonction filter ainsi définie est une fonction partielle, i.e. elle n est pas définie pour tous les cas. Cela correspond au fait qu un filtrage peut échouer comme dans l expression match 1 with (x, y) x + y qui correspond à filter((x, y), 1) qui n est pas défini. De plus, cette fonction n a de sens que dans le cas de motifs linéaires (chaque variable apparaît au plus une fois). 6

7 3.2 Relation d évaluation Evaluation des expressions L évaluation des expressions repose sur une relation entre une expression e, un environnement E et une valeur v. Cette relation est notée e, E v et se lit : Dans l environnement E, l expression e s évalue en la valeur v. Elle est définie dans la figure 2 à partir de règles de la forme Conditions e, E v où les prémisses (Conditions) sont les conditions nécessaires pour que la conclusion (e, E v) soit valide. Une description intuitive de ces règles est données ci-dessous : L évaluation d une constante est immédiate puisque c est une valeur (règle (constant)) L évaluation d une variable donne la valeur associée à cette variable (si elle existe) dans l environnement. Les règles (variable hd) et (variable cons) parcourent l environnement à la recherche de la variable. L évaluation d un tuple consiste à évaluer toutes les composantes de ce tuple (règle (tuple)) L évaluation de l application d un opérateur unaire unop e consiste à évaluer e puis à appliquer l opérateur à la valeur obtenue. La sémantique d un opérateur unaire, notée [ ] unop correspond à la sémantique de l opérateur en Objective Caml. Par exemple, [ true ] not = false. L évaluation de l application d un opérateur binaire e 1 binop e 2 consiste à évaluer e 1 et e 2 puis à appliquer l opérateur aux valeurs obtenues. La sémantique d un opérateur binaire, notée [ ] binop correspond à la sémantique de l opérateur en Objective Caml. Par exemple [ (3, 2) ] + = 5. L évaluation d une fonction donne une clotûre contenant cette fonction et une copie de l environnement courant (règle (fun)) L évaluation d une application e 1 e 2 dans un environnement E donne lieu à deux cas 1. si e 1 s évalue en une clotûre simple [fun x e, E ], on évalue le corps de la fonction e dans l environnement E augmenté de la liaison (x, v 2 ) où v 2 est le résultat de l évaluation de e 2 dans E (règle (app)) 2. si e 1 s évalue en une clotûre récursive [fun x e, E ] f R, on évalue le corps de la fonction e dans l environnement E augmenté des liaisons (x, v 2 ) où v 2 est le résultat de l évaluation de e 2 dans E et (f, [fun x e, E ] f R ), (règle (app rec)) L évaluation d une liaison locale let x = e 0 in e dans un environnement E correspond à l évaluation de e dans l environnement E augmentée de la liaison (x, v 0 ) où v 0 est le résultat de l évaluation de e 0 dans l environnment E (règle (let in)). L évaluation d une liaison locale let rec f = e 0 in e dans un environnement E correspond à l évaluation de e dans l environnement E augmentée de la liaison (f, [fun x e, E ] f R ) si [fun x e, E ] est le résultat de l évaluation de e 0 dans E (règle (let rec in)). 7

8 c, E c (constant) x, (x, v) :: E v x y x, E v x, (y, v) :: E v (variable hd), (variable co e i, E v i, i = 1,..., n (e 1,..., e n ), E (v 1,..., v n ) (tuple) e 1, E v 1 e 2, E v 2 e 1 :: e 2, E v 1 :: v 2 e, E v [ v ] unop = v unop e, E v e 1, E v 1 e 2, E v 2 [ (v 1, v 2 ) ] binop = v e 1 binop e 2, E v (cons) (unop) (binop) fun x e, E [fun x e, E] e 2, E v 2 e 1, E [fun x e, E ] e, (x, v 2 ) :: E v e 1 e 2, E v (fun) (app) e 2, E v 2 e 1, E [fun x e, E ] f R e, (x, v 2 ) :: (f, [fun x e, E ] f R ) :: E v e 1 e 2, E v (app rec) e 0, E v 0 e, (x, v 0 ) :: E v let x = e 0 in e, E v e 0, E [fun x e, E ] e, (f, [fun x e, E ] f R ) :: E v let rec f = e 0 in e, E v e 0, E v 0 filter(p, v 0 ) = E e, E E v begin match e 0 with p e with list end, E v e 0, E v 0 filter(p, v 0 ) non défini begin match e with with list end, E v begin match e 0 with p e with list end, E v (let in) (let rec in) (match success) (match fail) e 0, E true e 1, E v if e 0 then e 1 else e 2, E v e 0, E false e 2, E v if e 0 then e 1 else e 2, E v (if success) (if fail) Figure 2 Evaluation des expressions 8

9 L évaluation d un filtrage match e 0 with p e withlist dans un environnement E donne lieu à deux cas, où v 0 est le résultat de l évaluation de e 0 dans l environnement E 1. si filter(p, v 0 ) donne l environnement E, on évalue e dans l environnement E E (règle (match success)) 2. sinon, on passe au cas suivant (règle (match fail)) L évaluation d une expression if e 0 then e 1 else e v correspond à l évaluation de e 1 où e 2 selon le résultat de l évaluation de e 0 (règles (if success) et (if fail)) Evaluation d un programme L évaluation d un programme consiste en l évaluation de toutes les définitions de ce programme. Après évaluation d une définition, la liaison associée doit être mise dans l environnement global afin de pouvoir être utilisée par les définitions suivantes. L évaluation d une définition def inition dans un environnment E donne donc un nouvel environnement E (E augmenté de la nouvelle définition), par opposition à l évaluation d une expression qui donne une valeur. La sémantique de l évaluation des programmes est donnée par des règles de la forme Conditions program, E E données ci-dessous. Les deux premières règles concernent l évaluation d une définition (non récursives et récursives) d une définition seule. Les deux règles suivantes sont similaires mais pour une définition suivie d autres définitions. e, E v let x = e; ;, E (x, v) :: E e, E [fun x e, E ] let rec f = e; ;, E (f, [fun x e, E ] f R ) :: E e, E v program, (x, v) :: E E let x = e; ; program, E E (eval stop) (eval stop rec) (eval continue) e, E [fun x e, E ] program, (f, [fun x e, E ] f R ) :: E E let rec x = e; ; program, E E (eval rec continue) 4 Programmation de l évaluateur 1. Définir le type value des valeurs de mini-ml en se basant sur la définition de la section

10 2. Définir le type environment des environnements d évaluation 3. Ecrire la fonction filter de type pattern value environment en se basant sur la définition de la section Ecrire la fonction eval unop de type unop value value telle que eval unop(unop, v) = [ v ] unop quelque soit unop. 5. Ecrire la fonction eval binop de type binop value value value telle que eval unop(unop, v 1, v 2 ) = [ (v 1, v 2 ) ] unop quelque soit unop. 6. Ecrire la fonction eval expression de type expression environment value en se basant sur les règles de la section Ecrire la fonction eval program de type program environment en se basant sur les règles de la section Après chaque évaluation d une définition, le résultat de cette définition devra être affiché (sans attendre l évaluation de tout le programme). Remarques importantes L évaluation des expressions et des programmes peut parfois échouer, ce qui correspond aux cas ou aucune des règles ne s applique. Dans ce cas, votre programme devra s interrompre en affichant un message d erreur expliquant précisément la raison de l échec. La fonction f ilter devra vérifier que le motif donné est linéaire et, dans le cas contraire, générer une erreur. La définition des fonctions ci dessus peut nécessiter l introduction de fonctions auxiliaires, de types de données et d exceptions que vous devez ajouter. 5 Support et remise du projet Vous recevrez une archive projet pf.tar.gz contenant un fichier README contenant un certain nombre d informations. un fichier Makefile permettant de compiler le projet. un fichier syntax.ml contenant la définition de la représentation d un programme en Objective Caml. un répertoire parser contenant différents fichiers permettant de lire un fichier source et de construire sa représentation en Objective Caml. un fichier eval.ml qui est le fichier dans lequel votre programme doit être écrit. Le projet est à réaliser par équipes de deux ou trois étudiants. Vous devrez rendre une archive au format tar.gz contenant uniquement (en particulier, l archive ne devra pas contenir les programmes générés) : Les fichiers qui vous ont été donnés (Readme, Makefile, syntax.ml, eval.ml et le répertoire parser) Un fichier test.ml contenant une suite de définitions permettant de tester votre programme (vous pourrez vous inspirer des feuilles de TD et TP pour construire cette liste) 10

11 Un fichier explication contenant 1. Les noms et prénoms des étudiants ayant participé à ce projet 2. Une description des choix que vous avez réalisé pour développer votre projet (modélisation, calcul,...) 3. Pour chaque cas ou le comportement de l évaluation n est pas défini, une explication de la raison pour laquelle l évaluation pose problème et du choix du message d erreur affiché par votre programme. 4. Une justification de la pertinance des tests contenus dans le fichier test.ml Le nom de l archive générée sera de la forme nom 1 nom 2 nom 3.tar.gz où nom 1, nom 2, nom 3 sont les trois premières lettres des noms de chaque étudiant ayant participé au projet. Le fichier rendu devra se conformer très précisément à la spécification donnée cidessus faute de quoi il pourra être refusé. 11

12 A Représentation des programmes mini-ml type variable = string type constant = CInt of int CBool of bool CEmptyList type pattern = PWildcard PVariable of variable PConstant of constant PTuple of pattern list PConsList of pattern * pattern type unop = Minus Not type binop = Add Sub Mult Div Mod And Or Lt Gt Le Ge Eq NEq type expression = Variable of variable Constant of constant Tuple of expression list ConsList of expression * expression Unop of unop * expression Binop of binop * expression * expression Function of variable * expression Apply of expression * expression LetIn of variable * expression * expression LetRecIn of variable * expression * expression Match of expression * with_list IfThenElse of expression * expression * expression and with_list = (pattern * expression) list type definition = Simple of string * expression Recursive of string * expression type program = definition list Figure 3 Représentation des programmes mini-ml en Objective Caml 12

13 B Exemple d arbres de syntaxe let rec fact = fun n -> begin match n with 0 -> 1 _ -> n * fact (n-1) end;; LetRecIn( fact, Function( n, Match(Variable n, [ (PConstant (CInt n), Constant(CInt 1)); (PWildcard, Binop(Mult, Variable n, Apply(Variable fact, Binop(Sub, Variable n, Constant(CInt1))))) ]))) [1] let. =. [2] fact [4] fun. ->. [3] n [5] begin match. with. end [6] n [20]. ->. [16]. ->. [17] 0 [18] 1 [7] _ [8] * [9] n [14] [10] fact [11] - [12] n [13] 1 13