The Rustlings exercises — part 2

Last week, I dived into the Rustlings exercises. It was a bit long, and I decided to split my understanding into two different posts. Now is the time to finish them.

This is the 4th post in the Start Rust focus series.Other posts include:

  1. My first cup of Rust
  2. My second cup of Rust
  3. The Rustlings exercises — part 1
  4. The Rustlings exercises — part 2 (this post)


There’s a single exercise for threads. It’s a bit disappointing because it’s a weak point of mine: I’d have loved more practice.

The solution is to wrap the JobStatus structure into a Mutex, just as the documentation describes. Mutex represents a global lock around an object. Please look at the above link for more details, which does a great job explaining Mutex in depth.


This section focuses on macros.

In general, I’m afraid of languages that offer macros. I think that macros decrease readability. Most macros are just a way to avoid duplicating code: other approaches achieve the same goal without the readability issue. Because Rust compiles to native code, most alternatives are not available. Hence, macros become a must.

The main problem of is that the code defines the macro in a dedicated module. The solution is more straightforward than what I tried first, namely use and prefix the macro with the namespace. You need to annotate the macro with #[macro_export]. Again, RTFM.

I couldn’t solve without hints. I was missing the correct separator between arms. I tried previously with commas, like for match, but it failed, so I wrongly ruled the separator out.

The point of is to (finally) write a simple macro. It’s pretty straightforward with the example of the previous macros files. My issue laid in how to concatenate &str. You first have to own the left operand with the usage of to_owned().


This series of exercises is pretty straightforward. But it allows us to know about Clippy.

No, I’m not talking about Microsoft Office’s assistant from the 2000s.

The Clippy tool is a collection of lints to analyze your code so you can catch common mistakes and improve your Rust code.

More Lints with Clippy

You install Clippy with the following command:

rustup component add clippy

From that point on, you can use Clippy like this:

cargo clippy

I believe Clippy should be mandatory on all projects.

In IntelliJ IDEA, you can configure Clippy by going to IntelliJ IDEA → Preferences and then Languages and Frameworks → RustCargo.


The exercises related to conversions allowed me to sum up the available functions that convert between &str and String.

Also, I learned that you need to collect() into a Vec<&str> after you’ve split() a String.


And that’s a wrap! I cannot resist the temptation to show the final reward that unlocks when you’ve completed all exercises.

🎉 All exercises completed! 🎉+----------------------------------------------------+
| You made it to the Fe-nish line! |
+-------------------------- ------------------------+
▒▒ ▒▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒▒ ▒▒
▒▒▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒▒▒
▒▒▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒▒▒
░░▒▒▒▒░░▒▒ ▒▒ ▒▒ ▒▒ ▒▒░░▒▒▒▒
▓▓▓▓▓▓▓▓ ▓▓ ▓▓██ ▓▓ ▓▓██ ▓▓ ▓▓▓▓▓▓▓▓
▒▒▒▒ ▒▒ ████ ▒▒ ████ ▒▒░░ ▒▒▒▒
▒▒ ▒▒▒▒▒▒ ▒▒▒▒▒▒ ▒▒▒▒▒▒ ▒▒
▒▒ ▒▒▒▒▒▒▒▒▒▒██████▒▒▒▒▒▒▒▒▒▒ ▒▒
▒▒ ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ▒▒
▒▒ ▒▒ ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ▒▒ ▒▒
▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒
▒▒ ▒▒ ▒▒ ▒▒

Thanks to all who contributed to build Rustlings; this is a fun experience: I recommend anybody who wants to learn Rust to have a try at them.

The complete source code for this post can be found on Github.

To go further:

Originally published at A Java Geek on June 27th 2021

Dev Advocate @Hazelcast . Former developer and architect. Still teaching, learning and blogging.