But: if you agree (and it sounds like you do) that the proposal's text is definitive, I can update the text above to try to iron out these potential sources of confusion.
Yes I do. Please do! And, it’s terribly late in the day, but if anyone wants to raise a new issue, please do so.
I do wonder about explicitly calling out the possibility of having (a) the syntactic sugar of this proposal with (b) no overloading. So that
r.x desugars to (x r)
e { x = e2 } desugars to case e of K { .. } -> K { x=e2, .. }
or something like that. That is strictly beyond what the proposal currently does, which is to *always* use setField/getField. But that means that for records with polymorphic fields you
simply can’t use the proposal at all.
Simon
From: Richard Eisenberg <rae@richarde.dev>
Sent: 31 March 2020 13:52
To: Simon Peyton Jones <simonpj@microsoft.com>
Cc: Simon Marlow <marlowsd@gmail.com>; Neil Mitchell <ndmitchell@gmail.com>; ghc-steering-committee <ghc-steering-committee@haskell.org>; Joachim Breitner <mail@joachim-breitner.de>; Shayne Fletcher <shayne.fletcher@daml.com>
Subject: Re: [ghc-steering-committee] Record dot syntax: vote results
What features of the proposal document are actually a part of the proposal?
Good -- that's very clear, then. And it had been clear for some time (to me) -- it's just that I find it disagrees with the proposed text on the document, which reads:
> The proposal is entirely about syntax; and specifically about
introducing the form `r.x` for record field selection. No changes
to the type system, or any other aspect of the language, are
proposed. The original proposal was more elaborate, providing ways
to update fields as well as set them, but was simplified to focus on
the essentials.
But: if you agree (and it sounds like you do) that the proposal's text is definitive, I can update the text above to try to iron out these potential sources of confusion.
There are two pretty much orthogonal things going on
-
Syntax for record selection r.x; this proposal
-
Using overloading to resolve duplicate record labels, via getField/setField
It’s true (2) pretty much precludes selection/update for records with polymorphic fields (unless we have impredicativity, which I think we should ignore for now). That has always been true.
If you don’t want (2) then (1) is still useful. Maybe the proposal should have different desugaring rules with and without OverloadedRecordFields. That would be an additional box in the matrix, which I suppose we might want to fill
in.
Including Shayne and Neil in this conversation.
Quoting from the document:
> The proposal is entirely about syntax; and specifically about
introducing the form `r.x` for record field selection. No changes
to the type system, or any other aspect of the language, are
proposed. The original proposal was more elaborate, providing ways
to update fields as well as set them, but was simplified to focus on
the essentials.
Is this fact enshrined in the proposal document? I view that as ground truth. And it describes, e.g., that (e { field = val }) now means (setField ...), which means that polymorphic record update is incompatible with -XRecordDotSyntax.
What features of the proposal document are actually a part of the proposal?
Otherwise, I am happy with the tone and content of the post.
Before we accept the proposal I think we should have a precise description of the changes to the syntax. For example, we don't address the question of whether a field name
can be an operator or not. We explicitly left these questions until later; wouldn't now be the right time to address them?
Also worth bringing up at this point, since we landed on C2a: Note 5 says
One mechanism for handling this is given
in the proposal. It involves no changes to the lexer, but instead an adjacency test one production of the parser.
I'm not sure about this as a language design. (1) it's an ad-hoc side-condition that can't be expressed in the lexical or context-free grammar (however there's precedent for
this kind of thing in the form of the layout rule of course), and (2) it's quite a costly feature in terms of implementation effort to add to the language, because your AST needs complete and accurate source-span information. We can do it in GHC, and haskell-src-exts
can do it nowadays, but earlier versions of haskell-src-exts before complete SrcSpanInfo was added wouldn't have been able to implement this rule. Arguably we're only accepting this as a GHC extension and not a Haskell extension in general, but as we know
GHC is the testbed for future language extensions, so it's a good time to consider these issues.
The alternative of course is to go with some variant of
which is also an ad-hoc side-condition sadly, but could be implemented in the lexer. Nevertheless, all this needs to be nailed down before the proposal can be accepted, IMO.