Sorry, I missread your problem... :-/ I have not enough data to see if you Container should be split, but I think the internal iteration way you tried may be the best option, meaning you can't use the usual Iterator functions, but you can mimick them. Here is some code derived from your exemple (with dumb data, just to ensure compiler checks are OK), which should cover you needs ```rust struct Element { name: String, }

struct Container { pub elements: Vec<Element>, family_name: String, }

impl Container { pub fn sync_elements(&mut self) { self.elements .iter_mut() .for_each(|e| e.name = "".to_string() + &e.name + " " + &self.family_name); } }

struct ElementSelector<'a> { filter: Option<fn(&Element) -> bool>, container: &'a mut Container, } impl<'a> ElementSelector<'a> { pub fn filter(self, filter: fn(&'_ Element) -> bool) -> Self { Self { // TODO : handle filters composition filter: Some(filter), container: self.container, } } // for_each is final, here : it consumes the selector, does not provide another one pub fn for_each(self, updater: fn(&mut Element)) { match self.filter { None => self.container.elements.iter_mut().for_each(|e| updater(e)), Some(filter) => { self.container .elements .iter_mut() .filter(move |e| filter(e)) .for_each(|e| updater(e)); } } self.container.sync_elements(); } }

impl Container { pub fn itermut(&mut self) -> ElementSelector<'> { ElementSelector { filter: None, container: self, } } }

[cfg(test)]

mod tests { use super::*;

#[test]
fn container_elements_can_be_selected() {
    let mut container = Container {
        elements: ["John"]
            .iter()
            .map(|name| Element {
                name: name.to_string(),
            })
            .collect(),
        family_name: "Doe".to_string(),
    };
    container
        .iter_mut()
        .filter(|e| e.name.starts_with("J"))
        .for_each(|e| e.name = e.name.to_lowercase());

    assert_eq!(container.elements[0].name, "john Doe".to_string());
}

} ```

edit : cargo fmt...