Boost logo

Boost :

From: Tobias Schwinger (tschwinger_at_[hidden])
Date: 2006-12-20 19:03:58

Christian Holmquist wrote:
> Tobias,
> Thanks you for the reply on this matter.
> Is your code available in the Boost Vault for download, and some example
> using it?

There used to be an early stage of both in the vault, but I took it offline once it was clear to me that it was still very much insufficient. I can only find the example code ITM and will attach it to this post.

>>There would be multiple variants of these class templates with different
>>properties of the call operator:
>> - only accepting lvalues (like make_<seq>)
>> - only accepting rvalues (like <seq>_tie)

Sorry, here's a typo - <seq>_tie binds lvalues and make_<seq> binds to rvalues, of course.

>> - only accepting predefined types (like <seq>'s ctor, this one would
>> have another template parameter)
>> - accepting any combination of lvalues and rvalues (exploding all 2^N
>> possibilities - a brute force solution to the forwarding problem,
>> until we have better ways to solve it)
> I don't understand your reason for the lvalues/rvalues explotion. The
> distinct type is available in the fusion sequence, why overload completely
> unspecified types? (if that's what you do?).

<quote from your original post>
    template<class A0, class A1, ....>
    void operator()(const A0& a0, const A1& a1, ...) const
        do_something_very_clever(fusion_sequence_type(a0, a1, ...));
</quote from your original post>

Here we don't know the template argument types, do we? It's the first case I mentioned (the most interesting cases are those where 'fusion_sequence_type' isn't known before operator() is instantiated).

Although (almost) everything binds to "T const &" we can't know whether it was a temporary, so we can't safely store the refernce - it might start dangling.

BTW: The result type is 'void'. If we want to factor this code out into some generic utility it's probably a wise choice to allow different results.

The second case I mentioned is:

    template<class A0, class A1, ....>
    whatever operator()(A0& a0, A1& a1, ...) const;

Now temporary arguments are not allowed at all (which can be very impractical of an interface) - a "pure tie".

The fourth case lets us detect whether something is not a temporary, which can be a very valuable thing, especially if we want to defer function invocations.

For an in-depth discussion of the issue see - The Forwarding Problem - Dimov, Hinnant, Abrahams

> Given the sequence<int, int&, const int&> I would expect the overload to be
> (ignoring return type here) void operator()(int, int&, const int&).

In this case we are talking about the third case (the one where we know the types).

> I assume I've oversimplified the issue, so what aspect am I missing here?

Never mind - I did so two times. I'm talking about how things should be done and not about I did them, after all.



// (C) Copyright Tobias Schwinger
// Use modification and distribution are subject to the boost Software License,
// Version 1.0. (See


// A simple bind implementation (compiles with msvc >= 7.1)

#include <typeinfo>
#include <iostream>

#include <boost/fusion/sequence/container/vector/vector.hpp>
#include <boost/fusion/sequence/intrinsic/front.hpp>
#include <boost/fusion/sequence/intrinsic/value_at.hpp>
#include <boost/fusion/sequence/intrinsic/at.hpp>
#include <boost/fusion/sequence/utility/unpack_args.hpp>
#include <boost/fusion/algorithm/transformation/transform.hpp>
#include <boost/fusion/algorithm/transformation/pop_front.hpp>

// "case 1" from the post NOTE: NOT PART OF FUSION
#include <boost/fusion/sequence/generation/vector_generator.hpp>

// this header defines an experimental component that allows to specify the
// result of a Fusion function object with an MPL lambda expression
#include <boost/fusion/support/lambda_result.hpp>

#include <boost/mpl/if.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/bool.hpp>

#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/add_reference.hpp>

// needed to workaround unpack_args bug
#include <boost/fusion/sequence/conversion/as_vector.hpp>
// note: another bug in unpack_args keeps this binder from working with
// non-class functors.

namespace impl

    // note: one character identifiers keep qualified names short
    namespace r = boost::fusion; // r for runtime code
    namespace m = boost::fusion::result_of; // m for metafunctions

    namespace mpl = boost::mpl;
    using namespace mpl::placeholders;

    // use runtime code by default,
    using namespace r;

    // metafunctions unlikely to clash can go here
    using boost::add_const;
    using boost::add_reference;

    // placeholder template
    template<int I> struct placeholder
      : mpl::int_<I>
    { };

    // is T the type of a placeholder?
    template<typename T> struct is_placeholder
      : mpl::false_
    { };
    template<int I> struct is_placeholder< placeholder<I> >
      : mpl::true_
    { };

    // runtime code for the transform operation
    template<typename Args> class transform_op
      : public
            mpl::if_< is_placeholder<_2>, m::at< add_const<_1>, _2>
                    , add_reference< add_const<_2> > >
        ::template closure<Args>
        Args const & ref_args;

        explicit transform_op(Args const & args)
          : ref_args(args)
        { }

        // return bound argument
        template<typename BindingArg>
        inline BindingArg const & operator()(BindingArg const & a) const
          return a;

        // substitute placeholders with elements from the arguments tuple
        template<int Index>
        inline typename m::at_c<Args const, Index>::type
        operator()(placeholder<Index> const &) const
          return at_c<Index>(this->ref_args);

    // bound_function's operator() contains the argument transformation and
    // invokes the function
    template<class Binding> class bound_function
      : public

            m::unpack_args< m::value_at< add_const<_1> , mpl::int_<0>::type>
m::as_vector< // <-- workaround for unpack_args bug
                            m::transform< m::pop_front< add_const<_1> >
                                        , transform_op<_2>
> // <-- workaround for unpack_args bug
        ::template closure<Binding>

        Binding tpl_binding;

        explicit bound_function(Binding const & binding)
          : tpl_binding(binding)
        { }

        template<typename Args>
        inline typename result<Args>::type
        operator()(Args const & args) const
            return unpack_args( front(this->tpl_binding)
as_vector( // <-- workaround for unpack_args bug
                                transform( pop_front(this->tpl_binding)
                                         , transform_op<Args>(args)
         ) // <-- workaround for unpack_args bug


        typedef bound_function type;

        // we leave this out for the sake of simplicity -- a full bind is not
        // possible...
        typedef mpl::false_ accepts_nullary_sequence;

    // vector_generator is used to create a bound_function
    struct bind_op
        lambda_result< vector_generator< bound_function<_> > >
        template<typename Binding>
        inline typename result<Binding>::type
        operator()(Binding const & binding) const
            return typename result<Binding>::type(bound_function<Binding>(binding));

    typedef vector_generator<bind_op, mpl::false_> binder;

// placeholder globals
impl::placeholder<0> const _1_ = impl::placeholder<0>();
impl::placeholder<1> const _2_ = impl::placeholder<1>();
impl::placeholder<2> const _3_ = impl::placeholder<2>();
impl::placeholder<3> const _4_ = impl::placeholder<3>();

// the binder is a global variable with an overloaded call operator
impl::binder const bind = impl::binder();

//// example code

struct func
    typedef int result_type;

    inline int operator()(char const * greeting, char const * name) const
      std::cout << greeting << ' ' << name << '!' << std::endl;

      return 77;

int main()
    func f;

    return 0;

Boost list run by bdawes at, gregod at, cpdaniel at, john at