#10843: Allow do blocks without dollar signs as arguments -------------------------------------+------------------------------------- Reporter: agibiansky | Owner: agibiansky Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 (Parser) | Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Revisions: -------------------------------------+------------------------------------- Description changed by agibiansky: Old description:

I would like the following to be valid Haskell code:

{{{#!hs main = when True do putStrLn "Hello!" }}}

Instead of requiring a dollar sign before the "do". This would parse as

{{{#!hs main = when True (do putStrLn "Hello!") }}}

New description: I would like the following to be valid Haskell code: {{{#!hs main = when True do putStrLn "Hello!" }}} Instead of requiring a dollar sign before the "do". This would parse as {{{#!hs main = when True (do putStrLn "Hello!") }}} Similarly, allow lambdas in the same way {{{#!hs main = forM values \value -> print value }}} parses as {{{#!hs main = forM values (\value -> print value) }}} One possible question: does this also do the same thing for LambdaCase? It's an option but I would say no. -- -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/10843#comment:2 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#10843: Allow do blocks without dollar signs as arguments -------------------------------------+------------------------------------- Reporter: agibiansky | Owner: agibiansky Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 (Parser) | Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Revisions: -------------------------------------+------------------------------------- Description changed by agibiansky: Old description:

I would like the following to be valid Haskell code:

{{{#!hs main = when True do putStrLn "Hello!" }}}

Instead of requiring a dollar sign before the "do". This would parse as

{{{#!hs main = when True (do putStrLn "Hello!") }}}

Similarly, allow lambdas in the same way {{{#!hs main = forM values \value -> print value }}}

parses as

{{{#!hs main = forM values (\value -> print value) }}}

One possible question: does this also do the same thing for LambdaCase? It's an option but I would say no.

New description: I would like the following to be valid Haskell code: {{{#!hs main = when True do putStrLn "Hello!" }}} Instead of requiring a dollar sign before the "do". This would parse as {{{#!hs main = when True (do putStrLn "Hello!") }}} Similarly, allow lambdas in the same way {{{#!hs main = forM values \value -> print value }}} parses as {{{#!hs main = forM values (\value -> print value) }}} One possible question: does this also do the same thing for LambdaCase? I think that since people expect lambda case to just be a simple desugaring it should also work, so then {{{#!hs main = forM values \case Just x -> print x Nothing -> print y }}} parses as {{{#!hs main = forM values (\case Just x -> print x Nothing -> print y) }}} -- -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/10843#comment:4 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#10843: Allow do blocks without dollar signs as arguments -------------------------------------+------------------------------------- Reporter: agibiansky | Owner: agibiansky Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 (Parser) | Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Revisions: -------------------------------------+------------------------------------- Comment (by agibiansky): I don't see a common usecase for `case`, `if`, and `let`, and think we should not include them. The motivation for this change is that `do` and lambdas are very commonly used in custom control structures (`when`, `unless`, `for`, `forM`, `with*`, and so on). -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/10843#comment:6 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#10843: Allow do blocks without dollar signs as arguments -------------------------------------+------------------------------------- Reporter: agibiansky | Owner: agibiansky Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 (Parser) | Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Revisions: -------------------------------------+------------------------------------- Comment (by goldfire): Replying to [comment:3 nomeata]:

Is there code that is valid with and without your extension, but with different semantics?

To me, this is the key question. I can't think of any. But let's dig deeper. I'm looking at the [https://www.haskell.org/onlinereport/haskell2010/haskellch3.html#x8-220003 Haskell 2010 Report] for parsing these sorts of things. Here's the relevant bit: {{{ exp → infixexp :: [context =>] type (expression type signature) | infixexp infixexp→ lexp qop infixexp (infix operator application) | - infixexp (prefix negation) | lexp lexp → \ apat1 … apatn -> exp (lambda abstraction, n ≥ 1) | let decls in exp (let expression) | if exp [;] then exp [;] else exp (conditional) | case exp of { alts } (case expression) | do { stmts } (do expression) | fexp fexp → [fexp] aexp (function application) aexp → qvar (variable) | gcon (general constructor) | literal | ( exp ) (parenthesized expression) | ( exp1 , … , expk ) (tuple, k ≥ 2) | [ exp1 , … , expk ] (list, k ≥ 1) | [ exp1 [, exp2] .. [exp3] ] (arithmetic sequence) | [ exp | qual1 , … , qualn ] (list comprehension, n ≥ 1) | ( infixexp qop ) (left section) | ( qop⟨-⟩ infixexp ) (right section) | qcon { fbind1 , … , fbindn } (labeled construction, n ≥ 0) | aexp⟨qcon⟩ { fbind1 , … , fbindn } (labeled update, n ≥ 1) }}} From this grammar, I was inspired to try the following silliness: {{{ {-# LANGUAGE Haskell2010 #-} instance Num (IO ()) where negate = id main = - do putStrLn "hi" }}} (Note the `-` after the `main =`.) This fails with a parse error. I'd love for someone else to check this against the grammar and see if I should report a separate bug. How does this work in the patch supplied? In any case, even looking at the grammar, it looks like you've found a spot free in the grammar. How many shift/reduce conflicts does the grammar have? At last check, GHC's parser had 47. This isn't great, but we don't want to increase this number! Thanks for submitting a patch! -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/10843#comment:8 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#10843: Allow do blocks without dollar signs as arguments -------------------------------------+------------------------------------- Reporter: agibiansky | Owner: agibiansky Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 (Parser) | Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Revisions: Phab:D1219 -------------------------------------+------------------------------------- Changes (by simonpj): * differential: => Phab:D1219 Comment: I'm not against this, but not wildly in favour either. It might be convenient, but it's another small wrinkle. Some thoughts * Haskell allows {{{ f MkT { x = 3 } y z }}} meaning {{{ f (MkT {x = 3}) y z }}} which I have always thought of as a bit of a mistake. The former looks (to my eye) too much like a function call with four argument. However, you could argue that the `do` version is less harmful, because the initial `do` signals the start of a `do` block, whereas the initial `MkT` could be a bare constructor argument. * What do you intend for {{{ f x do { blarg } y z }}} Is that equivalent to this? {{{ f x (do { blarg }) y z }}} If so, better to say so. * Also give an example with layout. So perhaps {{{ f x do p <- ps return (p+1) z z }}} is equivalent to {{{ f x (do { p <- ps; return (p+1) }) y z }}} I think lambda-case is similar. * Lambda is different because it does not start implicit layout. So perhaps an un-parenthesised lambda can only appear as the last argument. Better say so. * If you allow lambda, why not `if`? And I suppose `case`? {{{ f x if this then that else the_other }}} means {{{ f x (if this then that else the_other }}} I suspect that this is a bridge too far, but I think it poses no more parsing difficulty than Lambda. Right? * What about infix functions? I.e. is this ok? {{{ f >>> do blarg }}} Presumably the `do` binds more tightly than any operator? I suggest that you make a wiki page on the GHC Trac to describe the extension, along with examples to cover these corner cases, and advertise it on the ghc-users list. That might elicit some info about whether people would find this useful or not. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/10843#comment:10 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#10843: Allow do blocks without dollar signs as arguments -------------------------------------+------------------------------------- Reporter: agibiansky | Owner: agibiansky Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 (Parser) | Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Revisions: Phab:D1219 -------------------------------------+------------------------------------- Comment (by bgamari): I tried to count the +1s and -1s but it seems to be fairly evenly split. Moreover, it seems like many users are fairly ambivalent on the matter. Andrew's message from Sept 7 nicely reviews the various arguments for and against the proposal. I'll reproduce it and a few other notable points here, == Pro == - It's easier to read than the alternative. - This extension removes syntactic noise. - This makes basic `do`-syntax more approachable to newbies; it is a commonly asked question as to why the `$` is necessary. - This simplifies the resulting AST, potentially making it simpler for editors and other tools to do refactoring. - It's something that belongs in the main language, and if its something we'd consider for a mythical Haskell', it has to start as an extension. - It gets rid of some cases where using `$` doesn't work because `$` interacts with other infix operators being used in the same expression. - This would make do blocks consistent with record creation, where parentheses are skipped, allowing things such as `return R { x = y}` - This does not change the meaning of any old programs, only allows new ones that were previously forbidden. - This gets rid of the need for a specially-typed `$` allowing `runSt $ do ...` - Richard Eisenberg points out that the proposal arguably makes the language **more** consistent, not less, > I think that it makes the language *more* regular, not less: Look at https://www.haskell.org/onlinereport/haskell2010/haskellch3.html#x8-220003, the Haskell 2010 Report on expression syntax. This proposal (if we include `if`, `let`, and `case`, along with `\` and `do`, which would seem to make it more consistent) amounts to dropping the /lexp/ nonterminal and combining it with /aexp/. == Con == - It's harder to read than the alternative. - Creating a language extension to get rid of a single character is overkill and unnecessary. - You can already get rid of the `$` by just adding parentheses. - More and more syntactic "improvements" just fragment the language. - Although this is consistent with record syntax, record syntax without parents was a mistake originally. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/10843#comment:12 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#10843: Allow do blocks without dollar signs as arguments -------------------------------------+------------------------------------- Reporter: agibiansky | Owner: agibiansky Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 (Parser) | Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11706 | Differential Rev(s): Phab:D1219 Wiki Page: | -------------------------------------+------------------------------------- Changes (by akio): * cc: akio (added) Comment: I would love this. Is there a way to move this forward? Write a wiki page? Or is this proposal abandoned? -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/10843#comment:14 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#10843: Allow do blocks without dollar signs as arguments -------------------------------------+------------------------------------- Reporter: agibiansky | Owner: agibiansky Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 (Parser) | Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11706 | Differential Rev(s): Phab:D1219 Wiki Page: | -------------------------------------+------------------------------------- Comment (by Iceland_jack): Would this allow {{{#!hs foo = do liftIO do putStrLn do "hello" ++ "world" }}} meaning {{{#!hs foo = do liftIO $ do putStrLn $ do "hello" ++ "world" }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/10843#comment:16 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#10843: Allow do blocks without dollar signs as arguments -------------------------------------+------------------------------------- Reporter: agibiansky | Owner: agibiansky Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 (Parser) | Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11706 | Differential Rev(s): Phab:D1219 Wiki Page: | -------------------------------------+------------------------------------- Comment (by Iceland_jack): Examples from EDSL [https://hackage.haskell.org/package/esqueleto-2.4.3/docs/Database- Esqueleto.html Esqueleto]: {{{#!hs -- select $ -- from $ \p -> do -- where_ (p ^. PersonName ==. val "John") -- return p select do from \p -> do where_ (p ^. PersonName ==. val "John") return p }}} {{{#!hs -- select $ -- from $ \person -> do -- where_ $ exists $ -- from $ \post -> do -- where_ (post ^. BlogPostAuthorId ==. person ^. PersonId) -- return person select do from \person -> do where_ do exists do from \post -> where_ (post ^. BlogPostAuthorId ==. person ^. PersonId) return person }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/10843#comment:18 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#10843: Allow do blocks without dollar signs as arguments -------------------------------------+------------------------------------- Reporter: agibiansky | Owner: agibiansky Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 (Parser) | Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11706 | Differential Rev(s): Phab:D1219 Wiki Page: | -------------------------------------+------------------------------------- Comment (by simonpj): I'm one of those who thinks that the fact that `f R { x = e }` means `f (R { x = e })` is a mistake :-). But I appreciate the wiki page, which makes the proposal much more concrete. If there is a reasonable level of support (which seems to be the case) I won't object. I think it's be worth an email to ghc-users to draw attention to the wiki page and invite support or other feedback. Simon -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/10843#comment:22 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#10843: Allow do blocks without dollar signs as arguments -------------------------------------+------------------------------------- Reporter: agibiansky | Owner: agibiansky Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 (Parser) | Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11706 | Differential Rev(s): Phab:D1219 Wiki Page: | -------------------------------------+------------------------------------- Comment (by Iceland_jack): I'm intrigued by [https://ghc.haskell.org/trac/ghc/wiki/ArgumentDo#Multipleblockarguments multiple block arguments] {{{#!hs f do x do y }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/10843#comment:24 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#10843: Allow do blocks without dollar signs as arguments -------------------------------------+------------------------------------- Reporter: agibiansky | Owner: agibiansky Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 (Parser) | Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11706 | Differential Rev(s): Phab:D1219 Wiki Page: | -------------------------------------+------------------------------------- Comment (by akio): Replying to [comment:24 Iceland_jack]:

**Edit**: Will it let you write

Yes, your examples should be fine, and my preliminary implementation successfully parses them. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/10843#comment:26 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

Replying to [comment:22 simonpj]:

...

I'm one of those who thinks that the fact that `f R { x = e }` means `f (R { x = e })` is a mistake :-).

I agree with you here, but I think the proposal in this ticket is still sensible, given that the perhaps-unexpected parsing started with a keyword. In the record update case, the perhaps-unexpected parsing isn't known until the open-brace, even though your brain has to parse the

#10843: Allow do blocks without dollar signs as arguments -------------------------------------+------------------------------------- Reporter: agibiansky | Owner: agibiansky Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 (Parser) | Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11706 | Differential Rev(s): Phab:D1219 Wiki Page: | -------------------------------------+------------------------------------- Comment (by maeder): Replying to [comment:27 goldfire]: preceding space differently. To me, that's the real problem with the parsing of record-update: it's not left-to-right. I fully agree, too! The record syntax is unrelated to this proposal. Curly record braces are sort of a strong binding postfix operator and are thus different from plain parentheses. @aiko I would omit the point "This would make do blocks consistent with record creation ..." under Pros on https://ghc.haskell.org/trac/ghc/wiki/ArgumentDo. Record creation is only another kind of a more "non-atomic" aexp in the grammar. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/10843#comment:28 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#10843: Allow do blocks without dollar signs as arguments -------------------------------------+------------------------------------- Reporter: agibiansky | Owner: agibiansky Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 (Parser) | Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11706 | Differential Rev(s): Phab:D1219 Wiki Page: | -------------------------------------+------------------------------------- Comment (by maeder): By saying "curly record braces are sort of a strongly binding postfix operator" I suggest that it would also possible to allow, i.e. "R {...} {...}" as nested record updates (but that would be a different issues). The keywords, do, \, case, etc. in this proposal, however, are IMHO best characterized as weakly binding prefix operators (and I completely ignore curly layout braces here on purpose - I hardly use them). -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/10843#comment:30 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#10843: Allow do blocks without dollar signs as arguments -------------------------------------+------------------------------------- Reporter: agibiansky | Owner: agibiansky Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 (Parser) | Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11706 | Differential Rev(s): Phab:D1219 Wiki Page: | -------------------------------------+------------------------------------- Comment (by Iceland_jack): Lambda motivation {{{#!hs -- phoas :: Phoas v (x -> y -> x) -- phoas = PLam (\x -> PLam (\y -> PVar x)) phoas :: Phoas v (x -> y -> x) phoas = PLam \x -> PLam \y -> PVar x }}} {{{#!hs -- ex = λ (\x -> λ (\y -> x)) ex = λ \x -> λ \y -> x }}} Would this parse? {{{#!hs ex = λ\ x -> λ\ y -> x }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/10843#comment:32 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#10843: Allow do blocks without dollar signs as arguments -------------------------------------+------------------------------------- Reporter: agibiansky | Owner: agibiansky Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 (Parser) | Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11706 | Differential Rev(s): Phab:D1219 Wiki Page: | -------------------------------------+------------------------------------- Comment (by Iceland_jack): Replying to [comment:33 maeder]:

Replying to [comment:32 Iceland_jack]: Surely, this is a lexical issue. No space is needed between symbols (like "\") and (unicode) letters (like x, y, or λ), although I recommend to always leave a space, i.e. "f λ\ ..." would be parsed as "(f λ)\ ...".

I was wondering if we could mimic the upper-case lambda `Λ` by using a lower-case `l` for lambda {{{#!hs ex' = l\ x -> l\ y -> x }}} `l\` look like a malformed lambda! (don't) -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/10843#comment:34 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#10843: Allow do blocks without dollar signs as arguments -------------------------------------+------------------------------------- Reporter: agibiansky | Owner: agibiansky Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 (Parser) | Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11706 | Differential Rev(s): Phab:D1219 Wiki Page: | -------------------------------------+------------------------------------- Comment (by Iceland_jack): [https://gist.github.com/Icelandjack/5bdaea3692891a1ca3fbe6b7bbfd4cef gist] with examples -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/10843#comment:36 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#10843: Allow do blocks without dollar signs as arguments -------------------------------------+------------------------------------- Reporter: agibiansky | Owner: agibiansky Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 (Parser) | Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11706 | Differential Rev(s): Phab:D1219 Wiki Page: | -------------------------------------+------------------------------------- Comment (by nomeata): Is anyone still pursuing this? I was just tossing the idea in my head of proposing multiple block arguments akin to {{{ foo • one complex argument • second complex argument even on multiple lines • third complex argument }}} (with maybe not precisely this syntax), but if we had `ArgumentDo` I could smiply write, as was pointed out in [https://ghc.haskell.org/trac/ghc/wiki/ArgumentDo#Multipleblockarguments The wiki proposal], {{{ foo do one complex argument do second complex argument even on multiple lines do third complex argument }}} and I would have no need for a separate proposal… -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/10843#comment:38 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#10843: Allow do blocks without dollar signs as arguments -------------------------------------+------------------------------------- Reporter: agibiansky | Owner: agibiansky Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 (Parser) | Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11706 | Differential Rev(s): Phab:D1219 Wiki Page: | -------------------------------------+------------------------------------- Comment (by mentheta): Akio, did you get around to submitting a proposal? I'd be interested in being able to use this extension. Also, could I be of help somehow? -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/10843#comment:40 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#10843: Allow do blocks without dollar signs as arguments -------------------------------------+------------------------------------- Reporter: agibiansky | Owner: agibiansky Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 (Parser) | Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11706 | Differential Rev(s): Phab:D1219 Wiki Page: | -------------------------------------+------------------------------------- Comment (by akio): Submitted a proposal: https://github.com/ghc-proposals/ghc- proposals/pull/90. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/10843#comment:42 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#10843: Allow do blocks without dollar signs as arguments -------------------------------------+------------------------------------- Reporter: agibiansky | Owner: akio Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 (Parser) | Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11706 | Differential Rev(s): Phab:D1219 Wiki Page: | -------------------------------------+------------------------------------- Changes (by akio): * owner: agibiansky => akio Comment: The proposal has been approved. I'll work on the implementation. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/10843#comment:44 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#10843: Allow do blocks without dollar signs as arguments -------------------------------------+------------------------------------- Reporter: agibiansky | Owner: akio Type: feature request | Status: patch Priority: normal | Milestone: Component: Compiler | Version: 7.10.2 (Parser) | Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11706 | Differential Rev(s): Phab:D1219, Wiki Page: | Phab:D4260 -------------------------------------+------------------------------------- Comment (by Ben Gamari ): In [changeset:"be84823b956f0aa09c58d94d1901f2dff13546b4/ghc" be84823/ghc]: {{{ #!CommitTicketReference repository="ghc" revision="be84823b956f0aa09c58d94d1901f2dff13546b4" Implement BlockArguments (#10843) This patch implements the BlockArguments extension, as proposed at https://github.com/ghc-proposals/ghc-proposals/pull/90. It also fixes #10855 as a side-effect. This patch adds a large number of shift-reduce conflicts to the parser. All of them concern the ambiguity as to where constructs like `if` and `let` end. Fortunately they are resolved correctly by preferring shift. The patch is based on @gibiansky's ArgumentDo implementation (D1219). Test Plan: ./validate Reviewers: goldfire, bgamari, alanz, mpickering Reviewed By: bgamari, mpickering Subscribers: Wizek, dfeuer, gibiansky, rwbarton, thomie, mpickering, carter GHC Trac Issues: #10843, #10855 Differential Revision: https://phabricator.haskell.org/D4260 }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/10843#comment:46 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#10843: Allow do blocks without dollar signs as arguments -------------------------------------+------------------------------------- Reporter: agibiansky | Owner: akio Type: feature request | Status: closed Priority: normal | Milestone: 8.6.1 Component: Compiler | Version: 7.10.2 (Parser) | Resolution: fixed | Keywords: GHCProposal Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11706 | Differential Rev(s): Phab:D1219, Wiki Page: | Phab:D4260 -------------------------------------+------------------------------------- Changes (by RyanGlScott): * keywords: => GHCProposal -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/10843#comment:48 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler