How can I conditionally provide a default reference without performing unnecessary computation when it isn’t used?

by

You don’t have to create the default vector if you don’t use it. You just have to ensure the declaration is done outside the if block.

fn accept(input: &Vec<String>) {
    let def;
    let vec = if input.is_empty() {
        def = vec!["empty".to_string()];
        &def
    } else {
        input
    };
    // ... do something with `vec`
}

Note that you don’t have to build a new default vector every time you receive an empty one. You can create it the first time this happens using lazy_static or once_cell:

#[macro_use]
extern crate lazy_static;

fn accept(input: &[String]) {
    let vec = if input.is_empty() {
        lazy_static! {
            static ref DEFAULT: Vec<String> = vec!["empty".to_string()];
        }
        &DEFAULT
    } else {
        input
    };
    // use vec
}

More Related Contents:

  1. Why can’t I store a value and a reference to that value in the same struct?
  2. What are Rust’s exact auto-dereferencing rules?
  3. Why does linking lifetimes matter only with mutable references?
  4. How can I pass a reference to a stack variable to a thread?
  5. Why are explicit lifetimes needed in Rust?
  6. Why is it legal to borrow a temporary?
  7. Package with both a library and a binary?
  8. Do mutable references have move semantics?
  9. How do I match enum values with an integer?
  10. How does Rust provide move semantics?
  11. How to transform fields during serialization using Serde?
  12. Iterator returning items by reference, lifetime issue
  13. Why is the mutable reference not moved here?
  14. “borrowed value does not live long enough” when using the builder pattern
  15. How do I use static lifetimes with threads?
  16. Is it possible to conditionally enable an attribute like `derive`?
  17. How can I create a function with a variable number of arguments?
  18. Thread ” has overflowed its stack when allocating a large array using Box
  19. Type mismatches resolving a closure that takes arguments by reference
  20. How do you enable a Rust “crate feature”?
  21. How to implement Iterator yielding mutable references [duplicate]
  22. How can a Rust program access metadata from its Cargo package?
  23. How can the ref keyword be avoided when pattern matching in a function taking &self or &mut self?
  24. How do I disambiguate traits in Rust?
  25. How to swap two variables?
  26. Expected bound lifetime parameter, found concrete lifetime [E0271]
  27. Can Cargo download and build dependencies without also building the application?
  28. How do I pass Rc to a function accepting Rc?
  29. Is there a way for me to use #[derive] on a struct or enum from a library without editing the actual library’s source code?
  30. Why is this Rust slower than my similar Python? [duplicate]

Leave a Comment