It would be neat if it did produce a view, but right now this produces a copy not a view, right?

This particular example produces a copy, because even before this PR a copy was unavoidable.

However, it was actually your suggestion to rework the code so structured_to_unstructured returns a view in many cases, for instance structured_to_unstructured(arr[['f1', 'f2', 'f3']], dtype='float64') actually makes no copies.

This sentence should be reworked to avoid the word view though...

for instance structured_to_unstructured(arr[['f1', 'f2', 'f3']], dtype='float64') actually makes no copies.

Is that a statement about what actually happens in master, or just what I was suggesting?

I was proposing something stronger, where the following would also produce a view:

• structured_to_unstructured(arr[['f1', 'f3']], dtype='float64')
• structured_to_unstructured(arr[['f3', 'f1']], dtype='float64')
• structured_to_unstructured(arr[['f3', 'f2', 'f1']], dtype='float64')

For clarity, let's say we're dealing with the array arr = np.ones(3, dtype='f8,f8,f8'). Then arr[['f0', 'f2']] returns a 24-byte structured array where each element is organized as FxF where F is 8 bytes of float memory, and x is 8 bytes of padding. The 3-element array as a whole is FxFFxFFxF (72 bytes).

Is it possible to view this as an unstructured float64 array with the right stride? I suppose this particular 3-field array might be viewed with shape (3, 2) and stride (24, 16). np.ndarray((3,2), strides=(24, 16), dtype='f8', buffer=arr) works.

But it seems it would be quite an involved computation to determine more generally whether appropriate strides exist, given arbitrary field offsets. Fo three fields it is always possible, but with 4 fields it is not, eg np.ones(3, 'f8,f8,f8,f8')[['f0', 'f1, 'f3']] cannot be viewed as an unstructured array.

My feeling is it's too difficult to do the calculation generally, it needs some complex gcd computation.

Fo three fields it is always possible

Not if they're not contiguous. You're right that it's only possible in some special cases - but reshape can only avoid copies in some special cases, and we decided that was worth doing - so it might also be worthwhile here

But it seems it would be quite an involved computation to determine more generally whether appropriate strides exist, given arbitrary field offsets

The computation is straightforward - pseudo-code:

if len(offsets) == 0:
    stride = 0
    offset = 0
elif len(offsets) == 1:
    stride = 0
    offset = offsets[0]
else:
    offset = offsets[0]
    stride = offsets[1] - offsets[0]
    for i, o in enumerate(offsets[2:],2):
        if o != offset + stride * i:
            raise NotViewable
return offset, stride

Which should give enough information to be passed to as_strided somehow

That should work, indeed. I would have to mostly rewrite structured_to_unstructured to account for it, and it seems like not enough of a good enough cost/benefit ratio for the effort, to me. I'd rather leave that to a separate PR if it's desired.

As long as the contract of structured_to_unstructured allows us to make that change in a later release, I'm fine with not doing it now