Approche objet et types abstraits de données

Voici le diagramme des types à obtenir.

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

// Sélecteur
boolean estEvaluee();
// Destructeurs
Function<E, E> fonction();
ListeParesseuse<E> support();

Une liste n'est pas évaluée si elle est égale à une application d'une fonction à une liste ; elle est évaluée si elle est vide ou construite. Lorsqu'elle n'est pas évaluée, les destructeurs donnent respectivement la fonction et la liste à laquelle la fonction est appliquée.

Définir trois classes génériques d'implémentation de l'interface ListeParesseuse.

• ListeVide : classe singleton représentant la liste vide (et évaluée)
• ListeCons : classe représentant les listes construites (et évaluées)
• ApplicationListe : classe représentant l'application d'une fonction à une liste (non évaluée, en mode paresseux)

Suivre les indications suivantes.

• On lancera une exception UnsupportedOperationException lorsque les méthodes tete et reste sont appeléee sur une liste vide, et lorsque les méthodes fonction et support sont appellées sur des listes évaluées.
• Pour implémenter la classe singleton, on utilisera la méthode traditionnelle : classe finale (sans sous-classe), constructeur privé, constante statique publique de type Liste<?>.

Définir l'interface générique ModuleListes<E, Rep> par héritage de FabriqueSequences, ModuleFoncteurListe 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 ModuleListesParesseuses<E> implémentant ModuleListes<E, ListeParesseuse<E>>

Suivre les indications suivantes.

• Définir récursivement les méthodes somme et egal.
• Implémenter la méthode representation par une boucle. La liste sera représentée sous la forme \([e_0, \ldots, e_n]\).
• Pour implémenter la méthode application, procéder ainsi :
  • si la liste est évaluée, créer une nouvelle application (de type ApplicationListe),
  • si la liste n'est pas évaluée et est donc une application, créer une nouvelle application de même support et de fonction la composition des deux fonctions.
• Définir un constructeur privé.
• Définir une fonction (statique) d'abstraction ainsi.

  public static <E> ModuleListes<E, ?> abstraction() {
    return new ModuleListesParesseuses<E>();
  }                           
  

  Expliquer en commentaire à quoi elle sert.

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

Voici le diagramme des types à obtenir.

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

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

Précisément, définir une classe ListeAvecModule<E, Rep> implémentant l'interface Liste<E>. Le paramètre Rep représente le type des listes é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 une liste.

  private ModuleListes<E, Rep> module;
  private Rep liste;
  

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

  private Rep concretiser(Liste<E> l){
    if(l.estVide())
      return module.vide();
    return module.cons(l.tete(), concretiser(l.reste()));
  }
  

• Définir la méthode equals en utilisant les méthodes estVide, tete et reste.
• Définir la méthode toString en utilisant la méthode representation.

Dans la classe TestListes, décommenter le code et définir la fonction (statique) fabrique qui prend comme argument un module et renvoie une fabrique. Veiller à réaliser la capture du joker (?) en quantifiant universellement la définition.