#include <boost/type_erasure/any.hpp>
#include <boost/type_erasure/concept_interface.hpp>
#include <boost/type_erasure/builtin.hpp>
#include <boost/functional/hash.hpp>
#include <functional>
#include <vector>
#include <iostream>
#include <cstddef>

namespace mpl = boost::mpl;
namespace te = boost::type_erasure;

template<class C = te::_self>
struct hashable
{
  static std::size_t apply(const C& c) { return std::hash<C>()(c); }
};

typedef mpl::vector<
    te::copy_constructible<>,
    hashable<te::_self>
> requirements;

typedef te::any<requirements> test;

namespace std {
  template<>
  class hash<test> {
  public :
    size_t operator()(const test &t ) const
    {
      return te::call(hashable<>(), t);
    }
  };
};

struct C {
    std::size_t hash() const {
        //coord is a member std::vector<int>
        return boost::hash_range(coord.begin(), coord.end());
    }
    std::vector<int> coord;
};

namespace std {
  template<>
  class hash<C> {
  public :
    size_t operator()(const C& c)
    {
      return c.hash();
    }
  };
}

int main() {
    C c = { { 1, 2 } };
    test t(c);
    std::cout << std::hash<test>()(t) << std::endl;
}