Guessing-Game | pretty cool guessing game that you can play just to pass | Bot library

I am studying Rust and upon working on the Guessing Game I found this odd behaviour:

I'm learning rust. As part of the guessing game tutorial, I downloaded the rand crate. I am concerned about dependency confusion, and do not wish to download any more packages than absolutely necessary.

Therefore, I set my Cargo.toml to:

I am creating a guessing-game program where the user must enter a number between 1 and 100 and try and guess the 'magic number'.

I am trying to add a 'hint' feature where depending on how close the users guess was to the random number chosen by the computer, a message will appear displaying messages such as:

• Freezing—more than 50 away.
• Cold—more than 25 away.
• Cool—more than 15 away.
• Warm—more than 10 away.
• Hot—more than 5 away.
• Boiling—between 1 and 4 away.

Unfortunately when I enter a number and press the button "GUESS", the wrong 'hint' shows up for the number guessed. Specifically, "Boiling! Between 1 and 4 away!" However, when I enter the exact 'Magic Number', the correct text shows up. ""YOU GOT IT! " (the magic number) " is the magic number!"

In order for me to see what the 'Magic Number' is each time, I have added a line of code that I will remove later.

FYI: This is for a school project, and my teacher added this hint to the assignment:

In the Math class, there is a method that you can use to find the absolute (positive) value of a number. You will need to use this method to help you determine how far the guess is from the secret number. This will allow you to determine which message you should report for a hint. Sample code below:

Looking at the guessing game example from the intro book, specifically the part where you use a match statement to perform error-handling:

When/why do Rust traits need to be used/Imported, or why does this question not make sense?

I'm an experienced programmer, but I'm new to Rust.

I'm working my way through The Rust Programming Language -- in chapter 2 there's the following statment.

First, we add a use line: use rand::Rng. The Rng trait defines methods that random number generators implement, and this trait must be in scope for us to use those methods. Chapter 10 will cover traits in detail.

Emphasis mine.

It's not clear to me why this program

There's a crate I want to use as a library for some of my own code (speedtest-rs specifically, but it doesn't really matter). However, whenever I try to use this crate, the compiler doesn't want to play nice with it.

I wanted to input a value and assign it to a variable that is immutable (should be). How can I do that?

Currently, I am doing this:

My issue is when running the below program it simply breaks after max attempts but does NOT print the "I'm out of guesses and you cheated.... Why not?

In Rust it is encouraged to shadow variables:

But wait, doesn’t the program already have a variable named guess? It does, but Rust allows us to shadow the previous value of guess with a new one.

Won't this feature just introduce problems like:

• hard to follow code (easier to create bugs)
• accessing variables when one intended to access a different variable (creates bugs)

I have based this information from my own experience and the following sources: 1 2 3 4 5

What are the underlying reasons behind the decision to include variable shadowing?

It does have it advantages as to just create guess and not guess_str vs guess_int. There are both advantages and disadvantages.

What convinced the inventors of Rust that the advantages are greater than the disadvantages?

The programming world seems divided about this; some languages only issue warnings and discourage shadowing, some languages disallow it explicitly, some allow it and others even encourage it. What is the reasoning?

If possible I'd like to understand more, and a complete answer would possibly include:

• What kind of advantages/disadvantages are there?
• What are the use cases for shadow variables?
• When not to use them in Rust?
• What do different people from different programming background have to keep in mind? (and which pitfalls not to fall into)