I had quick hack I wanted to try with XL's modular module system.  I
changed MiniML.ML.term to a polymorphic variant and thus changed the 
definitions of MiniML.MLScoping.scope_term : MiniML.ML.term ->
MiniML.ML.term
as follows:


    type 'term lst = [
      | `Nil
      | `Cons of 'term * 'term lst
      ]
    type 'term lambda = [
      | `Constant of int                        (* integer constants *)
      | `Longident of path                      (* id or mod.mod...id *)
      | `Function of Ident.t * 'term             (* fun id -> expr *)
      | `Apply of 'term * 'term                   (* expr(expr) *)
      | `Let of Ident.t * 'term * 'term           (* let id = expr in
expr *)
      ]
    type term = [
      | term lambda
      | term lst
      ]

    let rec scope_term_lst scope_term sc = function 
      | `Nil -> `Nil
      | `Cons(h,t) -> `Cons(scope_term sc h,scope_term_lst scope_term sc
t) 

    let rec scope_term_lambda scope_term sc = function
      | `Constant n -> `Constant n
      | `Longident path -> `Longident(Scope.value_path path sc)
      | `Function(id, body) ->
          `Function(id, scope_term (Scope.enter_value id sc) body)
      | `Apply(t1, t2) -> `Apply(scope_term sc t1, scope_term sc t2)
      | `Let(id, t1, t2) ->
          `Let(id, scope_term sc t1, scope_term (Scope.enter_value id
sc) t2)

     let rec scope_term sc  = function
       | #lambda as t -> scope_term_lambda scope_term sc t
       | #lst as t    -> scope_term_lst scope_term sc t

But I did not get the type I expected.  Instead I got:

val scope_term :
 Scope.t ->
 ([< `Apply of 'a * 'a
   | `Cons of 'a * 'a lst
   | `Constant of int
   | `Function of Ident.t * 'a
   | `Let of Ident.t * 'a * 'a
   | `Longident of path
   | `Nil] as 'a) ->
 ([> `Apply of 'b * 'b
   | `Cons of 'b * 'b    <<<<<<<<<<<<<<< what?
   | `Constant of int
   | `Function of Ident.t * 'b
   | `Let of Ident.t * 'b * 'b
   | `Longident of path
   | `Nil] as 'b)

But if I tried a slightly different definition:

     let rec scope_term sc  = function
       | #lambda as t -> scope_term_lambda scope_term sc t
       | `Nil -> `Nil
       | `Cons(h,t) -> `Cons(scope_term sc h,scope_term_lst scope_term
sc t)

Then I do get the type I expect:

val scope_term :
 Scope.t ->
 ([< `Apply of 'a * 'a
   | `Cons of 'a * ([< `Cons of 'a * 'b | `Nil] as 'b)
   | `Constant of int
   | `Function of Ident.t * 'a
   | `Let of Ident.t * 'a * 'a
   | `Longident of path
   | `Nil] as 'a) ->
 ([> `Apply of 'c * 'c
   | `Cons of 'c * ([> `Cons of 'c * 'd | `Nil] as 'd)
   | `Constant of int
   | `Function of Ident.t * 'c
   | `Let of Ident.t * 'c * 'c
   | `Longident of path
   | `Nil] as 'c) 

Does anyone have any ideas?

Thanks, 

-D

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners