Re: boost::bind and the preprocessor

From: vesa_karvonen (vesa_karvonen_at_[hidden])
Date: 2002-03-08 09:09:00

--- In boost_at_y..., "David Abrahams" <david.abrahams_at_r...> wrote:
> From: "vesa_karvonen" <vesa_karvonen_at_h...>
> > --- In boost_at_y..., "David Abrahams" <david.abrahams_at_r...> wrote:
> > > From: "vesa_karvonen" <vesa_karvonen_at_h...>
[...]
> And PLEASE make it clear that I can just pass "ignore" for R in most
> simple cases.

hmm... I've tried to use the same one character names for every macro 
parameter used for the same purpose in the library, but there are 
still many exceptions to the rules. I'll try to fix those exceptions 
and add a separate page that explicitly explains the naming of 
parameters.

The R and D parameters are actually "generated" by BOOST_PP_FOR() and 
BOOST_PP_WHILE(), respectively, and passed to the user written macro. 
Both R and D serve as recursion depth and are an unfortunate 
implementation detail necessitated by the C++ preprocessor. The R and 
D parameters can often be ignored by the user.

The P parameter is a parameter specified by the user and is passed to 
the user written macro. The P parameter serves as a way to provide 
context for the user written macro. Many user written macros do not 
need the context and the user can pass almost anything (e.g. 'ignore' 
or 'dummy') as the P parameter. I personally recommend '_' (a single 
underscore), because it is often used for the same or similar purpose 
in functional programming languages.

> You could look at
> boost/python/converter/from_python_data.hpp for what I ended up 
> with.

That looks quite nice.

As this case requires iteration over types (which can be done using 
template metaprogramming), and is not a specialization of a template 
(which can not be done using template metaprogramming), I think that 
it should be possible to achieve the same effect using only MPL, 
which might be preferable.

The basic idea would be to make a metafunction that generates nested 
unions. Consider the following union:

  template<class T0, class T1>
  union union_pair
  {
    T0 t0;
    T1 t1;
  };

The idea is to generate nested union like this:

  union_pair<T1, union_pair<T2, ... union_pair<TN, char> ... > >

The above kind of nested union can certainly be generated using MPL. 
It should provide an alignment that is at least as high as the 
alignment of the highest aligned type TI.