Warum dieses Rust-Programm Unveränderlichkeit ignorieren

Question

Ich habe das folgende Rust-Programm und ich erwarte, dass es zu einem Kompilierungsfehler führt, da x später neu zugewiesen wird. Aber es entspricht und gibt eine Ausgabe. Warum?

fn main() { 
    let (x, y) = (1, 3); 
    println!("X is {} and Y is {}", x, y); 

    let x: i32 = 565; 
    println!("Now X is {}", x); 
} 

Answer 1

Rust tatsächlich können Sie andere Variablen in einem Block Schatten, so ist let x: i32 = 565; eine neue Variable x definieren, die die x definiert früher mit let (x,y) = (1,3); Schatten. Beachten Sie, dass Sie sogar x neu definiert haben könnten, um einen anderen Typ zu haben, da die zweite x eine ganz neue Variable ist!

fn main(){ 
    let x = 1; 
    println!("Now X is {}",x); 

    let x = "hi"; 
    println!("Now X is {}",x); 
} 

Diese reddit thread geht mehr ins Detail darüber, warum dies sinnvoll ist. Die beiden Dinge, die erwähnt werden, die interessant scheinen, sind:

• Für Operationen, die das Eigentum an der Variablen nehmen, aber eine andere Variable des gleichen Typs zurückgeben, ist es manchmal „schön aussieht“, um die zurückgegebenen Variablen neu zu definieren, die haben gleicher Name. Von here:

  let iter = vec.into_iter(); 
  let iter = modify(iter); 
  let iter = double(iter); 
  

• oder eine Variable unveränderlich zu machen:

  let mut x; 
  // Code where `x` is mutable 
  let x = x; 
  // Code where `x` is immutable