Boost type erasure error with free function const and non-const overloads

Question

This is the code.

BOOST_TYPE_ERASURE_FREE((has_arg1), arg1, 1)

namespace te = ::boost::type_erasure;

typedef te::any<
            ::boost::mpl::vector<
                te::copy_constructible<>,
                te::typeid_<>,
                te::destructible<>,
                te::assignable<>,
                has_arg1<Vector<Val>&( te::_self& )>,
                has_arg1<const Vector<Val>&( const te::_self& )>>> Bar;

struct Foo {
    Vector<Val> mVals;
};

const Vector<Val>& arg1(const Foo& f) {
    return f.mVals;
}

Vector<Val>& arg1(Foo& f) {
    return f.mVals;
}

BOOST_AUTO_TEST_CASE(Foo1) {
    Foo f;
    Bar i = f;
}

It fails with the following error. Any ideas why? Is this not possible using boost type erasure. I am using Clang++ 3.5 compiler.

      functions that differ only in their return type cannot be overloaded
BOOST_TYPE_ERASURE_FREE((has_arg1), arg1, 1)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~

Answer 1

Technically, the issue is as described in Basic Usage:

If we wanted to define a const member function, we would have to change it to const _self, as shown below.

So you'd write

Live On Coliru

#include <boost/type_erasure/any.hpp>
#include <boost/type_erasure/free.hpp>
#include <boost/type_erasure/member.hpp>
#include <iostream>
#include <vector>

template <typename T>
using Vector = std::vector<T>;

struct Val {};

BOOST_TYPE_ERASURE_FREE((has_free1),     free1,   1)
BOOST_TYPE_ERASURE_MEMBER((has_member1), member1, 0)

namespace te = ::boost::type_erasure;

typedef te::any< ::boost::mpl::vector<te::copy_constructible<>
          , te::typeid_<>
          , te::destructible<>
          , te::assignable<>
          , has_free1<Vector<Val>&(te::_self&)>
          , has_free1<Vector<Val> const&(te::_self const&)>
          , has_member1<Vector<Val>&(), te::_self>
          , has_member1<Vector<Val> const &(), te::_self const> >,
     te::_self const &> Bar;

struct Foo {
    Vector<Val> mVals;
    Vector<Val>&       member1()       { std::cout << __PRETTY_FUNCTION__ << "\n"; return mVals; }
    const Vector<Val>& member1() const { std::cout << __PRETTY_FUNCTION__ << "\n"; return mVals; }
};

Vector<Val>&       free1(Foo& f)       { std::cout << __PRETTY_FUNCTION__ << "\n"; return f.mVals; }
const Vector<Val>& free1(const Foo& f) { std::cout << __PRETTY_FUNCTION__ << "\n"; return f.mVals; }

int main() {
    std::cout << " ==== Foo f; ==============\n";
    {
        Foo f {};
        std::cout << "Direct: "; free1(f);
        std::cout << "Direct: "; f.member1();
        Bar i = f; std::cout << "\n";
        std::cout << "Erased: "; free1(f);
        std::cout << "Erased: "; i.member1();
    }
    std::cout << " ==== Foo const f; ========\n";
    {
        Foo const f {};
        std::cout << "Direct: "; free1(f);
        std::cout << "Direct: "; f.member1();
        Bar i = f; std::cout << "\n";
        std::cout << "Erased: "; free1(f);
        std::cout << "Erased: "; i.member1();
    }
}

Prints:

 ==== Foo f; ==============
Direct: Vector<Val>& free1(Foo&)
Direct: Vector<Val>& Foo::member1()

Erased: Vector<Val>& free1(Foo&)
Erased: Vector<Val>& Foo::member1() const
 ==== Foo const f; ========
Direct: Vector<Val>& free1(const Foo&)
Direct: Vector<Val>& Foo::member1() const

Erased: Vector<Val>& free1(const Foo&)
Erased: Vector<Val>& Foo::member1() const