rust - 为什么 Foo <'a, P<' b>> 与 Foo2<'a> 不同？

Question

use std::collections::{HashMap, HashSet};

pub struct P<'a> {
    x: &'a str
}

pub struct Foo<'a, T> {
    callbacks: Vec<Box<'a + FnMut(&T)>>
}

impl<'a, T> Foo<'a, T>{
    pub fn foo(&mut self, payload: T) {
    }

}

pub struct Foo2<'a> {
    callbacks: Vec<Box<'a + FnMut(&P)>>
}

impl<'a> Foo2<'a>{
    pub fn foo(&mut self, payload: P) {
    }

}


struct Bar<'a, 'b> {
    x: Foo<'a, P<'b>>,
    y: Foo2<'a>,
    data: HashMap<String, String>
}


impl<'a, 'b> Bar<'a, 'b> {
    // fn test(&mut self) {
    //     // Cannot infer an appropriate lifetime.
    //     match self.data.get("foo") {
    //         Some(x) => {
    //             let p = P {x};
    //             self.x.foo(p);
    //         },
    //         None => {}
    //     }
    // }

    fn test2(&mut self) {
        match self.data.get("foo") {
            Some(x) => {
                let p = P {x};
                self.y.foo(p);
            },
            None => {}
        }
    }

}

Playground .我正在使用 rustc 1.19.0-nightly。

为什么 test2 有效而 test 无效？如何正确制作通用结构 Foo？

我不认为这个例子涉及Why can't I store a value and a reference to that value in the same struct?并且不是重复的。

Answer 1

什么是 'a , 什么是 'b ？

如果我们隔离失败的案例(请注意，我为 self 引入了生命周期以使其更容易):

pub struct P<'a> {
    x: &'a str
}

pub struct Foo<'a, T> {
    callbacks: Vec<Box<'a + FnMut(&T)>>
}

impl<'a, T> Foo<'a, T>{
    pub fn foo(&mut self, payload: T) {
    }
}

struct Bar<'a, 'b> {
    x: Foo<'a, P<'b>>,
    data: HashMap<String, String>
}


impl<'a, 'b> Bar<'a, 'b> {
    fn test<'c>(&'c mut self) {
        // Cannot infer an appropriate lifetime.
        match self.data.get("foo") {
            Some(x) => {
                let p = P {x};
                self.x.foo(p);
            },
            None => {}
        }
    }
}

这里的问题是当你实例化 Bar ，你修复什么'a和 'b是。

具体来说，此生命周期不是 'c , 这是完全不相关的。

编译器看到:

• self.x.foo 的参数必须有类型 P<'b> ,
• 它的类型是P<'unknown> , 其中'unknown是任何生命周期 小于 'c ,
• 它的类型是P<'unknown> , 所以 'unknown必须大于 'b ,
• 'b和 'c是无关的。

不知道是什么'unknown应该是。

---

一个潜在的解决方案是避免修复 'b :

pub struct Foo<'a> {
    callbacks: Vec<Box<'a + FnMut(&P)>>,
}

impl<'a> Foo<'a> {
    pub fn foo(&mut self, payload: P) {}
}

struct Bar<'a> {
    x: Foo<'a>,
    data: HashMap<String, String>,
}

注意:此时，'a似乎也是多余的。

然而，这需要我们修复 T同样，因为在使用类型参数时(就像我们对 Foo<'a, T> 所做的那样)，我们需要完全指定类型并因此命名 P 的生命周期。将包含。