4. Règles prédéfinies sur les tuples 5. Les listes
6. Les chaînes 7. Exemples
Que trouve-t-on dans ce chapitre ?
Le domaine de Prolog III est celui des arbres (finis et infinis). Un nouvel opérateur universel a été ajouté par rapport aux Prolog standard : le constructeur général d'arbres. La notion de liste a également été étendue à celle de tuple, et ce domaine muni d'une véritable opération de concaténation. Les chaînes de caractères sont, d'autre part, un sous-ensemble des tuples. Enfin, pour des raisons de compatibilité et d'efficacité, les listes classiques de Prolog ont été conservées. Ce chapitre présente les opérations et les relations définies sur les arbres et les tuples, ainsi qu'un certain nombre d'exemples utilisant des contraintes sur ces domaines.
1 . Introduction
Prolog III améliore sensiblement le traitement des arbres, en introduisant un opérateur qui autorise la représentation d'un arbre de manière totalement générique, indépendamment de son arité. En ce qui concerne les listes, structures de données de base des programmes Prolog, l’amélioration apportée par Prolog III est fondamentale et introduit un nouvel objet : le tuple. Cette évolution répond à un double constat. Tout d’abord, la structure même de liste, un arbre construit à partir d’un symbole fonctionnel binaire, rend l'opération de concaténation très onéreuse. Ensuite, tout accès au n-ième élément d’une liste (y compris lors d'une concaténation programmée en Prolog) ne peut être effectué qu’au travers d’un parcours séquentiel. Ces deux inconvénients sont supprimés grâce à l’introduction de contraintes sur les tuples, munis d’une concaténation dont les propriétés répondent à ce que l’on est en droit d’attendre.
2 . Les arbres
Les arbres forment la classe la plus générale d’objets définis en Prolog III. Tous les objets définis dans la suite de ce document (tuples, listes, chaînes, valeurs numériques ou booléennes, …) sont des éléments de l’ensemble des arbres et toute variable Prolog III représente une valeur prise dans cet en- semble.
Ces arbres sont composés de nœuds étiquetés par : • des identificateurs,
• des caractères,
• les valeurs booléennes 0' et 1', • des valeurs numériques ,
• le signe spécial <>
{
On prendra bien garde à ne pas confondre arbres et termes. Les arbres sont des éléments du domaine de Prolog III ; les termes sont des constructions syntaxiques.Voici un exemple d’arbre : érable <> `a` `c` `e` `r` feuilles lobes caduques 7 1'
Les arbres dont l’étiquette initiale est un identificateur sont appelés arbres
factuels, et ceux dont l’étiquette initiale est le signe <> sont appelés tuples. Les tuples dont tous les éléments sont des caractères sont appelés chaînes.
{
NOTATION : En Prolog III, les chaînes sont plutôt représentéesentre guillemets (par exemple : "Ralliez vous à mon panache blanc") et les tuples entre chevrons (par exemple<Marignan, 1515, 1'>).
Opérations sur les arbres
Les opérations définies sur les arbres sont les opérations de construction. On trouve ainsi, comme en Prolog II le constructeur d’arbres, mais également deux nouveaux opérateurs, le constructeur de tuple, et le constructeur général
d’arbres, qui permet de désigner tout arbre de manière totalement générique, indépendamment de son nombre de fils. Voici les schémas illustrant ces opérations.
xn … x 0 = x1 x 0 (x1 …xn ) Le constructeur d’arbres xn … <> = x0 x n … <x 0 > Le constructeur de tuples x0 = xn … x1 x0 [ <> ] xn … x1
Le constructeur général d’arbres
Le constructeur général d'arbres permet de représenter tout arbre à l'aide seulement de son étiquette initiale et du tuple formé de ses fils immédiats.
{
ATTENTION : on ne peut pas insérer d'espaces entre le terme qui représente l'étiquette de l'arbre et la parenthèse ouvrante du constructeur. C'est là l'un des rares cas en Prolog III où l'écriture d'un blanc est interdite.
Voici quelques exemples de l'utilisation de ces divers constructeurs. On donne ici plusieurs formes syntaxiques possibles qui utilisent les différents constructeurs, et les arbres correspondants :
exemple 1 2 3 exemple(1,2,3) exemple[<1,2,3>] <1,2,3> <>(1,2,3) <>[<1,2,3>] <> 2 3 1 exemple 1 2 3 exemple(<1,2,3>) exemple[<<1,2,3>>] <>
Voici enfin un exemple du même type portant sur une chaîne de caractères :
"123" <>(`1`,`2`,`3`) <>["123"] <>[<`1`,`2`,`3`>] <> `2` `3` `1`
Contraintes sur les arbres
Les contraintes sont construites à l’aide de relations. Les relations utilisées sur les arbres sont :
• l’égalité (=), • l’inégalité (#),
• la relation unaire qui impose à un arbre d'avoir un nombre déterminé de fils immédiats. Dans le cas où cet arbre est représenté par la variable A et son nombre de fils par N, cette relation se note A::N.
Exemples
Voici quelques exemples de contraintes sur les arbres.
{X = Erable("acer",feuilles(lobes(7),caduques(1')))}
Cette contrainte impose à la variable X de représenter l'arbre donné en exemple précédemment.
{X = E[U],Y = E[V]}
Cet ensemble de contraintes impose aux variables X et Y de représenter deux arbres dont les étiquettes initiales sont égales
{X = E[U], E # <>}
Cette contrainte impose à la variable X de représenter un arbre qui ne soit pas un tuple.
Examinons enfin quelques exécutions qui illustrent l'utilisation de ce type de contraintes :
{E = exemple, U = <1,2,3>} > {E[U] = <1,2,3>}; {E = <>, U = <1,2,3>} > {E[U] = exemple(<1,2,3>)}; {E = exemple, U = <<1,2,3>>} > {E[U] = "123"}; {E = <>, U = "123"} > {E[U] = 121/3}; {E = 121/3, U = <>}
Les exemples suivants montrent comment sont simplifiées certaines équations sur les arbres :
> {X(Y) = Y(X) }; {Y = X, X::0 } > {<X> = X[Y]}; {X = <>, Y = <<>>} > {Y[X] = X[Y] }; {Y = <>, X = <>}
Voici enfin des exemples qui montrent des contraintes pour lesquelles les solutions sont des arbres infinis :
> {X(Y) = X[Y]}; {Y = <Y>, X::0 } > {X(Y) = <<X,Y>>};
Restrictions sur la contrainte de taille
En Prolog III on ne peut imposer à un arbre d'avoir un nombre déterminé de fils immédiats qu'à la condition que ce nombre soit une constante, c'est-à- dire un entier positif. Toutefois, pour augmenter la facilité de programmation, si ce nombre est représenté par un terme contenant des variables un mécanisme de retardement est mis en place par Prolog III. Nous reviendrons sur ce mécanisme dans le chapitre spécialement consacré aux retardements.
{E[<X, ff(Y)>. Z] :: 13};
Dans une contrainte de taille, le nombre de fils immédiats doit être explicitement connu