Discussion :

[Blustuff]

Bonjour,

J'ai une signature de module que j'aimerais implanter de deux manières différentes. Les modules doivent définir un type t. L'un des modules définit t comme un tableau. L'autre module définit t comme des Mappe (camllib)

Or la signature contient des fonctions manipulant clairement t comme une structure impérative que les Mappe ne sont pas. (i.e. des fonctions -> unit, dont la sémantique est clairement de faire des modification sur la structure passée en paramètre)

Donc, le type t doit être une structure de donnée modifiable. L'idée la plus simple est de le déclarer dans le second cas comme une référence sur des Mappe. Mais alors, les fonctions ne retournent plus le type désiré, en particulier la fonction empty.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

let empty = ref Mappe.empty

qui du coup n'est plus de type

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

val empty : 'a t

mais de type

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

val empty : '_a t

Et là... je ne sais pas quoi faire. Non, seulement, je ne comprends pas la différence avec l'implantation avec des tableaux, puisque les tableaux sont une structure de donnée modifiable, mais de plus, je ne sais pas comment modifier la signature de mes modules ou bien comment modifier l'implantation pour avoir le même résultat, mais que ce soit typable.

Pourriez vous m'éclairer sur les solutions succeptibles de résoudre le problème ?

[alex_pi]

Même en dehors d'un point de vue "typage", écrire dans ton module

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

let empty = ref Map.empty

est faux.
En effet, supposons que deux utilisateurs de ton module M récupèrent la map vide, puis fassent des choses dessus. Il vont en fait travailler avec la même référence, et donc se marcher sur les pieds.

C'est d'ailleurs ce qui explique que le type est avec un _. Si tu écris que ref Mappe.empty est de type 'a t, ça veut dire que tu peux y ajouter autant des entier que des booléens. Et donc obtenir une map hétérogène. Beuuuuuurk.

Une solution est donc de faire quelque chose comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
module M = 
(struct
  type 'a t =  'a list ref
 
  let empty () = ref []
 
  let add e rl = rl := e :: !rl
 
end : sig
   type 'a t
   val empty : unit -> 'a t
   val add : 'a -> 'a t -> unit
 end);;

(J'ai mis des listes pour être sûr que ça compile chez moi).
En effet ici, chaque appel à "empty" génère une nouvelle référence, donc pas de problème. Et là le type de empty se lit "pour tout type 'a, si tu me donnes un unit, je te fournis un 'a t", et surtout pas "si tu me fourni un unit, je te donne quelque chose qui pour tout type 'a est de type 'a t" qui poserait le même problème. Moralement, l'instanciation de 'a se fait avant l'appel de la fonction.

[Blustuff]

C'est parfait !

Merci.