Polymorphic record update

[Isaac Jones]

Henrik, can you please be sure this is captured on the wiki somewhere?
(Sorry, I haven't checked to see if you already did that).  Make
yourself the owner :)

peace,

  isaac


Niklas Broberg <niklas.broberg at gmail.com> writes:

> On 1/23/06, Henrik Nilsson <nhn at cs.nott.ac.uk> wrote:
>
> [snip lots of good stuff]
>
> This suggestion would go a long way to alleviate the burden of
> boiler-plate coding. It is a conservative extension, and it is
> intuitive at that. Indeed I believe I have written code with the
> suggested update mechanism many times without thinking on the type
> mismatch (and been beaten on my fingers by the compiler of course).
> :-)
>
>> But we'd rather not have to write such functions by hand, just as
>> we'd rather not write update functions by hand. Maybe the record
>> update syntax could be extended so that the function that gets
>> generated behind the scenes only includes constructors that
>> does NOT mention a particular field. For example, the field
>> name(s) that must not occur could be prefixed by "~" which suggests
>> negation in some settings. It does not have this connotation in Haskell,
>> but at least "~" is already a special symbol. We could then write:
>>
>>     foo :: T a -> T Int
>>     foo x@(C1 {}) = x {f1 = 1}
>>     foo x@(C2 {}) = x {f1 = 2}
>>     foo x         = x {~f1}
>>
>> Now the code for "foo" only has to be changed if new constructors
>> having a field "f1" are added.
>>
>> Of course, it should be possible to combine this with the normal
>> record update syntax. E.g.
>>
>>     foo :: T a -> T Int
>>     foo x@(C1 {}) = x {f1 = 1}
>>     foo x@(C2 {}) = x {f1 = 2}
>>     foo x         = x {~f1, f2 = f2 x + 1}
>
> Is this really necessary? Adding '~' seems less intuitive to me than
> just writing
>
>      foo :: T a -> T Int
>      foo x@(C1 {}) = x {f1 = 1}
>      foo x@(C2 {}) = x {f1 = 2}
>      foo x         = x
>
> or
>      foo x = x {f2 = f2 x + 1}
>
> for the last example. From an implementor's point of view, if we
> expect the proper coercions to be inferred by the type checker it
> would still have to check that there are indeed no more fields than
> other than 'f1' that mention the parameter 'a', and also that there
> are no more constructors that mention 'f1'. Wouldn't it be just as
> simple to assert that for all the fields that mention 'a', none of
> these appear in any of the remaining constructors?
>
> On the other hand pattern matching would certainly be more expressive
> if '~' is added, so perhaps adding it has merit of its own. If we
> write
>
>      foo :: T a -> T Int
>      foo x@(C1 {}) = x {f1 = 1}
>      foo x@(C2 {}) = x {f1 = 2}
>      foo x         = x {~f1}
>
> there could still be more constructors in T a that do mention the 'f1'
> field, but there is no matching clause for them in the definition of
> 'foo'. But I would see that as a second separate proposal, e.g. a
> Proposal for Negation in Record Pattern Matching. Sure it would fit
> very well with the Polymorphic record update discussed here, but I
> would think they should be treated separately.
>
> /Niklas
> _______________________________________________
> Haskell-prime mailing list
> Haskell-prime at haskell.org
> http://haskell.org/mailman/listinfo/haskell-prime