From 5ff23a286185daef544c72b00f90567183898929 Mon Sep 17 00:00:00 2001 From: Mikael Frosthage Date: Tue, 26 Jul 2022 22:02:50 +0200 Subject: Improve hint for as_ref_mut --- info.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'info.toml') diff --git a/info.toml b/info.toml index f07b926..c3b0ca8 100644 --- a/info.toml +++ b/info.toml @@ -1135,4 +1135,4 @@ name = "as_ref_mut" path = "exercises/conversions/as_ref_mut.rs" mode = "test" hint = """ -Add AsRef as a trait bound to the functions.""" +Add AsRef or AsMut as a trait bound to the functions.""" -- cgit v1.2.3 From e2da663628f61f19066cd92b005bae3adc8521d8 Mon Sep 17 00:00:00 2001 From: deedy5 <65482418+deedy5@users.noreply.github.com> Date: Fri, 21 Apr 2023 15:51:52 +0000 Subject: Update info.toml modules2.rs: add more information to hint --- info.toml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'info.toml') diff --git a/info.toml b/info.toml index 28f9bb3..ac04fc7 100644 --- a/info.toml +++ b/info.toml @@ -478,7 +478,8 @@ hint = """ The delicious_snacks module is trying to present an external interface that is different than its internal structure (the `fruits` and `veggies` modules and associated constants). Complete the `use` statements to fit the uses in main and -find the one keyword missing for both constants.""" +find the one keyword missing for both constants. +Learn more at https://doc.rust-lang.org/book/ch07-04-bringing-paths-into-scope-with-the-use-keyword.html#re-exporting-names-with-pub-use""" [[exercises]] name = "modules3" -- cgit v1.2.3 From a7257a1d1ef59642f692e2638085ec00a6f2f391 Mon Sep 17 00:00:00 2001 From: b1ue64 <77976308+b1ue64@users.noreply.github.com> Date: Sat, 20 May 2023 16:38:33 -0400 Subject: feat(iterators5): remove outdated part of hint --- info.toml | 3 --- 1 file changed, 3 deletions(-) (limited to 'info.toml') diff --git a/info.toml b/info.toml index ac04fc7..2add5f0 100644 --- a/info.toml +++ b/info.toml @@ -897,9 +897,6 @@ hint = """ The documentation for the std::iter::Iterator trait contains numerous methods that would be helpful here. -Return 0 from count_collection_iterator to make the code compile in order to -test count_iterator. - The collection variable in count_collection_iterator is a slice of HashMaps. It needs to be converted into an iterator in order to use the iterator methods. -- cgit v1.2.3 From 1e02f194fdd1cb1ca99cf1d93d11455db8b1bce6 Mon Sep 17 00:00:00 2001 From: tajo48 Date: Wed, 31 May 2023 16:37:41 +0200 Subject: update hint for vecs2 to match with exercise as it was updated to fix clarity --- info.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'info.toml') diff --git a/info.toml b/info.toml index 2add5f0..a7155d4 100644 --- a/info.toml +++ b/info.toml @@ -260,8 +260,8 @@ name = "vecs2" path = "exercises/vecs/vecs2.rs" mode = "test" hint = """ -Hint 1: `i` is each element from the Vec as they are being iterated. Can you try -multiplying this? +Hint 1: In the code, the variable `element` represents an item from the Vec as it is being iterated. +Can you try multiplying this? Hint 2: For the first function, there's a way to directly access the numbers stored in the Vec, using the * dereference operator. You can both access and write to the -- cgit v1.2.3 From a96bbcd9675933b19454d627ab6291d4739f0e53 Mon Sep 17 00:00:00 2001 From: luhem7 Date: Sat, 3 Jun 2023 10:20:29 -0400 Subject: fix(threads, smart pointers): Swap order of threads and smart pointers exercises closes #1541 --- info.toml | 122 +++++++++++++++++++++++++++++++------------------------------- 1 file changed, 61 insertions(+), 61 deletions(-) (limited to 'info.toml') diff --git a/info.toml b/info.toml index 2add5f0..3abb2f8 100644 --- a/info.toml +++ b/info.toml @@ -905,67 +905,6 @@ The fold method can be useful in the count_collection_iterator function. For a further challenge, consult the documentation for Iterator to find a different method that could make your code more compact than using fold.""" -# THREADS - -[[exercises]] -name = "threads1" -path = "exercises/threads/threads1.rs" -mode = "compile" -hint = """ -`JoinHandle` is a struct that is returned from a spawned thread: -https://doc.rust-lang.org/std/thread/fn.spawn.html - -A challenge with multi-threaded applications is that the main thread can -finish before the spawned threads are completed. -https://doc.rust-lang.org/book/ch16-01-threads.html#waiting-for-all-threads-to-finish-using-join-handles - -Use the JoinHandles to wait for each thread to finish and collect their results. -https://doc.rust-lang.org/std/thread/struct.JoinHandle.html -""" - -[[exercises]] -name = "threads2" -path = "exercises/threads/threads2.rs" -mode = "compile" -hint = """ -`Arc` is an Atomic Reference Counted pointer that allows safe, shared access -to **immutable** data. But we want to *change* the number of `jobs_completed` -so we'll need to also use another type that will only allow one thread to -mutate the data at a time. Take a look at this section of the book: -https://doc.rust-lang.org/book/ch16-03-shared-state.html#atomic-reference-counting-with-arct -and keep reading if you'd like more hints :) - - -Do you now have an `Arc` `Mutex` `JobStatus` at the beginning of main? Like: -`let status = Arc::new(Mutex::new(JobStatus { jobs_completed: 0 }));` -Similar to the code in the example in the book that happens after the text -that says "We can use Arc to fix this.". If not, give that a try! If you -do and would like more hints, keep reading!! - - -Make sure neither of your threads are holding onto the lock of the mutex -while they are sleeping, since this will prevent the other thread from -being allowed to get the lock. Locks are automatically released when -they go out of scope. - -If you've learned from the sample solutions, I encourage you to come -back to this exercise and try it again in a few days to reinforce -what you've learned :)""" - -[[exercises]] -name = "threads3" -path = "exercises/threads/threads3.rs" -mode = "compile" -hint = """ -An alternate way to handle concurrency between threads is to use -a mpsc (multiple producer, single consumer) channel to communicate. -With both a sending end and a receiving end, it's possible to -send values in one thread and receive them in another. -Multiple producers are possible by using clone() to create a duplicate -of the original sending end. -See https://doc.rust-lang.org/book/ch16-02-message-passing.html for more info. -""" - # SMART POINTERS [[exercises]] @@ -1028,6 +967,67 @@ Check out https://doc.rust-lang.org/std/borrow/enum.Cow.html for documentation on the `Cow` type. """ +# THREADS + +[[exercises]] +name = "threads1" +path = "exercises/threads/threads1.rs" +mode = "compile" +hint = """ +`JoinHandle` is a struct that is returned from a spawned thread: +https://doc.rust-lang.org/std/thread/fn.spawn.html + +A challenge with multi-threaded applications is that the main thread can +finish before the spawned threads are completed. +https://doc.rust-lang.org/book/ch16-01-threads.html#waiting-for-all-threads-to-finish-using-join-handles + +Use the JoinHandles to wait for each thread to finish and collect their results. +https://doc.rust-lang.org/std/thread/struct.JoinHandle.html +""" + +[[exercises]] +name = "threads2" +path = "exercises/threads/threads2.rs" +mode = "compile" +hint = """ +`Arc` is an Atomic Reference Counted pointer that allows safe, shared access +to **immutable** data. But we want to *change* the number of `jobs_completed` +so we'll need to also use another type that will only allow one thread to +mutate the data at a time. Take a look at this section of the book: +https://doc.rust-lang.org/book/ch16-03-shared-state.html#atomic-reference-counting-with-arct +and keep reading if you'd like more hints :) + + +Do you now have an `Arc` `Mutex` `JobStatus` at the beginning of main? Like: +`let status = Arc::new(Mutex::new(JobStatus { jobs_completed: 0 }));` +Similar to the code in the example in the book that happens after the text +that says "We can use Arc to fix this.". If not, give that a try! If you +do and would like more hints, keep reading!! + + +Make sure neither of your threads are holding onto the lock of the mutex +while they are sleeping, since this will prevent the other thread from +being allowed to get the lock. Locks are automatically released when +they go out of scope. + +If you've learned from the sample solutions, I encourage you to come +back to this exercise and try it again in a few days to reinforce +what you've learned :)""" + +[[exercises]] +name = "threads3" +path = "exercises/threads/threads3.rs" +mode = "compile" +hint = """ +An alternate way to handle concurrency between threads is to use +a mpsc (multiple producer, single consumer) channel to communicate. +With both a sending end and a receiving end, it's possible to +send values in one thread and receive them in another. +Multiple producers are possible by using clone() to create a duplicate +of the original sending end. +See https://doc.rust-lang.org/book/ch16-02-message-passing.html for more info. +""" + # MACROS [[exercises]] -- cgit v1.2.3 From 479574e88eef4a4299b005388bec74f07a9c57d5 Mon Sep 17 00:00:00 2001 From: "Florine W. Dekker" Date: Wed, 7 Jun 2023 16:58:02 +0200 Subject: fix(vecs): rename outdated variable name in hint --- info.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'info.toml') diff --git a/info.toml b/info.toml index 2add5f0..8706ee5 100644 --- a/info.toml +++ b/info.toml @@ -260,8 +260,8 @@ name = "vecs2" path = "exercises/vecs/vecs2.rs" mode = "test" hint = """ -Hint 1: `i` is each element from the Vec as they are being iterated. Can you try -multiplying this? +Hint 1: `element` is each element from the Vec as they are being iterated. Can you +try multiplying this? Hint 2: For the first function, there's a way to directly access the numbers stored in the Vec, using the * dereference operator. You can both access and write to the -- cgit v1.2.3 From 369ae2e63d06de6fee36aeebfd1ff3e8bcdfa25a Mon Sep 17 00:00:00 2001 From: liv Date: Mon, 12 Jun 2023 12:07:18 +0200 Subject: feat(move_semantics2): rewrite hint --- exercises/move_semantics/move_semantics2.rs | 10 ++++------ info.toml | 29 +++++++++++++++-------------- 2 files changed, 19 insertions(+), 20 deletions(-) (limited to 'info.toml') diff --git a/exercises/move_semantics/move_semantics2.rs b/exercises/move_semantics/move_semantics2.rs index 93bb82e..66ddb4c 100644 --- a/exercises/move_semantics/move_semantics2.rs +++ b/exercises/move_semantics/move_semantics2.rs @@ -2,23 +2,21 @@ // 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]` +// vec0 has length 3, with contents `[22, 44, 66]` +// vec1 has length 4, with contents `[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); + println!("{} has length {}, with contents: `{:?}`", "vec0", vec0.len(), vec0); vec1.push(88); - println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1); + println!("{} has length {}, with contents `{:?}`", "vec1", vec1.len(), vec1); } fn fill_vec(vec: Vec) -> Vec { diff --git a/info.toml b/info.toml index 2add5f0..8febf41 100644 --- a/info.toml +++ b/info.toml @@ -287,23 +287,24 @@ Also: Try accessing `vec0` after having called `fill_vec()`. See what happens!"" [[exercises]] name = "move_semantics2" path = "exercises/move_semantics/move_semantics2.rs" -mode = "compile" +mode = "test" hint = """ -So, `vec0` is passed into the `fill_vec` function as an argument. In Rust, -when an argument is passed to a function and it's not explicitly returned, -you can't use the original variable anymore. We call this "moving" a variable. -Variables that are moved into a function (or block scope) and aren't explicitly -returned get "dropped" at the end of that function. This is also what happens here. -There's a few ways to fix this, try them all if you want: -1. Make another, separate version of the data that's in `vec0` and pass that +When running this exercise for the first time, you'll notice an error about +"borrow of moved value". In Rust, when an argument is passed to a function and +it's not explicitly returned, you can't use the original variable anymore. +We call this "moving" a variable. When we pass `vec0` into `fill_vec`, it's being +"moved" into `vec1`, meaning we can't access `vec0` anymore after the fact. +Rust provides a couple of different ways to mitigate this issue, feel free to try them all: +1. You could make another, separate version of the data that's in `vec0` and pass that to `fill_vec` instead. 2. Make `fill_vec` borrow its argument instead of taking ownership of it, - and then copy the data within the function in order to return an owned - `Vec` -3. Make `fill_vec` *mutably* borrow a reference to its argument (which will need to be - mutable), modify it directly, then not return anything. Then you can get rid - of `vec1` entirely -- note that this will change what gets printed by the - first `println!`""" + and then copy the data within the function (`vec.clone()`) in order to return an owned + `Vec`. +3. Or, you could make `fill_vec` *mutably* borrow a reference to its argument (which will need to be + mutable), modify it directly, then not return anything. This means that `vec0` will change over the + course of the function, and makes `vec1` redundant (make sure to change the parameters of the `println!` + statements if you go this route) +""" [[exercises]] name = "move_semantics3" -- cgit v1.2.3 From adc7ca56901ed1f53659fb8fa139a65423affd13 Mon Sep 17 00:00:00 2001 From: liv Date: Thu, 22 Jun 2023 10:10:44 +0200 Subject: fix(move_semantics2): change type back to compile --- info.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'info.toml') diff --git a/info.toml b/info.toml index ba3e585..b4fd8ff 100644 --- a/info.toml +++ b/info.toml @@ -287,7 +287,7 @@ Also: Try accessing `vec0` after having called `fill_vec()`. See what happens!"" [[exercises]] name = "move_semantics2" path = "exercises/move_semantics/move_semantics2.rs" -mode = "test" +mode = "compile" hint = """ When running this exercise for the first time, you'll notice an error about "borrow of moved value". In Rust, when an argument is passed to a function and -- cgit v1.2.3 From 405b32e77a6643f08e5bc895d6d2d1e684d47324 Mon Sep 17 00:00:00 2001 From: vnprc <9425366+vnprc@users.noreply.github.com> Date: Mon, 26 Jun 2023 09:17:39 -0400 Subject: chore: use correct line number in strings2.rs hint --- info.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'info.toml') diff --git a/info.toml b/info.toml index b4fd8ff..e4863cb 100644 --- a/info.toml +++ b/info.toml @@ -439,7 +439,7 @@ mode = "compile" hint = """ Yes, it would be really easy to fix this by just changing the value bound to `word` to be a string slice instead of a `String`, wouldn't it?? There is a way to add one character to line -9, though, that will coerce the `String` into a string slice. +12, though, that will coerce the `String` into a string slice. Side note: If you're interested in learning about how this kind of reference conversion works, you can jump ahead in the book and read this part in the smart pointers chapter: https://doc.rust-lang.org/stable/book/ch15-02-deref.html#implicit-deref-coercions-with-functions-and-methods""" -- cgit v1.2.3 From b99c7b8c37b7f95d450ad3fa5461a9398c0f7819 Mon Sep 17 00:00:00 2001 From: Will Hack <18036720+willhack@users.noreply.github.com> Date: Sun, 2 Jul 2023 13:46:59 -0400 Subject: chore: update line reference in strings2 hint --- info.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'info.toml') diff --git a/info.toml b/info.toml index ba3e585..05012cf 100644 --- a/info.toml +++ b/info.toml @@ -439,7 +439,7 @@ mode = "compile" hint = """ Yes, it would be really easy to fix this by just changing the value bound to `word` to be a string slice instead of a `String`, wouldn't it?? There is a way to add one character to line -9, though, that will coerce the `String` into a string slice. +12, though, that will coerce the `String` into a string slice. Side note: If you're interested in learning about how this kind of reference conversion works, you can jump ahead in the book and read this part in the smart pointers chapter: https://doc.rust-lang.org/stable/book/ch15-02-deref.html#implicit-deref-coercions-with-functions-and-methods""" -- cgit v1.2.3 From 0ab781c7a7e5240f86033a5c9d242ef5aca391aa Mon Sep 17 00:00:00 2001 From: Will Hack <18036720+willhack@users.noreply.github.com> Date: Mon, 3 Jul 2023 14:20:38 -0400 Subject: chore: remove line reference from strings2 hint --- info.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'info.toml') diff --git a/info.toml b/info.toml index 05012cf..9885cdc 100644 --- a/info.toml +++ b/info.toml @@ -438,8 +438,8 @@ path = "exercises/strings/strings2.rs" mode = "compile" hint = """ Yes, it would be really easy to fix this by just changing the value bound to `word` to be a -string slice instead of a `String`, wouldn't it?? There is a way to add one character to line -12, though, that will coerce the `String` into a string slice. +string slice instead of a `String`, wouldn't it?? There is a way to add one character to the +if statement, though, that will coerce the `String` into a string slice. Side note: If you're interested in learning about how this kind of reference conversion works, you can jump ahead in the book and read this part in the smart pointers chapter: https://doc.rust-lang.org/stable/book/ch15-02-deref.html#implicit-deref-coercions-with-functions-and-methods""" -- cgit v1.2.3 From 287172698aea106723682542e011b64f3d6d218a Mon Sep 17 00:00:00 2001 From: Joshua Carlson Date: Mon, 3 Jul 2023 14:52:13 -0400 Subject: added if3 based on: `Using if in a let Statement` --- exercises/if/if3.rs | 55 +++++++++++++++++++++++++++++++++++++++++++++++++++++ info.toml | 7 +++++++ 2 files changed, 62 insertions(+) create mode 100644 exercises/if/if3.rs (limited to 'info.toml') diff --git a/exercises/if/if3.rs b/exercises/if/if3.rs new file mode 100644 index 0000000..73a7025 --- /dev/null +++ b/exercises/if/if3.rs @@ -0,0 +1,55 @@ +// if3.rs +// +// Execute `rustlings hint if3` or use the `hint` watch subcommand for a hint. + +// I AM NOT DONE + +pub fn animal_habitat(animal: &str) -> &'static str { + let identifier = if animal == "crab" { + 1 + } else if animal == "gopher" { + 2.0 + } else if animal == "snake" { + 3 + } else { + "Unknown" + }; + + // DO NOT CHANGE THIS STATEMENT BELOW + let habitat = if identifier == 1 { + "Beach" + } else if identifier == 2 { + "Burrow" + } else if identifier == 3 { + "Desert" + } else { + "Unknown" + }; + + habitat +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn gopher_lives_in_burrow() { + assert_eq!(animal_habitat("gopher"), "Burrow") + } + + #[test] + fn snake_lives_in_desert() { + assert_eq!(animal_habitat("snake"), "Desert") + } + + #[test] + fn crab_lives_on_beach() { + assert_eq!(animal_habitat("crab"), "Beach") + } + + #[test] + fn unknown_animal() { + assert_eq!(animal_habitat("dinosaur"), "Unknown") + } +} diff --git a/info.toml b/info.toml index e4863cb..e8a28cb 100644 --- a/info.toml +++ b/info.toml @@ -167,6 +167,13 @@ For that first compiler error, it's important in Rust that each conditional block returns the same type! To get the tests passing, you will need a couple conditions checking different input values.""" +[[exercises]] +name = "if3" +path = "exercises/if/if3.rs" +mode = "test" +hint = """ +In Rust, every arm of an `if` expression has to return the same type of value. Make sure the type is consistent across all arms.""" + # QUIZ 1 [[exercises]] -- cgit v1.2.3 From 662e5bddd7faf7ba383d964ef3c6a2d33168e66c Mon Sep 17 00:00:00 2001 From: Yamila Moreno Date: Mon, 17 Jul 2023 15:58:29 +0200 Subject: fix(primitives-4.rs): update hint so it's less confusing --- info.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'info.toml') diff --git a/info.toml b/info.toml index e8a28cb..f484ecd 100644 --- a/info.toml +++ b/info.toml @@ -216,7 +216,7 @@ mode = "test" hint = """ Take a look at the Understanding Ownership -> Slices -> Other Slices section of the book: https://doc.rust-lang.org/book/ch04-03-slices.html -and use the starting and ending indices of the items in the Array +and use the starting and ending (plus one) indices of the items in the Array that you want to end up in the slice. If you're curious why the first argument of `assert_eq!` does not -- cgit v1.2.3 From af76794627ac9252650c8d3ec41d9afe251ca5e5 Mon Sep 17 00:00:00 2001 From: Roi Gabay Date: Sun, 20 Aug 2023 21:09:10 +0300 Subject: info.toml: update threads2 text. the previous text does not appear in the provided link (https://doc.rust-lang.org/book/ch16-03-shared-state.html#atomic-reference-counting-with-arct). --- info.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'info.toml') diff --git a/info.toml b/info.toml index e8a28cb..05bb0d5 100644 --- a/info.toml +++ b/info.toml @@ -1009,7 +1009,7 @@ and keep reading if you'd like more hints :) Do you now have an `Arc` `Mutex` `JobStatus` at the beginning of main? Like: `let status = Arc::new(Mutex::new(JobStatus { jobs_completed: 0 }));` Similar to the code in the example in the book that happens after the text -that says "We can use Arc to fix this.". If not, give that a try! If you +that says "Sharing a Mutex Between Multiple Threads". If not, give that a try! If you do and would like more hints, keep reading!! -- cgit v1.2.3 From 3cc9be0d115c8fd614dff9ab982c84c3d645173c Mon Sep 17 00:00:00 2001 From: mo8it Date: Sat, 26 Aug 2023 23:25:12 +0200 Subject: Avoid line numbers in hints --- info.toml | 28 +++++++++++++++------------- 1 file changed, 15 insertions(+), 13 deletions(-) (limited to 'info.toml') diff --git a/info.toml b/info.toml index e8a28cb..1afe338 100644 --- a/info.toml +++ b/info.toml @@ -22,8 +22,8 @@ name = "variables1" path = "exercises/variables/variables1.rs" mode = "compile" hint = """ -The declaration on line 8 is missing a keyword that is needed in Rust -to create a new variable binding.""" +The declaration in the first line in the main function is missing a keyword +that is needed in Rust to create a new variable binding.""" [[exercises]] name = "variables2" @@ -32,7 +32,7 @@ mode = "compile" hint = """ 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 7 with a type annotation? +What happens if you annotate the first line in the main function with a type annotation? What if you give x a value? What if you do both? What type should x be, anyway? @@ -44,8 +44,9 @@ path = "exercises/variables/variables3.rs" mode = "compile" hint = """ Oops! In this exercise, we have a variable binding that we've created on -line 7, and we're trying to use it on line 8, but we haven't given it a -value. We can't print out something that isn't there; try giving x a value! +in the first line in the main function, and we're trying to use it in the next line, +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!""" @@ -123,8 +124,8 @@ name = "functions4" path = "exercises/functions/functions4.rs" mode = "compile" hint = """ -The error message points to line 17 and says it expects a type after the -`->`. This is where the function's return type should be -- take a look at +The error message points to the function `sale_price` and says it expects a type +after the `->`. This is where the function's return type should be -- take a look at the `is_even` function for an example! Also: Did you figure out that, technically, u32 would be the more fitting type @@ -285,9 +286,10 @@ name = "move_semantics1" path = "exercises/move_semantics/move_semantics1.rs" mode = "compile" hint = """ -So you've got the "cannot borrow immutable local variable `vec1` as mutable" error on line 13, -right? The fix for this is going to be adding one keyword, and the addition is NOT on line 13 -where the error is. +So you've got the "cannot borrow immutable local variable `vec1` as mutable" error on the line +where we push an element to the vector, right? +The fix for this is going to be adding one keyword, and the addition is NOT on the line where +we push to the vector (where the error is). Also: Try accessing `vec0` after having called `fill_vec()`. See what happens!""" @@ -445,8 +447,9 @@ path = "exercises/strings/strings2.rs" mode = "compile" hint = """ Yes, it would be really easy to fix this by just changing the value bound to `word` to be a -string slice instead of a `String`, wouldn't it?? There is a way to add one character to line -12, though, that will coerce the `String` into a string slice. +string slice instead of a `String`, wouldn't it?? There is a way to add one character to the +line with the function call `is_a_color_word`, though, that will coerce the `String` into a +string slice. Side note: If you're interested in learning about how this kind of reference conversion works, you can jump ahead in the book and read this part in the smart pointers chapter: https://doc.rust-lang.org/stable/book/ch15-02-deref.html#implicit-deref-coercions-with-functions-and-methods""" @@ -825,7 +828,6 @@ To handle that you need to add a special attribute to the test function. You can refer to the docs: https://doc.rust-lang.org/stable/book/ch11-01-writing-tests.html#checking-for-panics-with-should_panic""" - # STANDARD LIBRARY TYPES [[exercises]] -- cgit v1.2.3 From 51e237d5f97610294798710ef8ba5349c2fd50c7 Mon Sep 17 00:00:00 2001 From: liv Date: Mon, 4 Sep 2023 14:20:37 +0200 Subject: fix: refactor move semantics 1-4 into tests --- exercises/move_semantics/move_semantics1.rs | 15 +++++---------- exercises/move_semantics/move_semantics2.rs | 18 ++++++------------ exercises/move_semantics/move_semantics3.rs | 13 ++++--------- exercises/move_semantics/move_semantics4.rs | 16 ++++++---------- info.toml | 16 ++++++---------- 5 files changed, 27 insertions(+), 51 deletions(-) (limited to 'info.toml') diff --git a/exercises/move_semantics/move_semantics1.rs b/exercises/move_semantics/move_semantics1.rs index 710d20d..e063937 100644 --- a/exercises/move_semantics/move_semantics1.rs +++ b/exercises/move_semantics/move_semantics1.rs @@ -5,24 +5,19 @@ // I AM NOT DONE +#[test] fn main() { - let vec0 = Vec::new(); + let vec0 = vec![22, 44, 66]; let vec1 = fill_vec(vec0); - println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1); - - vec1.push(88); - - println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1); + assert_eq!(vec1, vec![22, 44, 66, 88]); } fn fill_vec(vec: Vec) -> Vec { - let mut vec = vec; + let vec = vec; - vec.push(22); - vec.push(44); - vec.push(66); + vec.push(88); vec } diff --git a/exercises/move_semantics/move_semantics2.rs b/exercises/move_semantics/move_semantics2.rs index 72d37fa..baf6bcc 100644 --- a/exercises/move_semantics/move_semantics2.rs +++ b/exercises/move_semantics/move_semantics2.rs @@ -1,32 +1,26 @@ // move_semantics2.rs // -// Expected output: -// vec0 has length 3, with contents `[22, 44, 66]` -// vec1 has length 4, with contents `[22, 44, 66, 88]` +// Make the test pass by finding a way to keep both Vecs separate! // // Execute `rustlings hint move_semantics2` or use the `hint` watch subcommand // for a hint. // I AM NOT DONE +#[test] fn main() { - let vec0 = Vec::new(); + let vec0 = vec![22, 44, 66]; let mut vec1 = fill_vec(vec0); - println!("{} has length {}, with contents: `{:?}`", "vec0", vec0.len(), vec0); - - vec1.push(88); - - println!("{} has length {}, with contents `{:?}`", "vec1", vec1.len(), vec1); + assert_eq!(vec0, vec![22, 44, 66]); + assert_eq!(vec1, vec![22, 44, 66, 88]); } fn fill_vec(vec: Vec) -> Vec { let mut vec = vec; - vec.push(22); - vec.push(44); - vec.push(66); + vec.push(88); vec } diff --git a/exercises/move_semantics/move_semantics3.rs b/exercises/move_semantics/move_semantics3.rs index ea21493..69e564a 100644 --- a/exercises/move_semantics/move_semantics3.rs +++ b/exercises/move_semantics/move_semantics3.rs @@ -8,22 +8,17 @@ // I AM NOT DONE +#[test] fn main() { - let vec0 = Vec::new(); + let vec0 = vec![22, 44, 66]; 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); + assert_eq!(vec1, vec![22, 44, 66, 88]); } fn fill_vec(vec: Vec) -> Vec { - vec.push(22); - vec.push(44); - vec.push(66); + vec.push(88); vec } diff --git a/exercises/move_semantics/move_semantics4.rs b/exercises/move_semantics/move_semantics4.rs index 75a3b6b..80b49db 100644 --- a/exercises/move_semantics/move_semantics4.rs +++ b/exercises/move_semantics/move_semantics4.rs @@ -9,25 +9,21 @@ // I AM NOT DONE +#[test] fn main() { - let vec0 = Vec::new(); + let vec0 = vec![22, 44, 66]; 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); + assert_eq!(vec1, vec![22, 44, 66, 88]); } -// `fill_vec()` no longer takes `vec: Vec` as argument +// `fill_vec()` no longer takes `vec: Vec` as argument - don't change this! fn fill_vec() -> Vec { + // Instead, let's create and fill the Vec in here - how do you do that? let mut vec = vec; - vec.push(22); - vec.push(44); - vec.push(66); + vec.push(88); vec } diff --git a/info.toml b/info.toml index 0aca022..b41985e 100644 --- a/info.toml +++ b/info.toml @@ -284,9 +284,9 @@ better. What do you think is the more commonly used pattern under Rust developer [[exercises]] name = "move_semantics1" path = "exercises/move_semantics/move_semantics1.rs" -mode = "compile" +mode = "test" hint = """ -So you've got the "cannot borrow immutable local variable `vec1` as mutable" error on the line +So you've got the "cannot borrow immutable local variable `vec` as mutable" error on the line where we push an element to the vector, right? The fix for this is going to be adding one keyword, and the addition is NOT on the line where we push to the vector (where the error is). @@ -296,7 +296,7 @@ Also: Try accessing `vec0` after having called `fill_vec()`. See what happens!"" [[exercises]] name = "move_semantics2" path = "exercises/move_semantics/move_semantics2.rs" -mode = "compile" +mode = "test" hint = """ When running this exercise for the first time, you'll notice an error about "borrow of moved value". In Rust, when an argument is passed to a function and @@ -309,16 +309,12 @@ Rust provides a couple of different ways to mitigate this issue, feel free to tr 2. Make `fill_vec` borrow its argument instead of taking ownership of it, and then copy the data within the function (`vec.clone()`) in order to return an owned `Vec`. -3. Or, you could make `fill_vec` *mutably* borrow a reference to its argument (which will need to be - mutable), modify it directly, then not return anything. This means that `vec0` will change over the - course of the function, and makes `vec1` redundant (make sure to change the parameters of the `println!` - statements if you go this route) """ [[exercises]] name = "move_semantics3" path = "exercises/move_semantics/move_semantics3.rs" -mode = "compile" +mode = "test" hint = """ The difference between this one and the previous ones is that the first line of `fn fill_vec` that had `let mut vec = vec;` is no longer there. You can, @@ -328,7 +324,7 @@ an existing binding to be a mutable binding instead of an immutable one :)""" [[exercises]] name = "move_semantics4" path = "exercises/move_semantics/move_semantics4.rs" -mode = "compile" +mode = "test" hint = """ Stop reading whenever you feel like you have enough direction :) Or try doing one step and then fixing the compiler errors that result! @@ -337,7 +333,7 @@ So the end goal is to: - so then `vec0` doesn't exist, so we can't pass it to `fill_vec` - `fill_vec` has had its signature changed, which our call should reflect - since we're not creating a new vec in `main` anymore, we need to create - a new vec in `fill_vec`, similarly to the way we did in `main`""" + a new vec in `fill_vec`, and fill it with the expected values""" [[exercises]] name = "move_semantics5" -- cgit v1.2.3