Reply in text.

> From: Bow-Yaw Wang <bywang@saul.cis.upenn.edu>
> 
> > I'd like to know how to make independent copies of parameterized 
> > objects. Consider the following example:
> > 
> > # class ['a] t = object method id (x:'a) = x end;;
> > class ['a] t : object method id : 'a -> 'a end
> > # let o = new t;;
> > val o : '_a t = <obj>
> > # let p = Oo.copy o;;
> > val p : < id : '_a -> '_a > = <obj>
> > # o#id 1;;
> > - : int = 1
> > 
> > After defining a simple parameterized class t, I create an
> > object o of type '_a t and make p as a copy. After the type 
> > '_a is instantiated to int, I'd expect p to retain its type
> > < id : '_a -> '_a >. However, 
> > 
> > # p;;
> > - : < id : int -> int > = <obj>
> 
> That's just the point of non-generalized variables: if you instantiate
> them somewhere, the type is propagated everywhere. So as long as the
> type of o is '_a t, there is no hope.

But is it necessary to propagate everywhere? If I create 
another t object, it is of type '_a t too. But the new
object remains intact while the copied object changes its 
type when I instantiate the original.

> > So my questions are:
> > 
> > 1. Is there a way to make a copy of o so that it can be 
> > instantiated differently?
> 
> No.

Thanks for the info. It is a little disappointing, though.

> 
> > 2. If not, is there any type-theoretic explanation? I'm
> > just curious if it may make type system unsound.
> 
> In this case, this is pretty simple: '_a is not a polymorphic
> variable, this is just a monomorphic type which is not yet known.
> If you copy it, you just get a pointer to the same type.

'_a is not a polymorphic variable, and I didn't want it to be.
I think what I want is to have a pointer to a new monomorphic
type variable in copies. 

[snip]

> I wonder what you need exactly.

It is about a simplified visitor design pattern. Let's say
we have:

class ['value, 'visitor] a = 
  object 
    constraint 'visitor = < in_a : unit -> 'value; .. > 
    method invite (v : 'visitor) = v#in_a () 
  end;;

class virtual ['value] visitor_t = 
  object 
    method virtual in_a : unit -> 'value
  end;;

I can create two different visitors:

class int_visitor_t = 
  object 
    inherit [int] visitor_t 
    method in_a () = 0 
  end;;

let int_v = new int_visitor_t;;

class string_visitor_t = 
  object 
    inherit [string] visitor_t 
    method in_a () = "a" 
  end;;

let str_v = new string_visitor_t;;

Suppose I have two objects:

let x = new a;;
let y = Oo.copy x;;

I want both int_v and str_v to be invited. I can do

x#invite int_v;;

But then x will be instantiated and cannot apply str_v
again. So I thought a copy of x might be used in
applying str_v. But it turns out the copy y will be 
instantiated as well. 

Now since the visitor type is constrained, it cannot
be polymorphic in class a. A simple solution (IMHO)
is to have an independent copy of x. It doesn't seem
to be necessary to tie the monomorphic type variables
of the copy to the original. And it would make the
previous visitor pattern implementation cleaner. 
Otherwise, I'll have to build another x from scratch.

Bow-Yaw

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