On Thu, 22 May 2003 16:00:12 +0200 (CEST) Christophe TROESTLER wrote:

> What about:
> 
> class a x =
> let x = match x with 0 -> 0 | x -> 33 mod x in
> object
>   method calc = x
> end;;
> 
> class b x =
> object
>   inherit (a x)
> end;;

Laurent Vibert answered me the same thing...
I've simplified too much :(

I meant
>class a x = object
>	method calc y = match x with
>	| 0 -> 0
>	| x -> y mod x
>end

that can be rewritten
>class a x = 
>let f = match x with
>	| 0 -> fun _ -> 0
>	| x -> fun y -> y mod x
>in
> 	object method calc = f
>end

this works pretty well while there is only a few calc-like methods,
if not the code becomes less readable.


In fact I was more interested by the question of seeing objects as
_real_ first class values.
Laurent Vibert answered to me this had been studied but that it 
complicates the compiler too much with respect to the benefits brought.

the other case it could be handy is when you want to "unify" two objects
that are quite complex (thus with "read-only" implementation) :
>class type t = (* something dealing with a dozen modules *)
>class a: t
>class b: t
>
>class ab = function
>| `A -> a
>| `B -> b
>class c x = object 
>	inherit ab x
>	...
>end

I found this nice :)

damien

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