Re: [Boost-users] [Proto] Processing Lists

23 Feb 2010


      Hi David,

On 2/22/2010 10:29 PM, David Greene wrote:
...
I want to process a list that looks something like this:
struct List : or_<
   comma<
     List,
     Item
...
,
   Item
{};
But rather than processing each item separately, I want to pass a fusion (or
some other) sequence to a semantic action:
when<
   List,
   SomeAction(...)
...
{};
Ideally the argument to SomeAction would be a fusion sequence but I don't
know how to produce one.  This doesn't work:
when<
   List,
   SomeAction(flatten(_))
...
{};
because flatten is not a transform.
You were SO close. You want proto::functional::flatten here (the type of 
a function object), not proto::flatten (an ordinary function).
...
I don't want to use fold_tree because I
don't want to actually fold the sequence.  SomeAction is something like this:
struct SomeAction : callable {
   template<typename Seq>
   void operator()(Seq range) {
     typedef ... iterator;
// Is this legal for fusion sequences?
     for(iterator i = begin(range), iend = end(range);
          i != iend;
          i = next(i)) {
         ...
     }
   }
}
Is there a way to do this?
Try this:

   #include <iostream>
   #include 
   #include 

   using namespace std;
   using namespace boost;
   using namespace boost::proto;

   struct display_value {
     typedef void result_type;
     template<typename Item>
     void operator()(Item i) const {
       cout << value(i) << ' ';
     }
   };

   struct SomeAction : callable {
     typedef void result_type;
     template<typename Seq>
     void operator()(Seq const &range) {
       // Use fusion algorithms to process the list.
       fusion::for_each(range, display_value());
     }
   };

   struct Item : terminal<_> {};

   struct List : or_<
     comma<
       List,
       Item
     >,
     Item
...
{};
struct ProcessList : when<
     List,
     SomeAction(functional::flatten(_))
...
{};
int main()
   {
     ProcessList()((lit(1), 2, 3, 4));
   }
...
On a related note, I know I can use varag<>  to match a function call
expression with an arbitrary number of operands and invoke a transform
on each operand.  But how would I generate a fusion sequence of all
the operands?  In other words, with:
proto::function<  X, proto::vararg<Y>  >
how do I talk about the vararg<>  part in a semantic action?  CalculatorGrammar
has a use of vararg but it uses fold<>  to process it.  I don't want to fold a
sequence, I want to pass it to a transform.
Manjunath already answered this one. Proto expressions already are 
fusion sequences, and proto::_expr returns the current expression. You 
can use proto::functional::pop_front in a transform to pop off the first 
bit (the thing that matches X in your example) and pass the result to 
something that accepts fusion sequences.

HTH,

-- 
Eric Niebler
BoostPro Computing
http://www.boostpro.com