As far as I know, a (C-like) language must either have:

- A statement separator (semicolons)

- Significant whitespace

Otherwise parsing the language is very likely ambiguous, e.g JavaScript [1] [2].

[1] https://flaviocopes.com/javascript-automatic-semicolon-inser...

[2] https://medium.com/better-programming/you-might-need-those-s...

Swift and Go don't have either. Neither does Kotlin. The difference is that Rust is an expression language (much like ML), and the semicolon determines whether the resulting expression is returned or thrown away. OCaml needs semicolons when you're doing imperative programming too.

Swift, Go, and Kotlin all take newlines into account. I guess one could have a definition of “significant whitespace” that excludes that but in any case I strongly suspect that’s what they were referring to.

yes, but I believe they support semicolons as a statement separator on the same line

JavaScript messed it up, but Python did it well. A newline is a statement separator, unless it's e.g. between parentheses where a statement separator wouldn't make sense. Unlike JavaScript, that means you don't have to look at the next line to figure out whether the statement continues.

JavaScript assumes a newline doesn't end a statement, until proven otherwise. Python assumes it does end a statement unless it very clearly can't.

It's independent from Python's other significant whitespace, so you could use it in a more "C-like" syntax.

But it wouldn't be a good fit for Rust. In Rust, leaving the semicolon off the final statement in a block already changes its meaning, so that would become ambiguous. It also uses method chaining syntax a great deal more than Python, which is a bit awkward because you have to wrap the expression in parentheses (though autoformatting helps). And of course it would break most existing code.

Go doesn't have either: https://play.golang.org/

Ah, but it does. Statements are separated by newlines. That is the same as significant whitespace (or a statement separator; you can interpret it either way).

Technically correct.

But the point is about ergonomy. Go doesn't require semicolons neither indentation. That coupled with gofmt auto-formatter makes coding more pleasant.

I’d like that too, but: if you get rid of semicolons, how do you avoid something like JavaScript’s automatic semicolon insertion mess? For example:

    return
        x;

turns into:

    return;
        x;

which is clearly not what was intended. Sure, if Rust copied JavaScript’s algorithm, the compiler would throw a type error (where () is not compatible with typeof(x)) and complain of dead code instead of silently failing, but it seems like a hard task. Then again, I’m not a compiler writer.

Python's solution to this is that a randomly indented block is an error.

Many languages restrict statement-expressions to function calls and other expressions with explicit side-effects.

Another choice would be to avoid syntax where you can optionally append expressions to an otherwise complete statement (so only one of "return" and "return expr" are allowed, and the other has an alternate spelling)

Or the parser could forbid line continuation in the absence of a trailing binary operator, which makes mid-statement newlines illegal outside of a highly visible special case so users would be trained out of inserting them at random before they introduced errors.

Both JavaScript and python do something like the last one but both screw it up; JavaScript also allows leading operators and open-brackets to continue the previous line which is a huge mess, and python uses brackets to continue lines but parens are both optional around most expressions and overloaded (generators, tuples). If you wanted to go that way you would need a bracket that meant "this is syntactically a single expression and has no other meaning"

The easiest solution might be to simply allow \ as a line-continuation operator. So you'd write:

  return \
     x;

But then you’ve just swapped one set of trade offs for another. It seems like a weak solution. IIRC semicolons were added to the languages of old to avoid the need for line continuation marks.

I wasn't a fan at first (coming from Python), but I really like that it allows you to make expressions into statements (I'm sure there's more going on then just that, but it was pretty cool to see that if/match are generally expressions but if I don't want them to be, ";" can change that!).

of all the complaints to have...

Any such move will eventually result in automatic semicolon insertion in some shape or form.

What's wrong with semicolons anyway?

Nothing wrong with semicolons. IMO they make code look a little bit less readable - you need to look at semicolon while you could be just looking at the empty line. One of the reasons people like python.

This is a valid point. Without the context, the “everything is an expression” forces one to look for a line without a semicolon to see the expression result. In a 5 line function, that’s easy, but in a nested match, it can be hard.

It can only possibly be at the end, so it's not really hard?