How to use struct self in member method closure

by

Split your data and methods into smaller components, then you can take disjoint borrows to various components on self:

fn fetch_access_token(_base_url: &str) -> String { String::new() }
fn get_env_url() -> String { String::new() }

#[derive(Default)]
struct BaseUrl(Option<String>);

impl BaseUrl {
    fn get(&mut self) -> &str {
        self.0.get_or_insert_with(|| get_env_url())
    }
}

#[derive(Default)]
struct App {
    base_url: BaseUrl,
    access_token: Option<String>,
}

impl App {
    fn new() -> App {
        App::default()
    }

    fn get_access_token(&mut self) -> &str {
        let base_url = &mut self.base_url;
        self.access_token
            .get_or_insert_with(|| fetch_access_token(base_url.get()))
    }
}

fn main() {}

You can go further and do this for both values:

fn fetch_access_token(_base_url: &str) -> String { String::new() }
fn get_env_url() -> String { String::new() }

#[derive(Default)]
struct BaseUrl(Option<String>);

impl BaseUrl {
    fn get(&mut self) -> &str {
        self.0.get_or_insert_with(|| get_env_url())
    }
}

#[derive(Default)]
struct AccessToken(Option<String>);

impl AccessToken {
    fn get(&mut self, base_url: &str) -> &str {
        self.0.get_or_insert_with(|| fetch_access_token(base_url))
    }
}

#[derive(Default)]
struct App {
    base_url: BaseUrl,
    access_token: AccessToken,
}

impl App {
    fn new() -> App {
        App::default()
    }

    fn get_access_token(&mut self) -> &str {
        let base_url = self.base_url.get();
        self.access_token.get(base_url)
    }
}

fn main() {}

Which lets you see that you can abstract out common functionality:

fn fetch_access_token(_base_url: &str) -> String { String::new() }
fn get_env_url() -> String { String::new() }

#[derive(Default)]
struct StringCache(Option<String>);

impl StringCache {
    fn get<F>(&mut self, f: F) -> &str
    where
        F: FnOnce() -> String,
    {
        self.0.get_or_insert_with(f)
    }
}

#[derive(Default)]
struct App {
    base_url: StringCache,
    access_token: StringCache,
}

impl App {
    fn new() -> App {
        App::default()
    }

    fn get_access_token(&mut self) -> &str {
        let base_url = self.base_url.get(get_env_url);
        self.access_token.get(|| fetch_access_token(base_url))
    }
}

fn main() {}

And then you realize the abstraction can be made generic:

fn fetch_access_token(_base_url: &str) -> String { String::new() }
fn get_env_url() -> String { String::new() }

#[derive(Default)]
struct Cache<T>(Option<T>);

impl<T> Cache<T> {
    fn get<F>(&mut self, f: F) -> &T
    where
        F: FnOnce() -> T,
    {
        self.0.get_or_insert_with(f)
    }
}

#[derive(Default)]
struct App {
    base_url: Cache<String>,
    access_token: Cache<String>,
}

impl App {
    fn new() -> App {
        App::default()
    }

    fn get_access_token(&mut self) -> &str {
        let base_url = self.base_url.get(get_env_url);
        self.access_token.get(|| fetch_access_token(base_url))
    }
}

fn main() {}

See also:

More Related Contents:

  1. Mutably borrow one struct field while borrowing another in a closure
  2. How can I modify self in a closure called from a member function?
  3. Can’t borrow mutably within two different closures in the same scope
  4. Why can’t I store a value and a reference to that value in the same struct?
  5. Cannot move out of value which is behind a shared reference when unwrapping
  6. Why does refactoring by extracting a method trigger a borrow checker error?
  7. How do I return a reference to something inside a RefCell without breaking encapsulation?
  8. Temporarily move out of borrowed content
  9. Returning a reference from a HashMap or Vec causes a borrow to last beyond the scope it’s in?
  10. When does a closure implement Fn, FnMut and FnOnce?
  11. Passing mutable self reference to method of owned object
  12. Do mutable references have move semantics?
  13. Cannot borrow as immutable because it is also borrowed as mutable in function arguments
  14. Double mutable borrow error in a loop happens even with NLL on
  15. What are the options to end a mutable borrow in Rust?
  16. How to update-or-insert on a Vec?
  17. How do I convert a Rust closure to a C-style callback?
  18. “borrowed value does not live long enough” when using the builder pattern
  19. cannot borrow `self.x` as immutable because `*self` is also borrowed as mutable
  20. Temporary value is freed at the end of this statement [duplicate]
  21. How to use a struct’s member as its own key when inserting the struct into a map without duplicating it?
  22. How do I move out of a struct field that is an Option?
  23. Why does this mutable borrow live beyond its scope?
  24. Is there another option to share an Arc in multiple closures besides cloning it before each closure?
  25. Why can’t I reuse a &mut reference after passing it to a function that accepts a generic type?
  26. How do I pass a closure through raw pointers as an argument to a C function?
  27. Why does a mutable borrow of a closure through DerefMut not work?
  28. How does the Rust compiler know `Cell` has internal mutability?
  29. How do I implement Copy and Clone for a type that contains a String (or any type that doesn’t implement Copy)?
  30. Can I write an Iterator that mutates itself and then yields a reference into itself?

Leave a Comment