My two cents

[Jonathan M Davis]

On Friday, October 20, 2017 02:49:34 Adam Wilson via Digitalmars-d wrote:
> Here is the thing that bothers me about that stance. You are correct,
> but I don't think you've considered the logical conclusion of the
> direction your argument is headed. Pray tell, why must we stop adding
> syntactic sugar? Why does their need to be an (by your own admission)
> arbitrary limit?
>
> If we look at any moderately successful language
> (C++/C#/Java/Python/etc.) you will find that all of them have
> accumulated syntax sugar over the years at a fairly constant rate. For
> example, C# has added point releases to it's release schedule for which
> the express purpose is adding syntax sugar.

It simply doesn't make sense to add every stray feature that folks ask for.
Maybe some additional syntactic sugar will be added to D in the future, but
there are way too many feature requests for it to make sense to implement
even a small fraction of them. Some things are worth adding, but many really
aren't. We have to say no frequently, or we'll be drowned in stray features
to implement. And only so much can be added to a language before it becomes
completely unwieldy. For instance, how many people are actually experts on
C++ and understand all of its ins and outs? _Very_ few people. It's simply
too complicated a language. Other languages aren't necessarily as bad off in
that regard, but if you add enough to any language, it will get there. Every
time you add something to the language, you stand the chance of improving
some aspect of the language, but it comes at the cost of additional
complexity. Sometimes the addition is worth that complexity, and sometimes
it isn't.

Knowing when to add something and when not to is often a tough question, but
it's still true that you can't add everything. And inevitably, some of the
things you leave out will annoy some people by their absence, just as some
of the things you add will annoy some folks by being there.

For better or worse, Walter and Andrei's current stance is essentially that
if something can be reasonably done already in the language as it is,
they're not adding a feature to do it. D is already insanely powerful as it
is, and too often folks are looking to add a feature to the language when
it's trivial to do it with a library solution. That certainly doesn't mean
that nothing new is going to be added, but we have far more important
features to worry about than saving someone from having to type a few extra
characters because they want to use a couple of ?'s instead of typing out
the code themselves or using a function call to encapsulate the behavior -
e.g. finishing sorting out stuff like scope, @safety, and shared are far
more critical.

If someone has a really strong argument for why something is worth adding,
then they're free to create a DIP for it, and if they can convince Walter
and Andrei, it can make it into the language. But at this point in D's
development, syntactic sugar really isn't high on the list of things that
they consider to be of value. That doesn't mean that they're always right,
but on the whole, I agree with them.

- Jonathan M Davis