let foo = 5; // immutable
let mut bar = 5; // mutable

You now know that let mut guess will introduce a mutable variable named guess. On the other side of the equal sign (=) is the value that guess is bound to, which is the result of calling String::new, 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.

The :: syntax in the ::new line indicates that new is an associated function of the String type. An associated function is implemented on a type, in this case String, rather than on a particular instance of a String. Some languages call this a static method.

This new function creates a new, empty string. You’ll find a new function on many types, because it’s a common name for a function that makes a new value of some kind.

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

io::stdin().read_line(&mut guess)
    .expect("Failed to read line");

If we hadn’t listed the use std::io line at the beginning of the program, we could have written this 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.

The next part of the code, .read_line(&mut guess), calls the read_line method on the standard input handle to get input from the user. We’re also passing one argument to read_line: &mut guess.

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 are a complex feature, and one of Rust’s major advantages is how safe and easy it is to use references. You don’t need to know a lot of those details to finish this program. For now, all you need to know is that like variables, references are immutable by default. Hence, you need to write &mut guess rather than &guessto make it mutable.

.expect("Failed to read line");

As mentioned earlier, read_line puts what the user types into the string we’re passing it, but it also returns a value—in this case, an io::Result. Rust has a number of types named Result in its standard library: a generic Result as well as specific versions for submodules, such as io::Result.

The Result types are enumerations, often referred to as enums. An enumeration is a type that can have a fixed set of values, and those values are called the enum’s variants.

An instance of io::Result has an expectmethod that you can call. If this instance of io::Result is an Err value, expect will cause the program to crash and display the message that you passed as an argument to expect. If the read_line method returns an Err, it would likely be the result of an error coming from the underlying operating system. If this instance of io::Result is an Ok value, expect will take the return value that Ok is holding and return just that value to you so you can use it. In this case, that value is the number of bytes in what the user entered into standard input.

If you don’t call expect, the program will compile, but you’ll get a warning.

println!("You guessed: {}", guess);

let x = 5;
let y = 10;

println!("x = {} and y = {}", x, y);

[root@itoracle src]# cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.01s                                                                                                               
     Running `/usr/local/automng/src/rust/test/guessing_game/target/debug/guessing_game`
Guess the number!
Please input your guess.
happly new year
You guessed: happly new year

[root@itoracle guessing_game]# vim Cargo.toml 

[package]
name = "guessing_game"
version = "0.1.0"
authors = ["tanpf <[email protected]>"]
edition = "2018"

[dependencies]
rand = "0.3.14"

[root@itoracle guessing_game]# cargo build
    Updating crates.io index
  Downloaded rand v0.3.22                                                                                                                                                   
  Downloaded rand v0.4.5                                                                                                                                                    
  Downloaded libc v0.2.47                                                                                                                                                   
   Compiling libc v0.2.47                                                                                                                                                   
   Compiling rand v0.4.5                                                                                                                                                    
   Compiling rand v0.3.22                                                                                                                                                   
   Compiling guessing_game v0.1.0 (/usr/local/automng/src/rust/test/guessing_game)                                                                                          
    Finished dev [unoptimized + debuginfo] target(s) in 42.07s 

# cargo update
    Updating crates.io index

[dependencies]

rand = "0.4.0"

use std::io;
use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1, 101);

    println!("The secret number is: {}", secret_number);

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin().read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {}", guess);
}

[root@itoracle guessing_game]# cargo run
   Compiling guessing_game v0.1.0 (/usr/local/automng/src/rust/test/guessing_game)                                                                                          
    Finished dev [unoptimized + debuginfo] target(s) in 3.55s                                                                                                               
     Running `target/debug/guessing_game`
Guess the number!
The secret number is: 38
Please input your guess.
8
You guessed: 8

[root@itoracle guessing_game]# cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.06s                                                                                                               
     Running `target/debug/guessing_game`
Guess the number!
The secret number is: 51
Please input your guess.
51
You guessed: 51

[root@itoracle src]# cat main.rs 
use std::io;
use std::cmp::Ordering;
use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1, 101);

    println!("The secret number is: {}", secret_number);

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin().read_line(&mut guess)
        .expect("Failed to read line");

    let guess: u32 = guess.trim().parse()
             .ok()
             .expect("Please type a number!");

    println!("You guessed: {}", guess);

    match guess.cmp(&secret_number) {
        Ordering::Less => println!("Too small!"),
        Ordering::Greater => println!("Too big!"),
        Ordering::Equal => println!("You win!"),
    };
}

[root@itoracle src]# cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.02s                                                            
     Running `/usr/local/automng/src/rust/test/guessing_game/target/debug/guessing_game`
Guess the number!
The secret number is: 69
Please input your guess.
69
You guessed: 69
You win!