Thank you for your comments Richard.
> I'm assuming `pattern Foo{bar, baz} = (bar, baz)` from the wiki page, without
> any further pattern type signature. This example then looks straightforward
> to me -- I feel I'm missing the subtlety. `foo` would get the type `(a,b) ->
> (b,b)` and would be roughly equivalent to `foo a@(bar, baz) = case a of (_,
> baz2) -> (baz, baz2)`. The case statement and baz2 is necessary just to
> provide a predictable desugaring of record updates; handwritten code should
> clearly be more succinct.
This is how I imagined it to work.
> This would desugar to `foo x = case x of Just _ -> Just 5`. I'm not sure
> about pattern exhaustiveness warnings, but I would expect such a record
> update to be partial. The partiality of record updates has been surprising in
> the past, but I don't think adding pattern synonyms to the mix should change
> that.
Yes, I agree.
> I would like to keep record updates for the same reasons you appear to. I
> will warn that they are quite hard to work with, though! About 220 lines of
> dense code (including comments) are necessary to type-check regular old
> record updates. This isn't to scare you off, but to have you suitably
> forewarned and forearmed.
I consider myself warned!
> What do you mean here? Without checking, I assumed that the x in `x { ... }`
> had to be a variable. But this is wrong! See 3.15.3 of the Haskell 2010
> report
> (https://www.haskell.org/onlinereport/haskell2010/haskellch3.html#x8-490003.15).
> So I think it's already generalized.
Good news. This should simplify the implementation.
>
> Many thanks for taking this on!
> Richard
>
_______________________________________________
ghc-devs mailing list
[email protected]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-devs
