Mutable self while reading from owner object

by

You’d want to compute the argument first in a form that doesn’t alias self, then pass that in. As it stands, it seems a little strange that an animal decides how much food it’s going to eat by looking at every other animal… regardless, you could add a method Animal::decide_feed_amount(&self, world: &World) -> f32. You can call that safely (&self and &World are both immutable, so that’s OK), store the result in a variable, then pass that to Animal::feed.

Edit to address your Edit: well, you’re kinda screwed, then. Rust’s borrow checker is not sophisticated enough to prove that the mutations you make to the Animal cannot possibly interfere with any possible immutable access to the containing World. Some things you can try:

  • Do a functional-style update. Make a copy of the Animal you want to update so that it has its own lifetime, update it, then overwrite the original. If you duplicate the whole array up front, this gives you what is effectively an atomic update of the whole array.

    As someone who worked on a simulator for like half a decade, I wish I’d done something like that instead of mutating updates. sigh

  • Change to Vec<Option<Animal>> which will allow you to move (not copy) an Animal out of the array, mutate it, then put it back (see std::mem::replace). Downside is that now everything has to check to see if there’s an animal in each position of the array.

  • Put the Animals inside Cells or RefCells, which will allow you to mutate them from immutable references. It does this by performing dynamic borrow checking which is infinitely slower (no checks vs. some checks), but is still “safe”.

  • Absolute last resort: unsafe. But really, if you do that, you’re throwing all your memory safety guarantees out the window, so I wouldn’t recommend it.

More Related Contents:

  1. Why can’t I store a value and a reference to that value in the same struct?
  2. The compiler suggests I add a ‘static lifetime because the parameter type may not live long enough, but I don’t think that’s what I want
  3. How do I pass disjoint slices from a vector to different threads?
  4. Why does Iterator::take_while take ownership of the iterator?
  5. When should I implement std::convert::From vs std::convert::Into?
  6. Compare enums only by variant, not value
  7. How can I call a mutating method while holding a reference to self?
  8. How do you actually use dynamically sized types in Rust?
  9. How do I use the Entry API with an expensive key that is only constructed if the Entry is Vacant?
  10. “parameter `’a` is never used” error when ‘a is used in type parameter bound
  11. Borrowing references to attributes in a struct
  12. How do I split a string in Rust?
  13. Is it possible to implement methods on type aliases?
  14. How to operate on 2 mutable slices of a Rust array?
  15. Mutating one field while iterating over another immutable field
  16. How can I use a module from outside the src folder in a binary project, such as for integration tests or benchmarks?
  17. How to match on data type in Rust?
  18. Why does Rust allow mutation through a reference field using an immutable binding?
  19. How can I modify self in a closure called from a member function?
  20. Multiple return types from a method
  21. How do I move out of a struct field that is an Option?
  22. Why does this mutable borrow live beyond its scope?
  23. What is unwrap in Rust, and what is it used for?
  24. How can I find a subsequence in a &[u8] slice?
  25. Why “explicit lifetime bound required” for Box in struct?
  26. How to quiet a warning for a single statement in Rust?
  27. Use of undeclared type or module `std` when used in a separate module
  28. Is there an elegant solution to modifying a structure while iterating?
  29. How do I cope with lazy iterators?
  30. Can a struct containing a raw pointer implement Send and be FFI safe?

Leave a Comment