Which language futures make D overcompicated?

[rumbu]

On Friday, 9 February 2018 at 16:35:47 UTC, Seb wrote:
>> On Friday, 9 February 2018 at 15:06:49 UTC, rumbu wrote:
>
> All understood, but just to get your mind set better, I would 
> have two quick follow-up questions if you don't mind.
>
> On Friday, 9 February 2018 at 15:06:49 UTC, rumbu wrote:
>>rough C# translation:
>> 
>> async void spawnedFunc()
>> {
>>     int i = await receive();
>> }
>
> OK, but that's because Phobos has no eventloop.
> With Vibe.d it looks like this:
>
>
> ```d
> auto val = async({
>      return 32;
> }).getResult;
> ```
>
> Is this really so different or what exactly do you miss from 
> the language?
>
>> C#:
>>
>> IEnumerable<int> Fibonacci(int limit)
>> {
>>    int a = 1, b = 1;
>>    while (a < limit)
>>    {
>>      yield return a;  //syntactic sugar
>>      var t = a;
>>      a = b;
>>      b = t + b;
>>    }
>> }
>
> So your point is that std.concurrency.Generator isn't so nice? 
> Not advertised?
> Or do you simply want to have a keyword that wraps a function 
> into generator like function* in ES6?
>
> ---
> auto fib = (int limit){
>     import std.concurrency;
>     return new Generator!int((){
>         int a = 1, b = 1;
>         while (a < limit)
>         {
>             a.yield; //syntactic sugar
>             auto t = a;
>             a = b;
>             b = t + b;
>         }
>     });
> };
> ---
>
> https://run.dlang.io/is/xQl0Ir


It's not about how nice is a solution, it's about how easy is for 
someone to find out about a language feature and use it. D has a 
library solution for everything that is missing from the core 
language instead to include in the language well proven patterns. 
  That's why is complicated: one must learn about fibers, ask 
himself why in the world he must use std.concurrency to obtain a 
list of numbers and so on. Even the cluttered ((){ will scare a 
potential learner.

This is the documentation for C#:
You use a *yield return* statement to return each element one at 
a time.
You can use a *yield break* statement to end the iteration.

Now, as an exercise, please explain for a newbie in two sentences 
the Generator class, the yield function and why should we need 
concurrency and fibers stuff for this.

Modern languages are evolving over time, D had a good start 
inspiring himself from popular language features (at that time I 
suppose it was Java), now it's stalling trying to win an 
impossible bet on C/C++ compatibility instead of evolving in its 
own way. Features are dropped from the language and moved to 
library solutions. Library solutions often result in 
incomprehensible compiler error messages, and that's normal, the 
compiler has not enough information to provide a decent error 
message.

Is the concept of range a first class citizen in D? If yes, the 
language must provide the necessary syntax for repetitive 
patterns linked to ranges and hide behind the scene the details. 
Are the fibers the de facto way to deal with concurrency in D? If 
yes, the language must provide the necessary syntax to write 
fiber-oriented code. This will not stop anyone to write his 
state-of-the-art-hand-made range or fiber solution, but it will 
help the potential learner to understand immediately how to deal 
with ranges or fibers.

A similar remark I have for traits: a lot of emphasis is put on 
compile time reflection, but to use it, you need to import 8200 
lines of code from std.traits.