On Sun, May 31, 2009 at 7:08 PM, Dario Teixeira <darioteixeira@yahoo.com> wrote:

I also meant "heavier" in terms of efficiency.  And like David said, it does
feel wrong to carry the performance penalty of the object system solely because
I need the structural subtyping features.

If you're willing to give up some of the syntactic niceties of records (and the ability to pattern-match) you can get what you want using an abstract type.

module type S = sig                                                            
   type 'a t                                                                   
   val create_t1 : a : int -> b : int -> c : int -> [ `a | `b | `c ] t         
   val create_t2 : a : int -> b : int -> c : int -> d : int                    
     -> [ `a | `b | `c | `d ] t                                                
   val create_t3 : b : int -> c : int -> d : int -> [ `b | `c | `d ] t         
                                                                               
   val a : [> `a ] t -> int                                                    
   val b : [> `b ] t -> int                                                    
   val c : [> `c ] t -> int                                                    
   val d : [> `d ] t -> int                                                    
end                                                                            
                                                                               
module M : S = struct                                                          
  type u = { a: int; b: int; c :int; d: int }                                  
  type 'a t = u                                                                
  let default = { a = 0; b = 0; c = 0; d = 0 }                                 
  let create_t1 ~a ~b ~c = { default with a = a; b = b; c = c }                
  let create_t2 ~a ~b ~c ~d = { a = a; b=b; c=c; d=d; }                        
  let create_t3 ~b ~c ~d =  { default with b=b; c=c; d=d }                     
                                                                               
  let a t = t.a                                                                
  let b t = t.b                                                                
  let c t = t.c                                                                
  let d t = t.d                                                                
end                                                                            
                                                                               
let f x = M.a x + M.b x                                                        
let g () = f (M.create_t1 ~a:0 ~b:0 ~c:0) (* accepted by compiler *)           
let g () = f (M.create_t2 ~a:0 ~b:0 ~c:0 ~d:0) (* accepted by compiler *)      
let g () = f (M.create_t3 ~b:0 ~c:0 ~d:0) (* rejected by compiler *)    

The compiler error you get on that last line is this:

Error: This expression has type [ `b | `c | `d ] M.t                           
       but is here used with type [> `a | `b ] M.t                             
       The first variant type does not allow tag(s) `a                         

Here, we've chosen to use a default value for fields that we don't fill in.  We could just as well have used options here.  The performance of the above will be roughly the same as the performance of a simple record.  Obviously, all of the different "subtypes" have the full record stored at a physical level.

y