How to implement Iterator yielding mutable references [duplicate]

by

Your code is invalid because you try to return multiple mutable references to the same slice with the same lifetime 'a.

For such a thing to work, you would need a different lifetime for each returned Item so that you wouldn’t hold 2 mutable references to the same slice. You cannot do that for now because it requires Generic Associated Types:

type Item<'item> = &'item mut D; // Does not work today

One solution is to check that the indices are unique and to rebind the lifetime of the referenced item to 'a in an unsafe block. This is safe because all the indices are unique, so the user cannot hold 2 mutable references to the same item.

Don’t forget to encapsulate the whole code inside a module, so that the struct cannot be build without the check in new:

mod my_mod {
    pub struct LookupIterMut<'a, D> {
        data: &'a mut [D],
        indices: &'a [usize],
        i: usize,
    }

    impl<'a, D> LookupIterMut<'a, D> {
        pub fn new(data: &'a mut [D], indices: &'a [usize]) -> Result<Self, ()> {
            let mut uniq = std::collections::HashSet::new();
            let all_distinct = indices.iter().all(move |&x| uniq.insert(x));

            if all_distinct {
                Ok(LookupIterMut {
                    data,
                    indices,
                    i: 0,
                })
            } else {
                Err(())
            }
        }
    }

    impl<'a, D> Iterator for LookupIterMut<'a, D> {
        type Item = &'a mut D;

        fn next(&mut self) -> Option<Self::Item> {
            self.indices.get(self.i).map(|&index| {
                self.i += 1;

                unsafe { std::mem::transmute(&mut self.data[index]) }
            })
        }
    }
}

Note that your code will panic if one index is out of bounds.

More Related Contents:

  1. What are non-lexical lifetimes?
  2. What are Rust’s exact auto-dereferencing rules?
  3. Why is a trait not implemented for a type that clearly has it implemented?
  4. How do I implement a trait I don’t own for a type I don’t own?
  5. What makes something a “trait object”?
  6. How do I convert a Vector of bytes (u8) to a string?
  7. Is it possible to use `impl Trait` as a function’s return type in a trait definition?
  8. Cannot borrow as immutable because it is also borrowed as mutable in function arguments
  9. What is the relation between auto-dereferencing and deref coercion?
  10. What is the return type of the indexing operation?
  11. How to do a binary search on a Vec of floats?
  12. Change enum variant while moving the field to the new variant
  13. I implemented a trait for another trait but cannot call methods from both traits
  14. When is it useful to define multiple lifetimes in a struct?
  15. Lifetime troubles sharing references between threads
  16. Moved variable still borrowing after calling `drop`?
  17. Is it possible to have stack allocated arrays with the size determined at runtime in Rust?
  18. Temporary value is freed at the end of this statement [duplicate]
  19. Sharing a struct with trait objects as properties across threads
  20. Efficiently insert or replace multiple elements in the middle or at the beginning of a Vec?
  21. Calling a generic async function with a (mutably) borrowed argument
  22. Why does a mutable borrow of a closure through DerefMut not work?
  23. How to switch between Rust toolchains?
  24. Why can Serde not derive Deserialize for a struct containing only a &Path?
  25. Creating a vector of zeros for a specific size
  26. What is the purpose of the unit type in Rust?
  27. Why does the Rust compiler request I constrain a generic type parameter’s lifetime (error E0309)?
  28. Cannot pass self as callback parameter due to double borrowing
  29. How to print structs and arrays?
  30. Can Rust optimise away the bit-wise copy during move of an object someday?

Leave a Comment