New subject: [fusion] more

17 May 2006

      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

[fusion] MPL-lambda adapter

Tobias Schwinger

Joel de Guzman

Tobias Schwinger

Joel de Guzman

Tobias Schwinger

Tobias Schwinger

dan marsden

João Abecasis

David Abrahams

João Abecasis

Tobias Schwinger

Tobias Schwinger

João Abecasis

Tobias Schwinger

tags

participants (5)