Types abstraits de données - Approche fonctionnelle et approche objet

Voici le diagramme des types à obtenir.

Définir l'interface générique MultiEnsembleParesseux<E> par héritage de Sequence (à instancier correctement). Y déclarer également les méthodes suivantes.

// Sélecteurs
boolean estApplication();
boolean estSomme();
// Destructeurs
Function<E, E> fonction();
MultiEnsembleParesseux<E> support();
MultiEnsembleParesseux<E> gauche();
MultiEnsembleParesseux<E> droit();

Un multi-ensemble est une application s'il est égal à une application d'une fonction à un multi-ensemble ; c'est une somme (union) s'il est égal à une somme. Aux sélecteurs sont associés des destructeurs, donnant d'une part la fonction et le multi-ensemble à laquelle la fonction est appliquée, d'autre part les deux termes de la somme.

Définir quatre classes génériques d'implémentation de l'interface générique MultiEnsembleParesseux.

• MultiEnsembleVide : classe singleton représentant le multi-ensemble vide
• MultiEnsembleCons : classe représentant les multi-ensembles construits
• ApplicationMultiEnsemble : classe représentant l'application d'une fonction à un multi-ensemble
• MultiEnsembleSomme : classe représentant la somme de deux multi-ensembles

On donnera une implémentation par défaut de toutes les méthodes dans une classe abstraite générique MultiEnsembleComposite, permettant ainsi des factorisations :

• les sélecteurs renverront false,
• les destructeurs renverront une exception UnsupportedOperationException,
• la méthode taille renverra la valeur d'un attribut en lecture, à initialiser par le paramètre de l'unique constructeur.

Suivre les indications suivantes pour l'implémentation des quatre classes.

• Les définir par héritage de la classe abstraite MultiEnsembleComposite.
• Les sélecteurs et les destructeurs sont spécifiés ainsi dans chaque classe d'implémentation.

  	estVide	element, reste	estApplication	fonction, support	estSomme	gauche, droit
  Vide	vrai	non défini	faux	non défini	faux	non défini
  Cons	faux	défini	faux	non défini	faux	non défini
  Application	?	?	vrai	défini	faux	non défini
  Somme	?	?	faux	non défini	vrai	défini

  (? : deux cas possibles)

• Pour implémenter la classe singleton, on utilisera la méthode traditionnelle : classe finale (sans sous-classe), constructeur privé, constante statique publique de type MultiEnsembleParesseux<?>, méthode statique <E> MultiEnsembleParesseux<E> singleton() permettant de convertir la constante.
• Pour implémenter les méthodes element et reste dans les classes ApplicationMultiEnsemble et MultiEnsembleSomme, utiliser la récursivité.

Définir l'interface générique ModuleMultiEnsembles<E, Rep> par héritage de FabriqueSequences, ModuleFoncteurSequence et ModuleMonoideAdditif (à instancier correctement). Cette interface est paramétrée par un type E représentant le type des éléments et par un type Rep sous-type de Sequence<Rep, E>. L'étendre avec deux méthodes, boolean egal(Rep x, Rep y) et String representation(Rep x), analogues aux méthodes equals et toString.

Définir une classe générique ModuleMultiEnsemblesParesseux<E> implémentant ModuleMultiEnsembles<E, MultiEnsembleParesseux<E>>.

Suivre les indications suivantes.

• Implémenter les fabriques vide et cons ainsi que la méthode somme par appel des constructeurs des classes du composite.
• Définir récursivement la méthode application en distinguant les cas suivants.
  • Si le multi-ensemble est vide, renvoyer le vide.
  • Si le multi-ensemble est une somme, renvoyer une somme.
  • Si le multi-ensemble est une application, créer une nouvelle application de même support et de fonction la composition des deux fonctions.
  • Si le multi-ensemble est construit (de type MultiEnsembleCons), créer une nouvelle application de manière paresseuse.
• Définir récursivement la méthode filtrage en distinguant les cas suivants.
  • Si le multi-ensemble est vide, renvoyer le vide.
  • Si le multi-ensemble est une somme, renvoyer une somme filtrée.
  • Si le multi-ensemble est une application, filtrer le support.
  • Si le multi-ensemble est construit (de type MultiEnsembleCons), filtrer l'élément puis le reste.
• Implémenter la méthode egal en utilisant deux tables de hachage de type Map<E, Integer> (initialisées par new HashMap<>()).
  • Remplir la première table avec les éléments du premier multi-ensemble, en associant à chaque élément son nombre d'occurrences.
  • Faire de même pour la seconde table.
  • Comparer pour chaque élément le nombre d'occurrences dans les deux multi-ensembles.
• Implémenter la méthode representation par une boucle. Le multi-ensemble sera représenté sous la forme \(\{e_0, \ldots, e_n\}\).
• Définir un constructeur privé.
• Définir une fonction (statique) d'abstraction ainsi.

  public static <E> ModuleMultiEnsembles<E, ?> abstraction(){
    return new ModuleMultiEnsemblesParesseux<>();
  }
  

  Expliquer en commentaire à quoi elle sert.

Tester l'implémentation du module en décommentant le corps de la classe TestMultiEnsemblesParesseux.

Voici le diagramme des types à obtenir.

Définir l'interface générique MultiEnsemble par héritage de Sequence, FabriqueSequences, FoncteurSequence et de MonoideAdditif (à instancier correctement).

On implémente l'interface MultiEnsemble en déléguant les calculs à un multi-ensemble élémentaire (sans opérations) et à un module permettant d'opérer sur ce multi-ensemble. On réalise donc une adaptation du module à la nouvelle interface.

Précisément, définir une classe MultiEnsembleAvecModule<E, Rep> implémentant l'interface MultiEnsemble<E>. Le paramètre Rep représente le type des multi-ensembles élémentaires.

Suivre les indications suivantes.

• Le paramètre Rep doit être un sous-type de Sequence<Rep, E>>.
• La classe possède deux attributs, un module et un multi-ensemble.

  private ModuleMultiEnsembles<E, Rep> module;
  private Rep multiEnsemble;
  

• Pour convertir de MultiEnsemble<E> vers Rep, utiliser la méthode concretiser ainsi définie.

  private Rep concretiser(MultiEnsemble<E> seq){
    if(seq.estVide())
      return module.vide();
    return module.cons(seq.element(), concretiser(seq.reste()));
  }
  

• Inversement, pour fabriquer un MultiEnsemble<E> à partir d'un Rep, utiliser la méthode fabriquer ainsi définie.

  private MultiEnsemble<E> fabriquer(Rep multiEnsemble){
    return new MultiEnsembleAvecModule<>(module, multiEnsemble);
  }
  

• Définir la méthode toString en utilisant la méthode representation.

Dans la classe TestMultiEnsembles, décommenter le code et définir la fonction (statique) fabrique qui prend comme argument un module et renvoie une fabrique, en construisant un objet de type MultiEnsembleAvecModule. Veiller à réaliser la capture du joker (?) en quantifiant universellement la définition non seulement par un paramètre de type E pour les éléments mais aussi par un paramètre de type Rep pour la représentation des multi-ensembles élémentaires, abstraite par le joker.