rustlings | Small exercises to get you used to reading and writing Rust

You can't have two mutable references to the same value at the same time. If you reorder the lines in your function like this:

map_err is returning a Result but you're trying to affect it to x, which you declared as an i64 variable. You need to add a ? so that an Err result will be returned and an Ok result will be unwrapped: let x = s.parse::().map_err(ParsePosNonzeroError::from_parseint)?;

There's a constraint in the return type of the join method that the char type does not meet, since it doesn't have a static lifetime:

The reason why is that we are in a big world and Rust strings are encoded in UTF-8, allowing for different languages and characters to be encoded correctly. In some languages, a lowercase letter might be one character, but its uppercase form is two characters.

For this reason, char.to_uppercase() return an iterator that must be collected to get the appropriate result.

Some(first) => first.to_uppercase().collect() should fix this issue

In rust only the last expression is taken as return value.

In your case:

You could change the match block to a ? if you map the error into an IntoColorError. That will allow you to continue chaining methods so you can call try_into() to convert the Vec into [u8; 3], which can in turn be destructured into separate red, green, and blue variables.

It appears that you have defined your own enum called Option in your program. Thus, there are two different types called Option: yours (main::Option), and the standard one (std::option::Option). The variable none has type main::Option, but None is of type std::option::Option.

Obvious solution is to just delete your own enum. If, however, for the sake of experiment you do want to create an instance of your own enum called Option, and assign the value of None to it, you'd need to qualify None:

Why can I call capitalize_first with a &&str argument?

The linked Q&A for auto-dereferencing rules is specifically for how self is resolved when using the a.b() syntax. The rules for arguments in general skip the auto-reference step and just rely on Deref coercions. Since &&str implements Deref (and indeed all references implement Deref), this &&str -> &str transformation happens transparently.

Why doesn't it work for .map() then?

Plain and simply, map() is expecting something that implements Fn(&&str) -> T and capitalize_first does not. A Fn(&str) is not transparently transformed into a Fn(&&str), it requires a transformation step like the one introduced by the closure (albeit transparently).

is the same pointer reused and just made mutable?

Yes. Well the same object entirely, at runtime it's essentially a no-op.

Why would shadowing be used in this case at all?

Some people like the pattern of temporally "locking" and "unlocking" bindings via shadowing e.g.