[boost] [fusion] MPL-lambda adapter

From: Tobias Schwinger (tschwinger_at_[hidden])
Date: 2006-05-17 17:48:51

Hi Dan & Joel,

>>Tobias Schwinger wrote:
>>>  (It would also be cool if one could just typedef the lambda expression to nested 
>>>  result or inherit from a wrapper. I don't know whether it's possible and a good 
>>>  idea - this part is just loud thinking)...
> 
> // rtc stands for runtime code
> 
>    struct a_func
>      : result< munch< _1, tweak<_2> > >
>    {
>       template<typename A, typename B>
>       typename result<A,B>::type operator()(A const & a, B const & b) const
>       { 
>         return rtc::munch(a,rtc::tweak(b)); 
>       }
>    };
> 

Here's an implementation.

I changed the name from 'result' to 'lambda' (because nested classes shouldn't
have the same name as the enclosing ones).

  FILES:
  ======

    o lambda.hpp         MPL-lambda adapter for result computation
    o lambda_test.cpp    test/example for MPL-lambda adapter

  TESTED WITH:
  ============

    o GCC 3.4.2
    o MSVC 8.0
    o MSVC 7.1 

It works really well -- the technique also reduces ambiguity problems 
caused by ADL with mutliple namespaces!

Hope you like it as much as I do... 

Regards,

Tobias


// (C) Copyright Tobias Schwinger
//
// Use modification and distribution are subject to the boost Software License,
// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).

//------------------------------------------------------------------------------

#include <boost/type.hpp>
#include <boost/fusion/algorithm/transformation/transform.hpp>
#include <boost/fusion/sequence/container/vector.hpp>
#include <boost/fusion/sequence/generation/make_vector.hpp>

#include <boost/fusion/support/lambda.hpp>

// namespace setup

namespace rmf // result metafunctions
{
    using namespace boost::fusion::result_of;
    using namespace boost::mpl::placeholders;
    using boost::add_const;
}

namespace rtc // runtime code
{
    using namespace boost::fusion;
}

// ---- transform function

namespace rmf
{
    typedef lambda< boost::type<_> > a_transform_op;
}

namespace rtc
{
    using namespace boost::mpl::placeholders;

    struct a_transform_op
      : rmf::a_transform_op
    {
        template<typename T>
        typename result<T>::type operator()(T const &) const
        {
            return boost::type<T>();
        }
    };
}

// ---- user defined algorithm built on top of fusion::transform

namespace rmf
{
    typedef lambda< transform<add_const<_>, rtc::a_transform_op> > a_transform;
}

namespace rtc
{
    template<typename Seq>
    typename rmf::a_transform::template result<Seq>::type
    inline a_transform(Seq const & seq)
    {
      return rtc::transform(seq, a_transform_op());
      // qualification pleases gcc
    }

    void test()
    {
      a_transform(make_vector("hi","there"));
    }
}


// (C) Copyright Tobias Schwinger
//
// Use modification and distribution are subject to the boost Software License,
// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).

//------------------------------------------------------------------------------

#ifndef BOOST_FUSION_LAMBDA_HPP_INCLUDED
#define BOOST_FUSION_LABBDA_HPP_INCLUDED

#include <boost/mpl/lambda.hpp>

#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/facilities/intercept.hpp>

namespace boost { namespace fusion { namespace result_of {

    template<typename PlaceholderExpression>
    struct lambda
    {
        template
        < BOOST_PP_ENUM_BINARY_PARAMS(BOOST_MPL_LIMIT_METAFUNCTION_ARITY,
              typename T, = mpl::na BOOST_PP_INTERCEPT)
        >
        struct result
          : mpl::lambda<PlaceholderExpression>::type::template apply< 
                BOOST_PP_ENUM_PARAMS(BOOST_MPL_LIMIT_METAFUNCTION_ARITY, T) >
        { };
    };

}}}

#endif