issue_comments

How about we call compute in assert_allclose for boolean dask arrays when dask < 2.9.1? This bit can then be removed in a couple of months.

This compute was happening in previous versions anyway (because assert_allclose was using .values) so this would not be a regression.

Would it make sense to wait until we can bump the dask version to 2.9?

Sounds good to me. It's only 1.5 months away

this comment: # Numpy < 1.13 does not handle object-type array. suggests that this code needs to be updated for our new numpy>=1.15 requirement

example failure: ``` ___ test_reduce[None-True-var-True-bool_-1] ______

dim_num = 1, dtype = <class 'numpy.bool_'>, dask = True, func = 'var' skipna = True, aggdim = None

@pytest.mark.parametrize("dim_num", [1, 2])
@pytest.mark.parametrize("dtype", [float, int, np.float32, np.bool_])
@pytest.mark.parametrize("dask", [False, True])
@pytest.mark.parametrize("func", ["sum", "min", "max", "mean", "var"])
# TODO test cumsum, cumprod
@pytest.mark.parametrize("skipna", [False, True])
@pytest.mark.parametrize("aggdim", [None, "x"])
def test_reduce(dim_num, dtype, dask, func, skipna, aggdim):

    if aggdim == "y" and dim_num < 2:
        pytest.skip("dim not in this test")

    if dtype == np.bool_ and func == "mean":
        pytest.skip("numpy does not support this")

    if dask and not has_dask:
        pytest.skip("requires dask")

    if dask and skipna is False and dtype in [np.bool_]:
        pytest.skip("dask does not compute object-typed array")

    rtol = 1e-04 if dtype == np.float32 else 1e-05

    da = construct_dataarray(dim_num, dtype, contains_nan=True, dask=dask)
    axis = None if aggdim is None else da.get_axis_num(aggdim)

    # TODO: remove these after resolving
    # https://github.com/dask/dask/issues/3245
    with warnings.catch_warnings():
        warnings.filterwarnings("ignore", "Mean of empty slice")
        warnings.filterwarnings("ignore", "All-NaN slice")
        warnings.filterwarnings("ignore", "invalid value encountered in")

        if da.dtype.kind == "O" and skipna:
            # Numpy < 1.13 does not handle object-type array.
            try:
                if skipna:
                    expected = getattr(np, f"nan{func}")(da.values, axis=axis)
                else:
                    expected = getattr(np, func)(da.values, axis=axis)

                actual = getattr(da, func)(skipna=skipna, dim=aggdim)
                assert_dask_array(actual, dask)
                assert np.allclose(
                    actual.values, np.array(expected), rtol=1.0e-4, equal_nan=True
                )
            except (TypeError, AttributeError, ZeroDivisionError):
                # TODO currently, numpy does not support some methods such as
                "casting='same_kind'"

              % (funcname(function), str(dtype), str(result.dtype))
            )

E ValueError: Inferred dtype from function 'sub' was 'int64' but got 'float64', which can't be cast using casting='same_kind' ```

I'm confused here. What did you change to trigger this error?

ALL WRONG: ~We could call arr1.compute(), arr2.compute() in https://github.com/pydata/xarray/blob/69548df9826cde9df6cbdae9c033c9fb1e62d493/xarray/core/duck_array_ops.py#L203-L204~

~At that point, we need to compare actual values. I'm not sure that dask exits all() early if one chunk evaluates to False ( in which case this change would be a performance regression)~

EDIT: ignore this. We can't compute because it might blow memory.

Our minimum versions policy allows us to bump dask. So let's do that? dask 2.2 (2019-08-01) 2.5 (2019-09-27) < distributed 2.2 (2019-08-01) 2.5 (2019-09-27) <

Also, where should I put the whats-new.rst entry?

New features? It is public API and is a very nice enhancement.

Let's mark those as xfail then?