Inspiré par le langage de requête XPath pour XML, le langage DPath permet d'exprimer des requêtes pour le format DepXML. Il est implanté en Perl mais possède sa propre syntaxe pour plus de compacité. 1. Le langage DPath s'appuie sur une représentation orientée objet des noeuds (DepXML::Node) et arcs (DepXML::Edge), et dans une moindre mesure des clusters (DepXML::Cluster). Les constituants et hypertags ne sont pas encore accessibles. Les primitives de base du langage sont des méthodes s'appliquant à ses objets. On distingue deux familles de méthodes:

• la première famille permet de tester une propriété sur un objet. La table~resolve illustre quelques une de ces propriétés.
• la seconde famille permet de naviguer d'un objet à un autre. La table~resolve liste les 4 déplacements de base.

Certaines méthodes sont en fait implicites, comme par exemple cat_in_v_aux pour indiquer que la catégorie d'un noeud est soit v, soit aux, ou label_in_subject_impsubj pour indiquer que le label d'un arc est soit subject, soit impsubj.

Il est bien sûr possible de définir ses propres méthodes sur les noeuds et les arcs pour les utiliser dans DPath, en respectant la convention que les méthodes de propriétés doivent commencer par is_ ou has_. Et il est tout à fait possible d'utiliser une requête DPath dans la définition d'une telle méthode.

Une succession de propriétés dénote une conjonction, tandis qu'une succession de déplacements dénote un chemin dans la structure de dépendance.

Il est à noter que les expressions DPath (comme XPath) travaillent sur des ensembles d'objets (de même nature, noeuds ou arcs). Elles prennent généralement un singleton en entrée mais peuvent très bien retourner plusieurs objets en sortie, ou l'ensemble vide. L'opérateur union peut ainsi être utilisé pour grouper les résultats de deux sous-requêtes (équivalent à un ou logique). Enfin, il est possible de parenthéser une expression E pour l'appliquer sur l'ensemble courant d'objets sans déplacement, même si E contient des déplacements, de manière analogue à la construction [0...]0 en XPath. DPath autorise ainsi les constructions suivantes, sans déplacement:

• .( <exp> ) pour filtrer l'ensemble courant en ne gardant que les membres vérifiant l'expression;
• .x( <exp> ) pour garder l'ensemble courant, si au moins un des membres vérifie l'expression;
• .a( <exp> ) pour garder l'ensemble courant, si tous ses membres vérifient l'expression;
• .n( <exp> ) pour garder l'ensemble courant, si aucun de ses membres vérifient l'expression.

Il est également possible d'itérer une expression avec la notation ( <exp>)*. L'expression suivante permet de récupérer les noeuds de catégorie coo (coordonnant), lié à un noeud fils verbal par un arc étiqueté coord3 et à un noeud père verbal par un arc d'adjonction.

dpath is_coo            
    .(out is_coord3 target is_v)            
    .(in is_adj source is_v)

exemple d'expression dpath

Les deux méthodes suivantes (sur les noeuds) s'appuient sur des expressions DPath pour se déplacer au noeud père (via l'arc entrant) ou aux noeuds fils (via les arcs sortants). Ces méthodes peuvent ensuite elles-mêmes être utilisées dans des expressions DPath.

sub parent {          
  shift->apply(dpath in source);           
}           
sub children {           
  shift->apply(dpath out target);           
}

méthodes de déplacement vers les noeuds père ou fils

En allant plus loin, on peut ainsi définir des méthodes de déplacement beaucoup plus complexes. Ainsi, la méthode suivante (sur les noeuds) permet de se déplacer vers son sujet. On notera l'emploi de l'opérateur union et l'emploi récursif de la méthode get_subject (intuitivement, un sujet est accroché directement sur le noeud ou doit être recherché récursivement sur un auxiliaire adjoint au noeud).

sub get_subject {          
  (shift->apply( dpath out           
       ( is_subject target union is_Infl is_adj target is_aux get_subject )           
                ) )[0]; }

méthode récursive pour se déplacer vers le sujet

• 1. Techniquement, les expressions DPath sont lues par un lexer spécifique qui produit du code Perl inclus dans le flux normal de compilation Perl. L'utilisation de la variable d'environnement shell DEBUG_PATH=1 permet de voir le code Perl produit par le lexer. Cette petite magie est rendue possible par le module Perl Module::Declare.