How do I squeeze?

[JJJHolscher]

I abstracted my ndarray from my user, such that each dimension of my array has a different enum variant.
Now, I want that user to be able to get all values from my array, that satisfy the values of the enum variants they send.
The kicker is: they can send a variable number of arguments, so I need to be able to return an array with a variable number of axes.

This, does not work:

fn get<'a, D>(&'a self, args: &[Argument]) -> ArrayView<'a, String, D::Smaller>
    where D: RemoveAxis + Dimension
    {
        let mut slice = self.array.slice(s![.., .., .., ..]);
        for arg in args {
            match arg {
                Argument::Data(_) => {
                    let d = self.arg2idx[&arg];
                    slice = slice.slice(s![d..d+1, .., .., ..]);
                },
                Argument::Feature(_) => {
                    let f = self.arg2idx[&arg];
                    slice = slice.slice(s![.., f..f+1, .., ..]);
                },
                Argument::Modification(_) => {
                    let m = self.arg2idx[&arg];
                    slice = slice.slice(s![.., .., m..m+1, ..]);
                },
                Argument::FileType(_) => {
                    let t = self.arg2idx[&arg];
                    slice = slice.slice(s![.., .., .., t..t+1]);
                },
            };
        }

        let out: ArrayView<'a, String, D::Smaller> = slice;  // Not Alllowed.
        for (axis, size) in slice.shape().iter().enumerate() {
            if *size == 1 {
                out = out.remove_axis(Axis(axis));
            }
        }
        out
    }

Now I'm using a weird for-loop that checks for axis with a size of 1, but even that doesn't work since Rust refuses to make my slice be of a dynamic number of axis.
Also the way that I slice I find ugly, I'm not eliminating axes immediately, because that might mess up the indexing.

My problem would be solved with a numpy-like squeeze function, how do I achieve that?

[nilgoyette]

I don't understand why you use a range instead of an index.

slice = slice.slice(s![d, .., .., ..]);

That would give you a 3d array (which seems to be what you want) instead of 4 dimensions with one of the dimension with a length of 1. Am I missing something?

[JJJHolscher]

Yeah, the user can supply one or more indices in a variable-length array, the type of the indices determines the dimension of the tensor that should be removed.

So index of type A is associated with dimension 0, and B with 1.
I might receive an array of [A], [B], [A, B] or [B, A].
In the case of [A, B], If I immediately remove dimension 0 after processing A, then my tensor only has a single dimension left, and B would index the wrong dimension.

Sure, I can work around this by keeping track of which indices have passed already, but that feels more complex than a squeeze-like functionality.

[bluss]

D and D::Smaller statically correspond to a fixed number of axes (in the general case). Take a D-parameterized array as input, but convert to dynamic dimensional (IxDyn) first thing you do in your function, only then is it possible to return something with a dynamic number of axes.