Wie man auf einem Vec abbildet und eine Schließung mit Musterabgleich in Rust verwendet

Question

Ich möchte map verwenden, um über ein Array zu iterieren und Sachen pro Gegenstand zu erledigen und die for-Schleife loszuwerden. Ein Fehler, den ich nicht verstehe, blockiert meinen Versuch. Was ich erreichen möchte, besteht darin, einen Vektor von i32 zu durchlaufen und auf sie zu passen, um eine Zeichenkette mit Zeichenkettenliteralen zu bilden und sie dann am Ende zurückzugeben.

Funktion:

pub fn convert_to_rainspeak(prime_factors: Vec<i32>) -> String { 
    let mut speak = String::new(); 
    prime_factors.iter().map(|&factor| { 
     match factor { 
      3 => { speak.push_str("Pling"); }, 
      5 => { speak.push_str("Plang"); }, 
      7 => { speak.push_str("Plong"); }, 
      _ => {} 
     } 
    }).collect(); 
    speak 
} 

fn main() {} 

Ausgang:

error[E0282]: type annotations needed 
    --> src/main.rs:10:8 
    | 
10 |  }).collect(); 
    |  ^^^^^^^ cannot infer type for `B` 

Answer 1

Iterator::collect ist definiert als:

fn collect<B>(self) -> B 
where 
    B: FromIterator<Self::Item> 

Das heißt, es eine Art gibt, die bis zu dem Anrufer ist. Sie haben die Ausgabe jedoch vollständig ignoriert, so dass sie nicht auf einen Typ schließen kann. Der Code missbraucht collect, wenn er grundsätzlich for verwenden möchte.

In Ihrer "korrigierten" Version (die seither bearbeitet wurde, was diesen Absatz sinnlos macht), sind Sie sehr ineffizient, indem Sie in jeder Iteration eine Zeichenfolge zuweisen. Und Sie brauchen keine explizite Typen, die nicht an der Funktion zu spezifizieren, und Sie sollten eine &[i32] stattdessen akzeptieren:

fn convert_to_rainspeak(prime_factors: &[i32]) -> String { 
    prime_factors.iter() 
     .map(|&factor| { 
      match factor { 
       3 => "Pling", 
       5 => "Plang", 
       7 => "Plong", 
       _ => "", 
      } 
     }) 
     .collect() 
} 

fn main() { 
    println!("{}", convert_to_rainspeak(&[1, 2, 3, 4, 5])); 
} 

Answer 2

paar Minuten später löste ich es mich (jedes Upgrade geschätzt):

pub fn convert_to_rainspeak(prime_factors:Vec<i32>) -> String{ 
    let mut speak:String = prime_factors.iter().map(|&factor| { 
     match factor { 
      3 => {"Pling"}, 
      5 => {"Plang"}, 
      7 => {"Plong"}, 
      _ => {""} 
     } 
    }).collect(); 
    speak 
} 

Das Problem war, dass ich nicht bewusst war, Das .collect() erwartet das Ergebnis der Karte. Ich habe dann prime_factors.iter()... einem String zugewiesen und var Bindings neu angeordnet, so dass es jetzt alles funktioniert.

EDIT: Refactoring redundante Zuweisungen an dem spricht Vektor

Answer 3

Der Fehler in diesem Fall ist, dass der Compiler nicht herausfinden können, welche Art Sie collect in ing. Wenn Sie eine Typanmerkung zu collect hinzufügen, dann wird es funktionieren:

pub fn convert_to_rainspeak(prime_factors:Vec<i32>) -> String{ 
    let mut speak = String::new(); 
    prime_factors.iter().map(| &factor| { 
     match factor { 
      3 => {speak.push_str("Pling");}, 
      5 => {speak.push_str("Plang");}, 
      7 => {speak.push_str("Plong");}, 
      _ => {} 
     } 
    }).collect::<Vec<_>>(); 
    speak 
} 

Dies ist jedoch nicht wirklich der idiomatische Weg, dies zu tun. Sie sollten for statt:

pub fn convert_to_rainspeak(prime_factors:Vec<i32>) -> String { 
    let mut speak = String::new(); 
    for factor in prime_factors.iter() { 
     match *factor { 
      3 => speak.push_str("Pling"), 
      5 => speak.push_str("Plang"), 
      7 => speak.push_str("Plong"), 
      _ => {} 
     } 
    } 

    speak 
} 

Answer 4

Sie auch flat_map() statt map() nutzen könnten. Auf diese Weise können Sie Option zuordnen und None anstelle einer leeren Zeichenfolge zurückgeben, wenn kein entsprechender Wert vorhanden ist.

fn convert_to_rainspeak(prime_factors: &[i32]) -> String { 
    prime_factors 
     .iter() 
     .flat_map(|&factor| match factor { 
      3 => Some("Pling"), 
      5 => Some("Plang"), 
      7 => Some("Plong"), 
      _ => None, 
     }) 
     .collect() 
} 


fn main() { 
    println!("{}", convert_to_rainspeak(&[1, 2, 3, 7])); 
}