Re: [Boost-users] Re: [MPL] map question

From: Aleksey Gurtovoy (agurtovoy_at_[hidden])
Date: 2004-12-21 05:06:54

David Abrahams writes:
> Oh, I see it now; you're trying to get the "types" member out of the
> result of invoking value_type.  Okay, to do that you need a metafunction
> that gets the types member:
> 
>    template <class Value>
>    struct get_types
>    {
>         typedef Value::types type;
>    };
> 
> now you can write:
> 
>    get_types<          // The ::types member of
>        value_type<     // The "value" component
>             map_types  // (when in map_types)
>          , _2          // of the current element being processed
>        >
>    >
> 
> So, IIUC, your ForwardOp is trying to use the copy algorithm with an
> inserter to insert each element of the sequence returned by the above
> lambda expression.  One other problem is that insert<_1, _2> will have
> its placeholders substituted immediately as the "fold" is evaluated.  So
> for each step of the copy, the same state and element will be passed.
> You need to protect that placeholder expression from early substitution.
>  The easiest way is to transform it into a metafunction class using the
> lambda metafunction:
> 
>    copy<
>        get_types<          // The ::types member of
>            value_type<     // The "value" component
>                 map_types  // (when in map_types)
>               , _2         // of the current element being processed
>            >
>        >
>      , inserter<           // an inserter starting with the outer state
>            _1              // (the sequence being built) as its state.
>          , lambda<         // [preventing early substitution]
>                insert<_,_> // and inserting each element into
>            >               // the inner state
>        >
>    >

Won't work. The 'lambda' metafunction doesn't have any special status here. 
For instance, 'lambda<_1>' is a regular, well, lambda expression, not 
different from, let's say, 'first<_1>'. It's all documented in the 
reference manual, and illustrated by the corresponding tests 
(e.g. http://cvs.sourceforge.net/viewcvs.py/boost/boost/libs/mpl/test/apply.cpp?view=markup).

Answering the OP question: MPL lambda expressions do not support scopes (yet),
so it's not possible to implement the above without an auxiliary metafunction 
incapsulating the nested scope. Which actually might be a good thing -- it's 
hard to imagine that the "inline" version would be shorter and easier to 
understand than this:

    template< typename Map, typename Entry >
    struct copy_entires
        : copy< 
              typename Entry::second::entries
            , inserter<Map, insert<_1,_2> >
            >
    {
    };

    typedef fold<map_types, map_types, copy_entires<_1,_2> >::type result;

--
Aleksey Gurtovoy
MetaCommunications Engineering