How to implement iter() for a type that wraps an NdArray?

As part of making a Rust-based tensor library, I have implemented a 2D Tensor type as:

use ndarray::prelude::*;

pub struct Tensor(Rc<RefCell<TensorData>>);

pub struct TensorData {
    pub data: Array2<f64>,
    pub grad: Array2<f64>,
    // other fields...
}

impl TensorData {
    fn new(data: Array2<f64>) -> TensorData {
        let shape = data.raw_dim();
        TensorData {
            data,
            grad: Array2::zeros(shape),
            // other fields...
        }
    }
}

impl Tensor {
    pub fn new(array: Array2<f64>) -> Tensor {
        Tensor(Rc::new(RefCell::new(TensorData::new(array))))
    }

    pub fn data(&self) -> impl Deref<Target = Array2<f64>> + '_ {
        Ref::map((*self.0).borrow(), |mi| &mi.data)
    }
}

Now I want to be able to iterate over the rows of a tensor (e.g. for implementing stochastic gradient descent). This is what I have so far:

impl Tensor {
	// other methods...
	
    pub fn iter(&self) -> impl Iterator<Item = Tensor> + '_ {
        self.data().outer_iter().map(|el| {
            let reshaped_and_cloned_el = el.into_shape((el.shape()[0], 1)).unwrap().mapv(|el| el.clone());
            reshaped_and_cloned_el
        }).map(|el| Tensor::new(el))
    }
}

The issue with this is that it is (1) unpleasant visually and (2) does not compile as the iterator is a temporary value that is dropped as soon as it goes out of scope:

error[E0515]: cannot return value referencing temporary value
   --> src/tensor/mod.rs:348:9
    |
348 |           self.data().outer_iter().map(|el| {
    |           ^----------
    |           |
    |  _________temporary value created here
    | |
349 | |             let reshaped_and_cloned_el = el.into_shape((el.shape()[0], 1)).unwrap().mapv(...
350 | |             reshaped_and_cloned_el
351 | |         }).map(|el| Tensor::new(el))
    | |____________________________________^ returns a value referencing data owned by the current function
    |
    = help: use `.collect()` to allocate the iterator

What would be an alternative implementation of iter() that would not have these issues?

Unfortunately, you cannot use the axis iterators, because this will make a self-referential struct (the data guard and the iterator borrowing from it). But you can index to access the axis:

pub fn iter(&self) -> impl Iterator<Item = Tensor> + '_ {
    let data = self.data();
    (0..data.shape()[0]).map(move |i| {
        let el = data.index_axis(Axis(0), i);
        let reshaped_and_cloned_el = el
            .into_shape((el.shape()[0], 1))
            .unwrap()
            .mapv(|el| el.clone());
        Tensor::new(reshaped_and_cloned_el)
    })
}