I need to write a map class which distinguishes read from writing using the subscripting notation, so I wrapped the std::map, forwarded all the typdefs and methods, except for operator[], like this template < class Key, class T, template < typename Core > class Access

struct my_map { typedef std :: map< Key, T > core_type; typedef Access< core_type > proxy_type;

typedef typename core_type :: key_type key_type; // ...lots of other stuff... proxy_type operator[]( const key_type & key ); }; where a typical 'Access' policy might be something like this. template < class T > struct proxy { typedef T map_type; typedef typename map_type :: key_type key_type; typedef typename map_type :: mapped_type mapped_type; proxy( map_type & core, const key_type & key ); proxy operator = ( const mapped_type & value ); operator mapped_type & ( ) const; }; Ok, all that broadly works, except expressions like my_map< string, string, proxy > m; if ( m[ "fred" ] == "bloggs" ).... won't compile even with a bool operator==(proxy, proxy), because the compiler can't figure out the implicit type conversions. What's needed is friend bool operator == ( proxy, const mapped_type & ); inside the proxy class, which does work. However I'd also like operator!=() to work in the same way, so I thought boost::operators, hence the declaration of proxy becomes template < class T > struct proxy : boost :: equality_comparable< proxy< T >, typename T :: mapped_type > { ... }; Which solves the problem. Now, the next twist is that I'd like to be able to compare my_map elements against any type which I can lexically convert to the mapped type, so an operator like friend template < class U > bool operator==( proxy, const U & ); but how do I express that to boost::equality_comparable, since the U type is generated by implicit instantiation, which applies to functions but not to classes? Thanks for reading. - Rob