issues

xref https://github.com/pandas-dev/pandas/issues/10259

Presumably deferring to the semantics of np.matmul - not sure if that API is stable yet?

It may be nice to take advantage of labels to show a different, labeled repr - especially for more than 3 dimensions, I personally find the the numpy array one hard to read.

Some sample data and the current repr

``` python

In [103]: d = xr.DataArray(np.arange(200).reshape((2,5,2,10)), dims=('a', 'b', 'c', 'd'), ...: coords={'a': ['A', 'B'], 'b': ['Cat 1', 'Cat 2', 'Cat 3', 'Cat 4', 'Cat 5'], ...: 'c': ['J', 'K']})

In [104]: d Out[104]: <xarray.DataArray (a: 2, b: 5, c: 2, d: 10)> array([[[[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]],

    [[ 20,  21,  22,  23,  24,  25,  26,  27,  28,  29],
     [ 30,  31,  32,  33,  34,  35,  36,  37,  38,  39]],

    [[ 40,  41,  42,  43,  44,  45,  46,  47,  48,  49],
     [ 50,  51,  52,  53,  54,  55,  56,  57,  58,  59]],

    [[ 60,  61,  62,  63,  64,  65,  66,  67,  68,  69],
     [ 70,  71,  72,  73,  74,  75,  76,  77,  78,  79]],

    [[ 80,  81,  82,  83,  84,  85,  86,  87,  88,  89],
     [ 90,  91,  92,  93,  94,  95,  96,  97,  98,  99]]],


   [[[100, 101, 102, 103, 104, 105, 106, 107, 108, 109],
     [110, 111, 112, 113, 114, 115, 116, 117, 118, 119]],

    [[120, 121, 122, 123, 124, 125, 126, 127, 128, 129],
     [130, 131, 132, 133, 134, 135, 136, 137, 138, 139]],

    [[140, 141, 142, 143, 144, 145, 146, 147, 148, 149],
     [150, 151, 152, 153, 154, 155, 156, 157, 158, 159]],

    [[160, 161, 162, 163, 164, 165, 166, 167, 168, 169],
     [170, 171, 172, 173, 174, 175, 176, 177, 178, 179]],

    [[180, 181, 182, 183, 184, 185, 186, 187, 188, 189],
     [190, 191, 192, 193, 194, 195, 196, 197, 198, 199]]]])

Coordinates: * a (a) <U1 'A' 'B' * b (b) <U5 'Cat 1' 'Cat 2' 'Cat 3' 'Cat 4' 'Cat 5' * c (c) <U1 'J' 'K' * d (d) int64 0 1 2 3 4 5 6 7 8 9

```

The labeled repr could instead look something (not exactly) like this?

``` <xarray.DataArray (a: 2, b: 5, c: 2, d: 10)>

a: 'A' b: 'Cat 1' c x d: 0 2 3 4 5 6 7 8 9 10 J 0 1 2 3 4 5 6 7 8 9 K 10 11 12 13 14 15 16 17 18 19

a: 'A' b: 'Cat 2' c x d <repeat> ...

Coordinates: * a (a) <U1 'A' 'B' * b (b) <U5 'Cat 1' 'Cat 2' 'Cat 3' 'Cat 4' 'Cat 5' * c (c) <U1 'J' 'K' * d (d) int64 0 1 2 3 4 5 6 7 8 9 ```

closes #1054

Usecase - I have a DataArray that will be passed into a numba function and need to pass in some slices. Very simplified example:

``` python from numba import njit @njit def f(arr, slc1, slc2): return arr[slc1].max() - arr[slc2].min()

da = xr.DataArray([1., 2., 3.], coords={'key': ['a', 'b', 'c']}) ```

Right now I'm accessing the underlying indexes to get slices, like so:

``` python f(da.values, da.indexes['key'].slice_indexer('a', 'b'), da.indexes['key'].slice_indexer('c', 'c'))

Out[52]: -1.0 ```

First question, am I missing some obviously better way to do this? Of course in this example I could just pass in sliced values, but in my actual usecase the data has higher dimensions and I use the slice multiple times across multiple arrays.

More broadly, should the underlying indexes be thought of as an implementation detail (e.g. could be swapped out with something else) or is it more-or-less an API guarantee that I'll get a pandas Index here?