@rabernat I can attend remotely.

uarray/unumpy is shaping up nicely. 😄

Let's move this discussion over to hameerabbasi/arrayish#1. But, in summary, I got the impression that the community in general is unhappy with the name "duck arrays".

I've written it up and already released version 0.0.1 on PyPI, except concatenate and stack (which need TypedSequence). I can still change the name, but I'd rather not.

Also, import duckarray as da conflicts with import dask.array as da.

I've created one, as per your e-mail: https://github.com/hameerabbasi/arrayish

The name is inspired from a recent discussion about this on the Numpy mailing list.

By minimal library, I'm assuming you mean something of the sort discussed about abstract arrays? What functionality would such a library have?

Maybe submit a PR? We could all use this. Does it support variable-length arguments?

Which really is totally fine -- this is all a stop gap measure until NumPy itself supports this sort of duck typing.

You're assuming here most users of XArray would be using a recent version of Numpy... Which is a totally fine assumption IMO. We make the same one for sparse.

However, consider that some people may be using something like conda, which (because of complex dependencies and all) may end up delaying updates (both for Numpy and XArray).

I guess however; if people really wanted the updates they could use pip.

so I'm not sure it's worth enshrining in multipledispatch either

I would say a little clean-up with some extra decorators for exactly this purpose may be in order, that way, individual wrapping functions aren't needed.

Something like @starargswrapper that would just cast to list, and call the VarArgs version.

Actually it'd be nice to have something like @dispatch(int, str, StarArgs[int]).

@llllllllll How hard would it be to make this work for star-args? I realize you could just add an extra wrapper but it'd be nice if you didn't have to.

Is there a way to handle kwargs (not with types, but ignoring them)?

This might even help us out in Sparse for dispatch with scipy.sparse.spmatrix, numpy.ndarray, etc.

Another benefit to this would be that if XArray didn't want to support a particular library in its own code, the library itself could add the hooks.

How about something like checking inside a list if something is top priority, then call a, if second priority, call b, etc.

Can't some wild metaprogramming make it so that [1.0, 'foo'] itself is an instance of VarArgs[float, str] (or be converted?)

Then I would suggest something like the following for hooks (omitting imports):

```python

Registered in order of priority

xarray.interfaces.register('DaskArray', lambda ar: isinstance(ar, da.array)) xarray.hooks.register('nansum', 'DaskArray', da.nansum)

xarray.interfaces.register('SparseArray', lambda ar: isinstance(ar, sparse.SparseArray)) xarray.hooks.register('nansum', 'SparseArray', sparse.nansum) ```

And then, in code, call the appropriate nansum instead of np.nansum:

python nansum = xarray.hooks.get(arr, 'nansum')

If you need help, I'd be willing to give it. :-) But I'm not a user of XArray, so I don't really understand the use-cases or codebase.