> One is the use of the full stop as an expression terminator, as in English, instead of the semicolon.

That’s something people complain about when looking at Erlang code. Thanks to its Prolog heritage, it uses commas, semi-colons, and full stops to terminate statements.

It’s actually very easy to remember which is which, despite the general angst, because they are directly analogous to those punctuation marks’ usage in English.

Commas indicate a continuation of statements, semi-colons separate clauses within a function, and full stops complete a function definition.

C++ has an optional digits separator too. Not '_' but single quotes, since c++14 [0]. Which is cool. Swift has it too [1].

Erlang has the full stop '.' as expresssion/statement terminator [2].

[0] https://en.cppreference.com/w/cpp/language/integer_literal [1] https://docs.swift.org/swift-book/ReferenceManual/LexicalStr... [2] https://erlang.org/doc/getting_started/seq_prog.html

I like those features too! I'm glad they are coming to contemporary languages.

"_" has been an option to separate digits in Perl for ages. I use it all the time if the integer is >10,000

`_` digit separators are also supported by both Python and Go.

I also liked the "corresponding" modifier for verbs like "move" and "add". It caused the operation to only be done on those fields which existed in both the source and destination and ignored the others. Do any other languages have this?

If we start using periods to end expressions, would we then have to use semicolons to chain things together? Or would you let the compiler know that foo.size(). was okay and that it shouldn't be waiting around for another function call there?

Hum... Prolog uses periods to end declarations, and as you expect, uses semicolons as combinators.

It reads really well, because it also uses colons as combinators, with higher precedence than the semicolon. But it does not map well into other paradigms.

Juxtaposition (`foo size()`) is a serious contender I think. In fact, I consider it is one of the most undervalued syntactic choices.

In HS I built a toy language where it was `foo's size()`, if you want to play even further down the English-like rabbit hole, even trying to stick to BNF-ish CFGs. `'s` is actually a surprisingly unambiguous token in a language without a "char type" and that sticks to double quotes only for strings.

Java has it since ages.

To extend this list a bit, Rust and Ruby also allow _ as a separator.

I think Nim also has digit separator.

It does.