Destrukturierung während Iterieren durch eine Vec <Enum (String)>

Ich habe eine Enumeration genannt Token (kann man erraten, was ich zu bauen bin versucht: P)Destrukturierung während Iterieren durch eine Vec <Enum (String)>

Es sieht sehr viel wie folgt aus:

enum Token { 
    Paren(String), 
    Number(String), 
    Name(String), 
}

Jetzt habe ich eine Funktion mit der folgenden Signatur:

fn tokenizer(input: String) -> Vec<Token>

ich habe keinen Grund zu glauben, dass es nicht im Grunde funktioniert, so dass ich obvio usly haben eine Vec<Token>.

nun in meine Hauptfunktion habe ich dies:

let tokens = tokenizer("(add 44 5)".to_owned());

und ich möchte etwas wie folgendes tun:

let mut iter = tokens.iter(); 
while let Some(token) = iter.next() { 
    match token { 
     Token::Paren(p) => println!("Token::Paren({})", p), 
     Token::Number(p) => println!("Token::Number({})", p), 
     Token::Name(p) => println!("Token::Name({})", p), 
    } 
}

Aber offensichtlich das Borge-checker isn‘ Ich lasse mich so leicht davonkommen.

Was ist der richtige Weg, dies zu tun? Offensichtlich, wie Sie durch die Natur dieses Projektes hoffentlich erzählen können, versuche ich gerade, Rust zu lernen, deshalb wäre jeder Rat hilfreich, selbst wenn es nicht wirklich direkt auf das Problem bezogen ist. =)

Quelle

2016-04-08 River Tam

Ihre Enum besitzt die Zeichenfolgen, die in und so weitergegeben werden Destrukturierung sie sie von Wert zu erfassen versucht (und es aus dem Enum) zu bewegen.

Sie können dieses Problem beheben, indem ref p mit, während sie durch Bezugnahme auf die Erfassung Destrukturierung .. Anhalten der Bewegung.

match *token { 
    Token::Paren(ref p) => println!("Token::Paren({})", p), 
    Token::Number(ref p) => println!("Token::Number({})", p), 
    Token::Name(ref p) => println!("Token::Name({})", p), 
}

Working sample on the Playpen

Beachten Sie, dass Sie auch dereferenzieren Token müssen, weil Sie iter() verwenden, die Verweise auf die Tokens in den Vektor zurückgibt. Wenn Sie into_iter() verwendet haben, wird die Eigentumsübertragung übernommen und Sie können auf Nichtverweise zugreifen. Ihre tokens Variable ist jetzt jedoch fehlerhaft, da die Werte verschoben werden.

Quelle

2016-04-08 02:40:00

Mein Held! Wenn ich eine andere Frage stellen kann, weil wir im Match-Block Mustervergleiche durchführen, führt das zu einem Umzug, einer Kopie oder keinem von beiden? Ich bin sehr neu in Rust. =) –

Es hängt davon ab, wie Sie sie erfassen. Dein Original hat einen Zug verursacht (oder versucht es zu bewegen), weil du "p" nach Wert aufgenommen hast. Die Verwendung von 'ref' erfasst es als Referenz und verschiebt es daher nicht. Es gibt andere Dinge, die hier zu beachten sind, aber sie müssen nur erläutert werden, da Ihre Match-Blöcke zu tatsächlichen Code-Blöcken werden und eine gewisse Komplexität aufweisen. Andere Dinge zu beachten ist, ob Ihre Art 'Copy' ist oder nicht .. aber wieder Sorgen darüber später :) –

Es idiomatische betrachtet zu schreiben' match * Token {...} '. –

Destrukturierung während Iterieren durch eine Vec <Enum (String)>

Antwort

Verwandte Themen