RE: [boost] Interest in CPP meta programming library?

From: Aleksey Gurtovoy (alexy_at_[hidden])
Date: 2001-05-20 08:53:48

 Vesa Karvonen wrote:
> I'm thinking of submitting a small CPP or C Pre Processor 
> meta programming library into Boost. For this reason I have
> uploaded a trivial demo subset of the library into the Files 
> section/Vault. You can find the files under the CPP folder. 
> The rest of this message contains a motivated example of the 
> use of a particular feature of the library.

Funny, I've been using something like this for about half a year too. First
time I saw a simple example of the technique in the Lambda library
(LL_REPEAT, IIRC), and extending it to handle self-referential situations
was trivial :). Actually, if you look at 'boost::mpl' library headers
(http://groups.yahoo.com/group/boost/files/mpl/mpl-apr-28-01.zip), you'll
find a few examples of the technique applied as well:

// from 'mpl/switch_on.hpp'

template<typename T, BOOST_MPL_ENUMERATE_DEFAULT_PARAMS(class C,
null_argument)> 
struct switch_on
    : mpl::detail::switch_impl< T,
mpl::type_list<BOOST_MPL_ENUMERATE_PARAMS(C)> >::result_type
    {
    };

// from 'mpl/list/factory.hpp'

#define BOOST_MPL_LIST_FACTORY_SPEC(N)
\
template<>
\
struct list_factory_part1<N>
\
    {
\
    template<class Tag, BOOST_MPL_ENUMERATE_PARAMS(typename T)>
\
    struct part2
\
        {
\
        typedef BOOST_MPL_ENUMERATE_N(N
\
            , typename mpl::list_traits<Tag>::template make_node<T)
\
            , typename mpl::list_traits<Tag>::null_node BOOST_MPL_REPEAT_N(N
\
            , >::type) type;
\
        };
\
    };

BOOST_MPL_ENUMERATE_USER_MACROS(BOOST_MPL_, LIST_FACTORY_SPEC)

and a couple of others. The macros themselves are in the
'mpl/enumeration_macros.hpp' and 'mpl/basic_macros.hpp' headers. Two-part
naming of the enumerated macro ("BOOST_MPL_, LIST_FACTORY_SPEC") is a
(historical) implementation artifact, but the rest is more or less
equivalent to your BOOST_LST0 and BOOST_LST1 approach, except that the names
of these are much longer - BOOST_MPL_ENUMERATE_MACRO_CALLS and
BOOST_MPL_ENUMERATE_USER_MACROS respectively :). Well, actually there are
some differences in techniques, but IMO they are rather minor. I would like
to see both approaches merged into something simple and elegant that would
become an official boost library :).

****************
An aside note: 

Besides 'boost::mpl', I've been using the technique a lot in other projects,
and I find it a really useful alternative to external code
generation/preprocessing. However, as others already mentioned, it has its
own problems, and the main source of those is that the technique is still
preprocessor-based. It would be really great to have the language to support
compile-time type lists in template parameters and function signatures, so
instead of

template<typename R, ENUMERATE_ARGUMENTS_N(10, typename T)>
inline
function< R, ENUMERATE_ARGUMENTS_N(10, T) >
make_function(R (*f)( ENUMERATE_ARGUMENTS_N(10, T) ))
  {
  return function2<R, ENUMERATE_ARGUMENTS_N(10, T)>(f);
  }

one could write something like this:

template<typename R, typename[10] Ts>
inline
function< R, Ts>
make_function(R (*f)(Ts)
  {
  return function2<R, Ts>(f);
  }

Of course, something like the above requires a core language change (if
someone writes a proposal :), and that won't happen any time soon (if ever),
so IMO the discussed library has its place here.

Aleksey