Version française
Home     About     Download     Resources     Contact us    

This site is updated infrequently. For up-to-date information, please visit the new OCaml website at

Browse thread
Re[2]: [Caml-list] obj.magic for polymorphic record fields
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Goswin von Brederlow <goswin-v-b@w...>
Subject: Re: [Caml-list] obj.magic for polymorphic record fields
Boris Yakobowski <> writes:

> On Tue, Dec 22, 2009 at 2:35 PM, Goswin von Brederlow <> wrote:
>> But the type inference should deduce that in
>> (Obj.magic fn) x
>> the 'a is actually 'b -> 'c as I am applying an argument to it.
> Sure, and it does. But it remains that the principal type of
> (Obj.magic fn) is 'a, without any other constraint on 'a. The fact
> that you use it with type 'b -> 'c for some 'b and 'c is irrelevant,
> and the type-checker can safely draw conclusions from the principal
> type. (This is similar to considering (fun x -> x). It has
> type 'a list -> 'a list, even though it is used with type int list ->
> int list if you apply it to [1].)
> Hope this helps,
> -- 
> Boris


# Obj.magic;;
- : 'a -> 'b = <fun>

# let id x = x;;
val id : 'a -> 'a = <fun>

# let f x y = (id x) y;;
val f : ('a -> 'b) -> 'a -> 'b = <fun>

The type checker inferes correctly that the 'a in id must actualy be
('a -> 'b) and gives that type to x.

# let g x y = (Obj.magic x) y;;
Warning X: this argument will not be used by the function.
val g : 'a -> 'b -> 'c = <fun>

No such luck here.

I think the difference is that in Obj.magic there is no connection
between the input ('a) and the output ('b). Something I think only
Obj.magic has. So the type inference can not infere that the 'a in g
must be of type ('d -> 'e) where 'd is compatible with 'b and 'e
compatible with 'c (as in it doesn't segfault).

Maybe there should be a special Obj.less_magic that preserves the
number of arguments between input and output type. Obj.less_magic
could only have types

'a               -> 'b
('a -> 'b)       -> ('c -> 'd)
('a -> 'b -> 'c) -> ('d -> 'e -> 'f)

That would be something that needs to be hardcoded into the type
inference or needs a new type syntax. But it would give verry little
extra security. Obj.magic just is evil. :)