Re: [boost] Re: Threads docs updated in CVS

From: Douglas Gregor (gregod_at_[hidden])
Date: 2001-08-17 09:24:42

On Thursday 16 August 2001 07:35, you wrote:
> Douglas Gregor wrote:
> > Boost.Function can eliminate the need for the template parameters:
> > typedef boost::function<void> Action;
> > typedef boost::function<bool> Pred;
> >
> > A library like Lambda, Boost.Bind, or FACT would let you define the
> > predicate and action inline.
>
> 	In general, it cannot be done.
> If you consider, say:
>
> 	x = x + 1
>
> you can wrap it using something like
>
> 	ASSIGN ( VAR(&x), SUM ( VAR(&x), VAL (1) )
>
> [the actual tempate code is probably grosser :-[

I believe it would be:
  bind(ref(x) = ref(x) + free1, 1)

> but such a decomposition only works for some constructions.
> Other constructions cannot be wrapped. For example,
> functions with n arguments, where n exceeds the number
> supported by the library. Struct member access,
> pointer to member formation, exception handling,
> multiple inheritance ... the list is long.

Most of these are possible - "n" can always be increased (and most libraries 
make it easy), Lambda supports exception handling; struct member 
access/pointer to member formation can be done (just form a pointer-to-member 
and pass it). I'm not saying the result is pretty, but I believe most 
constructs _can_ be handled. The only glaring omission I've found is the lack 
of "break"; exception handling works, but has terrifying performance 
implications on some compilers :(.

Multiple inheritance doesn't quite fit the above list, unless we're talking 
about very different problems...

[snip]
> FYI: I was writing a book on STL some years ago,
> and I gave up because, while it is _possible_ to do quite
> significant work using templates, the result
> is so gross as to be useless. You can replace
> a loop
>
> 	for(;;) { body }
>
> with
>
> 	for_each(body_functoid)
>
> but then you have to translate the body, and in the end
> the first form is easier to write, gives better
> diagnostics, compiles faster, generates better code,
> etc etc .. in the end, template metaprogramming
> is only interesting if you're considering how to
> fix the core language to actually make it useful.
>
> The killer was a triple loop: three or four lines
> of C++ turned into several _pages_ of templates.
> I used only plain STL, so I guess you could do better
> with more combinators (eg using Lambda or Bind,
> or whatever), but in the end, these library cannot
> solve the general problem, only slightly expand
> the class of problems which can be solved.

An identifier is worth a hundred comments, IMHO. This is by far more of a 
religious issue than any other, but given:

Container container;
for(Container::iterator i = container.begin(), i != container.end(); ++i)
{
  // code that does something
}

vs.

for_each(container.begin(), container.end(), doSomething());

I'll almost always take the second version, because doSomething can be an 
identifier that concisely state what operation is performed on each object. 
It couldn't possibly read more clearly.

        Doug