Soy nuevo en Rust y tengo algunos problemas con el corrector de préstamos. No entiendo por qué este código no se compilará. Lo siento si esto está cerca de una pregunta respondida anteriormente, pero parece que no puedo encontrar una solución en las otras preguntas que he visto.

Entiendo la similitud conDevuelve una cadena local como un segmento (& str) pero en ese caso, solo se devuelve una cadena y no es suficiente para razonar con mi código en el que estoy tratando de devolver un vector. Por lo que entiendo, estoy tratando de devolver referencias astr tipos que quedarán fuera de alcance al final del bloque de funciones y, por lo tanto, debería estar mapeando ese vector de&str en un vector deString? No estoy tan preocupado por los efectos de rendimiento de la conversión&str aString. Primero, me gustaría que funcione.

Este es el código, el error está en ellex función.

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);
    }
}

Aquí está el mensaje de error

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> {
                                                      ^

Me resulta difícil razonar con este código porque con mi nivel de experiencia con Rust no puedo visualizar la vida útil de estas variables. Cualquier ayuda sería apreciada ya que pasé una o dos horas tratando de resolver esto.