[Caml-list] objects and functions

[Caml-list] objects and functions

[Damien]

Hi,

I would like to create an object whose methods 
depend on a parameter.

the simple way is something like :
>class a x = object
>	method calc = match x with
>	| 0 -> 0
>	| x -> 33 mod x
>end

a more efficient way (if there are a lot of calc-like methods) 
would be to test for x before constructing the object :
>class a0 = object method calc = 0 end
>class ax x = object method calc = 33 mod x end
>let fa x = function 0 -> new a0 | x -> new ax x 

but then I can't nicely inherit from (fa x) :-(


so, is there a way (or wouldn't it be useful to have one) for doing 
something like :
>class a = function 
>| 0 -> object method calc = 0 end
>| x -> object method calc = 33 mod x end
or
>class b x = object
>	inherit fa x
>	...
>end


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

Re: [Caml-list] objects and functions

[Christophe TROESTLER]

On Thu, 22 May 2003, Damien <Damien.Pous@ens-lyon.fr> wrote:
> 
> so, is there a way (or wouldn't it be useful to have one) for doing 
> something like :
> >class a = function 
> >| 0 -> object method calc = 0 end
> >| x -> object method calc = 33 mod x end
> or
> >class b x = object
> >	inherit fa x
> >	...
> >end

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

Cheers,
ChriS

-------------------
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] objects and functions

[Damien]

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