Internally, Python is a lot like that, too - like in Haskell, the lexer adds in brace tokens when the code is indented an unindented, which keeps the grammar simpler. I guess the main difference here is that Haskell exposes the underlying whitespace-insensitive notation to the programmer, too, whereas Python keeps it hidden.

Haskell is also a LOT more lenient. So stuff like

    if x < 5
    then 42
    else x
       + 1
       + 2

is legal.

I’d honestly appreciate some examples of non-indentation syntax. They’re think on the ground.

It's as noted above: put an opening brace after the "where", "let", "do" and "of" keywords[0], put semi-colons between (or after both work) "statements" in a given "scope" e.g. declarations (in let and where blocks), clauses (in case/of blocks) and actual statements (in do blocks)

    module Main where {
    main = do {
    let {
    a :: Int; a = 8;
    b :: Int; b = 3;
    };
    let { c = a `quot` b } in print c;
    }}

You can also format it all on one line, it'll work just fine:

    module Main where { main = do {let {a :: Int; a = 8; b :: Int; b = 3;}; let { c = a `quot` b }; print c}}

[0] basically every keyword which opens a non-expression "body", a brace after `case` or `in` is a compilation error as they can only contain a single expression

Yeah, I think the real problem I have is the impossibility of opting out of the indentation style. Not using any indentation or newlines seems pretty extreme. All I want to do is write it like it was C, and that’s not possible (maybe we need yet another extension)

> Not using any indentation or newlines seems pretty extreme.

You can certainly use indentation and newlines, my examples were just demonstrating the ability to "obviously" not invoke layout since there's nowhere layout information can be.

Whether to use layout (braceless) or explicit structuring (braceful) is solely determined by a brace being present after a listed keyword, you can have any whitespace you want around it, and you can make that decision on a keyword-by-keyword basis[0] although it will apply to the entire block, so you can write

    module Main where -- no brace, layout rules

    main = do { -- brace, no layout
      let { a = 3 };
      let { b = 5 };
      print $ a + b;
    }

Now here the let statement (rather than expression) is a bit tricky because if we don't use the braces the ; will bind to the "let" which is not using layout, resulting in a parse error. An alternative — and the way do blocks normally desugar — is to use ; as a separator prefix, a style also used by e.g. Elm:

    module Main where

    main = do 
      { let a = 3
      ; let b = 5
      ; print $ a + b
      }

[0] this is very very useful when generating code which must surround user-provided code: the generated code can be braceful and the user-provided code can independently use layout without conflicts.

Thank you. Need to spend a bit more time grokking this.

Also, comments are considered to be lexemes for this purpose.