How do I pass Rc to a function accepting Rc?

by

(An older revision of this answer essentially advised to clone the underlying struct and put it in a new Rc<RefCell<Box<MyTrait>> object; this was necessary at the time on stable Rust, but since not long after that time, Rc<RefCell<MyStruct>> will coerce to Rc<RefCell<MyTrait>> without trouble.)

Drop the Box<> wrapping, and you can coerce Rc<RefCell<MyStruct>> to Rc<RefCell<MyTrait>> freely and easily. Recalling that cloning an Rc<T> just produces another Rc<T>, increasing the refcount by one, you can do something like this:

use std::rc::Rc;
use std::cell::RefCell;

trait MyTrait {
    fn trait_func(&self);
}

#[derive(Clone)]
struct MyStruct1;
impl MyStruct1 {
    fn my_fn(&self) {
        // do something
    }
}

impl MyTrait for MyStruct1 {
    fn trait_func(&self) {
        // do something
    }
}

fn my_trait_fn(t: Rc<RefCell<MyTrait>>) {
    t.borrow_mut().trait_func();
}

fn main() {
    // (The type annotation is not necessary here, but helps explain it.
    // If the `my_str.borrow().my_fn()` line was missing, it would actually
    // be of type Rc<RefCell<MyTrait>> instead of Rc<RefCell<MyStruct1>>,
    // essentially doing the coercion one step earlier.)
    let my_str: Rc<RefCell<MyStruct1>> = Rc::new(RefCell::new(MyStruct1));
    my_trait_fn(my_str.clone());
    my_str.borrow().my_fn();
}

As a general rule, see if you can make things take the contained value by reference, ideally even generically—fn my_trait_fn<T: MyTrait>(t: &T) and similar, which can typically be called as my_str.borrow() with automatic referencing and dereferencing taking care of the rest—rather than the whole Rc<RefCell<MyTrait>> thing.

More Related Contents:

  1. What makes something a “trait object”?
  2. Sending trait objects between threads in Rust
  3. Understanding Traits and Object Safety
  4. Why does using Option::map to Box::new a trait object not work?
  5. What are Rust’s exact auto-dereferencing rules?
  6. Why is a trait not implemented for a type that clearly has it implemented?
  7. How can I include a module from another file from the same project?
  8. What does “Sized is not implemented” mean?
  9. How do I implement a trait I don’t own for a type I don’t own?
  10. Is it possible to use `impl Trait` as a function’s return type in a trait definition?
  11. Cannot borrow as immutable because it is also borrowed as mutable in function arguments
  12. What is the relation between auto-dereferencing and deref coercion?
  13. What is the return type of the indexing operation?
  14. How to do a binary search on a Vec of floats?
  15. Change enum variant while moving the field to the new variant
  16. I implemented a trait for another trait but cannot call methods from both traits
  17. When is it useful to define multiple lifetimes in a struct?
  18. Moved variable still borrowing after calling `drop`?
  19. What is the difference between Copy and Clone?
  20. Is it possible to have stack allocated arrays with the size determined at runtime in Rust?
  21. Temporary value is freed at the end of this statement [duplicate]
  22. Sharing a struct with trait objects as properties across threads
  23. Calling a generic async function with a (mutably) borrowed argument
  24. Do all primitive types implement the Copy trait?
  25. What is the difference between `|_| async move {}` and `async move |_| {}`
  26. Cannot use moved BufReader after for loop with bufreader.lines()
  27. Expected closure, found a different closure
  28. Is there a good way to convert a Vec to an array?
  29. How can I conditionally provide a default reference without performing unnecessary computation when it isn’t used?
  30. How can I build multiple binaries with Cargo?

Leave a Comment