Voici le message (en francais uniquement)

--


Voici quelques suggestions qui me paraissent utiles pour
ameliorer la puissance du systeme de modules:

1) Les contraintes devraient pouvoir lier des champs du module dans le
membre droit d'une contrainte.

exemple:
 
module type V = 
  sig
    type t
    type t' 
  end

module type SV = V with type t = t'

module F = functor (M : V with type t = t') -> ....

Le second est simulable en faisant

module type Un_Type = 
  sig
    type t
  end

module F = functor (T : Un_Type) ->
           functor (M : V with type t = T.t and type t' = T.t) ->

Je me dis que cela ne doit donc pas etre tres dur a implementer ?

2) La commande include devrait etre documentee et accepter un "with
constraints" (Deja subgere par d'autres). On aurait ainsi de
l'heritage multiple sur les "modules types"

3) Le include devrait aussi marcher pour les structures afin d'avoir
aussi de l'heritage sur les modules (les contraintes n'ont pas de sens
dans ce cas, il s'agit donc d'un simple sucre syntaxique).

Exemple: il est penible d'ecrire

module T = struct
  let x = ...
  let y = ... 
end

module T' =
  let x = x.T
  let y = y.T
  let z = ...
end 

au lieu de

module T' =
  include T
  let z = ...
end 
 

4) Moins important : on devrait pouvoir passer une valeur ou un type a
un functor sans l'encapsuler a la main dans un module

Ainsi au lieu d'ecrire

module type Un_Int =
  sig
    val n : int
  end

module F = functor (N : Un_Int) -> ....

on pourrait ecrire

module F = functor (n : int) -> ....


Il suffit d'ajouter les sucres syntaxiques suivants:

  functor (type t) ->  :=  functor (T : sig type t end) -> 
    avec t = T.t dans la suite

  functor (v : t) ->   :=  functor (V : sig val v : t end) -> 
    avec v = V.v dans la suite

et les abbreviations similaires pour l'application et les declaration
de types (il me semble que cette syntaxe n'est pas ambigue ?)


5) Encore moins important: Pouvoir utiliser les symboles infix d'un
module en notation infix (C'est la moindre des choses ?)

genre  x Q.R.+ y  ou  x +.Q.R y  pour  Q.R.(+) x y