I didn't phrase it right. I meant that a let/lambda/if always extends to the next relevant (not part of a smaller expression) punctuation symbol; and if that phrase parses as an exp that's fine, otherwise it's a parse error. So I should not really speak in terms of 'ambiguity'. Perhaps we can simply say that let .. in exp is legal only if the phrase is followed by one of the punctuation symbols. That's nice, because we don't need to talk of "not part of a smaller expression". So (let x = 10 in x `div`) would be rejected because x `div` isn't a exp. Simon | -----Original Message----- | From: Ross Paterson [mailto:ross@soi.city.ac.uk] | Sent: 26 February 2002 16:06 | To: Simon Peyton-Jones | Cc: haskell@haskell.org | Subject: Re: H98 Report: expression syntax glitch | | | On Tue, Feb 26, 2002 at 07:30:44AM -0800, Simon Peyton-Jones wrote: | > Replace "The ambiguity is resolved by the meta rule that | each of these | > constructs extends as far to the right as possible" by | > | > "The ambiguity is resolved by the meta rule that each | > of these constructs extends to the nearest occurrence of | > the following punctuation symbols that does not form part of | > a nested expression: | > | > ) ] } | ; , .. where of then else | | I didn't think this was going to be pretty, but it doesn't | quite work either. There's no ambiguity in | | (let x = 10 in x `div`) | | The context-free grammar gives exactly one parse for this, | and we want to disallow it. It seems you need to retain the | old meta-rule for the ambiguities but also explicitly exclude | certain forms. |
On Tue, Feb 26, 2002 at 08:23:03AM -0800, Simon Peyton-Jones wrote:
I didn't phrase it right. I meant that a let/lambda/if always extends to the next relevant (not part of a smaller expression) punctuation symbol; and if that phrase parses as an exp that's fine, otherwise it's a parse error. So I should not really speak in terms of 'ambiguity'.
Perhaps we can simply say that let .. in exp is legal only if the phrase is followed by one of the punctuation symbols. That's nice, because we don't need to talk of "not part of a smaller expression".
OK, so you have a context-free grammar qualified by a rule forbidding some of the derivations of that grammar. Another solution would be to subdivide exp^10 using a superscript I've called A or B from lack of imagination: exp10A -> \ apat[1] ... apat[n] -> exp (lambda abstraction, n>=1) | let decls in exp (let expression) | if exp then exp else exp (conditional) exp10B -> case exp of { alts } (case expression) | do { stmts } (do expression) | fexp Only the latter sort can be followed by infix operators or type signatures. We could extend the distinction to the exp^i (here x ranges over {A,B}): exp -> exp0B :: [context =>] type (expression type signature) | exp0 expi -> expiA | expiB expix -> expi+1B [qop(n,i) expi+1x] | lexpix | rexpix lexpix -> (lexpiB | expi+1B) qop(l,i) expi+1x lexp6x -> - exp7x rexpix -> expi+1B qop(r,i) (rexpix | expi+1x) and the rules for sections would be aexp -> ... | ( expi+1B qop(a,i) ) (left section) | ( qop(a,i) expi+1 ) (right section) It's complicated, but it does at least specify precisely the language and parses we want in a single context-free description.
In the context-free grammar proposed by Ross Paterson the following line: expix -> expi+1B [qop(n,i) expi+1x] should be replaced by expix -> [expi+1B qop(n,i)] expi+1x Without this modification a single exp10A-expression can not be derived from the nonterminal exp. Apart from this small mistake, I think that the proposed grammar correctly specifies the language we want. Cheers Arthur On 27-02-2002 11:42, "Ross Paterson" <ross@soi.city.ac.uk> wrote:
OK, so you have a context-free grammar qualified by a rule forbidding some of the derivations of that grammar.
Another solution would be to subdivide exp^10 using a superscript I've called A or B from lack of imagination:
exp10A -> \ apat[1] ... apat[n] -> exp (lambda abstraction, n>=1) | let decls in exp (let expression) | if exp then exp else exp (conditional) exp10B -> case exp of { alts } (case expression) | do { stmts } (do expression) | fexp
Only the latter sort can be followed by infix operators or type signatures. We could extend the distinction to the exp^i (here x ranges over {A,B}):
exp -> exp0B :: [context =>] type (expression type signature) | exp0 expi -> expiA | expiB expix -> expi+1B [qop(n,i) expi+1x] | lexpix | rexpix lexpix -> (lexpiB | expi+1B) qop(l,i) expi+1x lexp6x -> - exp7x rexpix -> expi+1B qop(r,i) (rexpix | expi+1x)
and the rules for sections would be
aexp -> ... | ( expi+1B qop(a,i) ) (left section) | ( qop(a,i) expi+1 ) (right section)
It's complicated, but it does at least specify precisely the language and parses we want in a single context-free description.
On Wed, Feb 27, 2002 at 04:00:39PM +0100, Arthur Baars wrote:
In the context-free grammar proposed by Ross Paterson the following line: expix -> expi+1B [qop(n,i) expi+1x]
should be replaced by expix -> [expi+1B qop(n,i)] expi+1x
Yes. (In fact that's what I had in the revised hssource grammar, but I mistranscribed it.)
participants (3)
-
Arthur Baars -
Ross Paterson -
Simon Peyton-Jones