data label overloading

[Serge D. Mechveliani]

To my recent suggestion on the field label overloading 

> > ...
> >   data Foo1 = Foo1 {size :: Int ...}
> >   data Foo2 = Foo2 {size :: Int ...}
> >   ...
> >   f x y z = let size = Foo1..size in
> >                                (size x)+(size y)+(Foo2..size z)  
> 

Hal Daume III wrote on Jan 13, 2004 

> How does this save you typing over:
> 
> data Foo1 = Foo1 { foo1_size :: Int }
> data Foo2 = Foo2 { foo2_size :: Int }
> 
> f x y z = let size = foo1_size
>           in
>           (size x) + (size y) + (Foo2..size z)
> 
> also, this would lead to highly ambiguous parses, i think.
> 


Here is an example with improved suggestion:

  data Foo1     = Foo1 {size :: Int, ...}
  data Foo2     = Foo2 {size :: Int, ...}
  data Foo3 a b = Foo3 {size :: a,   ...}

  f :: Foo1 -> Foo1 -> Foo2 -> Int
  f    x       y       z    =  let  n = (size x)+(size y)+(size z)
                               in
                               (g (x {size = n})) + 1  

  h v =  v {size = 0}          :: Foo3 _ _
  g u =  size (u :: Foo3 _ _)


Very often the type or argument is clear. In such a case the compiler 
solves the label version. And in a dubious case the programmer adds 
the type denotation.
Will this do?

Copy, please, the answer to  mechvel at botik.ru

With kind regards,

-----------------
Serge Mechveliani
mechvel at botik.ru