On the richness of C++

[Bill Baxter]

Sean Kelly wrote:
> == Quote from Walter Bright (newshound1 at digitalmars.com)'s article
>> Sean Kelly wrote:
>>> Sure, but templates don't suit every situation.  It's not uncommon for
>>> APIs to have to overload on accepting a function and a delegate for
>>> flexibility.
>> The only way to merge function pointers with delegates is to have the
>> compiler generate trampolines. This isn't very runtime efficient - the
>> template approach will be faster.
> 
> Certainly.  Templates are always faster.  But they don't always suit.  To
> choose the simplest example, let's say that I want to ship a library with
> no source code exposed.  Templates are obviously out.  Now, to support
> callable parameters I must either overload routines for both function and
> delegate simply to account for pointers to global vs. non-global callable
> routines, or I need to use a wrapper object to pass instead.  Either way,
> the same efficiency is lost, and I'm stuck doing a bunch of wrapping or
> conversion in library code as well.  Now perhaps the library is indeed the
> best place for this, but either way I disagree that "just use templates
> because they're faster" is an acceptable solution for every situation.  The
> 80-20 rule dictates that generalized arguments about performance are
> baseless anyway because 80% of the time the performance difference
> isn't even noticeable.  Rather, I would argue that in such instances
> elegance is of utmost importance because of its effect on code
> maintainability.  The great thing about D is that it often manages to
> achieve top-tier performance in an eminently elegant manner.

Example #2 is that you might want a virtual function that accepts a 
callable.  Something like setCallback(&fn).

--bb