Prolog – Eiffel

Prolog – Eiffel
Pourquoi pas Prolog?
Pourquoi Java?
par Jean Ledesma
Je vais essayer avec ce petit rapport de vous demontrer la validite de mon choix envers Java
plutot que Prolog pour faire la transcription Prolog Eiffel.
1. Les avantages de Prolog:
Il est vrai que Prolog nous fournit une possibilite non triviale aux premiers abords en Java
qui est la requete sur faits.
Je pourrais par exemple faire etant donne deux faits
identifier(#id, 'nom')
classDecl(#id, #identifier)
ecrireClass(X) := classDecl(X,Y), identifier(Y,Z), write(“class ”), write(Z),
write(“end”).
Ceci etant en cas trivial on pourrait se dire que c'est plutot simple.
Jusqu'a ce qu'on voie des faits plus compliqués a traiter du a la syntaxe d'Eiffel , qui
contrairement a celle de Java est assez confuse. J'aurais surement choisi d'effectuer le travail
avec Prolog sur Java tout comme Gunther mais certainement pas pour Eiffel.
Voyons pourquoi dans la section suivante.
2. Les incovenients Prolog:
Voyons maintenant le fait inheritance.
inheritance(#id,#classDecl,#classDecl).
Il faut que je rattache a la classe d'id classDecl l'heritage vers la
classe d'id classDecl.
Je ferais quelque chose du genre:
ecrireInheritance(Z) := inheritance(Z,X,Y), ecrireClass(X), write(Y).
Mais alors il faut que je modifie le premier fait ecrire Class et que j'y
ajoute l'ecrire inheritance.
Jusque la ca va.
Maintenant voyons le fait rename.
Rename appartient a un fait d'inheritance tel que:
rename(#id,#inheritance or #exheritance,#featureDecl,#identifier)
j'ecrirais rename tel que:
ecrireRename(R) := rename(R,P,Y,I), write(“inherit”),
ecrireInheritance(P),
write(“feature”), ecrireFeatureDecl(Y),
ecrireIdentifier(I).
Mais si je veux faire attention a l'ordre il faut je modifie aussi le fait
ecrireInheritance.....
Il faut savoir aussi que le dernier rename de la liste des rename s'il est suvi d'un redefine par
exemple ou d'un export , en soit pas suivi d'un “;”.
Etc, etc...
Si vous tenez compte du fait qu'il ya 90 faits.
Je trouve ca peut etre trop compliqué et ca empeche de travailler proprement.
Pourquoi java alors?
Nous allons voir ca dans la section suivante.
3. Les avantages de Java:
En Java, il y a plusieurs possibilites offerte pour faciliter le traitement de ces faits.
1.
2.
3.
4.
Langage objet
Traitement des strings
Classes abstraites
Possibilites d'ecrire sur des fichiers facile
J'ai parle dans la section inconvenients Prolog de rattacher des faits a d'autres.
Quoi de mieux pour le faire que les objets?
Pour cela je sais deja que je vais devoir implementer les differents faits en classe.
Oui, ca sera plus long a ecrire mais beaucoup plus propre et je garantis que les classes seront
ecrites dans l'ordre attendu.
Je cree une class Fact abstraite, contenant un id et une fonction write() qui renvoie la
representation de ce fait.
Je tombe alors sur le fait classDecl
identifier(#id, 'nom')
classDecl(#id, #identifier)
Je me dis, il faut que j'ai une table des faits , avec chaque fait a sa place dans la table, sa
place etant l'id.
Qu'a cela en tienne je cree une table Fact[].
Puis je commence:
identifier (#id, 'nom')
--> IdentifierFact.java --> j'ajoute le fait a la place id dans la table. --> j'implemente la
fonction write() avec return 'nom';
classDecl(#id, #identifier)
-->ClassDeclFact.java --> j'ajoute le fait a la place id dans la table --> j'implemente la
fonction write() qui return 'class 'nom' end; pour l'instant.
inheritance(#id, #classDecl, #classDecl)
-->InheritanceFact.java --> j'ajoute le fait a la place id dans la table --> j'implemente la
fonction write() qui return pour l'instant getFactById(#classDecl).write(), le nom de classe
heritee. Puis je vois que inheritance se referre a une classDecl, qua cela en tienne, je modifie
legerement classDecl pour lui rajouter une listed' inheritance.
ArrayList<InheritanceFact> inheritanceFacts = new ArrayList<InheritanceFact>();
Dont j'integrel'affichage dans la fonction write() de classDecl qui devient:
String buffer=””;
buffer+= 'class 'nom' ;
if (inheritanceFacts.size()!=0){
buffer+= “inherit “;
for (int i=0; i< inheritanceFacts.size(); i++){
buffer+= inheritanceFacts.get(i).write();
}
buffer+=”end\n”
}
buffer+”end”;
Puis maintenant j'ai un rename.
Ce rename fait reference a une inheritance.
Je modifie un peu inheritance... je lui rajoute une liste de rename....
Je modifie sa fonction write().
Pour tous les objets crees, pour tous les faits, ce systeme est automatique et c'est fait de
maniere incrementale et toujours respectant un ordre.
L'avantage?
Je cree une classe et je la remplis petit a petit selon que les faits fassent reference a lui ou
pas.
Donc on a une hierarchie comme ci dessous
ClassDecl -> Indexing ...
-> Genericite....
-> Inheritance -> rename
->export
->redefine
-> undefine
-> select
->CreatorsFeatures -->...
-->...
--> Features --> local, routine etc
--> Invariant...
.....
Je n'ai pas tout mis bien sur mais c'est pour vous donner une idee
Et de cette maniere, premierement, j'automatise toutes mes ecritures de code
Je passe par une factory qui gere chaque fait different et cree l'objet oportun selon le nom du
fait.
J'ai une base de faits a laquelle je peux acceder facilement par getFactById(..), je simule
donc tres facilement le seul avantage que nous ayons pour cela en Prolog.
Et pour ajouter un fait, comme dans la classe abstraite Fact j'ai l'id du fait, je lui ai ajoute
une procedure addFact();
qui ajoute directement le fait dans la table.
Un exemple de fait:
type(#id, #classType)
public class TypeFact extends Fact{
int idClassType;
public TypeFact(String[]f){
id=Integer.parseInt(f[0]);
idClassType= Integer.parseInt(f[1]);
addFact();
}
public String write() {
return getFactById(idClassType).write();
}
}
Avec id , addFact venant de la super classe Fact.
Tous les faits suivent ce type de demarche.
A la fin?
String buffer =ClassDecl.write();
WriteToAFile(buffer);
ceci pour chaque classDecl diferent et le tour et joue.
Et le tour est joué.
On en peut plus clair.
Quand je programme en Prolog j'ai l'impression de faire de l'Extreme Programming
la c'est clair, net, precis. Je en vois pas de vrai inconvenient mais plutot une securite au
niveau du code genere que je n'ai pas la sensation d'avoir en Prolog tant les modifications
apportes a chaque nouveau fait implante seraient nombreuses.
En Java je peux rajouter un fait, puis un autre, puis un autre...
ce qui marchait avant marche encore apres.
4. Les inconvenients java:
C'est un peu fastidieux d'ecrire toujours la meme chose.
Mais c'est quand meme beaucoup plus propre que sur Prolog.