@ -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
@ -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 . M ake 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 m ake 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 < i32 > `
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 < i32 > ` .
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"
@ -905,67 +906,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<T> 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 +968,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<T> 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 ] ]
@ -1170,4 +1171,4 @@ name = "as_ref_mut"
path = "exercises/conversions/as_ref_mut.rs"
mode = "test"
hint = "" "
Add AsRef < str > as a trait bound to the functions . "" "
Add AsRef < str > or AsMut < u32 > as a trait bound to the functions . "" "