'Combine two differentials, or a differential with a representation.
If ``other`` is of the same differential type as ``self``, the
components will simply be combined.  If ``other`` is a representation,
it will be used as a base for which to evaluate the differential,
and the result is a new representation.
Parameters
op : `~operator` callable
Operator to apply (e.g., `~operator.add`, `~operator.sub`, etc.
other : `~astropy.coordinates.BaseRepresentation` instance
The other differential or representation.
reverse : bool
Whether the operands should be reversed (e.g., as we got here via
``self.__rsub__`` because ``self`` is a subclass of ``other``).'

def _combine_operation(self, op, other, reverse=False):

    if isinstance(self, type(other)):
        (first, second) = ((self, other) if (not reverse) else (other, self))
        return self.__class__(*[op(getattr(first, c), getattr(second, c)) for c in self.components])
    else:
        try:
            self_cartesian = self.to_cartesian(other)
        except TypeError:
            return NotImplemented
        return other._combine_operation(op, self_cartesian, (not reverse))
