Ich bin neu in Rust und habe Probleme mit dem Leihschein. Ich verstehe nicht, warum dieser Code nicht kompiliert werden kann. Es tut mir leid, wenn dies in der Nähe einer zuvor beantworteten Frage liegt, aber ich kann in den anderen Fragen, die ich mir angesehen habe, keine Lösung finden.

Ich verstehe die Ähnlichkeit zuReturn local String as a slice (& str) aber in diesem Fall wird nur eine Zeichenfolge zurückgegeben, und es reicht mir nicht aus, mit meinem Code zu argumentieren, in dem ich versuche, einen Vektor zurückzugeben. Soweit ich weiß, versuche ich, Verweise auf @ zurückzugebestr -Typen, die am Ende des Funktionsblocks den Gültigkeitsbereich verlassen, und daher sollte ich diesen Vektor von @ abbild&str in einen Vektor vonString? Ich bin nicht so besorgt über die Leistungseffekte der Konvertierung&str zuString. Zuerst möchte ich es einfach zum Laufen bringen.

Dies ist der Code, der Fehler ist imlex Funktion.

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

Hier ist die Fehlermeldung

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

Ich finde es schwierig, mit diesem Code zu argumentieren, da ich aufgrund meiner Erfahrung mit Rust die Lebensdauer dieser Variablen nicht visualisieren kann. Für jede Hilfe wäre ich dankbar, da ich ein oder zwei Stunden damit verbracht habe, dies herauszufinden.