issue_comments

Thank you v much @jsignell ! Both for the excellent code and for bearing with the changes!

If we're all happy with copy (which I think we are), then this should be good to go!

Is this good to go?

I added some examples on copy for each of the object types and I decided to let Datasets do this too. I just require that the user pass a dict where keys are contained in data_vars and each value has the same shape as the corresponding data_var.

template.copy(data=new_data)? That seems pretty clear, actually.

how about + dataarray_like / variable_like + copy_labels ?

Sorry I'm late to the party here. @jsignell thank you for the PR!

Pandas has something similar: the ._shallow_copy method, which accepts optional data to replace the current data.

Ambitious suggestion: given that we already create shallow copies when copying, could data become an optional arg to copy? I realize it's may be a little surprising to change all the data and still call it a copy, but there's precedent.

Less ambitious: I'd vote to have this as a method. I'm generally partial to methods given their discoverability and namespaces-without-cost. I think the context is clear. OTOH there is precedent with ones_like et al.

Naming: I'd vote labelled_like > structured_like, but not strongly

That said, given my timing, I'd understand if we go forward as-is

I made the docs changes and added an example.

I think this is good to merge

👍 for xarray.structured_like(new_data, template)

More ideas: - xarray.copy_structure(template, new_data) - xarray.structured_like(new_data, template) - xarray.copy_labels(template, new_data)

That said. I think with_data is better than anything replace. I would worry about confusion with the pandas replace which replaces specific values.

I don't like it being a method on an existing object. I think the syntax is clearer if the template object is an argument and the second argument is the data. I think that conveys the concept of creating a new object that is just using the structure of another object.

What about a DataArray method called replace_data or with_data? e.g., data_array.replace_data(new_data) or data_array.with_data(new_data).

We could also make a more general DataArray.replace method (inspired by collections.namedtuple._replace) that lets you replace any of data, coords, dims, attrs or encoding on a top object. Then this would look like data_array.replace(new_data) or data_array.replace(attrs=new_attrs). Replacing name or dims could invoke the rename() method.

Or what about xr.DataArray.like and xr.Variable.like? My main worry is that it kind of feels like these should return bools. Another option would be xr.DataArray.from_dataarray and xr.Variable.from_variable, but that is maybe also confusing...

LGTM. I'm not a big fan of the name though, but I can't think of a better one. I wonder if we should have dataarray_like and variable_like that call _label_like.

Also, this needs additions to whats-new.rst and api.rst.

Any thoughts on this one?