On 5/21/2022 1:30 PM, mee6 wrote:
> Do you have hard numbers on that? IIRC there's only been one survey done for the community and almost all the most desired features from it aren't implemented.

No, I don't have hard numbers. There's always selection bias in self-reporting of desired features. I admit to using judgement to decide what to do.

For example, many years ago, only one person asked for User Defined Attributes (Manu). He made a compelling case for it. I implemented it. The result was a lot of pushback from the community.

But it has turned out to be a very well liked and used feature.

Of course, things don't always work out so well. D has some features I wish we'd never done.

ImportC is another one that has been met with a lot of skepticism. I have faith in it, and we'll see if I'm right or wrong about it.

On Saturday, 21 May 2022 at 21:24:33 UTC, Walter Bright wrote:
> I implemented it. The result was a lot of pushback from the community.

You implemented *some* of it.

The part I specifically wanted wasn't released until September 2018

https://dlang.org/changelog/2.082.0.html#uda-function-parameters


I don't recall when the basic UDAs were added and I can't find it searching the changelog right now, but if memory serves, it was about 2013 (which is late enough that I already had other alternatives to them implemented in my web server library), but there was a gap of *several years* between your initial implementation and it actually covering all the bases to make it compelling.


This is a good example of the overall point: so many things are announced with much fanfare as soon as they do the bare minimum of functionality....... then it sits at bare minimum for an unspecified amount of time before it reaches the point where it is actually useful, if it ever reaches that point.

On Saturday, 21 May 2022 at 11:39:06 UTC, Timon Gehr wrote:
> On 21.05.22 05:45, Walter Bright wrote:
>> On 5/20/2022 4:28 AM, deadalnix wrote:
>>> I'd like to remind everybody of a simple fact: it is impossible to write a high quality generic container in D, right now. This is because there is no way to explain to the compiler that a `const Vector!T` is the same as a `const Vector!(const T)`.
>> 
>> I don't recall anyone ever bringing it up before.
>
> I brought it up a number of times. ;) I think the last time was here:
> https://forum.dlang.org/post/sk4v9b$2apt$1@digitalmars.com
>
> deadalnix has also talked about this multiple times over the years.
> [snip]

As Walter says multiple times, if things aren't on bugzilla, then they get lost in the shuffle...

On Saturday, 21 May 2022 at 20:02:22 UTC, Walter Bright wrote:
> On 5/21/2022 6:02 AM, deadalnix wrote:
>> We've got a ton of good stuff in D, but we keep adding more rather than making sure that what we have is really good.
>
> I can't help but think this is a bit of a quixotic quest.

This has been discussed so many times:

1) Freeze the current features, and release as the final version D2 (i.e put into maintenance mode, only have bug fix update, not any more new language features). I think any serious enterprise users want language/library stability.


2) all future work going to D3, for you to add / experiment new language features; and for adventurous users to play with it.


So, one more time, how about D3? Walter, do you hear?

On 5/21/2022 2:41 PM, Adam D Ruppe wrote:
> On Saturday, 21 May 2022 at 21:24:33 UTC, Walter Bright wrote:
>> I implemented it. The result was a lot of pushback from the community.
> 
> You implemented *some* of it.

I implemented all of the specified functionality.


> The part I specifically wanted wasn't released until September 2018
> 
> https://dlang.org/changelog/2.082.0.html#uda-function-parameters
> 
> 
> I don't recall when the basic UDAs were added and I can't find it searching the changelog right now, but if memory serves, it was about 2013 (which is late enough that I already had other alternatives to them implemented in my web server library), but there was a gap of *several years* between your initial implementation and it actually covering all the bases to make it compelling.
> 
> 
> This is a good example of the overall point: so many things are announced with much fanfare as soon as they do the bare minimum of functionality....... then it sits at bare minimum for an unspecified amount of time before it reaches the point where it is actually useful, if it ever reaches that point.

UDAs found plenty of uses immediately. The parameters feature was clearly an enhancement, not a missing thing. And yes, it was a good enhancement.

On Saturday, 21 May 2022 at 22:33:05 UTC, Walter Bright wrote:
> I implemented all of the specified functionality.

Are you gonna make me dig up the original posts?

I was part of those original discussions with my use cases, one of which was specifically putting it on parameters.

Not that anybody in D's leadership ever listens to me anyway.

On Saturday, 21 May 2022 at 19:46:48 UTC, Walter Bright wrote:
> On 5/21/2022 4:54 AM, deadalnix wrote:
>> There are holes in the foundations of the languages. These hole prevent basic things from being possible at all. For instance, containers.
>
>
> Ok, can you please provide a comprehensive list of these holes?

I've done so a gazilion time, and the fact you cannot think of one is the focus problem I'm talking about. Just on type qualifiers:
 - Transitivity of type qualifier doesn't play nice with template. There is no way to tell the compiler that a `const Tpl!T` actually is a `const Tpl!(const T)`. As a result, no container library is possible and ranges have serious problem when it come to qualifiers too.
 - delegates break constness guarantees as the type qualifier ont he context is not tracked and/or checked.
 - closure break constness guarantee, as I can mutate an immutable variable visible in a closure when iterating in a loop.
 - There is no way to build a shared object without breaking the type system.
 - shared is supposed to be explicit, yet all objects have a monitor - granted this one is not broken per se, but a major WTF.
 - synchronized shared object cannot provide the guarantee they are supposed to because there is no adequate escape analysis.
 - const/immutable doesn't play nice with reference types (the qualify both the object and the reference), making the type qualifier system pretty much unworkable with OOP style code.

It's just on top of my head, but I'm sure there is more.

Now, don't get me wrong, some of these are hard problems. But the more we add to the pile of stuff we have, the harder they become to solve.

On Saturday, 21 May 2022 at 22:11:22 UTC, jmh530 wrote:
>> deadalnix has also talked about this multiple times over the years.
>> [snip]
>
> As Walter says multiple times, if things aren't on bugzilla, then they get lost in the shuffle...

Every one of these that qualify as a bug is in bugzilla. Some of them are more than a decade old, for instance: https://issues.dlang.org/show_bug.cgi?id=6857