#include <iostream>
using std::cout;
using std::endl;

namespace tag {
struct storage {};
template<int c> struct expression {};
}//namespace tag

template<typename tag>
struct tag_complexity { enum { value = 0 }; };
template<int c>
struct tag_complexity<tag::expression<c> > { enum { value = c }; };

struct general {};
struct shapeX {};

template<typename expr_t, typename tag_t, typename shape = general>
struct expression : public expression<expr_t, tag::expression<tag_complexity<tag_t>::value>, general>
{};
template<typename expr_t, typename tag_t>
struct expression<expr_t, tag_t, general>
{};

struct too : public expression<too, tag::storage>
{};

struct gives : public expression<gives, tag::storage, shapeX>
{};

template<typename expr_t, typename tag>
void foo(const expression<expr_t, tag, general> &a)
{ cout << "foo reports\n " << typeid(a).name() << "\n\n"; return; }

template<typename expression_type> struct subexpression;
template<typename expr_t, typename tag_t, typename shape>
struct subexpression<expression<expr_t, tag_t, shape> > :
	public expression<subexpression<expression<expr_t, tag_t, shape> >,
					  tag::expression<tag_complexity<tag_t>::value>,
					  shape
					  >
{
	subexpression(const expr_t&) {}
};

template<typename expr_t, typename tag, typename shape> inline
subexpression<expression<expr_t, tag, shape> >
bar(const expression<expr_t, tag, shape> &a)
{
	cout << "bar reports\n " << typeid(a).name() << "\n\n";
	return static_cast<const expr_t&>(a);
}

int  main()
{
	{
		too trivial;
		foo(trivial);
		foo(bar(trivial));
	}
	{
		gives error;

		foo(error);	//comment this line in order to compile
		/*msvc 77626-009-0000007-41564 (ide msvs 8.0.50727.762(sp050727-7600))
		can not deduce 'tag' template argument
		hierarchy for class 'gives' looks like
			expression<gives, tag::expression<0>, general>
			^
			expression<gives, tag::storage, shapeX>
			^
			gives
		so template arguments should obviously be deduced as*/
		foo<gives, tag::expression<0> >(error);

		foo(bar(error));	//comment this line in order to compile
		foo(
		/*icc 11.0.066 can not match an instance of bar() with 'error'
		given hierarchy for 'gives' class
		template arguments for bar() should be deduced at least as*/
		bar<gives, tag::storage, shapeX>(error)
		);//foo(
	}
	return 0;
}