issue_comments

Yes, I do think this deviation from pandas would make sense -- though it would be even better if we could convince pandas to make the same change!

We already have low-level tools for controlling how alignment works (construct the index yourself and use .reindex), but we should make the default behavior as user friendly as possible.

From a user perspective, I think it's plain weird to merge a bunch of datasets with montonically decreasing coordinates and land up with a new dataset that has monotonically increasing coordinates.

I'm definitely not convinced it's a great idea either; a pull request is hopefully the best way to get some discussion going! Putting it in the _get_joiner is definitely the sensible choice, and the last suggestion is definitely more clear to me.

I've had a bit more thought and maybe it's useful to consider what xarray's philosophy about these things is. I think flexibility is a primary concern and generally, things *just work*. The reason I'm running into issues here is because I'm writing some code which operates on DataArrays, which isn't nearly as robust or flexible, and doesn't just work.

The answer in this case might be that I should be using xarray's powerful alignment machinery to do the work for me, rather than to assume/demand certain features of the data. Of course, that requires some digging into how xarray does alignment. But I'd end up with a more flexible tool in the end.

Perhaps that should be the general rule: if you're extending xarray, like xarray, don't rely too much about your coordinates staying the way they are. Maybe such a description could belong in the xarray Internals page just to make it explicit.

I'm not entirely sure this is a good idea -- a discrepancy in the behavior of an outer join between pandas seems non-ideal. Perhaps somebody else has opinions about whether this would be worthwhile?

If we do want to do this, let's put the change inside the _get_joiner function. Specifically, instead of python def _get_joiner(join): if join == 'outer': return functools.partial(functools.reduce, operator.or_) you could write something like: ```python def outer_join(indexes): index = functools.reduce(indexes, operator.or) # your logic for reverse sorting the result return index

def _get_joiner(join): if join == 'outer': return _outer_join ```

Note that operator.or_ on a pandas.Index is the same thing as pandas.Index.union, so this could be equivalently written (maybe more clearly) as: python def _outer_join(indexes): index = indexes[0] for other in indexes[1:] index = index.union(other) # your logic for reverse sorting the result return index