The Rustlings exercises - part 2
Tags: rust, beginners, learning, practice
Published: 2021-06-27 16:04:33

Last week, I dived into the [documentation](https://doc.rust-lang.org/stable/book/ch16-03-shared-state.html). It was a bit long, and I decided to split my understanding into two different posts. Now is the time to finish them.

## Threading

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](https://doc.rust-lang.org/stable/book/ch16-03-shared-state.html) 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.

## Macros

This section focuses on [macros](https://doc.rust-lang.org/stable/book/ch19-06-macros.html).

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 `macro3.rs` 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, <abbr title="Read The Fine Manual">RTFM</abbr>.

I couldn't solve `macro4.rs` 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 `quizz4.rs` 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()`.

## Clippy

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

![Microsoft Office's Clippy](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/uvrpqytjhcomlg6ez8a4.png)

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](https://doc.rust-lang.org/stable/book/appendix-04-useful-development-tools.html#more-lints-with-clippy)

You install Clippy with the following command:

```bash
rustup component add clippy
```

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

```bash
cargo clippy
```

I believe Clippy should be mandatory on all projects.

In IntelliJ IDEA, you can configure Clippy by going to menu:IntelliJ IDEA[Preferences] and then menu:Languages and Frameworks[Rust > Cargo].

## Conversions

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

![&str and String back and forth conversion functions](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/jpjfok74n18k3bjbfsqu.png)

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

## Conclusion

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 on the `work` branch:

{% github ajavageek/rustlings/ %}

**To go further:**

* [rustlings](https://github.com/rust-lang/rustlings)

_Originally published at [A Java Geek](https://blog.frankel.ch/start-rust/4/) on June 27<sup>th</sup> 2021_