Version française
Home     About     Download     Resources     Contact us    
Browse thread
Very very short question on objects
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Emmanuel CHAILLOUX <Emmanuel.Chailloux@l...>
Subject: Re: Very very short question on objects

Hi Christian,

> Hi everybody,
>
> I'm getting started with OCaml objects and, trying to compose
> functional updates, I ran into something like the following
> toy example:
>
>        Objective Caml version 2.02
>
> # class x >     object
>       method private f = ()
>       method g = {< >} # f
>     end
>   ;;
> class x : object method f : unit method g : unit end
> #
>
> Method [f] is not private... Shouldn't be this an error?

Because  you add a type constraint  as follow :

$ ocaml
        Objective Caml version 2.02

 class t = object(self :'a)
    constraint 'a = <  f : unit; ..>  (* from {<>}#f *)
    method private f = ()
     method g = {<>}#f
 end;;
class t : object method f : unit method g : unit end

If you have in the same class declaration, a method f with the attribute private, and the same method  f without it, the
last  definition  wins.
# class d = object method private f = print_string "private" method f = print_string "public" end;;
class d : object method f : unit end
# let q = new d;;
val q : d = <obj>
# q#f;;
public- : unit = ()

including the case where the last declaration is private.
# class e = object method f = print_string "public" method private f = print_string "private" end;;
class e : object method f : unit end
# let i = new e;;
val i : e = <obj>
# i#f;;
private- : unit = ()

So the last declaration wins, includind a "private" declaration.

The other examples show some type constraints :

(* don't  copy the instance to keep private method *)
#   class y = object(self) method private f = () method g = self#f end;;
class y : object method private f : unit method g : unit end

(* It's same that your example *)
# class z = object(self) method private f = () method g = (Oo.copy self)#f end;;
class z : object method f : unit method g : unit end

(* Another case to add a type constraint (for the parameter o) *)
# class u o = object(self:'a) method private f = () method g (o : 'a) = o#f end;;
class u : 'b -> object ('a) method f : unit method g : 'a -> unit end

(* to see an inherited private method *)
# class v = object(self) inherit y as super method f = super#f end;;
class v : object method f : unit method g : unit end


If you want to simulate the attribute "private", you can use a functional instance variable as follows :
# class p (h : 'b)  = object (self : 'a)
       constraint 'b = 'a -> unit
       val f = h
        method g = f({<>})
    end;;
class p : ('a -> unit) -> object ('a) val f : 'a -> unit method g : unit end
# let h x = ignore(Oo.copy x); ();;
val h : < .. > -> unit = <fun>
# let ip = new p h;;
val ip : p = <obj>
# ip#g;;
- : unit = ()


> Best regards,
>
> Christian

Best regards,

Emmanuel...