right let's try this one again

exercises/variables/variables1.rs

@@ -0,0 +1,42 @@
+// variables1.rs
+// Make me compile! Scroll down for hints :)
+
+fn main() {
+    x = 5;
+    println!("x has the value {}", x);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// Hint: The declaration on line 5 is missing a keyword that is needed in Rust
+// to create a new variable binding.

exercises/variables/variables2.rs

@@ -0,0 +1,47 @@
+// variables2.rs
+// Make me compile! Scroll down for hints :)
+
+fn main() {
+    let x;
+    if x == 10 {
+        println!("Ten!");
+    } else {
+        println!("Not ten!");
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// The compiler message is saying that Rust cannot infer the type that the
+// variable binding `x` has with what is given here.
+// What happens if you annotate line 5 with a type annotation?
+// What if you give x a value?
+// What if you do both?
+// What type should x be, anyway?
+// What if x is the same type as 10? What if it's a different type?

exercises/variables/variables3.rs

@@ -0,0 +1,43 @@
+// variables3.rs
+// Make me compile! Scroll down for hints :)
+
+fn main() {
+    let x = 3;
+    println!("Number {}", x);
+    x = 5;
+    println!("Number {}", x);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// In Rust, variable bindings are immutable by default. But here we're trying
+// to reassign a different value to x! There's a keyword we can use to make
+// a variable binding mutable instead.

exercises/variables/variables4.rs

@@ -0,0 +1,45 @@
+// variables4.rs
+// Make me compile! Scroll down for hints :)
+
+fn main() {
+    let x: i32;
+    println!("Number {}", x);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// Oops! In this exercise, we have a variable binding that we've created on
+// line 5, and we're trying to use it on line 6, but we haven't given it a
+// value. We can't print out something that isn't there; try giving x a value!
+// This is an error that can cause bugs that's very easy to make in any
+// programming language -- thankfully the Rust compiler has caught this for us!