[MLton] an analysis to flatten refs into tuples

[Daniel C. Wang]

The ref flattening is really a nice optimization, but as a MLton user I'd 
like some help from the compiler to warn me when refs that I expect to be 
flattenable aren't.

For example as a user who knows MLTon is doing ref flattening I'd probably 
end up doing the following so that I'm sure that things get flattened the 
way I'd like.

signature M_PAIR :> sig
   type ('a,'b) mpair
   val cons : ('a * 'b) -> ('a, 'b) mpair
   val car : ('a , 'b) mpair -> 'a
   val cdr : ('a , 'b) mpair -> 'b
   val set_car : ('a ,'b) mpair -> 'a -> unit
   val set_cdr : ('a ,'b) mpair -> 'b -> unit
end =
structure MPair :> M_PAIR =
   struct
     type ('a,'b) mpair = ('a ref * 'b ref) (*: mutable tuple :*)
     fun cons (x,y) = (ref x,ref y)
     fun car (ref x,_) = x
     fun cdr (_,ref y) = y
     fun set_car (x,_) x' = x := x'
     fun set_cdr (_,y) y' = y := y'
   end

It would be nice if my mutable tuple comment was some how checked by the ref 
flattening code so that if for some reason it is not smart enough to flatten 
  the refs, I get a warning, and as a user I think about how to structure my 
code so it is more obvious.

In fact given the code above, I expect MLton to be able to flatten any value 
of type ('a,'b) mpair. Of course the reason I expect this is because of 
type-abstraction. I'm not so clear if MLton can exploit this 
type-abstraction info in the ref-flattening analysis. If would be very nice 
if it did.