Passing in method reference to a struct - rust

Question

I have a struct other_struct that has a bunch of methods that I need to call depending on certain situations (in this example there is only foo(). I'd like to have a field in other_struct called fmap that stores a HashMap of other_struct methods.
use std::collections::HashMap;
pub struct fn_struct {
pub func: Option<fn(&other_struct) -> ()>,
}
pub struct other_struct<'a> {
fmap: HashMap<String, fn_struct>,
some_str: &'a str,
}
impl<'a> other_struct<'a> {
fn new(some_str: &str) -> other_struct {
let mut new_struct = other_struct {
fmap: HashMap::new(),
some_str: some_str,
};
new_struct.fmap.insert(
String::from("foo"),
fn_struct {
func: Some(other_struct::foo),
},
);
new_struct
}
pub fn foo(&self) {
println!("Do some stuff foo");
}
}
fn main() {
let test_str = "test";
let mut new_o = other_struct::new(test_str);
new_o.fmap.get("foo").unwrap().func.unwrap()(&new_o);
}
I'm struggling with dealing with the lifetimes, as I get the following error:
error[E0308]: mismatched types
--> src/main.rs:22:28
|
22 | func: Some(other_struct::foo),
| ^^^^^^^^^^^^^^^^^ one type is more general than the other
|
= note: expected fn pointer `for<'r, 's> fn(&'r other_struct<'s>)`
found fn pointer `for<'r> fn(&'r other_struct<'_>)`
I've been reading the high ranked trait bound documentation but it's unclear to me what's happening here. Does this mean the compiler wants me to specify the lifetime of the instance of other_struct somehow in relation to the lifetime of the pointer to the method?

Answer 1

The fn(&other_struct) -> () part of fn_struct is a function pointer that must be able to accept other_structs of any lifetime for<'r, 's> fn(&'r other_struct<'s>) -> (). However, other_struct::foo only accepts a specific lifetime for other_struct<'_>.
You can fix it by specifying that lifetime in some manner, here basically saying its always going to pass in itself:
pub struct fn_struct<'a> {
pub func: Option<fn(&other_struct<'a>) -> ()>,
}
pub struct other_struct<'a> {
fmap: HashMap<String, fn_struct<'a>>,
some_str: &'a str,
}
Or by making foo more generic by unbinding it from 'a.
pub fn foo(_self: &other_struct) {
println!("Do some stuff foo");
}
The difference is subtle, but the original is other_struct<'a>::foo<'b>(&'b other_struct<'a>) -> () and the fixed version is other_struct<'a>::foo<'b, 'c>(&'b other_struct<'c>) -> ().