Sou novo no Rust e estou tendo alguns problemas com o verificador de empréstimos. Não entendo por que esse código não será compilado. Desculpe se isso se aproxima de uma pergunta respondida anteriormente, mas não consigo encontrar uma solução nas outras perguntas que examinei.

Eu entendo a semelhança comRetornar String local como uma fatia (& str) mas nesse caso, é apenas uma string sendo retornada e não é suficiente para eu raciocinar com meu código no qual estou tentando retornar um vetor. Pelo que entendi, estou tentando retornar referências astr tipos que ficarão fora do escopo no final do bloco de funções e, portanto, devo mapear esse vetor de&str em um vetor deString? Não estou tão preocupado com os efeitos no desempenho da conversão&str paraString. Primeiro, gostaria de fazê-lo funcionar.

Este é o código, o erro está nolex função.

use std::io::prelude::*;
use std::fs::File;
use std::env;

fn open(mut s: &mut String, filename: &String) {
    let mut f = match File::open(&filename) {
        Err(_) => panic!("Couldn't open file"),
        Ok(file) => file,
    };
    match f.read_to_string(&mut s) {
        Err(_) => panic!("Couldn't read file"),
        Ok(_) => println!("File read successfully"),
    };

}

fn lex(s: &String) -> Vec<&str> {
    let token_string: String = s.replace("(", " ( ")
        .replace(")", " ) ");

    let token_list: Vec<&str> = token_string.split_whitespace()
        .collect();
    token_list
}

fn main() {
    let args: Vec<_> = env::args().collect();
    if args.len() < 2 {
        panic!("Please provide a filename");
    } else {
        let ref filename = args[1];

        let mut s = String::new();
        open(&mut s, filename);
        let token_list: Vec<&str> = lex(&s);
        println!("{:?}", token_list);
    }
}

Aqui está a mensagem de erro

error: borrowed value does not live long enough
        self.0.borrow().values.get(idx)
        ^~~~~~~~~~~~~~~
reference must be valid for the anonymous lifetime #1 defined on the block at 23:54...
    pub fn value(&self, idx: usize) -> Option<&Value> {
                                                      ^
note: ...but borrowed value is only valid for the block at 23:54
    pub fn value(&self, idx: usize) -> Option<&Value> {
                                                      ^

Estou achando difícil argumentar com esse código porque, com meu nível de experiência com Rust, não consigo visualizar a vida útil dessas variáveis. Qualquer ajuda seria apreciada, pois passei uma ou duas horas tentando descobrir isso.