Wie leihen Sie sich während eines Spiels eine veränderbare Referenz aus?

Question

Ich habe this gefunden, konnte aber meinen Code nicht zum Funktionieren bringen. Ich habe immer noch den schleichenden Verdacht, dass ich irgendwie ref brauche.

Ich versuche eine vernünftige Tabelle Klasse in Rust zu machen, um mehr über die Sprache zu lernen und in einige Schwierigkeiten mit dem Verständnis der Borger Checker und Mutability Konzepte sowie ihre entsprechende Syntax zu geraten.

Ich möchte, dass die Tabellenklasse flexibel ist und verschiedene Spaltentypen zulässt, bei denen die Datentypen in den Spalten homogen sind. Also, eine Spalte von Ints, Schwimmern, Strings usw.

---

begann ich ohne flexible Datentypen und kam mit this hashmap Mapping Ints (die Spaltenbeschriftungen in diesem Fall) Vektoren von Ints (die Daten innerhalb der Säulen).

use std::collections::HashMap; 

fn main() { 
    let mut d: HashMap<isize, Vec<isize>> = HashMap::new(); 
    d.insert(0, Vec::new()); 
    d.get_mut(&0).unwrap().push(0); 

    println!("{:?}", d); 
    // nice {0: [0]} 
} 

flexible Datentypen zu implementieren, schien enum wie ein anständiger Start so that is where I started aber ich bin über die Umsetzung fest.

use std::collections::HashMap; 

#[derive(Debug)] 
enum VT { 
    A(Vec<isize>), 
    B(Vec<f64>), 
} 

fn main() { 
    let mut d: HashMap<isize, VT> = HashMap::new(); 
    d.insert(0, VT::A(Vec::new())); 

    match d.get_mut(&0).unwrap() { 
     &mut VT::A(v) => v.push(0), 
     &mut VT::B(v) => v.push(0.1), // would not be reached as-is 
    } 

    println!("{:?}", d); 
} 
// cannot borrow immutable local variable `v` as mutable :(

Letztlich würde eine Bibliothek ähnlich wie mit pandas der Traum sein. Fürs Erste ist die Umsetzung einer Tabelle eine gute Rust-Praxis.

Answer 1

Ihr Spiel Block sollte wie folgt sein:

match *d.get_mut(&0).unwrap() { 
    VT::A(ref mut v) => v.push(0), 
    VT::B(ref mut v) => v.push(0.1), 
} 

In Mustern ref mut nimmt eine veränderbare Referenz, auch als &mut dereferenziert eine veränderbare Referenz.

(Übereinkommen ist auch match *foo { X => … } statt match foo { &mut X => … }, aber das ist eine sehr kleine Angelegenheit.)