ch-ch-changes

[Andrei Alexandrescu]

grauzone wrote:
> Consider you have this code:
> 
>  > map!("a*3")(a)
> 
> Now you see that you forgot something! For some reason, you actually 
> need to return absolute values! Uh-oh, let's fix that:
> 
>  > map!("fabs(a*3)")(a)
> 
> Oops, this doesn't work. fabs() isn't available, because the code is 
> compiled inside the standard library, and not the module, where the code 
> was written. This is confusing and non-intuitive. Even more, you don't 
> have _any_ way to access fabs() in this code (except if std.algorithm 
> imports std.math). You'll have to rewrite this line of code somehow. 
> Maybe turn it into a delegate. But then you lose the performance benefit 
> you had before. What to do now? Looks like this simple issue caused more 
> work than you thought! And all this even though the predicate is simple 
> and trivial!

Lest a misunderstanding arises, the code:

auto r = map!((float a) { return fabs(a); })(a);

does *not* involve a delegate; it's still a direct call. This code 
doesn't currently compile because of a bug in the compiler, but this 
equivalent code does:

float fun(float a) { return fabs(a); }
auto r = map!(fun)(a);

and again it does not involve a delegate.

> I don't see how this is simple and elegant. Looks more like a hack. It 
> reminds me a bit of C++, where things first look simple, but actually... 
> they really aren't.
> 
> But I get Don's and Andrei's points. End of discussion, I guess.

Whereas I reckon in the beginning you weren't fully aware of the 
flexibility offered by pass-by-alias, you brought some good points. The 
functionality afforded by strings can be improved by importing more 
modules inside std.functional. I just added std.math and std.contracts. 
At the end of the day std.functional could include the entire Phobos 
(you'd be surprised how fast that compiles). I agree that that's not 
elegant, but let's not forget that strings are just that - an 
*additional* convenience to the many conveniences that pass-by-alias 
imparts.


Andrei