shows that any consumes an iterator

any_consumes.rs

#[cfg(test)]
mod test {
    struct SimpleStruct {
        id: String,
    }

    impl SimpleStruct {
        fn new(id: &str) -> Self {
            Self {
                id: String::from(id),
            }
        }
    }

    #[test]
    fn test_any_works() {
        let expected = vec![String::from("1")];
        let my_ids = vec![
            SimpleStruct::new(&"1"),
            SimpleStruct::new(&"2"),
            SimpleStruct::new(&"3"),
        ];
        let mut just_ids = my_ids.iter().map(|s| s.id.clone());
        for e in expected {
            assert!(just_ids.any(|d| {
                d == e
            }));
        }
    }

    #[test]
    #[should_panic]
    fn test_any_is_consuming() {
        let expected = vec![String::from("1"), String::from("1")];
        let my_ids = vec![
            SimpleStruct::new(&"0"),
            SimpleStruct::new(&"1"),
            SimpleStruct::new(&"2"),
            SimpleStruct::new(&"3"),
        ];
        let mut just_ids = my_ids.iter().map(|s| s.id.clone());
        for e in expected {
            assert!(just_ids.any(|d| {
                d == e
            }));
        }
    }

    #[test]
    #[should_panic]
    fn test_any_consumes_non_matching() {
        let my_ids = vec![
            SimpleStruct::new(&"0"),
            SimpleStruct::new(&"1"),
            SimpleStruct::new(&"2"),
            SimpleStruct::new(&"3"),
        ];
        let mut just_ids = my_ids.iter().map(|s| s.id.clone());
        assert!(just_ids.any(|d| {
            d == String::from("1")
        }));

        assert!(just_ids.any(|d| {
            d == String::from("0")
        }));
    }

    #[test]
    fn test_any_works_into_iter() {
        let expected = vec![String::from("1")];
        let my_ids = vec![
            SimpleStruct::new(&"1"),
            SimpleStruct::new(&"2"),
            SimpleStruct::new(&"3"),
        ];
        let mut just_ids = my_ids.into_iter().map(|s| s.id.clone());
        for e in expected {
            assert!(just_ids.any(|d| {
                d == e
            }));
        }
    }

    #[test]
    #[should_panic]
    fn test_any_is_consuming_into_iter() {
        let expected = vec![String::from("1"), String::from("1")];
        let my_ids = vec![
            SimpleStruct::new(&"1"),
            SimpleStruct::new(&"2"),
            SimpleStruct::new(&"3"),
        ];
        let mut just_ids = my_ids.into_iter().map(|s| s.id.clone());
        for e in expected {
            assert!(just_ids.any(|d| {
                d == e
            }));
        }
    }
}

This made me think I was crazy for a minute.