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