Re: Suggestions pour les modules

Re: Suggestions pour les modules

[Thierry Bravier]

Dear ocamlers,

Christophe Raffalli wrote:

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

>   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

I have already encountered this problem, and I also feel there is a need
for including structs.

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

I once had to write:

module type UNIT = sig end

module Make_Foo (Unit : UNIT) = struct ... end

module Foo = Make_Foo (struct end)

which looks really silly, it would become

module Foo = Make_Foo ()

would not it ?

>  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

I happen to have already suggested this useful feature (the answer was
that it would complicate parsing)

Cheers.

--
Thierry Bravier                     Dassault Aviation - DGT / DPR / DESA
78, Quai Marcel Dassault              F-92214 Saint-Cloud Cedex - France
Telephone : (33) 01 47 11 53 07          Telecopie : (33) 01 47 11 52 83
E-Mail :                     mailto:thierry.bravier@dassault-aviation.fr


Christophe Raffalli wrote:

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

> 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
>
>

I have already encountered this problem, and I also feel there is a need
for including structs.

> 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 ?)

I once had to write:

module type UNIT = sig end

module Make_Foo (Unit : UNIT) = struct ... end

module Foo = Make_Foo (struct end)

which looks really silly, it would become

module Foo = Make_Foo ()

would not it ?

> 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

I happen to have already suggested this useful feature (the answer was
that it would complicate parsing)

Cheers.

--
Thierry Bravier                     Dassault Aviation - DGT / DPR / DESA
78, Quai Marcel Dassault              F-92214 Saint-Cloud Cedex - France
Telephone : (33) 01 47 11 53 07          Telecopie : (33) 01 47 11 52 83
E-Mail :                     mailto:thierry.bravier@dassault-aviation.fr

Re: Suggestions pour les modules

[Christophe Raffalli]

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