How to avoid writing duplicate accessor functions for mutable and immutable references in Rust?

by

(playground links to solutions using type parameters and associated types)

In this case &T and &mut T are just two different types. Code that is generic over different types (at both compile-time and run-time) is idiomatically written in Rust using traits. For example, given:

struct Foo { value: i32 }
struct Bar { foo: Foo }

suppose we want to provide Bar with a generic accessor for its Foo data member. The accessor should work on both &Bar and &mut Bar appropriately returning &Foo or &mut Foo. So we write a trait FooGetter

trait FooGetter {
    type Output;
    fn get(self) -> Self::Output;
}

whose job is to be generic over the particular type of Bar we have. Its Output type will depend on Bar since we want get to sometimes return &Foo and sometimes &mut Foo. Note also that it consumes self of type Self. Since we want get to be generic over &Bar and &mut Bar we need to implement FooGetter for both, so that Self has the appropriate types: 

// FooGetter::Self == &Bar
impl<'a> FooGetter for &'a Bar {
    type Output = &'a Foo;
    fn get(self) -> Self::Output { & self.foo }
}

// FooGetter::Self == &mut Bar
impl<'a> FooGetter for &'a mut Bar {
    type Output = &'a mut Foo;
    fn get(mut self) -> Self::Output { &mut self.foo }
}

Now we can easily use .get() in generic code to obtain & or &mut references to Foo from a &Bar or a &mut Bar (by just requiring T: FooGetter). For example:

// exemplary generic function:
fn foo<T: FooGetter>(t: T) -> <T as FooGetter>::Output {
    t.get() 
}

fn main() {
    let x = Bar { foo: Foo {value: 2} };
    let mut y = Bar { foo: Foo {value: 2} };

    foo(&mut y).value = 3;
    println!("{} {}\n", foo(&x).value, foo(&mut y).value);
}

Note that you can also implement FooGetter for Bar, so that get is generic over &T,&mut T, and T itself (by moving it in). This is actually how the .iter() method is implemented in the standard library, and why it always does “the right thing” independently of the reference-ness of the argument its invoked on.

More Related Contents:

  1. Is there any way to return a reference to a variable created in a function?
  2. Why can I return a reference to a local literal but not a variable?
  3. Cannot move out of borrowed content / cannot move out of behind a shared reference
  4. Why are explicit lifetimes needed in Rust?
  5. Cannot borrow as mutable because it is also borrowed as immutable
  6. How do I implement the Add trait for a reference to a struct?
  7. Cannot move out of borrowed content when trying to transfer ownership
  8. Iterator returning items by reference, lifetime issue
  9. Why does pattern matching on &Option yield something of type Some(&T)?
  10. What is the purpose of `&` before the loop variable?
  11. Why is “&&” being used in closure arguments?
  12. When should I not implement a trait for references to implementors of that trait?
  13. What is an idiomatic way to collect an iterator of &T into a collection of Ts?
  14. How to abstract over a reference to a value or a value itself?
  15. Rust lifetime error expected concrete lifetime but found bound lifetime
  16. Why can’t I store a value and a reference to that value in the same struct?
  17. Why is it discouraged to accept a reference to a String (&String), Vec (&Vec), or Box (&Box) as a function argument?
  18. What are Rust’s exact auto-dereferencing rules?
  19. What’s the difference between placing “mut” before a variable name and after the “:”?
  20. Why does linking lifetimes matter only with mutable references?
  21. Why is it possible to implement Read on an immutable reference to File?
  22. In Rust, what’s the difference between “shadowing” and “mutability”?
  23. Why is the return type of Deref::deref itself a reference?
  24. Convert Vec into a slice of &str in Rust?
  25. What lifetimes do I use to create Rust structs that reference each other cyclically?
  26. How to query mongodb with DBRef
  27. What is the difference between immutable and const variables in Rust?
  28. Finding all references of a variable or a method in Xcode4
  29. How can I conditionally provide a default reference without performing unnecessary computation when it isn’t used?
  30. Pass by reference problem with PHP 5.3.1 [duplicate]

Leave a Comment