Interesting user mistake

[Jonathan M Davis via Digitalmars-d]

On Thursday, 3 September 2015 at 16:46:30 UTC, Andrei 
Alexandrescu wrote:
> http://stackoverflow.com/questions/32369114/leap-years-not-working-in-date-and-time-program-in-dlang
>
> The gist of it is the user wrote =+ instead of +=. I wonder if 
> we should disallow during tokenization the sequence "=", "+", 
> whitespace. Surely it's not a formatting anyone would aim for, 
> but instead a misspelling of +=.

Well, in this particular case, wouldn't it make more sense to 
simply make + as a unary operator illegal? It doesn't even _do_ 
anything, and I, for one, didn't even know that such an operator 
existed before this thread.

In general though, I think that warning based on whitespace is a 
slippery slope, especially when the language is designed such 
that whitespace doesn't matter unless it's required to make it so 
that a compound token is separate tokens. And this particular 
case isn't even generalizable, because there are other operators 
where they _would_ go in that order, and if you don't actually 
want to properly space out your operators with whitespace, then 
you'll end up with stuff like =-a and =*a which are perfectly 
legitimate. So, we're forced to either special case =+, or we're 
essentially going to require that you put a space after =, and 
while I think that everyone should, that's basically requiring 
folks to format their code in a particular way which isn't in 
line with D or its C/C++ ancestry and the expectations of the 
developers who use such languages.

So, honestly, I'm more inclined to tell folks that maybe if they 
want their code to be clear and avoid mistakes like this, they 
should put whitespace around operators, but it's a free world, 
and they're free to format their code in a way that's harder to 
read and more likely to help them shoot themselves in the foot if 
they really want to.

But regardless, I question that even allowing + as a unary 
operator even makes sense in the first place. I guess that some 
folks might use it to try and make the difference between a 
positive and a negative number more obvious? But I would have 
thought that it would make it _harder_ to distinguish them rather 
than easier. So, maybe we can just get rid of the unary + 
operator. But still, that would only help this particular case, 
and other operators which _do_ make sense as unary operators to 
the right of an assignment still have the potential of being 
mistyped to painful results if programmers don't actually put 
whitespace around = like most of us would.

- Jonathan M Davis