由于需求冲突，无法推断出合适的生命周期

Question

我是 Rust 的新手，我正在使用 rust-tui 构建一个 TUI 应用程序来练习和理解 Rust 的概念。 我有这个代码：

// the widgets that can be renderd on the screen
#[derive(Clone)]
pub enum Widgets<'a> {
    ResList(ResList<'a>),
    ListResults(ListResults<'a>),
    Input(Input),
}

pub struct Screen<'a> {
    renders_done: u32,
    tx: Sender<Result<Event, crossterm::ErrorKind>>,
    rx: Receiver<Result<Event, crossterm::ErrorKind>>,
    main_screen: Widgets<'a>,
}


impl Screen<'_> {

    pub async fn handle_events(&mut self) {
        let event = self
            .rx
            .recv()
            .expect("Err while recievent the events in the reciever")
            .unwrap();

        let new_screen: Option<Widgets> = match &mut self.main_screen {
            Widgets::ResList(res_list) => {
                match event {
                    Event::Key(event) => match event.code {
                        KeyCode::Esc => {
                            Screen::exit_app();
                            None
                        }
                    _ => None,
                }
            }
            Widgets::Input(input) => input.handle_events(event).await,  <-- the problem comes when I add this
            _ => None,
        };
        match new_screen {
            Some(screen) => self.main_screen = screen,
            None => {}
        }
    }

}

impl Input {
    async fn handle_events(&mut self, event: Event) -> Option<Widgets> {
       None
    }
}

这个想法是，如果子模块返回一个小部件，主屏幕应该更改为该新小部件。 现在出于发短信的目的，我从不返回小部件。 但是当我尝试构建代码时，编译器会抱怨：

error[E0495]: cannot infer an appropriate lifetime due to conflicting requirements
   --> src/model/tui/screen.rs:84:32
    |
84  |     pub async fn handle_events(&mut self) {
    |                                ^^^^^^^^^
    |
note: first, the lifetime cannot outlive the lifetime `'_` as defined on the method body at 84:32...
   --> src/model/tui/screen.rs:84:32
    |
84  |     pub async fn handle_events(&mut self) {
    |                                ^
note: ...so that the expression is assignable
   --> src/model/tui/screen.rs:84:32
    |
84  |     pub async fn handle_events(&mut self) {
    |                                ^^^^^^^^^
    = note: expected `&mut Screen<'_>`
               found `&mut Screen<'_>`
note: but, the lifetime must be valid for the lifetime `'_` as defined on the impl at 45:13...
   --> src/model/tui/screen.rs:45:13
    |
45  | impl Screen<'_> {
    |             ^^
note: ...so that the expression is assignable
   --> src/model/tui/screen.rs:126:52
    |
126 |             Some(mut screen) => self.main_screen = screen,
    |                                                    ^^^^^^
    = note: expected `Widgets<'_>`
               found `Widgets<'_>`

error: aborting due to previous error; 8 warnings emitted

For more information about this error, try `rustc --explain E0495`.

据我所知，生命周期不足以保存在结构中，但我没有在任何地方使用引用，它们都是拥有的值。 有人可以帮助我了解我错过了什么吗？

Answer 1

在返回的小部件上明确指定生命周期并创建对象的明确生命周期：

impl<'screen> Screen<'screen> {

    pub async fn handle_events<'c>(&'cmut self) {
        let event = self
            .rx
            .recv()
            .expect("Err while recievent the events in the reciever")
            .unwrap();

        let new_screen: Option<Widgets<'screen>> = match &mut self.main_screen {
            Widgets::ResList(res_list) => {
                match event {
                    Event::Key(event) => match event.code {
                        KeyCode::Esc => {
                            Screen::exit_app();
                            None
                        }
                    _ => None,
                }
            }
            Widgets::Input(input) => input.handle_events(event).await,
            _ => None,
        };
        match new_screen {
            Some(screen) => self.main_screen = screen,
            None => {}
        }
    }

}

从函数内部返回 Widget 时，还要显式添加生命周期