Comment by T-R

15 hours ago

No, the issue is if the first binding is on the same line as the `let`, you are required to write, e.g.:

    someValue = let f = 9
                    fo = 10
                    foo = 123
      in f+fo+foo

rather than:

    someValue = let f = 9
      fo = 10
      foo = 123
      in f+fo+foo

I think it used to be the case that it had to be indented past the `=` or the `let` even if it was't on the same line. Note also that `in` has to be indented past `someValue`, but doesn't need to be indented as far `let`.

This is fine:

    someValue = let
      f = 9
      fo = 10
      foo = 123
      in f+fo+foo

So, it is possible to land on sane indentation, but the parser is much pickier than, e.g., Python's off-sides rule, so it takes some trial and error for new users to find it, and it can be frustrating if you're just temporarily modifying an expression to quickly try something out.

I honestly think it would be less surprising if the parser just disallowed writing the first binding on the same line as the `let` entirely, treating it only as a block, but some people (bewilderingly) do seem to prefer to write their code with the excessive indentation (I'd imagine with editor support, rather than manually maintaining the spacing).

2 comments

T-R

projektfu 1 hour ago

In Haskell, you can do, if you prefer,

    someValue = let {f = 9;
      fo = 10;
      foo = 123 }
      in f+fo+foo

it will just look a little out of place.

Edited to add that this is also OK:

    someValue = let 
      f = 9
      fo = 10
      foo = 123
      in f+fo+foo

Skeime 9 hours ago

I feel like you are describing that the parser is too lenient rather than too picky. It could just require you to always put `let` and `in` on their own lines, in which case the indentation makes sense, I think. It's only when trying to keep more stuff on the same line that the details of Haskell's indentation rules come into play.