Programming A Guessing Game

Question 1

What is the command to create a new Rust project?

Answer 1

cargo new project_name

cd project_name

Question 2

What is the io library?

Answer 2

input/output

Question 3

Where does the io library come from?

Answer 3

The standard library known as std

Example: use std::io;

Question 4

What is the prelude?

Answer 4

The prelude is the list of things that Rust automatically imports into every Rust program. It’s kept as small as possible, and is focused on things, particularly traits, which are used in almost every single Rust program.

More info in the standard library documentation:

https://doc.rust-lang.org/std/prelude/index.html

Question 5

How do you use a type that isn’t in the prelude?

Answer 5

You must bring the type into scope explicitly with a use statement.

Using the std::io library provides you with a number useful features, including the ability to accept user input.

Question 6

fn main() {

The main function is the entry point into the program.

What do each of these mean?

fn
main()
{

Answer 6

The fn syntax declares a new function.

The parentheses, (), indicate there are no parameters.

The curly bracket, {, starts the body of the function.

Question 7

How do you make a variable mutable?

Answer 7

Add mut before the variable’s name.

let apples = 5; // immutable
let mut bananas = 5; // mutable

Question 8

let mut guess will introduce a mutable variable named what?

Answer 8

The mutable variable will be named guess.

Question 9

What does the = sign mean?

Answer 9

It tells Rust we want to bind something to the variable now.

Question 10

let mut guess = String::new();

String::new is bound to guess. What is String:new?

Answer 10

It is a function that returns a new instance of a String.

String is a string type provided by the standard library that is a growable, UTF-8 encoded bit of text.

https://doc.rust-lang.org/std/string/struct.String.html

Question 11

let mut guess = String::new();

What does the :: syntax in the ::new line indicate?

Answer 11

The :: syntax in the ::new line indicates that new is an associated function of the String type.

An associated function is a function that’s implemented on a type, in this case String. This new function creates a new, empty string.

Question 12

What is an associated function?

Answer 12

An associated function is a function that’s implemented on a type.

Question 13

let mut guess = String::new();

What does this code create?

Answer 13

In full, the let mut guess = String::new(); line has created a mutable variable that is currently bound to a new, empty instance of a String.

Question 14

We’ll call the stdin function from the io module.

io::stdin()
.read_line(&mut guess)

What does this allow us to do?

Answer 14

It will allow us to handle user input.

Question 15

io::stdin()
.read_line(&mut guess)

If we hadn’t imported the io library with use std::io at the beginning of the program, how else could we still use the function?

Answer 15

We could write the function call as std::io:stdin.

The stdin function returns an instance of std::io::Stdin, which is a type that represents a handle to the standard input for your terminal.

Question 16

.read_line(&mut guess)

What method does this line call?

Answer 16

The line .read_line(&mut guess) calls the read_line method on the standard input handle to get input from the user.

Question 17

.read_line(&mut guess)

What is the purpose of &mut guess in this line?

Answer 17

We pass &mut guess as the argument to read_line to tell it what string to store the user input in.

Question 18

io::stdin()
.read_line(&mut guess)

What is the full job of read_line?

Answer 18

The full job of read_line is to take whatever the user types into standard input and append that into a string (without overwriting its contents), so we therefore pass that string as an argument. The string argument needs to be mutable so the method can change the string’s content.

Question 19

What does & indicate?

Answer 19

The & indicates that this argument is a reference, which gives you a way to let multiple parts of your code access one piece of data without needing to copy that data into memory multiple times.

References, like variables, are immutable by default. You need to write &mut guess rather than &guess to make it mutable.

Question 20

How do you make a reference mutable?

Answer 20

Write mut after the &.

&mut guess

Question 21

Result is from the standard library. It has two variants. What are they?

Answer 21

Ok and Err

Question 22

What do the Ok and Err variants of Result indicate?

Answer 22

The Ok variant indicates the operation was successful, and inside Ok is the successfully generated value. The Err variant means the operation failed, and Err contains information about how or why the operation failed.