[Caml-list] classes, objects, and class variables

[Caml-list] classes, objects, and class variables

[Jacques Garrigue]

To whom it may concern,

I'm in the process of improving the ocaml class system.
Principally the following two points:
1) making class creation cheaper.
   If you believed you could create classes in a "let module", and
   get away with it, you weere: it was prohibitively expensive in both
   time and space. Now I'm seeing 10000% speeups.
2) using this to make objects (or final classes) first class.
   Be able to write "let o = object (self) method m = ... end"
   Side advantage, there are no restrictions on polymorphism.

But in this process, I came along with the rather strange behaviour of
class variables. Class variables are defined by a let before any
parameters, for instance
  class c = let a = init () in fun ... -> object ... end
Their current semantics is to be evaluated repeatedly, once for c,
but again for all classes inheriting from c. The problem is that this
is costly for the implementation, doesn't fit well with the
possibility to create dynamically an arbitrary number of classes
inheriting from, and that I don't see what it's intended for.

So I'm planning to revert to the more intuitive semantics: evaluation
when creating c, but never again.

Does that bother anybody?

Jacques Garrigue

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

Re: [Caml-list] classes, objects, and class variables

[Gerd Stolpmann]

Am Don, 2003-11-20 um 14.07 schrieb Jacques Garrigue:
> To whom it may concern,
> 
> I'm in the process of improving the ocaml class system.
> Principally the following two points:
> 1) making class creation cheaper.
>    If you believed you could create classes in a "let module", and
>    get away with it, you weere: it was prohibitively expensive in both
>    time and space. Now I'm seeing 10000% speeups.
> 2) using this to make objects (or final classes) first class.
>    Be able to write "let o = object (self) method m = ... end"
>    Side advantage, there are no restrictions on polymorphism.
> 
> But in this process, I came along with the rather strange behaviour of
> class variables. Class variables are defined by a let before any
> parameters, for instance
>   class c = let a = init () in fun ... -> object ... end
> Their current semantics is to be evaluated repeatedly, once for c,
> but again for all classes inheriting from c. The problem is that this
> is costly for the implementation, doesn't fit well with the
> possibility to create dynamically an arbitrary number of classes
> inheriting from, and that I don't see what it's intended for.
> 
> So I'm planning to revert to the more intuitive semantics: evaluation
> when creating c, but never again.
> 
> Does that bother anybody?

Just experimenting (to understand what you mean, I never discovered this
"feature" myself):

- Classes without arguments:

# class x = let _ = prerr_endline "X" in object end;;
X
class x : object  end
# class y = let _ = prerr_endline "Y" in object inherit x end;;
X
Y
class y : object  end

-  Classes with arguments:

# class x() = let _ = prerr_endline "X" in object end;;
class x : unit -> object  end
# class y() = let _ = prerr_endline "Y" in object inherit x() end;;
class y : unit -> object  end
# new x();;
X
- : x = <obj>
# new y();;
Y
X
- : y = <obj>

I suppose you are only referring to the case where classes do not have
arguments (because in the other case, the class variables can be
dependent on class arguments, so they must be evaluated again for every
subclass).

I'm quite surprised that the class variables are evaluated in the
reverse order in the argument-less case. This seems to be an
inconsistency anyway, so I guess this is a rarely used feature. (When
"inherit" is read as an _instruction_ to initialize the named class
again for usage in the subclass, the order of evaluation should be the
same as in the case with arguments.)

If somebody needs repeated evaluation, he can add unit arguments to the
class definition.

So my conclusion is: do it.

Gerd 
-- 
------------------------------------------------------------
Gerd Stolpmann * Viktoriastr. 45 * 64293 Darmstadt * Germany 
gerd@gerd-stolpmann.de          http://www.gerd-stolpmann.de
------------------------------------------------------------

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

Re: [Caml-list] classes, objects, and class variables

[james woodyatt]

[just now catching up with my caml mail; i left it accumulating unread 
for a couple months]

On 20 Nov 2003, at 05:07, Jacques Garrigue wrote:
>
> But in this process, I came along with the rather strange behaviour of
> class variables. Class variables are defined by a let before any
> parameters, for instance
>   class c = let a = init () in fun ... -> object ... end
> Their current semantics is to be evaluated repeatedly, once for c,
> but again for all classes inheriting from c. The problem is that this
> is costly for the implementation, doesn't fit well with the
> possibility to create dynamically an arbitrary number of classes
> inheriting from, and that I don't see what it's intended for.
>
> So I'm planning to revert to the more intuitive semantics: evaluation
> when creating c, but never again.
>
> Does that bother anybody?

The behavior you want to change is a behavior I noticed and it bothered 
me when I noticed it.  I just chalked it up to yet another weird thing 
about classes.  In order to get the behavior I wanted, I just lifted 
all my class variables out of the class definitions and used module 
signatures to hide them.

You want to make this change?  I'm supportive.  Please do.

One request I would make: please retain the functional object semantics 
and the {< ... >} syntax.  I used that feature with state monads and I 
like it a lot.


-- 
j h woodyatt <jhw@wetware.com>

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