Take non-contiguous slices

[multimeric]

Let's say I have a 4x4 array and I want to take rows 0, 1, and 3, and columns 0, 1, and 3.

let arr = array![
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
    [13, 14, 15, 16]
]

I can't use slice() here, because slice only takes ranges and single indices:

arr.slice(s![[0, 1, 3], [0, 1, 3]]);

             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `SliceNextDim` is not implemented for `[{integer}; 3]`
the trait bound `[{integer}; 3]: SliceNextDim` is not satisfied
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `SliceNextDim` is not implemented for `[{integer}; 3]`
the trait bound `[{integer}; 3]: SliceNextDim` is not satisfied
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `SliceNextDim` is not implemented for `[{integer}; 3]`
the trait bound `[{integer}; 3]: SliceNextDim` is not satisfied
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `SliceNextDim` is not implemented for `[{integer}; 3]`
the trait bound `[{integer}; 3]: SliceNextDim` is not satisfied
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `From<[{integer}; 3]>` is not implemented for `SliceInfoElem`
the trait bound `SliceInfoElem: From<[{integer}; 3]>` is not satisfied

I can use select(), but since I want to slice along two different axes, this will copy the array twice instead of once:

arr.select(Axis(0), [1, 2, 4]).select(Axis(1), [1, 2, 4]);

[[1, 2, 4],
 [5, 6, 8],
 [13, 14, 16]], shape=[3, 3], strides=[1, 3], layout=Ff (0xa), const ndim=2

Is there a better way to do this?

My ideal would be a way to not have to copy the array at all, and just have a view of the array that excludes this row/column index. If the view machinery can't support this (which would be a bit surprising considering it supports slicing with ranges with arbitrary steps), then the next best solution would be a multi-dimensional select() method that lets me do this all in one step.

[bluss]

ArrayView does not support representing that subset as one view, since it works by using one size and one stride per axis (the subset cannot be described that way). What's wanted is called "fancy indexing" sometimes and it makes sense. The question is what a useful and general interface to it would look like in Rust.

[multimeric]

Thanks for the answer. I could see some kind of "copy slice" method, with the assumption that it returns a new array, unlike the regular slice. Then we define a new kind of slice object that accepts ranges, or lists.

So something like:

impl ArrayBase<A, D> {
    fn copy_slice(slice: Into<CopySliceInfo>) -> Self {}
}

struct CopySliceInfo {}

struct CopySliceInfoElem {
    indices: [usize]
}

impl CopySliceInfoElem{
    fn new<A: Iterable>(iterable: A){
        CopySliceInfoElem {
            indices: iterable.collect()
        };
    }
}

Plus a corresponding macro e.g. cs![ [0, 1, 3], [0, 1, 3] ].