Why is returning a cloned ndarray throwing an overflow error(exceeded max recursion limit)?

Question

I'm currently trying to write a function that is generally equivalent to numpy's tile. Currently each time I try to return a (altered or unaltered) clone of the input array, I get a warning about an overflow, and cargo prompts me to increase the recursion limit. however this function isn't recursive, so I'm assuming its happening somewhere in the implementation.

here is the stripped down function, (full version):

pub fn tile<A, D1, D2>(arr: &Array<A, D1>, reps: Vec<usize>) -> Array<A, D2>
where
    A: Clone,
    D1: Dimension,
    D2: Dimension,
{
    let num_of_reps = reps.len();

    //just clone the array if reps is all ones
    let mut res = arr.clone();
    let bail_flag = true;
    for &x in reps.iter() {
        if x != 1 {
            bail_flag = false;
        }
    }
    if bail_flag {
        let mut res_dim = res.shape().to_owned();
        _new_shape(num_of_reps, res.ndim(), &mut res_dim);
        res.to_shape(res_dim);
        return res;
    }
    ...
    //otherwise do extra work
    ...
    return res.reshape(shape_out);
}

this is the actual error I'm getting on returning res:

overflow evaluating the requirement `&ArrayBase<_, _>: Neg`
consider increasing the recursion limit by adding a `#![recursion_limit = "1024"]` attribute to your crate (`mfcc_2`)
required because of the requirements on the impl of `Neg` for `&ArrayBase<_, _>`
511 redundant requirements hidden
required because of the requirements on the impl of `Neg` for `&ArrayBase<OwnedRepr<A>, D1>`rustcE0275

I looked at the implementation of Neg in ndarray, it doesn't seem to be recursive, so I'm a little confused as to what is going on.

p.s. I'm aware there are other errors in this code, as those appeared after I switched from A to f64(the actual type I plan on using the function with), but those are mostly trivial to fix. Still if you have suggestions on any error you see I appreciate them nonetheless.