Version française
Home     About     Download     Resources     Contact us    
Browse thread
[Caml-list] extensible records again
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Michael Vanier <mvanier@c...>
Subject: [Caml-list] extensible records again

Hi everyone,

I sent some email to this list a while back asking for advice on how to
handle a problem which called for extensible records.  I got some good
suggestions involving polymorphic variants, but it turns out that the
best proposed solution won't work because of problems with polymorphic
references.  I'll recap the problem here and (once again) ask for advice from
the experts.
 
I've written a dynamically-typed language in ocaml, and I want to be able to
add new types to the language without having to add new primitive types to
the system.  So, for instance, my basic type definition looks something like
this:
 
    type data =
        Int of int
      | Float of float
      | ...
 
Now I want to add a type for (say) files.  I don't want this to be a type
at the same level as ints or floats, because I want users to be able to add
their own types to the language without hacking the core type definition.
I can do this as follows:
 
    (* types.mli *)
    type data =
        Int of int
      | Float of float
      | ...
      | Extension of exn
 
    (* files.ml *)
    exception File of out_channel
                                                                                        
    let close (d : data) =
      match data with
        Extension ext ->
          (match ext with
              File f -> (* close the file *)
            | _ -> raise (Failure "invalid type")))
        | _ -> raise (Failure "invalid type")
                                                                                        
This is OK, but it abuses the exception system.  I asked for ways to get the
same result with polymorphic variants.  A suggested approach (thanks to
Aleksey Nogin) was this:
                                                                                        
# type 'a data = Int of int | Ext of 'a;;
type 'a data = Int of int | Ext of 'a
# let open_file f =
      match f with
         Ext `File f -> print_string ("Opening file" ^ f)
       | _ -> raise (Invalid_argument "open_file")
   ;;
val open_file : [> `File of string] data -> unit = <fun>
# let run ( f :  [> ] data -> unit) = f (Ext (`Foo 1));;
val run : ([> `Foo of int] data -> unit) -> unit = <fun>
# run open_file;;
Exception: Invalid_argument "open_file".
 
 
So I tried this.  Aside from the pain of having to change data to 'a data in
lots of places (which I can live with), I got bitten by the polymorphic
reference limitation.  Specifically, I have a mutable stack of data values
which became a mutable stack of 'a data values, but the function which
creates the mutable stack is of type '_a data, so it doesn't type check.  I
can't figure out any way around this.  Basically, my main data type _cannot_
be parameterized.  I would like to be able to say something like
 
# type data = Int of int | Ext of [> ];;
Unbound type parameter [..]
 
but this doesn't work either, as you can see.  Is there any way to get the
effect that I want?
 
Thanks in advance,
 
Mike
 

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