#include <boost/mpl/print.hpp>

namespace mpl = boost::mpl;

#include <utility>
#include <cassert>
#include <boost/type_erasure/any.hpp>
#include <boost/type_erasure/any_cast.hpp>
#include <boost/type_erasure/builtin.hpp>
#include <boost/type_erasure/concept_interface.hpp>
#include <boost/type_erasure/rebind_any.hpp>
#include <boost/type_erasure/operators.hpp>
#include <boost/type_erasure/deduced.hpp>

#include <vector>


using namespace boost::type_erasure;


//#define FOO_RETURNS_PAIR


template<class TIterator, class C=_self>
struct foo_concept
{
#ifdef FOO_RETURNS_PAIR
	typedef std::pair<TIterator, TIterator> result_type;
	static result_type apply(C& c) { return std::make_pair(c.begin(),c.end()); }
#else
	typedef TIterator result_type;
	static result_type apply(C& c) { return c.begin(); }
#endif
};


/*namespace boost {
namespace type_erasure {

	template<class C, class TIterator, class Base>
	struct concept_interface< ::foo_concept<TIterator, C>, Base, C> : Base
	{
		typedef typename rebind_any<Base, TIterator>::type iterator;

#ifdef FOO_RETURNS_PAIR
		std::pair<iterator, iterator> foo()
#else
		iterator foo()
#endif
		{ return call(::foo_concept<TFirst, C>(), *this); }
	};

}
}*/

template <typename C>
struct container_iterator_impl
{
	typedef typename C::iterator type;
};

template <typename C>
struct container_iterator
{
	typedef typename mpl::eval_if<
		is_placeholder<C>
		, void*
		, container_iterator_impl<C>
	>::type type;
};


struct _iterator : public placeholder {};


template <class C=_self>
struct something_with_begin
	: public mpl::vector<
		relaxed_match
		, same_type<deduced< container_iterator<C> >, _iterator>
		, foo_concept<_iterator, C>
		//, constructible<C()>
		//, destructible<C>
		, copy_constructible<C>
//		, copy_constructible<_b>
//		, typeid_<_b>
	>
{
};




int main(int argc, char* argv[])
{
	typedef any<something_with_begin<> >
		anything_with_begin;

	std::vector<int> v;

	anything_with_begin c(v);

	return 0;
}