ex(01): variables

.rustlings-state.txt

···
 DON'T EDIT THIS FILE!
 
-variables1
+functions1
 
 intro1
-intro2
+intro2
+variables1
+variables2
+variables3
+variables4
+variables5
+variables6

exercises/01_variables/variables1.rs

···
 fn main() {
     // TODO: Add the missing keyword.
-    x = 5;
+    let x = 5;
 
     println!("x has the value {x}");
 }

exercises/01_variables/variables2.rs

···
 fn main() {
     // TODO: Change the line below to fix the compiler error.
-    let x;
+    let x = 0;
 
     if x == 10 {
         println!("x is ten!");

exercises/01_variables/variables3.rs

···
 fn main() {
     // TODO: Change the line below to fix the compiler error.
-    let x: i32;
+    let x: i32 = 0;
 
     println!("Number {x}");
 }

exercises/01_variables/variables4.rs

···
 // TODO: Fix the compiler error.
 fn main() {
-    let x = 3;
+    let mut x = 3;
     println!("Number {x}");
 
     x = 5; // Don't change this line

exercises/01_variables/variables5.rs

···
     println!("Spell a number: {}", number);
 
     // TODO: Fix the compiler error by changing the line below without renaming the variable.
-    number = 3;
+    let number = 3;
     println!("Number plus two is: {}", number + 2);
 }

exercises/01_variables/variables6.rs

···
 // TODO: Change the line below to fix the compiler error.
-const NUMBER = 3;
+const NUMBER: i32 = 3;
 
 fn main() {
     println!("Number: {NUMBER}");

solutions/01_variables/variables1.rs

···
 fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+    // Declaring variables requires the `let` keyword.
+    let x = 5;
+
+    println!("x has the value {x}");
 }

solutions/01_variables/variables2.rs

···
 fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+    // The easiest way to fix the compiler error is to initialize the
+    // variable `x`. By setting its value to an integer, Rust infers its type
+    // as `i32` which is the default type for integers.
+    let x = 42;
+
+    // But we can enforce a type different from the default `i32` by adding
+    // a type annotation:
+    // let x: u8 = 42;
+
+    if x == 10 {
+        println!("x is ten!");
+    } else {
+        println!("x is not ten!");
+    }
 }

solutions/01_variables/variables3.rs

···
+#![allow(clippy::needless_late_init)]
+
 fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+    // Reading uninitialized variables isn't allowed in Rust!
+    // Therefore, we need to assign a value first.
+    let x: i32 = 42;
+
+    println!("Number {x}");
+
+    // It is possible to declare a variable and initialize it later.
+    // But it can't be used before initialization.
+    let y: i32;
+    y = 42;
+    println!("Number {y}");
 }

solutions/01_variables/variables4.rs

···
 fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+    // In Rust, variables are immutable by default.
+    // Adding the `mut` keyword after `let` makes the declared variable mutable.
+    let mut x = 3;
+    println!("Number {x}");
+
+    x = 5;
+    println!("Number {x}");
 }

solutions/01_variables/variables5.rs

···
 fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+    let number = "T-H-R-E-E";
+    println!("Spell a number: {}", number);
+
+    // Using variable shadowing
+    // https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html#shadowing
+    let number = 3;
+    println!("Number plus two is: {}", number + 2);
 }

solutions/01_variables/variables6.rs

···
+// The type of constants must always be annotated.
+const NUMBER: u64 = 3;
+
 fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+    println!("Number: {NUMBER}");
 }