Typage des modules

Typage des modules

[Daniel Bonniot]

Bonjour,

Comment resoudre le probleme suivant ?
Le module A declare un type a, le module B renvoie une valeur de type a
et A utilise B dans son implementation :

(* a.mli *)
type a
val v:a

(* a.ml *)
type a = { x: int}
let v = B.f {x=3}


(* b.mli *)
val f : A.a-> A.a

(* b.ml *)
let f x =x


Voici le resultat des compilations:
moo>ls
a.ml   a.mli  b.ml   b.mli
moo>ocamlc -c a.mli
moo>ocamlc -c b.mli
moo>ocamlc -c a.ml 
File "a.ml", line 2, characters 12-17:
This expression has type a but is here used with type A.a
moo>

Cette erreur est logique etant donne le systeme de typage des modules,
mais comment ecrire ce genre de dependances ?

Daniel Bonniot

Re: Typage des modules

[Sylvain BOULM'E]

Bonjour,

Pour repondre a votre question, il y a plusieurs solutions... La "meilleure" 
depend du probleme que vous avez a resoudre :

1. Le polymorphisme de OCAML
 
Dans "b.mli", vous declarez 
val f: 'a -> 'a

Si f utilise en fait des fonctions de "a.ml", vous passez ces fonctions en 
parametres de f. Cette methode devient vite penible si vous avez en fait 
plusieurs fonctions "f" qui dependent de plusieurs fonctions de "a.ml"

2. Dans ce cas, vous pouvez utilisez le mecanisme de foncteur de OCAML.
Par exemple :

module type B_Type =
  sig
    type t
    val f: t->t
  end

module MakeB (A: sig type a val g: a->a end) : B_Type with type t=A.a = 
  struct 
    type t=A.a
    let f x = (A.g x)
  end

module type A_Type =
  sig
    type a
    module B : B_Type with type t=a
    val v: a
    val g: a -> a
  end

module A: A_Type =
  struct
    type b = { x:int}
    type a = b
    let g x = x
    module B = MakeB  (struct type a = b  let g=g end)
    let v = B.f {x=3}
  end

module B = MakeB (A)

Dans cet exemple vous pouvez evidemment faire de "A_Type" un "a.mli", et de 
"A" un "a.ml". Mais ce mecanisme devient penible quand les dependences se 
compliquent (avec eventuellement des definitions de B et de A mutuellement 
recursives) : dans ce cas, soit on peut revoir son decoupage en "module" (deux 
fonctions mutuellement recursives devraient peut-etre appartenir au meme 
module), soit on peut utiliser les mecanismes objets.

3. 

class virtual ['a] a_type =
  object 
    method virtual stop: 'a -> bool
    method virtual v: 'a
    method virtual g: 'a -> 'a
  end

class ['b] b_class (o:'b) =
  object 
    constraint 'b = 'a #a_type
    method f x= 
        if (o#stop x) 
        then o#v
        else (o#g x)
  end


module type A_Type =
sig
  type a
  val obj : a a_type
  val p: a -> string
end

module A: A_Type = 
struct
  type a={x : int}
  class a_class = 
    object (s)
      inherit [a] a_type
      method b = new b_class s
      method stop y = y.x <= 0
      method v = s#b#f {x=3}
      method g y = 
         if (s#stop y) then (s#b#f y) else { x= y.x-5 }
    end
   let obj = (new a_class :> a a_type)
   let p y = string_of_int y.x
end;;
    
let obj_b = new b_class A.obj;;  


J'espere que vous trouverez ce que vous cherchez,

Sylvain.
                      

Re: Typage des modules

[David Monniaux]

On Tue, 22 Jun 1999, Daniel Bonniot wrote:

> Cette erreur est logique etant donne le systeme de typage des modules,
> mais comment ecrire ce genre de dependances ?

For our English-speaking friends: I've already had the same kind of
problem as Daniel's. When the compiler compiles a.ml to produce module A,
it doesn't see that A.a and a are the same thing, which leads to absurd
typing errors. It's sometimes unpleasant.

-- David