Section courante

A propos

Section administrative du site

Multiméthodes et hiérarchies

Clojure s'affranchit de l'approche orientée objet traditionnelle consistant à créer un nouveau type de données pour chaque situation, préférant construire une vaste bibliothèque de fonctions sur un petit ensemble de types. Cependant, Clojure reconnaît pleinement l'importance du polymorphisme d'exécution pour une architecture système flexible et extensible. Clojure prend en charge un polymorphisme d'exécution sophistiqué grâce à un système de multiméthodes permettant d'effectuer des appels sur les types, les valeurs, les attributs et les métadonnées d'un ou plusieurs arguments, ainsi que sur les relations entre eux.

Une multiméthode Clojure est la combinaison d'une fonction de répartition et d'une ou plusieurs méthodes. Lors de la définition d'une multiméthode, avec `defmulti`, une fonction de répartition doit être fournie. Cette fonction sera appliquée aux arguments de la multiméthode afin de produire une valeur de répartition. La multiméthode tentera ensuite de trouver la méthode associée à cette valeur ou une valeur dont elle est dérivée. Si une telle méthode a été définie (via `defmethod`), elle sera appelée avec les arguments, et cette méthode constituera la valeur de l'appel de la multiméthode. Si aucune méthode n'est associée à la valeur de répartition, la multiméthode recherchera une méthode associée à la valeur de répartition par défaut (qui est `:default`) et l'utilisera si elle existe. Sinon, l'appel générera une erreur.

Le système de multiméthodes expose l'API suivante : `defmulti` crée de nouvelles multiméthodes, `defmethod` crée et installe une nouvelle méthode de multiméthode associée à une valeur de répartition, `remove-method` supprime la méthode associée à une valeur de répartition et `prefer-method` établit un ordre entre les méthodes lorsqu'elles seraient autrement ambiguës.

La dérivation est déterminée par une combinaison d'héritage Java (pour les valeurs de classe) ou par le système hiérarchique ad hoc de Clojure. Ce système hiérarchique prend en charge les relations de dérivation entre les noms (symboles ou mots-clés) et les relations entre les classes et les noms. La fonction `derive` crée ces relations et la fonction `isa?` vérifie leur existence. Notez que `isa?` est différent de `instance?`.

Vous pouvez définir des relations hiérarchiques avec `(derive child parent)`. L'enfant et le parent peuvent être des symboles ou des mots-clefs et doivent être qualifiés par un espace de noms :

Notez la syntaxe `::reader`, tandis que `::keywords` résout les espaces de noms.

  1. ::rect
  2. -> :user/rect

derive est le créateur de relations fondamental (relationship-maker) :

  1. (derive ::rect ::shape)
  2. (derive ::square ::rect)

parents / ancestors / descendants et isa? permet d'interroger la hiérarchie :

  1. (parents ::rect)
  2. -> #{:user/shape}
  3.  
  4. (ancestors ::square)
  5. -> #{:user/rect :user/shape}
  6.  
  7. (descendants ::shape)
  8. -> #{:user/rect :user/square}

(= x y) implique (isa? x y) :

  1. (isa? 42 42)
  2. -> true

isa? utilise le système hiérarchique :

  1. (isa? ::square ::shape)
  2. -> true

Vous pouvez également utiliser une classe comme enfant (mais pas comme parent ; la seule façon de définir un élément comme enfant d'une classe est par le biais de l'héritage en Java).

Cela vous permet de superposer de nouvelles taxonomies à la hiérarchie de classes Java existante :

  1. (derive java.util.Map ::collection)
  2. (derive java.util.Collection ::collection)
  3.  
  4. (isa? java.util.HashMap ::collection)
  5. -> true

isa? teste également les relations entre classes :

  1. (isa? String Object)
  2. -> true

de même que les parents / ancestors (mais pas les descendants, puisque les descendants de classe constituent un ensemble ouvert).

  1. (ancestors java.util.ArrayList)
  2. -> #{java.lang.Cloneable java.lang.Object java.util.List
  3.     java.util.Collection java.io.Serializable
  4.     java.util.AbstractCollection
  5.     java.util.RandomAccess java.util.AbstractList}

La fonction `isa?` fonctionne avec les vecteurs en appelant `isa?` sur leurs éléments correspondants :

  1. (isa? [::square ::rect] [::shape ::shape])
  2. -> true

dispatch basé sur `isa?`

Les méthodes multiples utilisent `isa?` plutôt que `=` pour tester la correspondance des valeurs de dispatch. Notez que le premier test de `isa?` renvoie `=`, donc les correspondances exactes fonctionnent :

  1. (defmulti foo class)
  2. (defmethod foo ::collection [c] :a-collection)
  3. (defmethod foo String [s] :a-string)
  4.  
  5. (foo [])
  6. :a-collection
  7.  
  8. (foo (java.util.HashMap.))
  9. :a-collection
  10.  
  11. (foo "bar")
  12. :a-string

prefer-method permet de lever l'ambiguïté en cas de correspondances multiples où aucune valeur ne prédomine sur l'autre. Il suffit de déclarer, pour chaque méthode multiple, qu'une valeur de répartition est préférée à une autre :

  1. (derive ::rect ::shape)
  2.  
  3. (defmulti bar (fn [x y] [x y]))
  4. (defmethod bar [::rect ::shape] [x y] :rect-shape)
  5. (defmethod bar [::shape ::rect] [x y] :shape-rect)
  6.  
  7. (bar ::rect ::rect)
  8. -> Execution error (IllegalArgumentException) at user/eval152 (REPL:1).
  9.    Multiple methods in multimethod 'bar' match dispatch value:
  10.    [:user/rect :user/rect] -> [:user/shape :user/rect]
  11.    and [:user/rect :user/shape], and neither is preferred
  12.  
  13. (prefer-method bar [::rect ::shape] [::shape ::rect])
  14. (bar ::rect ::rect)
  15. -> :rect-shape

Tous les exemples ci-dessus utilisent la hiérarchie globale du système multiméthode, mais il est également possible de créer des hiérarchies entièrement indépendantes avec `make-hierarchy`. De plus, toutes les fonctions mentionnées peuvent prendre une hiérarchie optionnelle comme premier argument.

Ce système simple est extrêmement puissant. Pour comprendre la relation entre les multiméthodes Clojure et la fonction de répartition unique traditionnelle de Java, on peut considérer que la répartition unique est comparable à une multiméthode Clojure dont la fonction de répartition appelle `getClass` sur le premier argument et dont les méthodes sont associées à ces classes. Les multiméthodes Clojure ne sont pas figées à une classe ou un type ; elles peuvent être basées sur n'importe quel attribut des arguments, sur plusieurs arguments, valider les arguments et gérer les erreurs,...

Remarque : Dans cet exemple, le mot-clef `:Shape` est utilisé comme fonction de répartition, car les mots-clefs sont des fonctions de cartographie, comme expliqué dans la section Structures de données.

  1. (defmulti area :Shape)
  2. (defn rect [wd ht] {:Shape :Rect :wd wd :ht ht})
  3. (defn circle [radius] {:Shape :Circle :radius radius})
  4. (defmethod area :Rect [r]
  5.     (* (:wd r) (:ht r)))
  6. (defmethod area :Circle [c]
  7.     (* (. Math PI) (* (:radius c) (:radius c))))
  8. (defmethod area :default [x] :oops)
  9. (def r (rect 4 13))
  10. (def c (circle 12))
  11. (area r)
  12. -> 52
  13. (area c)
  14. -> 452.3893421169302
  15. (area {})
  16. -> :oops

Dernière mise à jour : Lundi, le 2 février 2026