20230726

.history/exercises/functions/functions1_20230726201504.rs

@@ -0,0 +1,8 @@
+// functions1.rs
+// Execute `rustlings hint functions1` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    call_me();
+}

.history/exercises/functions/functions1_20230726202007.rs

@@ -0,0 +1,12 @@
+// functions1.rs
+// Execute `rustlings hint functions1` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    call_me();
+}
+
+fn call_me(){
+    
+}

.history/exercises/functions/functions1_20230726202011.rs

@@ -0,0 +1,10 @@
+// functions1.rs
+// Execute `rustlings hint functions1` or use the `hint` watch subcommand for a hint.
+
+fn main() {
+    call_me();
+}
+
+fn call_me(){
+    
+}

.history/exercises/functions/functions2_20230726201504.rs

@@ -0,0 +1,14 @@
+// functions2.rs
+// Execute `rustlings hint functions2` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    call_me(3);
+}
+
+fn call_me(num:) {
+    for i in 0..num {
+        println!("Ring! Call number {}", i + 1);
+    }
+}

.history/exercises/functions/functions2_20230726202023.rs

@@ -0,0 +1,14 @@
+// functions2.rs
+// Execute `rustlings hint functions2` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    call_me(3);
+}
+
+fn call_me(num: i32) {
+    for i in 0..num {
+        println!("Ring! Call number {}", i + 1);
+    }
+}

.history/exercises/functions/functions2_20230726202028.rs

@@ -0,0 +1,12 @@
+// functions2.rs
+// Execute `rustlings hint functions2` or use the `hint` watch subcommand for a hint.
+
+fn main() {
+    call_me(3);
+}
+
+fn call_me(num: i32) {
+    for i in 0..num {
+        println!("Ring! Call number {}", i + 1);
+    }
+}

.history/exercises/functions/functions2_20230726222208.rs

@@ -0,0 +1,12 @@
+// functions2.rs
+// Execute `rustlings hint functions2` or use the `hint` watch subcommand for a hint.
+
+fn main() {s
+    call_me(3);
+}
+
+fn call_me(num: i32) {
+    for i in 0..num {
+        println!("Ring! Call number {}", i + 1);
+    }
+}

.history/exercises/functions/functions2_20230726222209.rs

@@ -0,0 +1,12 @@
+// functions2.rs
+// Execute `rustlings hint functions2` or use the `hint` watch subcommand for a hint.
+
+fn main() {
+    call_me(3);
+}
+
+fn call_me(num: i32) {
+    for i in 0..num {
+        println!("Ring! Call number {}", i + 1);
+    }
+}

.history/exercises/functions/functions3_20230726201504.rs

@@ -0,0 +1,14 @@
+// functions3.rs
+// Execute `rustlings hint functions3` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    call_me();
+}
+
+fn call_me(num: u32) {
+    for i in 0..num {
+        println!("Ring! Call number {}", i + 1);
+    }
+}

.history/exercises/functions/functions3_20230726222227.rs

@@ -0,0 +1,14 @@
+// functions3.rs
+// Execute `rustlings hint functions3` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    call_me(3);
+}
+
+fn call_me(num: u32) {
+    for i in 0..num {
+        println!("Ring! Call number {}", i + 1);
+    }
+}

.history/exercises/functions/functions3_20230726222232.rs

@@ -0,0 +1,12 @@
+// functions3.rs
+// Execute `rustlings hint functions3` or use the `hint` watch subcommand for a hint.
+
+fn main() {
+    call_me(3);
+}
+
+fn call_me(num: u32) {
+    for i in 0..num {
+        println!("Ring! Call number {}", i + 1);
+    }
+}

.history/exercises/functions/functions4_20230726201504.rs

@@ -0,0 +1,27 @@
+// functions4.rs
+// Execute `rustlings hint functions4` or use the `hint` watch subcommand for a hint.
+
+// This store is having a sale where if the price is an even number, you get
+// 10 Rustbucks off, but if it's an odd number, it's 3 Rustbucks off.
+// (Don't worry about the function bodies themselves, we're only interested
+// in the signatures for now. If anything, this is a good way to peek ahead
+// to future exercises!)
+
+// I AM NOT DONE
+
+fn main() {
+    let original_price = 51;
+    println!("Your sale price is {}", sale_price(original_price));
+}
+
+fn sale_price(price: i32) -> {
+    if is_even(price) {
+        price - 10
+    } else {
+        price - 3
+    }
+}
+
+fn is_even(num: i32) -> bool {
+    num % 2 == 0
+}

.history/exercises/functions/functions4_20230726222255.rs

@@ -0,0 +1,27 @@
+// functions4.rs
+// Execute `rustlings hint functions4` or use the `hint` watch subcommand for a hint.
+
+// This store is having a sale where if the price is an even number, you get
+// 10 Rustbucks off, but if it's an odd number, it's 3 Rustbucks off.
+// (Don't worry about the function bodies themselves, we're only interested
+// in the signatures for now. If anything, this is a good way to peek ahead
+// to future exercises!)
+
+// I AM NOT DONE
+
+fn main() {
+    let original_price = 51;
+    println!("Your sale price is {}", sale_price(original_price));
+}
+
+fn sale_price(price: i32) -> i32 {
+    if is_even(price) {
+        price - 10
+    } else {
+        price - 3
+    }
+}
+
+fn is_even(num: i32) -> bool {
+    num % 2 == 0
+}

.history/exercises/functions/functions4_20230726222302.rs

@@ -0,0 +1,25 @@
+// functions4.rs
+// Execute `rustlings hint functions4` or use the `hint` watch subcommand for a hint.
+
+// This store is having a sale where if the price is an even number, you get
+// 10 Rustbucks off, but if it's an odd number, it's 3 Rustbucks off.
+// (Don't worry about the function bodies themselves, we're only interested
+// in the signatures for now. If anything, this is a good way to peek ahead
+// to future exercises!)
+
+fn main() {
+    let original_price = 51;
+    println!("Your sale price is {}", sale_price(original_price));
+}
+
+fn sale_price(price: i32) -> i32 {
+    if is_even(price) {
+        price - 10
+    } else {
+        price - 3
+    }
+}
+
+fn is_even(num: i32) -> bool {
+    num % 2 == 0
+}

.history/exercises/functions/functions5_20230726201504.rs

@@ -0,0 +1,13 @@
+// functions5.rs
+// Execute `rustlings hint functions5` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let answer = square(3);
+    println!("The square of 3 is {}", answer);
+}
+
+fn square(num: i32) -> i32 {
+    num * num;
+}

.history/exercises/functions/functions5_20230726222322.rs

@@ -0,0 +1,13 @@
+// functions5.rs
+// Execute `rustlings hint functions5` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let answer = square(3);
+    println!("The square of 3 is {}", answer);
+}
+
+fn square(num: i32) -> i32 {
+    num * num
+}

.history/exercises/functions/functions5_20230726222326.rs

@@ -0,0 +1,11 @@
+// functions5.rs
+// Execute `rustlings hint functions5` or use the `hint` watch subcommand for a hint.
+
+fn main() {
+    let answer = square(3);
+    println!("The square of 3 is {}", answer);
+}
+
+fn square(num: i32) -> i32 {
+    num * num
+}

.history/exercises/if/if1_20230726201504.rs

@@ -0,0 +1,27 @@
+// if1.rs
+// Execute `rustlings hint if1` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+pub fn bigger(a: i32, b: i32) -> i32 {
+    // Complete this function to return the bigger number!
+    // Do not use:
+    // - another function call
+    // - additional variables
+}
+
+// Don't mind this for now :)
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn ten_is_bigger_than_eight() {
+        assert_eq!(10, bigger(10, 8));
+    }
+
+    #[test]
+    fn fortytwo_is_bigger_than_thirtytwo() {
+        assert_eq!(42, bigger(32, 42));
+    }
+}

.history/exercises/if/if1_20230726222345.rs

@@ -0,0 +1,28 @@
+// if1.rs
+// Execute `rustlings hint if1` or use the `hint` watch subcommand for a hint.
+
+pub fn bigger(a: i32, b: i32) -> i32 {
+    if a > b {
+        
+    }
+    // Complete this function to return the bigger number!
+    // Do not use:
+    // - another function call
+    // - additional variables
+}
+
+// Don't mind this for now :)
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn ten_is_bigger_than_eight() {
+        assert_eq!(10, bigger(10, 8));
+    }
+
+    #[test]
+    fn fortytwo_is_bigger_than_thirtytwo() {
+        assert_eq!(42, bigger(32, 42));
+    }
+}

.history/exercises/if/if1_20230726222347.rs

@@ -0,0 +1,28 @@
+// if1.rs
+// Execute `rustlings hint if1` or use the `hint` watch subcommand for a hint.
+
+pub fn bigger(a: i32, b: i32) -> i32 {
+    if a > b {
+        a
+    }
+    // Complete this function to return the bigger number!
+    // Do not use:
+    // - another function call
+    // - additional variables
+}
+
+// Don't mind this for now :)
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn ten_is_bigger_than_eight() {
+        assert_eq!(10, bigger(10, 8));
+    }
+
+    #[test]
+    fn fortytwo_is_bigger_than_thirtytwo() {
+        assert_eq!(42, bigger(32, 42));
+    }
+}

.history/exercises/if/if1_20230726222350.rs

@@ -0,0 +1,30 @@
+// if1.rs
+// Execute `rustlings hint if1` or use the `hint` watch subcommand for a hint.
+
+pub fn bigger(a: i32, b: i32) -> i32 {
+    if a > b {
+        a
+    } else {
+        b
+    }
+    // Complete this function to return the bigger number!
+    // Do not use:
+    // - another function call
+    // - additional variables
+}
+
+// Don't mind this for now :)
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn ten_is_bigger_than_eight() {
+        assert_eq!(10, bigger(10, 8));
+    }
+
+    #[test]
+    fn fortytwo_is_bigger_than_thirtytwo() {
+        assert_eq!(42, bigger(32, 42));
+    }
+}

.history/exercises/if/if2_20230726201504.rs

@@ -0,0 +1,36 @@
+// if2.rs
+
+// Step 1: Make me compile!
+// Step 2: Get the bar_for_fuzz and default_to_baz tests passing!
+// Execute `rustlings hint if2` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+pub fn foo_if_fizz(fizzish: &str) -> &str {
+    if fizzish == "fizz" {
+        "foo"
+    } else {
+        1
+    }
+}
+
+// No test changes needed!
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn foo_for_fizz() {
+        assert_eq!(foo_if_fizz("fizz"), "foo")
+    }
+
+    #[test]
+    fn bar_for_fuzz() {
+        assert_eq!(foo_if_fizz("fuzz"), "bar")
+    }
+
+    #[test]
+    fn default_to_baz() {
+        assert_eq!(foo_if_fizz("literally anything"), "baz")
+    }
+}

.history/exercises/if/if2_20230726222409.rs

@@ -0,0 +1,36 @@
+// if2.rs
+
+// Step 1: Make me compile!
+// Step 2: Get the bar_for_fuzz and default_to_baz tests passing!
+// Execute `rustlings hint if2` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+pub fn foo_if_fizz(fizzish: &str) -> &str {
+    if fizzish == "fizz" {
+        "foo"
+    } else if {
+        1
+    }
+}
+
+// No test changes needed!
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn foo_for_fizz() {
+        assert_eq!(foo_if_fizz("fizz"), "foo")
+    }
+
+    #[test]
+    fn bar_for_fuzz() {
+        assert_eq!(foo_if_fizz("fuzz"), "bar")
+    }
+
+    #[test]
+    fn default_to_baz() {
+        assert_eq!(foo_if_fizz("literally anything"), "baz")
+    }
+}

.history/exercises/if/if2_20230726222415.rs

@@ -0,0 +1,36 @@
+// if2.rs
+
+// Step 1: Make me compile!
+// Step 2: Get the bar_for_fuzz and default_to_baz tests passing!
+// Execute `rustlings hint if2` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+pub fn foo_if_fizz(fizzish: &str) -> &str {
+    if fizzish == "fizz" {
+        "foo"
+    } else if fizzish == "" {
+        1
+    }
+}
+
+// No test changes needed!
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn foo_for_fizz() {
+        assert_eq!(foo_if_fizz("fizz"), "foo")
+    }
+
+    #[test]
+    fn bar_for_fuzz() {
+        assert_eq!(foo_if_fizz("fuzz"), "bar")
+    }
+
+    #[test]
+    fn default_to_baz() {
+        assert_eq!(foo_if_fizz("literally anything"), "baz")
+    }
+}

.history/exercises/if/if2_20230726222417.rs

@@ -0,0 +1,36 @@
+// if2.rs
+
+// Step 1: Make me compile!
+// Step 2: Get the bar_for_fuzz and default_to_baz tests passing!
+// Execute `rustlings hint if2` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+pub fn foo_if_fizz(fizzish: &str) -> &str {
+    if fizzish == "fizz" {
+        "foo"
+    } else if fizzish == "fuzz" {
+        1
+    }
+}
+
+// No test changes needed!
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn foo_for_fizz() {
+        assert_eq!(foo_if_fizz("fizz"), "foo")
+    }
+
+    #[test]
+    fn bar_for_fuzz() {
+        assert_eq!(foo_if_fizz("fuzz"), "bar")
+    }
+
+    #[test]
+    fn default_to_baz() {
+        assert_eq!(foo_if_fizz("literally anything"), "baz")
+    }
+}

.history/exercises/if/if2_20230726222420.rs

@@ -0,0 +1,36 @@
+// if2.rs
+
+// Step 1: Make me compile!
+// Step 2: Get the bar_for_fuzz and default_to_baz tests passing!
+// Execute `rustlings hint if2` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+pub fn foo_if_fizz(fizzish: &str) -> &str {
+    if fizzish == "fizz" {
+        "foo"
+    } else if fizzish == "fuzz" z {
+        1
+    }
+}
+
+// No test changes needed!
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn foo_for_fizz() {
+        assert_eq!(foo_if_fizz("fizz"), "foo")
+    }
+
+    #[test]
+    fn bar_for_fuzz() {
+        assert_eq!(foo_if_fizz("fuzz"), "bar")
+    }
+
+    #[test]
+    fn default_to_baz() {
+        assert_eq!(foo_if_fizz("literally anything"), "baz")
+    }
+}

.history/exercises/if/if2_20230726222423.rs

@@ -0,0 +1,36 @@
+// if2.rs
+
+// Step 1: Make me compile!
+// Step 2: Get the bar_for_fuzz and default_to_baz tests passing!
+// Execute `rustlings hint if2` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+pub fn foo_if_fizz(fizzish: &str) -> &str {
+    if fizzish == "fizz" {
+        "foo"
+    } else if fizzish == "fuzz" {
+        1
+    }
+}
+
+// No test changes needed!
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn foo_for_fizz() {
+        assert_eq!(foo_if_fizz("fizz"), "foo")
+    }
+
+    #[test]
+    fn bar_for_fuzz() {
+        assert_eq!(foo_if_fizz("fuzz"), "bar")
+    }
+
+    #[test]
+    fn default_to_baz() {
+        assert_eq!(foo_if_fizz("literally anything"), "baz")
+    }
+}

.history/exercises/if/if2_20230726222427.rs

@@ -0,0 +1,36 @@
+// if2.rs
+
+// Step 1: Make me compile!
+// Step 2: Get the bar_for_fuzz and default_to_baz tests passing!
+// Execute `rustlings hint if2` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+pub fn foo_if_fizz(fizzish: &str) -> &str {
+    if fizzish == "fizz" {
+        "foo"
+    } else if fizzish == "fuzz" {
+        "bar"
+    }
+}
+
+// No test changes needed!
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn foo_for_fizz() {
+        assert_eq!(foo_if_fizz("fizz"), "foo")
+    }
+
+    #[test]
+    fn bar_for_fuzz() {
+        assert_eq!(foo_if_fizz("fuzz"), "bar")
+    }
+
+    #[test]
+    fn default_to_baz() {
+        assert_eq!(foo_if_fizz("literally anything"), "baz")
+    }
+}

.history/exercises/if/if2_20230726222430.rs

@@ -0,0 +1,38 @@
+// if2.rs
+
+// Step 1: Make me compile!
+// Step 2: Get the bar_for_fuzz and default_to_baz tests passing!
+// Execute `rustlings hint if2` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+pub fn foo_if_fizz(fizzish: &str) -> &str {
+    if fizzish == "fizz" {
+        "foo"
+    } else if fizzish == "fuzz" {
+        "bar"
+    } else {
+        
+    }
+}
+
+// No test changes needed!
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn foo_for_fizz() {
+        assert_eq!(foo_if_fizz("fizz"), "foo")
+    }
+
+    #[test]
+    fn bar_for_fuzz() {
+        assert_eq!(foo_if_fizz("fuzz"), "bar")
+    }
+
+    #[test]
+    fn default_to_baz() {
+        assert_eq!(foo_if_fizz("literally anything"), "baz")
+    }
+}

.history/exercises/if/if2_20230726222433.rs

@@ -0,0 +1,38 @@
+// if2.rs
+
+// Step 1: Make me compile!
+// Step 2: Get the bar_for_fuzz and default_to_baz tests passing!
+// Execute `rustlings hint if2` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+pub fn foo_if_fizz(fizzish: &str) -> &str {
+    if fizzish == "fizz" {
+        "foo"
+    } else if fizzish == "fuzz" {
+        "bar"
+    } else {
+        "baz"
+    }
+}
+
+// No test changes needed!
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn foo_for_fizz() {
+        assert_eq!(foo_if_fizz("fizz"), "foo")
+    }
+
+    #[test]
+    fn bar_for_fuzz() {
+        assert_eq!(foo_if_fizz("fuzz"), "bar")
+    }
+
+    #[test]
+    fn default_to_baz() {
+        assert_eq!(foo_if_fizz("literally anything"), "baz")
+    }
+}

.history/exercises/if/if2_20230726222437.rs

@@ -0,0 +1,36 @@
+// if2.rs
+
+// Step 1: Make me compile!
+// Step 2: Get the bar_for_fuzz and default_to_baz tests passing!
+// Execute `rustlings hint if2` or use the `hint` watch subcommand for a hint.
+
+pub fn foo_if_fizz(fizzish: &str) -> &str {
+    if fizzish == "fizz" {
+        "foo"
+    } else if fizzish == "fuzz" {
+        "bar"
+    } else {
+        "baz"
+    }
+}
+
+// No test changes needed!
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn foo_for_fizz() {
+        assert_eq!(foo_if_fizz("fizz"), "foo")
+    }
+
+    #[test]
+    fn bar_for_fuzz() {
+        assert_eq!(foo_if_fizz("fuzz"), "bar")
+    }
+
+    #[test]
+    fn default_to_baz() {
+        assert_eq!(foo_if_fizz("literally anything"), "baz")
+    }
+}

.history/exercises/intro/intro1_20230726201504.rs

@@ -0,0 +1,37 @@
+// intro1.rs
+// About this `I AM NOT DONE` thing:
+// We sometimes encourage you to keep trying things on a given exercise, even
+// after you already figured it out. If you got everything working and feel
+// ready for the next exercise, remove the `I AM NOT DONE` comment below.
+// Execute `rustlings hint intro1` or use the `hint` watch subcommand for a hint.
+//
+// If you're running this using `rustlings watch`: The exercise file will be reloaded
+// when you change one of the lines below! Try adding a `println!` line, or try changing
+// what it outputs in your terminal. Try removing a semicolon and see what happens!
+
+// I AM NOT DONE
+
+fn main() {
+    println!("Hello and");
+    println!(r#"       welcome to...                      "#);
+    println!(r#"                 _   _ _                  "#);
+    println!(r#"  _ __ _   _ ___| |_| (_)_ __   __ _ ___  "#);
+    println!(r#" | '__| | | / __| __| | | '_ \ / _` / __| "#);
+    println!(r#" | |  | |_| \__ \ |_| | | | | | (_| \__ \ "#);
+    println!(r#" |_|   \__,_|___/\__|_|_|_| |_|\__, |___/ "#);
+    println!(r#"                               |___/      "#);
+    println!();
+    println!("This exercise compiles successfully. The remaining exercises contain a compiler");
+    println!("or logic error. The central concept behind Rustlings is to fix these errors and");
+    println!("solve the exercises. Good luck!");
+    println!();
+    println!("The source for this exercise is in `exercises/intro/intro1.rs`. Have a look!");
+    println!(
+        "Going forward, the source of the exercises will always be in the success/failure output."
+    );
+    println!();
+    println!(
+        "If you want to use rust-analyzer, Rust's LSP implementation, make sure your editor is set"
+    );
+    println!("up, and then run `rustlings lsp` before continuing.")
+}

.history/exercises/intro/intro1_20230726201755.rs

@@ -0,0 +1,36 @@
+// intro1.rs
+// About this `I AM NOT DONE` thing:
+// We sometimes encourage you to keep trying things on a given exercise, even
+// after you already figured it out. If you got everything working and feel
+// ready for the next exercise, remove the `I AM NOT DONE` comment below.
+// Execute `rustlings hint intro1` or use the `hint` watch subcommand for a hint.
+//
+// If you're running this using `rustlings watch`: The exercise file will be reloaded
+// when you change one of the lines below! Try adding a `println!` line, or try changing
+// what it outputs in your terminal. Try removing a semicolon and see what happens!
+
+
+fn main() {
+    println!("Hello and");
+    println!(r#"       welcome to...                      "#);
+    println!(r#"                 _   _ _                  "#);
+    println!(r#"  _ __ _   _ ___| |_| (_)_ __   __ _ ___  "#);
+    println!(r#" | '__| | | / __| __| | | '_ \ / _` / __| "#);
+    println!(r#" | |  | |_| \__ \ |_| | | | | | (_| \__ \ "#);
+    println!(r#" |_|   \__,_|___/\__|_|_|_| |_|\__, |___/ "#);
+    println!(r#"                               |___/      "#);
+    println!();
+    println!("This exercise compiles successfully. The remaining exercises contain a compiler");
+    println!("or logic error. The central concept behind Rustlings is to fix these errors and");
+    println!("solve the exercises. Good luck!");
+    println!();
+    println!("The source for this exercise is in `exercises/intro/intro1.rs`. Have a look!");
+    println!(
+        "Going forward, the source of the exercises will always be in the success/failure output."
+    );
+    println!();
+    println!(
+        "If you want to use rust-analyzer, Rust's LSP implementation, make sure your editor is set"
+    );
+    println!("up, and then run `rustlings lsp` before continuing.")
+}

.history/exercises/intro/intro2_20230726201504.rs

@@ -0,0 +1,9 @@
+// intro2.rs
+// Make the code print a greeting to the world.
+// Execute `rustlings hint intro2` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    println!("Hello {}!");
+}

.history/exercises/intro/intro2_20230726201805.rs

@@ -0,0 +1,9 @@
+// intro2.rs
+// Make the code print a greeting to the world.
+// Execute `rustlings hint intro2` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    println!("Hello world!");
+}

.history/exercises/intro/intro2_20230726201812.rs

@@ -0,0 +1,7 @@
+// intro2.rs
+// Make the code print a greeting to the world.
+// Execute `rustlings hint intro2` or use the `hint` watch subcommand for a hint.
+
+fn main() {
+    println!("Hello world!");
+}

.history/exercises/move_semantics/move_semantics1_20230726201504.rs

@@ -0,0 +1,26 @@
+// move_semantics1.rs
+// Execute `rustlings hint move_semantics1` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let vec0 = Vec::new();
+
+    let vec1 = fill_vec(vec0);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+fn fill_vec(vec: Vec<i32>) -> Vec<i32> {
+    let mut vec = vec;
+
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics1_20230726223043.rs

@@ -0,0 +1,26 @@
+// move_semantics1.rs
+// Execute `rustlings hint move_semantics1` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let vec0 = Vec::new();
+
+    let vec1 = fill_vec(vec0);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+fn fill_vec(vec: Vec<i32>) -> Vec<i32> {
+    let mut vec = vec;
+
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics1_20230726223135.rs

@@ -0,0 +1,26 @@
+// move_semantics1.rs
+// Execute `rustlings hint move_semantics1` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let vec0 = Vec::new();
+
+    let vec1 = fill_vec(vec0);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+fn fill_vec(vec: Vec<i32>) -> mut Vec<i32> {
+    let mut vec = vec;
+
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics1_20230726223142.rs

@@ -0,0 +1,26 @@
+// move_semantics1.rs
+// Execute `rustlings hint move_semantics1` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let vec0 = Vec::new();
+
+    let vec1 = fill_vec(vec0);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+fn fill_vec(vec: Vec<i32>) -> mut zVec<i32> {
+    let mut vec = vec;
+
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics1_20230726223144.rs

@@ -0,0 +1,26 @@
+// move_semantics1.rs
+// Execute `rustlings hint move_semantics1` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let vec0 = Vec::new();
+
+    let vec1 = fill_vec(vec0);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+fn fill_vec(vec: Vec<i32>) -> Vec<i32> {
+    let mut vec = vec;
+
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics1_20230726223150.rs

@@ -0,0 +1,26 @@
+// move_semantics1.rs
+// Execute `rustlings hint move_semantics1` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let vec0 = Vec::new();
+
+    let mut vec1 = fill_vec(vec0);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+fn fill_vec(vec: Vec<i32>) -> Vec<i32> {
+    let mut vec = vec;
+
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics1_20230726223155.rs

@@ -0,0 +1,26 @@
+// move_semantics1.rs
+// Execute `rustlings hint move_semantics1` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let vec0 = Vec::new();
+
+    let mut vec1 = fill_vec(vec0);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+fn fill_vec(vec: Vec<i32>) -> Vec<i32> {
+    let mut vec = vec;
+
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics1_20230726223205.rs

@@ -0,0 +1,27 @@
+// move_semantics1.rs
+// Execute `rustlings hint move_semantics1` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let vec0 = Vec::new();
+
+    let mut vec1 = fill_vec(vec0);
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+fn fill_vec(vec: Vec<i32>) -> Vec<i32> {
+    let mut vec = vec;
+
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics1_20230726223207.rs

@@ -0,0 +1,27 @@
+// move_semantics1.rs
+// Execute `rustlings hint move_semantics1` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let vec0 = Vec::new();
+
+    let mut vec1 = fill_vec(vec0);
+    println!("{} has length {} content `{:?}`", "vec0", vec1.len(), vec1);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+fn fill_vec(vec: Vec<i32>) -> Vec<i32> {
+    let mut vec = vec;
+
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics1_20230726223209.rs

@@ -0,0 +1,27 @@
+// move_semantics1.rs
+// Execute `rustlings hint move_semantics1` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let vec0 = Vec::new();
+
+    let mut vec1 = fill_vec(vec0);
+    println!("{} has length {} content `{:?}`", "vec0", vec0.len(), vec0);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+fn fill_vec(vec: Vec<i32>) -> Vec<i32> {
+    let mut vec = vec;
+
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics1_20230726223237.rs

@@ -0,0 +1,27 @@
+// move_semantics1.rs
+// Execute `rustlings hint move_semantics1` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let vec0 = Vec::new();
+
+    let mut vec1 = fill_vec(vec0.clone());
+    println!("{} has length {} content `{:?}`", "vec0", vec0.len(), vec0);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+fn fill_vec(vec: Vec<i32>) -> Vec<i32> {
+    let mut vec = vec;
+
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics1_20230726223243.rs

@@ -0,0 +1,25 @@
+// move_semantics1.rs
+// Execute `rustlings hint move_semantics1` or use the `hint` watch subcommand for a hint.
+
+fn main() {
+    let vec0 = Vec::new();
+
+    let mut vec1 = fill_vec(vec0.clone());
+    println!("{} has length {} content `{:?}`", "vec0", vec0.len(), vec0);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+fn fill_vec(vec: Vec<i32>) -> Vec<i32> {
+    let mut vec = vec;
+
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics2_20230726201504.rs

@@ -0,0 +1,32 @@
+// move_semantics2.rs
+// Execute `rustlings hint move_semantics2` or use the `hint` watch subcommand for a hint.
+
+// Expected output:
+// vec0 has length 3 content `[22, 44, 66]`
+// vec1 has length 4 content `[22, 44, 66, 88]`
+
+// I AM NOT DONE
+
+fn main() {
+    let vec0 = Vec::new();
+
+    // Do not move the following line!
+    let mut vec1 = fill_vec(vec0);
+
+    // Do not change the following line!
+    println!("{} has length {} content `{:?}`", "vec0", vec0.len(), vec0);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+fn fill_vec(vec: Vec<i32>) -> Vec<i32> {
+    let mut vec = vec;
+
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics2_20230726223351.rs

@@ -0,0 +1,32 @@
+// move_semantics2.rs
+// Execute `rustlings hint move_semantics2` or use the `hint` watch subcommand for a hint.
+
+// Expected output:
+// vec0 has length 3 content `[22, 44, 66]`
+// vec1 has length 4 content `[22, 44, 66, 88]`
+
+// I AM NOT DONE
+
+fn main() {
+    let vec0 = Vec::new();
+
+    // Do not move the following line!
+    let mut vec1 = fill_vec(vec0);
+
+    // Do not change the following line!
+    println!("{} has length {} content `{:?}`", "vec0", vec0.len(), vec0);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+fn fill_vec(vec: Vec<i32>) -> Vec<i32> {
+    let mut vec = vec;
+
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics2_20230726223357.rs

@@ -0,0 +1,32 @@
+// move_semantics2.rs
+// Execute `rustlings hint move_semantics2` or use the `hint` watch subcommand for a hint.
+
+// Expected output:
+// vec0 has length 3 content `[22, 44, 66]`
+// vec1 has length 4 content `[22, 44, 66, 88]`
+
+// I AM NOT DONE
+
+fn main() {
+    let vec0 = Vec::new();
+
+    // Do not move the following line!
+    let mut vec1 = fill_vec(vec0.clone());
+
+    // Do not change the following line!
+    println!("{} has length {} content `{:?}`", "vec0", vec0.len(), vec0);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+fn fill_vec(vec: Vec<i32>) -> Vec<i32> {
+    let mut vec = vec;
+
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics2_20230726223422.rs

@@ -0,0 +1,30 @@
+// move_semantics2.rs
+// Execute `rustlings hint move_semantics2` or use the `hint` watch subcommand for a hint.
+
+// Expected output:
+// vec0 has length 3 content `[22, 44, 66]`
+// vec1 has length 4 content `[22, 44, 66, 88]`
+
+fn main() {
+    let vec0 = Vec::new();
+
+    // Do not move the following line!
+    let mut vec1 = fill_vec(vec0.clone());
+
+    // Do not change the following line!
+    println!("{} has length {} content `{:?}`", "vec0", vec0.len(), vec0);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+fn fill_vec(vec: Vec<i32>) -> Vec<i32> {
+    let mut vec = vec;
+
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics3_20230726201504.rs

@@ -0,0 +1,26 @@
+// move_semantics3.rs
+// Make me compile without adding new lines-- just changing existing lines!
+// (no lines with multiple semicolons necessary!)
+// Execute `rustlings hint move_semantics3` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let vec0 = Vec::new();
+
+    let mut vec1 = fill_vec(vec0);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+fn fill_vec(vec: Vec<i32>) -> Vec<i32> {
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics3_20230726223447.rs

@@ -0,0 +1,26 @@
+// move_semantics3.rs
+// Make me compile without adding new lines-- just changing existing lines!
+// (no lines with multiple semicolons necessary!)
+// Execute `rustlings hint move_semantics3` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let vec0 = Vec::new();
+
+    let mut vec1 = fill_vec(vec0);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+fn fill_vec(mut vec: Vec<i32>) -> Vec<i32> {
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics3_20230726223458.rs

@@ -0,0 +1,24 @@
+// move_semantics3.rs
+// Make me compile without adding new lines-- just changing existing lines!
+// (no lines with multiple semicolons necessary!)
+// Execute `rustlings hint move_semantics3` or use the `hint` watch subcommand for a hint.
+
+fn main() {
+    let vec0 = Vec::new();
+
+    let mut vec1 = fill_vec(vec0);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+fn fill_vec(mut vec: Vec<i32>) -> Vec<i32> {
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics4_20230726201504.rs

@@ -0,0 +1,30 @@
+// move_semantics4.rs
+// Refactor this code so that instead of passing `vec0` into the `fill_vec` function,
+// the Vector gets created in the function itself and passed back to the main
+// function.
+// Execute `rustlings hint move_semantics4` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let vec0 = Vec::new();
+
+    let mut vec1 = fill_vec(vec0);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+// `fill_vec()` no longer takes `vec: Vec<i32>` as argument
+fn fill_vec() -> Vec<i32> {
+    let mut vec = vec;
+
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics4_20230726223527.rs

@@ -0,0 +1,30 @@
+// move_semantics4.rs
+// Refactor this code so that instead of passing `vec0` into the `fill_vec` function,
+// the Vector gets created in the function itself and passed back to the main
+// function.
+// Execute `rustlings hint move_semantics4` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let vec0 = Vec::new();
+
+    let mut vec1 = fill_vec();
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+// `fill_vec()` no longer takes `vec: Vec<i32>` as argument
+fn fill_vec() -> Vec<i32> {
+    let mut vec = vec;
+
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics4_20230726223537.rs

@@ -0,0 +1,30 @@
+// move_semantics4.rs
+// Refactor this code so that instead of passing `vec0` into the `fill_vec` function,
+// the Vector gets created in the function itself and passed back to the main
+// function.
+// Execute `rustlings hint move_semantics4` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let vec0 = Vec::new();
+
+    let mut vec1: Vec<i32> = fill_vec();
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+// `fill_vec()` no longer takes `vec: Vec<i32>` as argument
+fn fill_vec() -> Vec<i32> {
+    let mut vec = vec;
+
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics4_20230726223546.rs

@@ -0,0 +1,30 @@
+// move_semantics4.rs
+// Refactor this code so that instead of passing `vec0` into the `fill_vec` function,
+// the Vector gets created in the function itself and passed back to the main
+// function.
+// Execute `rustlings hint move_semantics4` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let vec0: Vec<i32> = Vec::new();
+
+    let mut vec1: Vec<i32> = fill_vec();
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+// `fill_vec()` no longer takes `vec: Vec<i32>` as argument
+fn fill_vec() -> Vec<i32> {
+    let mut vec = vec;
+
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics4_20230726223600.rs

@@ -0,0 +1,30 @@
+// move_semantics4.rs
+// Refactor this code so that instead of passing `vec0` into the `fill_vec` function,
+// the Vector gets created in the function itself and passed back to the main
+// function.
+// Execute `rustlings hint move_semantics4` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let vec0: Vec<i32> = Vec::new();
+
+    let mut vec1: Vec<i32> = fill_vec();
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+// `fill_vec()` no longer takes `vec: Vec<i32>` as argument
+fn fill_vec() -> Vec<i32> {
+    let mut vec = Vec::new();
+
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics4_20230726223606.rs

@@ -0,0 +1,30 @@
+// move_semantics4.rs
+// Refactor this code so that instead of passing `vec0` into the `fill_vec` function,
+// the Vector gets created in the function itself and passed back to the main
+// function.
+// Execute `rustlings hint move_semantics4` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    // let vec0: Vec<i32> = Vec::new();
+
+    let mut vec1: Vec<i32> = fill_vec();
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+// `fill_vec()` no longer takes `vec: Vec<i32>` as argument
+fn fill_vec() -> Vec<i32> {
+    let mut vec = Vec::new();
+
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics4_20230726223611.rs

@@ -0,0 +1,29 @@
+// move_semantics4.rs
+// Refactor this code so that instead of passing `vec0` into the `fill_vec` function,
+// the Vector gets created in the function itself and passed back to the main
+// function.
+// Execute `rustlings hint move_semantics4` or use the `hint` watch subcommand for a hint.
+
+
+fn main() {
+    // let vec0: Vec<i32> = Vec::new();
+
+    let mut vec1: Vec<i32> = fill_vec();
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+
+    vec1.push(88);
+
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+
+// `fill_vec()` no longer takes `vec: Vec<i32>` as argument
+fn fill_vec() -> Vec<i32> {
+    let mut vec = Vec::new();
+
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+
+    vec
+}

.history/exercises/move_semantics/move_semantics5_20230726201504.rs

@@ -0,0 +1,15 @@
+// move_semantics5.rs
+// Make me compile only by reordering the lines in `main()`, but without
+// adding, changing or removing any of them.
+// Execute `rustlings hint move_semantics5` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let mut x = 100;
+    let y = &mut x;
+    let z = &mut x;
+    *y += 100;
+    *z += 1000;
+    assert_eq!(x, 1200);
+}

.history/exercises/move_semantics/move_semantics5_20230726223627.rs

@@ -0,0 +1,15 @@
+// move_semantics5.rs
+// Make me compile only by reordering the lines in `main()`, but without
+// adding, changing or removing any of them.
+// Execute `rustlings hint move_semantics5` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let mut x = 100;
+    let y = &mut x;
+    *y += 100;
+    let z = &mut x;
+    *z += 1000;
+    assert_eq!(x, 1200);
+}

.history/exercises/move_semantics/move_semantics5_20230726223943.rs

@@ -0,0 +1,13 @@
+// move_semantics5.rs
+// Make me compile only by reordering the lines in `main()`, but without
+// adding, changing or removing any of them.
+// Execute `rustlings hint move_semantics5` or use the `hint` watch subcommand for a hint.
+
+fn main() {
+    let mut x = 100;
+    let y = &mut x;
+    *y += 100;
+    let z = &mut x;
+    *z += 1000;
+    assert_eq!(x, 1200);
+}

.history/exercises/move_semantics/move_semantics6_20230726201504.rs

@@ -0,0 +1,25 @@
+// move_semantics6.rs
+// Execute `rustlings hint move_semantics6` or use the `hint` watch subcommand for a hint.
+// You can't change anything except adding or removing references.
+
+// I AM NOT DONE
+
+fn main() {
+    let data = "Rust is great!".to_string();
+
+    get_char(data);
+
+    string_uppercase(&data);
+}
+
+// Should not take ownership
+fn get_char(data: String) -> char {
+    data.chars().last().unwrap()
+}
+
+// Should take ownership
+fn string_uppercase(mut data: &String) {
+    data = &data.to_uppercase();
+
+    println!("{}", data);
+}

.history/exercises/move_semantics/move_semantics6_20230726224026.rs

@@ -0,0 +1,25 @@
+// move_semantics6.rs
+// Execute `rustlings hint move_semantics6` or use the `hint` watch subcommand for a hint.
+// You can't change anything except adding or removing references.
+
+// I AM NOT DONE
+
+fn main() {
+    let data = "Rust is great!".to_string();
+
+    get_char(data.clone());
+
+    string_uppercase(&data);
+}
+
+// Should not take ownership
+fn get_char(data: String) -> char {
+    data.chars().last().unwrap()
+}
+
+// Should take ownership
+fn string_uppercase(mut data: &String) {
+    data = &data.to_uppercase();
+
+    println!("{}", data);
+}

.history/exercises/move_semantics/move_semantics6_20230726224256.rs

@@ -0,0 +1,25 @@
+// move_semantics6.rs
+// Execute `rustlings hint move_semantics6` or use the `hint` watch subcommand for a hint.
+// You can't change anything except adding or removing references.
+
+// I AM NOT DONE
+
+fn main() {
+    let data = "Rust is great!".to_string();
+
+    get_char(data.clone());
+
+    string_uppercase(data);
+}
+
+// Should not take ownership
+fn get_char(data: String) -> char {
+    data.chars().last().unwrap()
+}
+
+// Should take ownership
+fn string_uppercase(mut data: &String) {
+    data = &data.to_uppercase();
+
+    println!("{}", data);
+}

.history/exercises/move_semantics/move_semantics6_20230726224315.rs

@@ -0,0 +1,25 @@
+// move_semantics6.rs
+// Execute `rustlings hint move_semantics6` or use the `hint` watch subcommand for a hint.
+// You can't change anything except adding or removing references.
+
+// I AM NOT DONE
+
+fn main() {
+    let data = "Rust is great!".to_string();
+
+    get_char(data.clone());
+
+    string_uppercase(data);
+}
+
+// Should not take ownership
+fn get_char(data: String) -> char {
+    data.chars().last().unwrap()
+}
+
+// Should take ownership
+fn string_uppercase(mut data: String) {
+    data = &data.to_uppercase();
+
+    println!("{}", data);
+}

.history/exercises/move_semantics/move_semantics6_20230726224316.rs

@@ -0,0 +1,25 @@
+// move_semantics6.rs
+// Execute `rustlings hint move_semantics6` or use the `hint` watch subcommand for a hint.
+// You can't change anything except adding or removing references.
+
+// I AM NOT DONE
+
+fn main() {
+    let data = "Rust is great!".to_string();
+
+    get_char(data.clone());
+
+    string_uppercase(data);
+}
+
+// Should not take ownership
+fn get_char(data: String) -> char {
+    data.chars().last().unwrap()
+}
+
+// Should take ownership
+fn string_uppercase(mut data: String) {
+    data = data.to_uppercase();
+
+    println!("{}", data);
+}

.history/exercises/move_semantics/move_semantics6_20230726224322.rs

@@ -0,0 +1,24 @@
+// move_semantics6.rs
+// Execute `rustlings hint move_semantics6` or use the `hint` watch subcommand for a hint.
+// You can't change anything except adding or removing references.
+
+
+fn main() {
+    let data = "Rust is great!".to_string();
+
+    get_char(data.clone());
+
+    string_uppercase(data);
+}
+
+// Should not take ownership
+fn get_char(data: String) -> char {
+    data.chars().last().unwrap()
+}
+
+// Should take ownership
+fn string_uppercase(mut data: String) {
+    data = data.to_uppercase();
+
+    println!("{}", data);
+}

.history/exercises/primitive_types/primitive_types1_20230726201504.rs

@@ -0,0 +1,19 @@
+// 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 :)
+
+// I AM NOT DONE
+
+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!");
+    }
+}

.history/exercises/primitive_types/primitive_types1_20230726222551.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!");
+    }
+}

.history/exercises/primitive_types/primitive_types1_20230726222559.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 is_evening: bool = false; // Finish the rest of this line like the example! Or make it be false!
+    if is_evening {
+        println!("Good evening!");
+    }
+}

.history/exercises/primitive_types/primitive_types1_20230726222601.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: bool = true;
+    if is_morning {
+        println!("Good morning!");
+    }
+
+    let is_evening: bool = false; // Finish the rest of this line like the example! Or make it be false!
+    if is_evening {
+        println!("Good evening!");
+    }
+}

.history/exercises/primitive_types/primitive_types2_20230726201504.rs

@@ -0,0 +1,31 @@
+// 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 :)
+
+// I AM NOT DONE
+
+fn main() {
+    // Characters (`char`)
+
+    // Note the _single_ quotes, these are different from the double quotes
+    // you've been seeing around.
+    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!");
+    }
+}

.history/exercises/primitive_types/primitive_types2_20230726222607.rs

@@ -0,0 +1,31 @@
+// 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 :)
+
+// I AM NOT DONE
+
+fn main() {
+    // Characters (`char`)
+
+    // Note the _single_ quotes, these are different from the double quotes
+    // you've been seeing around.
+    let my_first_initial: char = '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!");
+    }
+}

.history/exercises/primitive_types/primitive_types2_20230726222619.rs

@@ -0,0 +1,31 @@
+// 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 :)
+
+// I AM NOT DONE
+
+fn main() {
+    // Characters (`char`)
+
+    // Note the _single_ quotes, these are different from the double quotes
+    // you've been seeing around.
+    let my_first_initial: char = '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 your_character: char = ''// 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!");
+    }
+}

.history/exercises/primitive_types/primitive_types2_20230726222625.rs

@@ -0,0 +1,31 @@
+// 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 :)
+
+// I AM NOT DONE
+
+fn main() {
+    // Characters (`char`)
+
+    // Note the _single_ quotes, these are different from the double quotes
+    // you've been seeing around.
+    let my_first_initial: char = '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 your_character: char = 'a'// 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!");
+    }
+}

.history/exercises/primitive_types/primitive_types2_20230726222631.rs

@@ -0,0 +1,31 @@
+// 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 :)
+
+// I AM NOT DONE
+
+fn main() {
+    // Characters (`char`)
+
+    // Note the _single_ quotes, these are different from the double quotes
+    // you've been seeing around.
+    let my_first_initial: char = '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 your_character: char = 'a';// 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!");
+    }
+}

.history/exercises/primitive_types/primitive_types2_20230726222642.rs

@@ -0,0 +1,29 @@
+// 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`)
+
+    // Note the _single_ quotes, these are different from the double quotes
+    // you've been seeing around.
+    let my_first_initial: char = '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 your_character: char = 'a';// 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!");
+    }
+}

.history/exercises/primitive_types/primitive_types3_20230726201504.rs

@@ -0,0 +1,15 @@
+// primitive_types3.rs
+// Create an array with at least 100 elements in it where the ??? is.
+// Execute `rustlings hint primitive_types3` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+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.");
+    }
+}

.history/exercises/primitive_types/primitive_types3_20230726222655.rs

@@ -0,0 +1,15 @@
+// primitive_types3.rs
+// Create an array with at least 100 elements in it where the ??? is.
+// Execute `rustlings hint primitive_types3` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let a = [1; 100;]
+
+    if a.len() >= 100 {
+        println!("Wow, that's a big array!");
+    } else {
+        println!("Meh, I eat arrays like that for breakfast.");
+    }
+}

.history/exercises/primitive_types/primitive_types3_20230726222658.rs

@@ -0,0 +1,15 @@
+// primitive_types3.rs
+// Create an array with at least 100 elements in it where the ??? is.
+// Execute `rustlings hint primitive_types3` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let a: [i32; _] = [1; 100;]
+
+    if a.len() >= 100 {
+        println!("Wow, that's a big array!");
+    } else {
+        println!("Meh, I eat arrays like that for breakfast.");
+    }
+}

.history/exercises/primitive_types/primitive_types3_20230726222703.rs

@@ -0,0 +1,15 @@
+// primitive_types3.rs
+// Create an array with at least 100 elements in it where the ??? is.
+// Execute `rustlings hint primitive_types3` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let a = [1,]
+
+    if a.len() >= 100 {
+        println!("Wow, that's a big array!");
+    } else {
+        println!("Meh, I eat arrays like that for breakfast.");
+    }
+}

.history/exercises/primitive_types/primitive_types3_20230726222706.rs

@@ -0,0 +1,15 @@
+// primitive_types3.rs
+// Create an array with at least 100 elements in it where the ??? is.
+// Execute `rustlings hint primitive_types3` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let a = [1; 100]
+
+    if a.len() >= 100 {
+        println!("Wow, that's a big array!");
+    } else {
+        println!("Meh, I eat arrays like that for breakfast.");
+    }
+}

.history/exercises/primitive_types/primitive_types3_20230726222709.rs

@@ -0,0 +1,15 @@
+// primitive_types3.rs
+// Create an array with at least 100 elements in it where the ??? is.
+// Execute `rustlings hint primitive_types3` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let a = [1; 100];
+
+    if a.len() >= 100 {
+        println!("Wow, that's a big array!");
+    } else {
+        println!("Meh, I eat arrays like that for breakfast.");
+    }
+}

.history/exercises/primitive_types/primitive_types3_20230726222714.rs

@@ -0,0 +1,15 @@
+// primitive_types3.rs
+// Create an array with at least 100 elements in it where the ??? is.
+// Execute `rustlings hint primitive_types3` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let a: [i32; _] = [1; 100];
+
+    if a.len() >= 100 {
+        println!("Wow, that's a big array!");
+    } else {
+        println!("Meh, I eat arrays like that for breakfast.");
+    }
+}

.history/exercises/primitive_types/primitive_types3_20230726222716.rs

@@ -0,0 +1,13 @@
+// primitive_types3.rs
+// Create an array with at least 100 elements in it where the ??? is.
+// Execute `rustlings hint primitive_types3` or use the `hint` watch subcommand for a hint.
+
+fn main() {
+    let a: [i32; _] = [1; 100];
+
+    if a.len() >= 100 {
+        println!("Wow, that's a big array!");
+    } else {
+        println!("Meh, I eat arrays like that for breakfast.");
+    }
+}

.history/exercises/primitive_types/primitive_types3_20230726222722.rs

@@ -0,0 +1,13 @@
+// primitive_types3.rs
+// Create an array with at least 100 elements in it where the ??? is.
+// Execute `rustlings hint primitive_types3` or use the `hint` watch subcommand for a hint.
+
+fn main() {
+    let a: [i32; 100] = [1; 100];
+
+    if a.len() >= 100 {
+        println!("Wow, that's a big array!");
+    } else {
+        println!("Meh, I eat arrays like that for breakfast.");
+    }
+}

.history/exercises/primitive_types/primitive_types4_20230726201504.rs

@@ -0,0 +1,14 @@
+// primitive_types4.rs
+// Get a slice out of Array a where the ??? is so that the test passes.
+// Execute `rustlings hint primitive_types4` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+#[test]
+fn slice_out_of_array() {
+    let a = [1, 2, 3, 4, 5];
+
+    let nice_slice = ???
+
+    assert_eq!([2, 3, 4], nice_slice)
+}

.history/exercises/primitive_types/primitive_types4_20230726222730.rs

@@ -0,0 +1,14 @@
+// primitive_types4.rs
+// Get a slice out of Array a where the ??? is so that the test passes.
+// Execute `rustlings hint primitive_types4` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+#[test]
+fn slice_out_of_array() {
+    let a: [i32; 5] = [1, 2, 3, 4, 5];
+
+    let nice_slice = ???
+
+    assert_eq!([2, 3, 4], nice_slice)
+}

.history/exercises/primitive_types/primitive_types4_20230726222734.rs

@@ -0,0 +1,14 @@
+// primitive_types4.rs
+// Get a slice out of Array a where the ??? is so that the test passes.
+// Execute `rustlings hint primitive_types4` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+#[test]
+fn slice_out_of_array() {
+    let a: [i32; 5] = [1, 2, 3, 4, 5];
+
+    let nice_slice = a
+
+    assert_eq!([2, 3, 4], nice_slice)
+}

.history/exercises/primitive_types/primitive_types4_20230726222739.rs

@@ -0,0 +1,14 @@
+// primitive_types4.rs
+// Get a slice out of Array a where the ??? is so that the test passes.
+// Execute `rustlings hint primitive_types4` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+#[test]
+fn slice_out_of_array() {
+    let a: [i32; 5] = [1, 2, 3, 4, 5];
+
+    let nice_slice = a[1:=3];
+
+    assert_eq!([2, 3, 4], nice_slice)
+}

.history/exercises/primitive_types/primitive_types4_20230726222744.rs

@@ -0,0 +1,14 @@
+// primitive_types4.rs
+// Get a slice out of Array a where the ??? is so that the test passes.
+// Execute `rustlings hint primitive_types4` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+#[test]
+fn slice_out_of_array() {
+    let a: [i32; 5] = [1, 2, 3, 4, 5];
+
+    let nice_slice = a[1..=3];
+
+    assert_eq!([2, 3, 4], nice_slice)
+}

.history/exercises/primitive_types/primitive_types4_20230726222803.rs

@@ -0,0 +1,14 @@
+// primitive_types4.rs
+// Get a slice out of Array a where the ??? is so that the test passes.
+// Execute `rustlings hint primitive_types4` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+#[test]
+fn slice_out_of_array() {
+    let a: [i32; 5] = [1, 2, 3, 4, 5];
+
+    let nice_slice = &a[1..=3];
+
+    assert_eq!([2, 3, 4], nice_slice)
+}

.history/exercises/primitive_types/primitive_types4_20230726222808.rs

@@ -0,0 +1,12 @@
+// primitive_types4.rs
+// Get a slice out of Array a where the ??? is so that the test passes.
+// Execute `rustlings hint primitive_types4` or use the `hint` watch subcommand for a hint.
+
+#[test]
+fn slice_out_of_array() {
+    let a: [i32; 5] = [1, 2, 3, 4, 5];
+
+    let nice_slice = &a[1..=3];
+
+    assert_eq!([2, 3, 4], nice_slice)
+}

.history/exercises/primitive_types/primitive_types5_20230726201504.rs

@@ -0,0 +1,12 @@
+// primitive_types5.rs
+// Destructure the `cat` tuple so that the println will work.
+// Execute `rustlings hint primitive_types5` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let cat = ("Furry McFurson", 3.5);
+    let /* your pattern here */ = cat;
+
+    println!("{} is {} years old.", name, age);
+}

.history/exercises/primitive_types/primitive_types5_20230726222823.rs

@@ -0,0 +1,12 @@
+// primitive_types5.rs
+// Destructure the `cat` tuple so that the println will work.
+// Execute `rustlings hint primitive_types5` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let cat = ("Furry McFurson", 3.5);
+    let (&str, f64) = cat;
+
+    println!("{} is {} years old.", name, age);
+}

.history/exercises/primitive_types/primitive_types5_20230726222833.rs

@@ -0,0 +1,12 @@
+// primitive_types5.rs
+// Destructure the `cat` tuple so that the println will work.
+// Execute `rustlings hint primitive_types5` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+    let cat = ("Furry McFurson", 3.5);
+    let (str, f64) = cat;
+
+    println!("{} is {} years old.", name, age);
+}