Comportement dynamique des textes - Modification textuelle

1. Modification textuelle

La définition d'un texte, puis son utilisation, permet de concentrer, à la déclaration de ce texte, l'ensemble de l'information qu'il représente. Or un emploi un tant soit peu intéressant de ce mécanisme demande de pouvoir définir des textes incomplets : on conçoit que des textes "entièrement définis" ne correspondent qu'à des cas bien particuliers d'utilisation : ce peuvent être les mots-clés du langage utilisé, des identificateurs, certains schémas répétitifs qu'impose le langage, ... On est très vite limité par l'emploi exclusif de textes "entièrement définis" puisque alors à l'utilisation d'un texte on ne peut d'aucune manière bénéficier d'informations spécifiques au contexte d'utilisation dans lequel on se situe.

Une première réponse apportée est la paramétrisation des textes. Comme il est décrit dans la partie traitant du contexte d'évaluation des textes, le choix retenu a été de définir la paramétrisation comme l'absence de définition. Cela signifie que la notion de texte paramétré est elle-même fonction du contexte dans lequel on se situe, ou même de la vision qu'on a de ce contexte.

Sur la figure qui suit on montre un exemple où une simple paramétrisation est malgré tout insuffisante pour définir un unique texte pour la déclaration des deux types homme et femme :

TYPE type_sexe : (masculin,feminin);
TYPE type_info (sexe:type_sexe) : ...;
TYPE homme : RECORD
                identif  : type_info(masculin);
                conjoint : type_info(feminin);
             END RECORD;
TYPE femme : RECORD
                identif  : type_info(feminin);
                conjoint : type_info(masculin);
             END RECORD;

On reprend le texte de la figure précédente, en introduisant, dans le texte du programme, la notion de type paramétré :

TYPE type_sexe : (masculin,feminin);

FUNCTION oppose (sexe:type_sexe)
 BEGIN
   CASE sexe
    WHEN masculin : oppose:=feminin;
    WHEN feminin  : oppose:=masculin;
   END CASE;
 END;
TYPE type_info (sexe:type_sexe) : ...;

TYPE humain (sexe:type_sexe) :
      RECORD
         identif  : type_info(sexe);
         conjoint : type_info(oppose(sexe));
      END RECORD;

TYPE homme : humain(masculin);
TYPE femme : humain(feminin);

Il faut noter qu'on demande alors beaucoup de bienveillance de la part du langage utilisé :

on peut paramétrer un type par un objet de n'importe quel type (ici : type_sexe) ;
on peut instancier un paramètre formel par un autre paramètre formel (ici : sexe) ;
on peut appeler, à la définition d'un type, une fonction définie par l'utilisateur (ici : oppose) ;
on peut définir des types dérivés (ici : homme et femme) ;

On peut noter aussi que le texte obtenu :

est plus long,
n'est pas tellement plus général,
mais est certainement plus délicat à relire.

Il serait donc souhaitable de pouvoir définir des "points de dialogue" entre les textes définis et l'évaluation des textes. A ces points, la représentation serait alors calculée en partie par l'application d'instructions intelligibles de l'évaluateur.

Par exemple :

def humain
 = "TYPE " (nom) ":" "^M"
   "RECORD" "^M"
   " identif  : type_info(" (sexe) ");" "^M"
   " conjoint : type_info("
        (si (sexe) = "masculin"
            alors "feminin"
            sinon "masculin") ");" "^M"
   "END RECORD;" "^M"

def homme
 = (use humain
      (def nom = "homme"
       def sexe = "masculin"))
def femme
 = (use humain
      (def nom = "femme"
       def sexe = "feminin"))