How to implement Clone on a struct that contains dyn Iterator in Rust?

I have the following struct in Rust:

#[derive(Clone)]
pub struct EquationIterator<F> {
    counter: Box<dyn Iterator<Item = usize>>,
    formula: Arc<dyn Fn(usize) -> Equation<F>>,
}

I had to use an Arc to wrap the closure otherwise I couldn't implement Clone on the struct. Even with this, I still cannot derive Clone because the compiler is complaining about the dyn Iterator not implementing Clone.

I've tried implementing Clone manually but no luck either. Any idea?

To add more colors, this structure is an iterator that goes through some arbitrary range (e.g. counter = [2, 5, 9]) and calls some closure with the current counter value as argument

https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=9fb31441d9007d51c050bdd9e8f2d5c7

Because Clone isn't object-safe (it would return the actual type, not Box<dyn Clone>), you need a workaround. You can almost use the method from this question, except because you don't own the Iterator trait, you need to make a new trait. (playground)

trait ClonableIterator: Iterator {
    fn clone_box(&self) -> Box<dyn ClonableIterator<Item = Self::Item>>;
}

impl<T, I> ClonableIterator for T
where
    T: Iterator<Item = I> + Clone + 'static,
{
    fn clone_box(&self) -> Box<dyn ClonableIterator<Item = I>> {
        Box::new(self.clone())
    }
}

Then you can store a trait object of this trait in your struct.

counter: Box<dyn ClonableIterator<Item = usize>>

And you can implement Clone for your struct using clone_box.

impl<F> Clone for EquationIterator<F> {
    fn clone(&self) -> Self {
        EquationIterator {
            counter: self.counter.clone_box(),
            formula: self.formula.clone(),
        }
    }
}

You can also do this for the Fn trait, which I've upgraded to FnMut since it is now owned exclusively.

trait ClonableFnMut<T, O>: FnMut(T) -> O {
    fn clone_box(&self) -> Box<dyn ClonableFnMut<T, O>>;
}

impl<F, T, O> ClonableFnMut<T, O> for F
where
    F: FnMut(T) -> O + Clone + 'static,
{
    fn clone_box(&self) -> Box<dyn ClonableFnMut<T, O>> {
        Box::new(self.clone())
    }
}

And then you can add it to the struct.

formula: Box<dyn ClonableFnMut<usize, F>>

And change your Clone implementation.

formula: self.formula.clone_box()

I couldn't quite get this to work with dyn-clone, but there might be a way.

Note that you would need to implement Clone manually anyway because the derive would make it conditional on F being Clone, which isn't necessary.

It is possible that an implementor of Iterator is not clonable. You need to specify to the compiler that only types that implement Clone and Interator are allowed.

use std::sync::Arc;

#[derive(Clone)]
pub struct EquationIterator<F, I: Iterator<Item = usize> + Clone> {
    counter: Box<I>,
    formula: Arc<dyn Fn(usize) -> F>,
}

fn main() {

}

https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=9fb31441d9007d51c050bdd9e8f2d5c7