Come si fa a prendere in prestito un riferimento mutabile durante una partita?

Question

Ho trovato this ma non è riuscito a far funzionare il mio codice. Ho ancora il vago sospetto che ho bisogno dello ref in qualche modo.

Sto cercando di creare una classe Table ragionevole in Rust per imparare di più sulla lingua e incorrere in qualche problema con la comprensione dei concetti di mutuatario e mutevole e la loro sintassi corrispondente.

Desidero che la classe della tabella sia flessibile e consenta tipi di colonna diversi in cui i tipi di dati all'interno delle colonne sono omogenei. Quindi, una colonna di int, galleggia, corde ecc

---

ho iniziato senza i tipi di dati flessibili e si avvicinò con interi mappatura this HashMap (le etichette di colonna in questo caso) a vettori di interi (i dati all'interno del colonne).

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]} 
} 

Per implementare tipi di dati flessibili, enum sembrava un inizio decente quindi that is where I started ma io sono bloccato sulla realizzazione.

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 :(

In ultima analisi, avere una biblioteca simile a pandas sarebbe il sogno. Per ora, implementare un tavolo è una buona pratica della ruggine.

Answer 1

tua partita blocco dovrebbe essere simile a questo:

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

In modelli ref mut prende un riferimento mutabile, anche come &mut dereference un riferimento mutevole.

(Convenzione è anche match *foo { X => … } piuttosto che match foo { &mut X => … }, ma questa è una questione molto minore.)