Context

By using copy(deep=False) custom operations may avoid copying large amounts of data but can modify, e.g., coord dicts:

```python tmp = da.copy(deep=False) del tmp.coords['abc']

Use tmp

`` Whenda` wraps a duck-array with substructure the current implementation is insufficient:

```python tmp = da.copy(deep=False)

Imagine a duck-array similar to numpy.ma but with a dict of masks

del tmp.data.masks['abc'] # Bad: breaks da

Use tmp

```

Describe the solution you'd like

Currently there does not appear a solution to this, unless we know details about the duck array. Therefore, I wonder if we need an additional "hook" that duck-arrays may provide, which could be called by Xarray to make a non-deep copy?

python class MyDuckArray: def _copy_shallow_(self): # TODO: better name """Copy everything except buffers"""

```python

in xarray.Variable

def copy(self, deep=True): if deep: data = copy.deepcopy(data) elif hasattr(data, 'copy_shallow'): data = data.copy_shallow() ```

Additional context

This is the current implementation for Variable. There is no operation for deep=False: https://github.com/pydata/xarray/blob/716973e41060184beebd64935afe196a805ef481/xarray/core/variable.py#L956-L957

This is an idea and meant as a discussion starter on an potential route to providing support for physical units and propagation of uncertainties for xarray.

Context

1. NEP 18 (which, as far as I understand, was pushed by you guys, for similar purposes) provides means to combine such features with xarray using __array_function__, if the underlying array implementation supports it.

2. I am working on scipp, which (based on a decision I may or may not regret in the future) is reimplementing a lot of features that xarray provides, plus some additional features. Two of these features are physical units and propagation of uncertainties.

3. scipp.Variable is essentially equivalent to a numpy array with a unit, dimension labels, and an optional array of uncertainties. [*]

4. scipp implements basic arithmetic operations (and some more) for scipp.Variable, including efficient propagation of uncertainties.

[] Caveat: scipp's current unit implementation is static an would probably need to be replaced for becoming useful for a wider audience.*

Idea and questions

Can we implement the __array_function__ protocol for scipp.Variable so it can be used with xarray? As far as I can tell this would simply be a lightweight wrapper.

• Did I understand __array_function__ correctly?
• Is there anything else I should be aware of?
• Would anyone be interested in this?

This would amount to using the lower-level parts of scipp which is quite compact and can be extended to support more data types and more operations in a relatively simple manner (requiring recompilation, since it is written in C++).