Does D have too many features?

[bearophile]

Peter Alexander:

> f(x) ---> x.f() is not progress in language design.

I used to think the same. But Haskell offers "." and $ to chain 
functions and remove parentheses, F# has the  |>  pipe operator. 
In D UCFS is almost equally useful to turn nesting of function 
calls in a more readable chain. In functional-style code this 
makes a lot of difference, turning:

foo(bar(copy(baz(a), spam(b))))

Into:

baz(a).copy(b.spam()).bar().foo()

When I see 3+ nested parentheses I find it hard to read the 
expression. While a chain is easy to read.


> In theory. IMO the amount of time you spend trying to please 
> the type system could have been better spent optimizing your 
> code manually.
>
> No code I have ever written would benefit significantly from 
> these potential optimisations. For example, one optimisation is 
> that pure function calls could be hoisted out of loops. Great, 
> except that if that function call had any significant cost 
> whatsoever, I would have already done that optimisation myself.

I used to write lot of D1 code too, and I've seen that managing 
D2 const-related issues slows down significantly my coding 
compared to D1 coding, so undeniably they have a cost.

But in D the main purpose of "pure" is not as optimization tool, 
but more as a tool to enforce a better coding style, that makes 
code understanding (and testing simpler), and helps avoid some 
bugs, coming from using variables from outer scopes.

Bye,
bearophile