How do I borrow a reference to what is inside an Option?

by

As of Rust 1.26, match ergonomics allows you to write:

impl Bar {
    fn borrow(&mut self) -> Result<&Box<Foo>, BarErr> {
        match &self.data {
            Some(e) => Ok(e),
            None => Err(BarErr::Nope),
        }
    }
}

Prior to that, you can use Option::as_ref, you just need to use it earlier:

impl Bar {
    fn borrow(&self) -> Result<&Box<Foo>, BarErr> {
        self.data.as_ref().ok_or(BarErr::Nope)
    }
}

There’s a companion method for mutable references: Option::as_mut:

impl Bar {
    fn borrow_mut(&mut self) -> Result<&mut Box<Foo>, BarErr> {
        self.data.as_mut().ok_or(BarErr::Nope)
    }
}

I’d encourage removing the Box wrapper though.

Since Rust 1.40, you can use Option::as_deref / Option::as_deref_mut:

impl Bar {
    fn borrow(&self) -> Result<&Foo, BarErr> {
        self.data.as_deref().ok_or(BarErr::Nope)
    }

    fn borrow_mut(&mut self) -> Result<&mut Foo, BarErr> {
        self.data.as_deref_mut().ok_or(BarErr::Nope)
    }
}

Before then, I’d probably use a map 

impl Bar {
    fn borrow(&self) -> Result<&Foo, BarErr> {
        self.data.as_ref().map(|x| &**x).ok_or(BarErr::Nope)
    }

    fn borrow_mut(&mut self) -> Result<&mut Foo, BarErr> {
        self.data.as_mut().map(|x| &mut **x).ok_or(BarErr::Nope)
    }
}

With the match ergonomics version, you can do the mapping inline:

impl Bar {
    fn borrow(&mut self) -> Result<&Foo, BarErr> {
        match &self.data {
            Some(e) => Ok(&**e),
            None => Err(BarErr::Nope),
        }
    }

    fn borrow_mut(&mut self) -> Result<&mut Foo, BarErr> {
        match &mut self.data {
            Some(e) => Ok(&mut **e),
            None => Err(BarErr::Nope),
        }
    }
}

See also:

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. Is it possible to control the size of an array using the type parameter of a generic?
  4. Does println! borrow or own the variable?
  5. How do I pass disjoint slices from a vector to different threads?
  6. Why does Iterator::take_while take ownership of the iterator?
  7. When should I implement std::convert::From vs std::convert::Into?
  8. Why would I implement methods on a trait instead of as part of the trait?
  9. How to initialize struct fields which reference each other
  10. “Expected fn item, found a different fn item” when working with function pointers
  11. How do you unwrap a Result on Ok or return from the function on Err?
  12. What does “mismatched types: expected `()`” mean when using an if expression?
  13. How do I read the entire body of a Tokio-based Hyper request?
  14. How can I downcast from Box to a trait object type?
  15. How do I ‘pass down’ feature flags to subdependencies in Cargo?
  16. How does Rust pattern matching determine if the bound variable will be a reference or a value?
  17. Using generic trait methods like .into() when type inference is impossible
  18. Why does an enum require extra memory size?
  19. What is a crate attribute and where do I add it?
  20. Parameter type may not live long enough?
  21. How to model complex recursive data structures (graphs)?
  22. Why can’t I reuse a &mut reference after passing it to a function that accepts a generic type?
  23. print! macro not executed until pressing Enter
  24. How can I define an async method in a trait?
  25. How do I specify the linker path in Rust?
  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. Is there a way to get the field names of a struct in a macro?

Leave a Comment