Coercion of arrays of objects (and some other containers)

Coercion of arrays of objects (and some other containers)

[Martin Jambon]

Here is my problem:

# let obj =
object
  method a = ()
  method b = ()
end;;
        val obj : < a : unit; b : unit > = <obj>

(* That is nice: *)
# ([ obj ] :> < a : unit > list);;
- : < a : unit > list = [<obj>]

(* But why doesn't it work with arrays? *)
# ([| obj |] :> < a : unit > array);;
Characters 1-10:
  ([| obj |] :> < a : unit > array);;
   ^^^^^^^^^
This expression cannot be coerced to type < a : unit > array; it has type
  < a : unit; b : unit > array
but is here used with type < a : unit > array
Only the first object type has a method b


In practice I have this problem with a hash table of objects, and I
expected it to work since it works fine with lists of the same
type of objects...
Is there any workaround?

Martin

--
Martin Jambon, PhD
http://martin.jambon.free.fr

Re: [Caml-list] Coercion of arrays of objects (and some other containers)

[Olivier Andrieu]

Salut Martin,

 > Martin Jambon [Tue, 12 Apr 2005]:
 > Here is my problem:
 > 
 > # let obj =
 > object
 >   method a = ()
 >   method b = ()
 > end;;
 >         val obj : < a : unit; b : unit > = <obj>
 > 
 > (* That is nice: *)
 > # ([ obj ] :> < a : unit > list);;
 > - : < a : unit > list = [<obj>]
 > 
 > (* But why doesn't it work with arrays? *)
 > # ([| obj |] :> < a : unit > array);;
 > Characters 1-10:
 >   ([| obj |] :> < a : unit > array);;
 >    ^^^^^^^^^
 > This expression cannot be coerced to type < a : unit > array; it has type
 >   < a : unit; b : unit > array
 > but is here used with type < a : unit > array
 > Only the first object type has a method b

It's a variance problem : a list is covariant so the coercion
works. But an array is invariant (because of the Array.set
operations).

Otherwise after coercion you would be able to do store in the array an
object without a `b' method, this object being also reachable through
the original array.

 > In practice I have this problem with a hash table of objects, and I
 > expected it to work since it works fine with lists of the same
 > type of objects...
 > Is there any workaround?

Maybe this :

  Array.map (fun o -> (o :> < a : unit >)) [| obj |] 

-- 
   Olivier

Re: [Caml-list] Coercion of arrays of objects (and some other containers)

[Jacques Garrigue]

From: Martin Jambon <martin_jambon@emailuser.net>

> Here is my problem:
> 
> # let obj =
> object
>   method a = ()
>   method b = ()
> end;;
>         val obj : < a : unit; b : unit > = <obj>
> 
> (* That is nice: *)
> # ([ obj ] :> < a : unit > list);;
> - : < a : unit > list = [<obj>]
> 
> (* But why doesn't it work with arrays? *)
> # ([| obj |] :> < a : unit > array);;
> Characters 1-10:
>   ([| obj |] :> < a : unit > array);;
>    ^^^^^^^^^
> This expression cannot be coerced to type < a : unit > array; it has type
>   < a : unit; b : unit > array
> but is here used with type < a : unit > array
> Only the first object type has a method b

Suppose that it worked.
Then you could have this scenario.
  let arr = [|obj|];;
  let arr' = (arr :> <a:unit> array);;
  arr'.(0) <- object method a = () end;;
  arr.(0)#b;;
  Segmentation fault.

Such subtyping is allowed in Java, but this is an unsafe part of the
type system, which requires time-consuming runtime checks.

> In practice I have this problem with a hash table of objects, and I
> expected it to work since it works fine with lists of the same
> type of objects...
> Is there any workaround?

If you don't need to add objects to this hash table, this is possible
with the following approach:

  class ['a,+'b] table tbl =
    object
      val tbl : ('a,'b) Hashtbl.t = tbl
      method find = Hashtbl.find tbl
      method find_all = Hashtbl.find_all tbl
      method mem = Hashtbl.mem tbl
    end
  (* class ['a, 'b] table :
    ('a, 'b) Hashtbl.t ->
    object
      val tbl : ('a, 'b) Hashtbl.t
      method find : 'a -> 'b
      method find_all : 'a -> 'b list
      method mem : 'a -> bool
    end *)
  let coerce tbl = (tbl : ('a,<a:int;b:int>) table :> ('a,<a:int>) table)

See that 'b appears only in covariant positions, allowing its
subtyping.

Jacques Garrigue

Re: [Caml-list] Coercion of arrays of objects (and some other containers)

[Matthieu Dubuget]

I'm sorry, but I feel stupid.

The variance and covariance terms/notions appear often in this list, and 
seems to be very basic notions.

I tried to find explanation on internet but did not succeed.

Could somebody point me some links  to understand, please?

Thanks in advance

Salutations

Matthieu

Re: [Caml-list] Coercion of arrays of objects (and some other containers)

[Olivier Andrieu]

 Matthieu Dubuget [Wed, 13 Apr 2005]:
 > I'm sorry, but I feel stupid.
 > 
 > The variance and covariance terms/notions appear often in this
 > list, and seems to be very basic notions.
 > 
 > I tried to find explanation on internet but did not succeed.
 > 
 > Could somebody point me some links  to understand, please?

I do not have a link but the idea (as I understand it) is simple :

This concerns parameterized types ('a t) and how a subtyping relation
on the parameter can yield a subtyping relation on the type.

When the parameter is covariant :
  if a is a subtype of b then a t is a subtype of b t

When the parameter is contravariant :
  if a is a subtype of b then b t is a subtype of a t

For instance lists are covariant. [`A|`B|`C] is a supertype of [`A|`B]
so a [`A|`B|`C] list is a supertype of [`A|`B] list.

Function arguments are contravariant : ([`A|`B] -> unit) is a
supertype of ([`A|`B|`C] -> unit). When you have a function that
accepts A B or C, you can also view it as a function that accepts just
A or B (qui peut le plus peut le moins).

Records with mutable fields (or arrays) are neither covariant nor
contravariant. 

Well maybe my terminology isn't quite correct but I hope you get the
idea.

-- 
   Olivier