Rust无法推断出合适的生命周期

Question

我有以下代码。我正在使用mio和服务器来接受连接。在接受客户端之后，它会将其s的引用放入客户端，并将客户端置于其自己的HashMap中。

use std::sync::Arc;
use std::collections::HashMap;
use mio::EventLoop;
use mio::EventSet;
use mio::Token;
use mio::Handler;
use mio::tcp::TcpListener;
use mio::tcp::TcpStream;

const SERVER_TOKEN: Token = Token(0);

struct FunctionWrapper<'a> {
    f: Arc<Fn() -> () + 'a>,
}

struct Client<'a> {
    socket: TcpStream,
    s: &'a Vec<FunctionWrapper<'a>>,
}

struct Server<'a> {
    s: Vec<FunctionWrapper<'a>>,
    token_counter: usize,
    socket: TcpListener,
    clients: HashMap<Token, Client<'a>>,
}

impl<'a> Handler for Server<'a> {
    type Timeout = ();
    type Message = ();
    fn ready(&mut self, event_loop: &mut EventLoop<Self>, token: Token, _: EventSet) {
        match token {
            SERVER_TOKEN => {
                let client_socket = match self.socket.accept() {
                    Ok(Some((sock, addr))) => sock,
                    Ok(None) => unreachable!(),
                    Err(_) => unreachable!(),
                };
                let new_token = Token(self.token_counter);
                self.token_counter += 1;
                let c = Client {
                    socket: client_socket,
                    s: &self.s,
                };
                self.clients.insert(new_token, c);
            },
            token => {
                // ...
            },
        }
    }
}

fn main() {
}

编译器说：

main.rs:155:24: 155:31 error: cannot infer an appropriate lifetime for borrow expression due to conflicting requirements [E0495]
main.rs:155                     s: &self.s,
                                   ^~~~~~~
main.rs:144:5: 163:6 help: consider using an explicit lifetime parameter as shown: fn ready(&'a mut self, event_loop: &mut EventLoop<Self>, token: Token,
         _: EventSet)
main.rs:144     fn ready(&mut self, event_loop: &mut EventLoop<Self>, token: Token, _: EventSet) {
main.rs:145         match token {
main.rs:146             SERVER_TOKEN => {
main.rs:147                 let client_socket = match self.socket.accept() {
main.rs:148                     Ok(Some((sock, addr))) => sock,
main.rs:149                     Ok(None) => unreachable!(),

看起来编译器无法计算客户端和服务器之间的生命周期。由于客户端包含在服务器的映射中，因此它们永远不会比服务器更耐用。所以我认为对服务器中的字段的引用会很好。

我该如何解决这个问题？