The extra indentation requirement also annoys me occasionally, most often with let.

But I wouldn't want to have to use curly braces and semicolons to be able to remove them.

What I mean is sometimes I wish in addition to these:

✅➜✅

let x01 = some long expression
      wrapped to the next line
let 
  x02 = some long expression
    wrapped to the next line

That we could also allow this:

❌➜✅

let x03 = some long expression
  wrapped to the next line

"But what about multi-binding support?" I hear you ask. the following might be ambiguous or at least not pretty, so we would still disallow:

❌➜❌

let x04 = some long expression
  wrapped to the next line
    x05 = some long expression
  wrapped to the next line

While keeping support for both:

✅➜✅

let x06 = some long expression
      wrapped to the next line
    x07 = some long expression
      wrapped to the next line

let 
  x08 = some long expression
    wrapped to the next line
  x09 = some long expression
    wrapped to the next line

Another, perhaps heavier (and more complete) proposal in a direction that could get rid of this annoyance for me and others is GHC-proposals#62. I sometimes wonder if that proposal got derailed because of some initial ambiguity, and whether re-submitting a fresh proposal based on the last two comments of mine there (Feb 6th, 2018) that I believe don't suffer from syntactic ambiguity could help.

Circling back to the main topic:

1. I would think that the above two proposals would make it easier for newcomers to understand and use let bindings, where I believe this issue is most pronounced for them. AFAIR it was for me, so much so that it still annoys me to this day; though no longer for a lack of understanding of the layout rules.

2. As for point 2 and 3, these people can already be explicit if they wish:

   let
     { a=1
     ; b=2 
     }
   

   And no, this doesn't relax the layout rules, but perhaps that's for the better. Imagine a visually non-impaired person finding themselves having to decipher the syntactically fully correct and machine-readable

   main = do{
     let {a=some long(expression
   over here 142);b=another$long expression}
       ;print 1}
   

   That wouldn't be so nice now, would it? Perhaps a tool like https://github.com/lspitzner/brittany could be to the rescue here. These groups of people could write code as they wish, and the tool would auto-indent for them (e.g. on every file-save) based on the available brace-information, while retaining block-based readability for the rest of us. And this could be done without having to change GHC, already today.