Operator overload playground

operators.hpp

#include <iostream>
#include <type_traits>

template <typename T>
struct is_expression : std::false_type {};

template <typename T, typename R = T>
using expression_enable = typename std::enable_if<
  is_expression<T>::value, R
>::type;

struct identifier_expression
{
    char const *name;
    void print(std::ostream &os) { os << name; }
};
template <>
struct is_expression<identifier_expression> : std::true_type {};

template <typename L, typename R, typename Op>
struct binary_expression
{
    L l;
    R r;
    Op op;
    void print(std::ostream &os)
    {
      // TODO: precedence
      os << "(";
      l.print(os);
      op.print(os);
      r.print(os);
      os << ")";
    }
};
template <typename L, typename R, typename Op>
struct is_expression<binary_expression<L, R, Op>> : std::true_type {};

#define BINARY_OPERATOR(OPCHARS, OPNAME)    \
struct OPNAME                               \
{                                           \
  void print(std::ostream &os)              \
  {                                         \
    os << #OPCHARS;                         \
  }                                         \
};                                          \
                                            \
template <typename L, typename R>           \
expression_enable<L,                        \
  expression_enable<R,                      \
    binary_expression<L, R, OPNAME>         \
  >                                         \
>                                           \
operator OPCHARS(L l, R r)                  \
{                                           \
  return { l, r, OPNAME{} };                \
}

BINARY_OPERATOR(-, sub);
BINARY_OPERATOR(+, add);
BINARY_OPERATOR(<<, lshift);
BINARY_OPERATOR(>>, rshift);
// TODO others
// TODO unary

use.cpp

#include "operators.hpp"
#include <iostream>

int main()
{
    identifier_expression a = {"a"}, b = {"b"}, c = {"c"}, d = {"d"}, e = {"e"};
    (a + b + c + d + e).print(std::cout << std::endl);
    (a << b + c << d + e).print(std::cout << std::endl);
    (a << b >> c - d + e).print(std::cout << std::endl);
}