C++ limiting a method for an rvalue caller, an expression evaluator example
I had a bunch of sections detailing the various aspects of your design that could be improved, but I ended up scrapping most of it, because at the end of the day, it can be resumed in two specific things:

But first: The idea of forcing RValues here is severely misguided. Forcing RValue usage should be limited to cases where things would break otherwise, not to enforce coding practices. What if someone wants to create a complex sub-expression and reuse it a few times? Tough luck!

1. Expression as a wrapper is misguided.

I do not like wrappers that exist just for the sake of giving value semantics to something. Value vs reference semantics should be delegated to the user as much as humanly possible as long as type erasure is not invovled. Specifically, someone will inevitably write std::unique_ptr&lt;Expression&gt; at some point in the future.

2. This is unjustifiably complicated.

You can obtain the same functionallity with bog-standard code, no need to get fancy. The trick is to separate the Sum() function in the API from the Sum type in the implementation.

class Expression {
public:
  virtual ~Expression() {};
  virtual std::unique_ptr&lt;Expression&gt; clone() const = 0;
};

class SumExpr : public Expression {
  std::unique_ptr&lt;Expression&gt; e1_;
  std::unique_ptr&lt;Expression&gt; e2_;
public:
  SumExpr(std::unique_ptr&lt;Expression&gt; e1, 
          std::unique_ptr&lt;Expression&gt; e2)
    : e1_(std::move(e1))
    , e1_(std::move(e2)) {}

  std::unique_ptr&lt;Expression&gt; clone() override {
    return std::make_unique&lt;SumExpr&gt;(e1-&gt;clone(), e2-&gt;clone());
  }
};

std::unique_ptr&lt;Sum&gt; Sum(std::unique_ptr&lt;Expression&gt; e1,
                         std::unique_ptr&lt;Expression&gt; e2) {
  return std::make_unique&lt;SumExpr&gt;(std::move(e1), std::move(e2));
}


Note that is is not "quite" how I'd go about implementing this, but this way matches your current functionality.

Bonus: Implement printing to ostream as operator &lt;&lt;

It's a shame that operator&lt;&lt;(std::ostream&amp;, Sum const&amp;) is not implemented. print() should delegate to it ideally, so that stream &lt;&lt; Sum()...; can work

Now, at first glance, it would seem that this would require some really annoying boilerplate, but you can get around that using some crafty CRTP:

class Expression {
public:
  virtual std::ostream&amp; print(std::ostream&amp;) const = 0;
};

template&lt;typename CRTP_T&gt;
class ExpressionImpl : public Expression {
  std::ostream&amp; print(std::ostream&amp; stream) const override {
    return stream &lt;&lt; *static_cast&lt;CRTP_T const*&gt;(this);
  }
};

class Sum : public ExpressionImpl&lt;Sum&gt; {
  friend std::ostream&amp; operator&lt;&lt;(std::ostream&amp;, Sum const&amp;) {
    ...
  }
};


As an exercise to the reader, you can similarly create a BinaryExpression&lt;CRTP_T&gt; to avoid having to reimplement the clone() function in every single leaf class.