Hello Xarray devs,

Thanks for your work on this fantastic package. I'm a new user, and the subtleties of different data stores are unfamiliar to me. I got tripped up by the fact that Zarr stores are (silently) read-only, and I think it would be helpful if this were more prominent in the docstring or zarr section of the docs.

When I try to assign values to parts of a local Zarr-backed Dataset, I get a silent failure:

```python In [142]: ds = xr.open_zarr('tmp.zarr', chunks=None)

In [143]: selector = dict(time='2014-06-06T01:00:00', azimuth=0, frequency=0.0)

In [144]: ds['counts'].loc[selector].values Out[144]: array(4294967295, dtype=uint32)

try to assign a value here, like the example in the docs:

In [55]: ds['empty'].loc[dict(lon=260, lat=30)] = 100

In [145]: ds['counts'].loc[selector].values = 0

just get the same value back

In [146]: ds['counts'].loc[selector].values Out[146]: array(4294967295, dtype=uint32)

```

The answer seems to be buried in the open_zarr source code:

python ... # Zarr supports a wide range of access modes, but for now xarray either # reads or writes from a store, never both. For open_zarr, we only read mode = 'r' zarr_store = ZarrStore.open_group(store, mode=mode, synchronizer=synchronizer, group=group, consolidated=consolidated) ...

Expected Output

Assignment that follows the examples in the documentation.

1. I think that mentioning mode='r' in the open_zarr docstring would be the most helpful.
2. A description of this and the reasoning behind why zarr datasets are read-only would be helpful in the zarr section of the docs.
3. Optionally, a note in the indexing and assignment that not all store backends support assignment would also be helpful.

I'm happy to make a PR on 1 & 3, but I'm not familiar with the reasoning behind why stores are never mixed-mode.

Thanks again!

Output of xr.show_versions()

Currently the quantile method raises an exception when it encounters a Dask array.

python if isinstance(self.data, dask_array_type): raise TypeError( "quantile does not work for arrays stored as dask " "arrays. Load the data via .compute() or .load() " "prior to calling this method." ) I think it's because taking a quantile needs to see all the data in the dimension it's quantile-ing, or blocked/approximate methods weren't on hand when the feature was added. Dask arrays where the dimension being quantile-ed was exactly one chunk in extent seem like a special case where no blocked algorithm is needed.

The problem with following the suggestion of the exception (loading the array into memory) is that "wide and shallow" arrays are too big to load into memory, yet each chunk is statistically independent if the quantile dimension is the "shallow" dimension.

I'm not necessarily proposing delegating to Dask's quantile (unless it's super easy), but wanted to explore this special case described above.

Related links:
* https://github.com/pydata/xarray/issues/2999 * https://stackoverflow.com/a/47103407/745557

Thank you!

EDIT: added stackoverflow link