Techniques de R éé criture et Transformations Pierre-Etienne Moreau

Manipulation de listes

Repr é sentation des listes Habituellement, on consid è re une liste vide nil, et un op é rateur de concat é nation cons nil : L cons : E x L L On repr é sente ainsi la liste a.b.c par cons(a,cons(b,cons(c,nil)))

Question Comment retrouver un é l é ment donn é ? appartient(cons(a,cons(b,cons(c,nil))),a) ? appartient(cons(a,cons(b,cons(c,nil))),b) ? appartient(cons(a,cons(b,cons(c,nil))),d) ?

Une r é ponse appartient(cons(x,l),x) true appartient(cons(y,l),x) appartient(l,x) appartient(nil,x) false

Une autre r é ponse Dans Tom on peut é crire appartient( (_*,x,_*), x) true appartient( l, x) false

Symboles associatifs f est associatif si : f(x,f(y,z)) = f(f(x,y),z) Dans ce cas, a-t-on : f(a,f(b,f(c,d))) = f(f(a,b),f(c,d)) ? tel que f(x,f(c,y)) = f(f(a,b),f(c,d)) ? f(x,f(c,y)) << f(f(a,b),f(c,d)) ? f(x,f(c,y)) << f(a,f(b,f(c,d))) ? f(x,f(d,y)) << f(a,f(b,f(c,d))) ?

Associativit é avec é l é ment neutre f(x,f(y,z)) = f(f(x,y),z) f(x,e) = f(e,x) = x Dans ce cas, a-t-on : f(x,f(c,y)) << f(a,f(b,f(c,d))) ? f(x,f(d,y)) << f(a,f(b,f(c,d))) ?

Associativit é dans Tom On consid è re les formes aplaties : f(a,b,c,d) f(x,c,y) On peut é crire : f(x,c,y) << f(a,b,c,d) f(x,d,y) << f(a,b,c,d)

Questions Comment savoir s il y a un a suivi d un b ? f(x,a,y,b,z) << f(a,b,c,d) Avec exactement un terme entre les deux ? On ne peut pas l exprimer

Signature f est d arit é variable et a pour profil : f : E x … x E -> L On le note : f( E* ) -> L Cela permet dé crire : f(a(),b(),c(),d()) f(x,a(),y,b(),z)

Questions Quel est le type de x,y et z dans f(x,a(),y,b(),z) ? r é ponse : E Comment exprimer f(x,c(),y) tel que cela filtre vers f(a(),b(),c(),d()) ? Il faut des variables de type L On les note f(x*,c(),y*)

Exercice Exprimer la fonction d appartenance sur des listes associatives appatient(f(_*,x,_*),x) -> True appatient(f(_*),x) -> False

Exercice Comment é liminer les doublons ? f(X*,e,e,Z*) -> f(X*,e,Z*) é limine les doublons cons é cutifs Comment é liminer les doublons distants f(X*,e,Y*,e,Z*) -> f(X*,e,Y*,Z*)

Exercice Etant donn é un ordre sur les é l é ments Exprimer un algorithme de tri f(X*,e1,e2,Y*) -> f(X*,e2,e1,Y*) if e2<e1 Implanter le en Tom

Demo

Implantation d un algorithme de filtrage syntaxique Utiliser des symboles associatifs Quelle signature choisir ? Variable(name:String) -> Term Appl(name:String, args:TermList)-> Term conc( Term* )-> TermList True-> Term False-> Term Match(pattern:Term, subject:Term)-> Term And( l:TermList ) -> Term

Codage des r è gles et des termes %rule { // PropagateClash And(conc(_*,False(),_*)) -> False() // PropagateSuccess And(conc(X*,True(),Y*)) -> And(conc(X*,Y*)) And(conc(X*,c,Y*,c,Z*)) -> And(conc(X*,c,Y*,Z*)) And(conc()) -> True() } Term p2 = `Appl("f",conc(Variable("x"),Appl("g",conc(Variable("y"))))); Term s2 = `Appl("f",conc(Appl("a",conc()),Appl("g",conc(Appl("b",conc())))));

Strat é gies

Programmation par r éé criture Avantages le filtrage est un m é canisme expressif les r è gles expriment des transformations é l é mentaires Limitations les syst è mes de r è gles sont souvent non- terminant et/ou non confluent en g é n é ral, on ne veut pas appliquer toutes les r è gles en même temps

Exemple de syst è me non terminant And(Or(x,y),z) Or(And(x,z),And(y,z)) And(z,Or(x,y)) Or(And(z,x),And(z,y)) Or(And(x,y),z) And(Or(x,z),Or(y,z)) Or(z,And(x,y)) And(Or(z,x),Or(z,y)) Not(Not(x)) x Not(And(x,y)) Or(Not(x),Not(y)) Not(Or(x,y)) And(Not(x),Not(y)) And(Or(a,b),c) Or(And(a,c),And(b,c)) And(Or(a, And(b,c)),Or(c, And(b,c))) …

Codage du contrôle dans les r è gles Solution classique introduire un nouvel op é rateur f pour restreindre l ensemble de r è gles permettant de normaliser l r devient f(l) r on normalise un terme f(t) l op é rateur f permet de contrôler les r è gles à appliquer

Encodage du contrôle f(And(x,y)) and(x,y) f(Not(x)) not(x) f(Or(x,y)) Or(f(x),f(y)) and(Or(x,y),z) Or(and(x,z),and(y,z)) and(z,Or(x,y)) Or(and(z,x),and(z,y)) and(x,y) And(x,y) not(Not(x)) x not(And(x,y)) Or(not(x),not(y)) not(Or(x,y)) and(not(x),not(y)) not(x) Not(x) f(And(Or(a,b),c)) and(Or(a,b),c)) Or(and(a,c),and(b,c)) Or(And(a,c),And(b,c))

Cons é quences Il faut d é finir la congruence explicitement, pour chaque r è gle et chaque constructeur Il n y a plus de s é paration entre transformation et contrôle cela rend la compr é hension plus difficile les r è gles sont moins r é utilisables

Ce qu on voudrait pouvoir contrôler l application des r è gles pouvoir sp é cifier simplement la « travers é e » d un terme (i.e. appliquer une r è gles dans les sous-termes) tout en s é parant r è gle et contrôle

Solution Utiliser des strat é gies Combiner des transformations é l é mentaires Exemples disjunctive normal form dnf = innermost(DAOL <+ DAOR <+ DN <+ … ) DAOL : And(Or(x,y),z) Or(And(x,z),And(y,z)) DAOR : And(z,Or(x,y)) Or(And(z,x),And(z,y)) DN : Not(Not(x)) x conjunctive normal form cnf = innermost(DOAL <+ DOAR <+ DN <+ … )

Strat é gies é l é mentaires

R è gle de r éé criture Une r è gle R : g d est une strat é gie é l é mentaire Exemples : R = a b (R)[a] = b (R)[b] = fail (R)[f(a)] = fail

Identit é et é chec id : ne fait rien, mais né choue pas fail : é choue tout le temps Exemples (id)[a] = a (id)[b] = b (fail)[a] = fail

Composition S1 ; S2 Applique S1, puis S2 Echoue si S1 ou S2 é choue Exemples (a b ; b c)[a] = c (a b ; c d)[a] = fail (b c ; a b)[a] = fail

Choix S1 <+ S2 Applique S1. Si cela é choue, applique S2 Exemples (a b <+ b c)[a] = b (b c <+ a b)[a] = b (b c <+ c d)[a] = fail (b c <+ id)[a] = a

Quelques lois id ; s = s s ; id = s id <+ s = s s <+ id s fail <+ s = s s <+ fail = s fail ; s = fail s ; fail fail (pourquoi ?)

Strat é gies param é tr é es try(s) = s <+ id repeat(s) = try(s ; repeat(s)) Exemples (try(b c))[a] = a (repeat(a b))[a] = b (repeat(b c <+ a b))[a] = c (repeat(b c))[a] = a

Primitives pour traverser applique une strat é gie à un ou plusieurs fils directes Congruence applique une strat é gie diff é rente à chaque fils d un constructeur all applique une strat é gie à tous les fils one applique une strat é gie à un fils

Congruence c(S 1, …,S n ) pour chaque constructeur c Exemples (f(a b))[a] = fail (f(a b))[f(a)] = f(b) (f(a b))[f(b)] = fail (g(try(b c) <+ try(a b)))[g(a,a)] = g(a,b) Exercice d é finir la strat é gie map sur les liste (cons,nil)

Congruence g é n é rique all(S), é choue si S é choue sur un des fils Exemples (all(a b))[f(a)] = f(b) (all(a b))[g(a,a)] = g(b,b) (all(a b))[g(a,b)] = fail (all(a b))[a] = a (all(try(a b)))[g(a,c)] = g(b,c)

Congruence g é n é rique one(S), é choue si S ne peut pas s appliquer sur un des fils Exemples (one(a b))[f(a)] = f(b) (one(a b))[g(a,a)] = g(a,b) (one(a b))[g(b,a)] = g(b,b) (one(a b))[a] = fail

Strat é gies de parcours bottomup(S) = all(bottomup(S)) ; S topdown(S) = S ; all(topdown(S)) innermost(S) = bottomup(try(S ; innermost(S))) oncebu(S) = one(oncebu(S)) <+ S oncetd(S) = S <+ one(oncetd(S)) innermost(S) = repeat(oncebu(innermost(S))) outermost(S) = repeat(oncetd(outermost(S)))

Strat é gies en Tom

Constructeurs é l é mentaires Identity Fail Sequence Choice All One mu

Utilisation Une strat é gie est de type VisitableVisitor VisitableVisitor s = `Identity(); Un terme est de type Visitable Visitable t = `a(); Une strat é gie peut s appliquer sur un terme Visitable result = s.visit(t); Une strat é gie pr é serve le type Term t = `a(); Term result = (Term) s.visit(t);

D é finition de strat é gies VisitableVisitor Try(VisitableVisitor S) { return `Choice(S,Identity()); } VisitableVisitor Repeat(VisitableVisitor S) { return `mu(MuVar("x"),Choice(Sequence(S,MuVar("x")),Identity())); } VisitableVisitor OnceBottomUp(VisitableVisitor S) { return `mu(MuVar("x"),Choice(One(MuVar("x")),S)) } } Exercice implanter innermost(a b)

Strat é gie é l é mentaire en Tom %strategy RewriteSystem extends `Fails() { visit Term { a() -> { return `b(); } } VisitableVisitor S = `Repeat(OnceBottomUp(RewriteSystem())) Term result = S.visit(`f(a(),g(b(),a())));

Utilisations VisitableVisitor rule = new RewriteSystem(); Term subject = `f(g(g(a,b),g(a,a))); `OnceBottomUp(rule).visit(subject); `Innermost(rule).visit(subject); `Repeat(OnceBottomUp(rule)).visit(subject);

(mode parano ï aque) VisitableVisitor rule = new RewriteSystem(); Term subject = `f(g(g(a,b),g(a,a))); VisitableVisitor onceBottomUp = `mu(MuVar("x"),Choice(One(MuVar("x")),rule)); onceBottomUp.visit(subject)); VisitableVisitor innermostSlow = `mu(MuVar("y"),Choice(Sequence(onceBottomUp,MuVar("y")),Identity())); innermostSlow.visit(subject)); VisitableVisitor innermost = `mu(MuVar("x"),Sequence(All(MuVar("x")),Choice(Sequence(rule,MuVar("x")),Ident ity))); innermost.visit(subject));

Questions Comment calculer des ensembles de r é sultats Exemples f(g(g(a,b),g(a,b))) trouver les x tels que g(x,b) filtre un sous terme

Solution considerer s(col) : g(x,b) col.add(x) appliquer Try(BottomUp(s(col))) é num é rer col

Codage %strategy RewriteSystem(c:Collection) extends Identity() { visit Term { g(x,b()) -> { collection.add(`x); } } Collection collection = new HashSet(); VisitableVisitor rule = `RewriteSystem(collection); Term subject = `f(g(g(a,b),g(c,b))); `Try(BottomUp(rule)).visit(subject); System.out.println("collect : " + collection);

Strat é gie Om é ga Om é ga Position

Replace et Subterm Etant donn é e une position p getReplace(t ) retourne une strat é gie qui, appliqu é e sur un terme donn é, remplace le sous-terme à la position p donn é e par le terme t getSubterm() retourne une strat é gie qui retourne le sous-terme à la position p ces strat é gies encodent les l acc è s à un sous-terme et l op é ration de remplacement cela permet d encoder de l exploration travers é e + non-d é terministe

Exemple complexe Xmas

Principales applications