function literals cannot be class members

[Mehrdad]

On 7/18/2011 6:21 AM, Steven Schveighoffer wrote:
>> I'm actually still confused at why _functions_ should be passed as 
>> template parameters
>
> The beauty of alias parameters <snip>

... the beauty?

Please excuse me my tone becomes a bit rant-y, but I was asking _why_, 
and the reason is just... beauty? IMHO, it's getting pretty darn ugly...

Templates are just that: *templates*. They're meant to avoid 
__duplication of code and/or unnecessary variation in code__, by 
providing a common style (i.e. a common *template*). Metaprogramming, 
conditional compilation, etc. are great uses of templates, since they 
avoid unnecessary duplication of code.
But using them _in lieu_ of delegates is kind of pointless -- delegates 
*already* avoid duplication of code, and aliases don't solve any 
problems here. (I'm guessing you disagree, in which case: Can you 
provide an example of a problem that they actually solve, aside from 
their "beauty"?)

Sure, they're beautiful, but they're ugly at the same time: they don't 
let the code describe itself. i.e. when you say
     void Foo(alias F)() { ... }
the reader has **no idea whatsoever** what kind of "thing" F is (string? 
delegate? data type?), and it gets cryptic fast. Sure, you can document 
it, but isn't the whole point to let the code document itself? Not only 
that, it becomes absolutely /painful/ to write completely correct 
conditions for a template like this, when you can have multiple kinds of 
parameters.

If you want to be able to pass multiple parameter types, then why not 
just either use overloading or, if you're really concerned about 
duplication, let the argument type be specified as a template? That 
would remove the duplication issue.
If you're worried about simple things like "a < b", then it's because we 
shouldn't be using a string in the first place! It's painful to write
     foo(delegate(a, b) { return a < b; })
but that's an easily solvable solution: Just support C#'s syntax of 
lambdas and you instead get:
     foo((a, b)  =>  a < b);
which is cleaner and easy to type, and which avoids using strings for 
code. Or you can just predefine it somewhere as a lessThan template, and 
pass it as an argument. Either way, no strings.
In any case, this shouldn't be an excuse for using templates -- if 
typing something is hard, simplifying the syntax is the answer (I'm all 
for C# lambdas...), not using the template hammer to solve everything.