Hi David,

The explanation of your problem is simple:
you've solved the input side, but you're still unifying everything on
the output side of your first scope_term.

A possible solution is to match again the output of scope_term_lst, to
avoid this spurious unification.

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

Cheers,

---------------------------------------------------------------------------
Jacques Garrigue      Kyoto University     garrigue at kurims.kyoto-u.ac.jp
		<A HREF=http://wwwfun.kurims.kyoto-u.ac.jp/~garrigue/>JG</A>

From: "Gurr, David (MED, self)" <David.Gurr@med.ge.com>
> 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