[boost] Re: [ANN] Phoenix-2 Preview

From: Reece Dunn (msclrhd_at_[hidden])
Date: 2004-11-28 11:50:31

Joel de Guzman wrote:
> Hi,
> 
> Hi. Here's a preview of Phoenix V2. This will probably be the last
> release of the library. Phoenix V2 will be the basis of the Phoenix
> and Boost.Lambda merger.
> 
> You can get it here:
> http://spirit.sourceforge.net/dl_more/phoenix-2.zip

I like it!

> You can browse the draft docs here:
> http://tinyurl.com/6crgp

There is a typeo in the table at composite.html#phoenix.operator:

Include Files:

    #include <boost/spirit/phoenix/operator/self.hppp>
---------------------------------------------------^

> What's new? A lot. This is a total rewrite based on earlier
> discussions with Jaakko Jarvi. The library's is built on
> top of Fusion and of course MPL.
> 
> Of particular interest are local variables and lambda-lambda
> scopes: http://tinyurl.com/3mn6w
> 
> There is also a set of lazy functions that work on STL
> sequences (e.g. push_back etc.): http://tinyurl.com/46bbm
> 
> and pretty soon, a final TODO item (built on top of scopes/
> lambda), lazy STL algorithms (e.g. find_if, etc). The scopes
> section (link provided above) in the docs illustrates how to
> write lazy functions that accept higher order functions
> (e.g. for_each).

I have written lazy veraions of pair.first and pair.second (see attachment).

Regards,
Reece


// (C) Copyright 2004: Reece H. Dunn. Distributed under the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_SPIRIT_PHOENIX_STL_UTILITY_HPP
#define BOOST_SPIRIT_PHOENIX_STL_UTILITY_HPP

#include <boost/spirit/phoenix/function/function.hpp>

namespace boost { namespace phoenix
{

namespace stl
{
   template< typename C >
   struct first_type_of{ typedef typename C::first_type type; };

   template< typename C >
   struct second_type_of{ typedef typename C::second_type type; };

   struct first
   {
      template< typename C >
      struct apply
      {
         typedef typename first_type_of< C >::type & type;
      };

      template< typename C >
      typename apply< C >::type
      operator()( C & c ) const
      {
         return c.first;
      }
   };

   struct second
   {
      template< typename C >
      struct apply
      {
         typedef typename second_type_of< C >::type & type;
      };

      template< typename C >
      typename apply< C >::type
      operator()( C & c ) const
      {
         return c.second;
      }
   };
}

/** Get the first item in a pair.
  * The standard way of accessing the first item in a pair is to use the
  * p.first syntax. This will not work in a lazy context:
  *    arg1.first; // error: first not a member of arg1.
  * To make this work in a lazy context, you need to use the first function:
  *    first( arg1 ); // lazy evaluation.
  */

function< stl::first > const first  = stl::first();

/** Get the second item in a pair.
  * The standard way of accessing the second item in a pair is to use the
  * p.second syntax. This will not work in a lazy context:
  *    arg1.second; // error: second not a member of arg1.
  * To make this work in a lazy context, you need to use the second function:
  *    second( arg1 ); // lazy evaluation.
  */

function< stl::second > const second = stl::second();

}}

#endif