When I can use either Cell or RefCell, which should I choose?

by

I think it is important to take into account the other semantic differences between Cell and RefCell:

  • Cell provides you values, RefCell with references
  • Cell never panics, RefCell can panic

Let us imagine a situation where these differences matter:

let cell = Cell::new(foo);
{
    let mut value = cell.get();
    // do some heavy processing on value
    cell.set(value);
}

In this case, if we imagine some complex workflow with a lot of callback and that cell is part of a global state, it is possible that the contents of cell are modified as a side effect of the “heavy processing”, and these potential changes will be lost when value is written back in cell.

On the other hand, a similar code using RefCell:

let cell = RefCell::new(foo);
{
    let mut_ref = cell.borrow_mut().unwrap();
    // do some heavy processing on mut_ref
}

In this case, any modification of cell as a side-effect of the “heavy processing” is forbidden, and would result into a panic. You thus are certain that the value of cell will not change without using mut_ref

I would decide which to use depending of the semantics of the value it holds, rather than simply the Copy trait. If both are acceptable, then Cell is lighter and safer than the other, and thus would be preferable.

More Related Contents:

  1. Traits and Rust
  2. Why do try!() and ? not compile when used in a function that doesn’t return Option or Result?
  3. Why does linking lifetimes matter only with mutable references?
  4. Why is adding a lifetime to a trait with the plus operator (Iterator + ‘a) needed?
  5. How do I collect into an array?
  6. Cannot borrow as mutable more than once at a time in one code – but can in another very similar
  7. Is it considered a bad practice to implement Deref for newtypes?
  8. Implementing a trait for multiple types at once
  9. How do I get an owned value out of a `Box`?
  10. How can I store a Chars iterator in the same struct as the String it is iterating on?
  11. Converting from Option to Option
  12. How to disable unused code warnings in Rust?
  13. Why doesn’t println! work in Rust unit tests?
  14. How do you use parent module imports in Rust?
  15. Why is the `Sized` bound necessary in this trait?
  16. If BufReader takes ownership of a stream, how can I read and write lines on it?
  17. Why can’t I return an &str value generated from a String?
  18. Why are recursive struct types illegal in Rust?
  19. Understanding Traits and Object Safety
  20. How can I create enums with constant values in Rust?
  21. What is the prelude?
  22. How to embed resources in Rust executable?
  23. Sized is not implemented for the type Fn
  24. Extend lifetime of variable
  25. Can’t implement a trait I don’t own for all types that implement a trait I do own
  26. What does Rust’s unary || (parallel pipe) mean?
  27. How to create and write to memory mapped files?
  28. Downcast traits inside Rc for AST manipulation
  29. How to check in Rust if architecture is 32 or 64 bit?
  30. Is there any way to restrict a generic type to one of several types?

Leave a Comment