Is overloading systematically for r-value references a good pattern? - c++11

Question

I have a class that behaves very similar to (the C++11 version of) std::ostream, to which I can stream many different (unrelated) types.
class mystream{...some implementation...};
The typical function to define is
mystream& operator<<(mystream& ms, type1 const& t1){...}
mystream& operator<<(mystream& ms, type2 const& t2){...}
etc.
However, (just like with C++11's stream) I would like to stream-on-construction. For example:
mystream{} << t1;
To be able to do this, I overload on l-value references, for each type:
mystream& operator<<(mystream&& ms, type1 const& t1){
return ms << t1; // this calls the l-value version
}
The code is not complicated, but it is repetitive because I have to do it for all types involved. Because of the nature of this class it makes sense to use on references and l-value references.
The question is if this is the correct approach? Should I write two functions for each type? Is this a good pattern?
Secondary question: Of course I could do some some template magic to accept l-value references when appropriate but again I don't know if this is the recommended path.
Ternary question: Should the function return mystream& (like above) or mystream&&.
This is the example code:
class A{};
class B{};
class mystream{};
mystream& operator<<(mystream& ms, A const& a){return ms;} // (1)
mystream& operator<<(mystream& ms, B const& b){return ms;} // (2)
mystream& operator<<(mystream&& ms, A const& a){return ms; /*ms << a;*/} // (3)
mystream& operator<<(mystream&& ms, B const& b){return ms; /*ms << a;*/} // (4)
int main(){
mystream ms;
ms << A{};
ms << B{};
mystream{} << A{}; // ok only if line (3) is defined
mystream{} << B{}; // ok only if line (4) is defined
}
If I comment line (3) the error message is
fatal error: invalid operands to binary expression ('mystream' and 'A')
mystream{} << A{}; // ok only if line (3) is defined
~~~~~~~~~~ ^ ~~~
././random.hpp:146:11: note: candidate function not viable: expects an l-value for 1st argument
mystream& operator<<(mystream& ms, A const& a){return ms;} // (1)
If I comment line (1) the converse happens
fatal error: invalid operands to binary expression ('mystream' and 'A')
ms << A{};
~~ ^ ~~~
././random.hpp:149:11: note: candidate function not viable: no known conversion from 'mystream' to 'mystream &&' for 1st argument
mystream& operator<<(mystream&& ms, A const& a){return ms; /*ms << a;*/} // (3)

Answer 1

C++ defines a single function template that takes an ostream rvalue reference:
template< class CharT, class Traits, class T >
basic_ostream< CharT, Traits >& operator<<( basic_ostream<CharT,Traits>&& os,
const T& value );
It calls an appropriate insertion operator. Accordingly, you should only define
template <typename X>
mystream& operator<< (mystream&& ms, const X& x)
{
ms << x;
return ms;
}