'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 both are different parts of
a `~astropy.coordinates.SphericalDifferential` (e.g., a
`~astropy.coordinates.UnitSphericalDifferential` and a
`~astropy.coordinates.RadialDifferential`), they will combined
appropriately.
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(other, BaseSphericalDifferential) and (not isinstance(self, type(other)))) or isinstance(other, RadialDifferential)):
        all_components = (set(self.components) | set(other.components))
        (first, second) = ((self, other) if (not reverse) else (other, self))
        result_args = {c: op(getattr(first, c, 0.0), getattr(second, c, 0.0)) for c in all_components}
        return SphericalDifferential(**result_args)
    return super(BaseSphericalDifferential, self)._combine_operation(op, other, reverse)
