comma overload semantics

the following compiles unless the first line is uncommented .
when I try to uncomment the first line I get:

error : 'B &FM::operator ,(FM::mystruct<A>,B &)' : could not deduce
template argument for 'FM::mystruct<A>' from
'std::basic_string<_Elem,_Traits,_Ax>::_Myt'
        with
        [
            _Elem=char,
            _Traits=std::char_traits<char>,
            _Ax=std::allocator<char>
        ]

As long as 'mystruct' is a normal struct no error occures,but there is
some trouble with template version.

error refers to to the 'assign' method of
'std::basic_string<_Elem,_Traits,_Ax>' :

    _Myt& assign(const _Myt& _Right, size_type _Roff, size_type _Count)
        { // assign _Right [_Roff, _Roff + _Count)
        ...//some code here
        if (this == &_Right)
            erase((size_type)(_Roff + _Num)), erase(0, _Roff);// substring
        ...//some code here
        }

I am confused since 'mystruct' does not declare any ctors and normally
the compiler should not try to cast anything to it . So, after failure
to find the appropriate overload , the default version must be used .
Is there any problem with my compiler or I have to declare a default
version? I mean some thing like this:

template <typename A, typename B>
inline B& operator,(A &,B& b){return b;};//default comma in global
namespace

Is there any restriction on overloading comma?
What are the semantics for overloading comma?

//#define uncomment
#include <iostream>

#ifdef uncomment/*template version of mystruct*/
# define BiTemplate(A,B) template < typename A ,typename B >
# define UnoTemplate(A) template < typename A >
# define With(A) < A >
#else/*none template version of mystruct: ignore A .*/
# define BiTemplate(A,B) template < typename B >
# define UnoTemplate(A)
# define With(A)
#endif

namespace FM{

    UnoTemplate(A)
    struct mystruct{
    };

    BiTemplate(A,B)
        B& operator,(mystruct With(A) ,B& i){return i;};

};
using namespace FM;

void main(void){};//just do nothing

Thanks in advance,
FM.