right let's try this one again

exercises/primitive_types/primitive_types1.rs

@@ -0,0 +1,17 @@
+// primitive_types1.rs
+// Fill in the rest of the line that has code missing!
+// No hints, there's no tricks, just get used to typing these :)
+
+fn main() {
+    // Booleans (`bool`)
+
+    let is_morning = true;
+    if is_morning {
+        println!("Good morning!");
+    }
+
+    let // Finish the rest of this line like the example! Or make it be false!
+    if is_evening {
+        println!("Good evening!");
+    }
+}

exercises/primitive_types/primitive_types2.rs

@@ -0,0 +1,27 @@
+// primitive_types2.rs
+// Fill in the rest of the line that has code missing!
+// No hints, there's no tricks, just get used to typing these :)
+
+fn main() {
+    // Characters (`char`)
+
+    let my_first_initial = 'C';
+    if my_first_initial.is_alphabetic() {
+        println!("Alphabetical!");
+    } else if my_first_initial.is_numeric() {
+        println!("Numerical!");
+    } else {
+        println!("Neither alphabetic nor numeric!");
+    }
+
+    let // Finish this line like the example! What's your favorite character?
+    // Try a letter, try a number, try a special character, try a character
+    // from a different language than your own, try an emoji!
+    if your_character.is_alphabetic() {
+        println!("Alphabetical!");
+    } else if your_character.is_numeric() {
+        println!("Numerical!");
+    } else {
+        println!("Neither alphabetic nor numeric!");
+    }
+}

exercises/primitive_types/primitive_types3.rs

@@ -0,0 +1,47 @@
+// primitive_types3.rs
+// Create an array with at least 100 elements in it where the ??? is. 
+// Scroll down for hints!
+
+fn main() {
+    let a = ???
+
+    if a.len() >= 100 {
+        println!("Wow, that's a big array!");
+    } else {
+        println!("Meh, I eat arrays like that for breakfast.");
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// There's a shorthand to initialize Arrays with a certain size that does not 
+// require you to type in 100 items (but you certainly can if you want!).
+// For example, you can do:
+// let array = ["Are we there yet?"; 10];
+
+// Bonus: what are some other things you could have that would return true
+// for `a.len() >= 100`?

exercises/primitive_types/primitive_types4.rs

@@ -0,0 +1,49 @@
+// primitive_types4.rs
+// Get a slice out of Array a where the ??? is so that the `if` statement
+// returns true. Scroll down for hints!!
+
+fn main() {
+    let a = [1, 2, 3, 4, 5];
+
+    let nice_slice = ???
+
+    if nice_slice == [2, 3, 4] {
+        println!("Nice slice!");
+    } else {
+        println!("Not quite what I was expecting... I see: {:?}", nice_slice);
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// Take a look at the Understanding Ownership -> Slices -> Other Slices section of the book:
+// https://doc.rust-lang.org/stable/book/second-edition/ch04-03-slices.html#other-slices
+// and use the starting and ending indices of the items in the Array
+// that you want to end up in the slice.
+
+// If you're curious why the right hand of the `==` comparison does not
+// have an ampersand for a reference since the left hand side is a
+// reference, take a look at the Deref coercions section of the book:
+// https://doc.rust-lang.org/stable/book/second-edition/ch15-02-deref.html#implicit-deref-coercions-with-functions-and-methods

exercises/primitive_types/primitive_types5.rs

@@ -0,0 +1,45 @@
+// primitive_types5.rs
+// Destructure the `cat` tuple so that the println will work.
+// Scroll down for hints!
+
+fn main() {
+    let cat = ("Furry McFurson", 3.5);
+    let /* your pattern here */ = cat;
+
+    println!("{} is {} years old.", name, age);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// Take a look at the Data Types -> The Tuple Type section of the book:
+// https://doc.rust-lang.org/stable/book/second-edition/ch03-02-data-types.html#the-tuple-type
+// Particularly the part about destructuring (second to last example in the section). 
+// You'll need to make a pattern to bind `name` and `age` to the appropriate parts
+// of the tuple. You can do it!!

exercises/primitive_types/primitive_types6.rs

@@ -0,0 +1,45 @@
+// primitive_types6.rs
+// Use a tuple index to access the second element of `numbers`.
+// You can put this right into the `println!` where the ??? is.
+// Scroll down for hints!
+
+fn main() {
+    let numbers = (1, 2, 3);
+    println!("The second number is {}", ???);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// While you could use a destructuring `let` for the tuple here, try 
+// indexing into it instead, as explained in the last example of the 
+// Data Types -> The Tuple Type section of the book:
+// https://doc.rust-lang.org/stable/book/second-edition/ch03-02-data-types.html#the-tuple-type
+// Now you have another tool in your toolbox!