#include <iostream>

struct property0 {};
struct property1 {};
struct property2 {};

template<typename type>
property0 get_prop(type*);

char id(property0);
char (&id(property1))[2];
char (&id(property2))[3];

template<size_t s> struct _impl;
template<> struct _impl<1> { typedef property0 type; };
template<> struct _impl<2> { typedef property1 type; };
template<> struct _impl<3> { typedef property2 type; };

template<typename t>
struct prop
{
  typedef typename _impl<sizeof(id(get_prop((t*)(42))))>::type type;
};

template<typename type, typename property = typename prop<type>::type>
struct expression
{
  friend property get_prop(type*) { return property(); }
};

struct s : public expression<s>
{};

struct s1 : public expression<s1, property1>
{};

struct s2 : public expression<s2, property2>
{};

template<typename type>
void foo(const expression<type>&)
{
  typedef typename prop<type>::type associated_property;
  std::cout << "foo: " << typeid(associated_property).name() << "\n";
  return;
}

template<typename type>
void bar(const expression<type, property2>&)
{}

int main()
{
  foo(s());
  foo(s1());
  foo(s2());
  //bar(s());  //should not compile
  //bar(s1());  //should not compile
  bar(s2());
  return 0;
}