Ideally, a program should be self-documenting by using descriptive variable names and easy-to-read code, but there are always cases where additional comments about a program's structure or algorithms are needed. Rust follows the C convention and has:

• // line comments; everything on the line after // is commentary and not compiled
• /* */block or multi-line comments; everything between the start /*and the end */ is not compiled

However, the preferred Rust style is to use only the // comment, also for multiple lines, as shown in the following code:

// see Chapter 2/code/comments.rs 
fn main() { 
  // Here starts the execution of the Game. 
  // We begin with printing a welcome message: 
  println!("Welcome to the Game!"); 
} 

Use the /* */ comments only to comment out code.

Rust also has a doc comment with ///, useful in larger projects that require an official...

Often, an application needs a few values that are in fact constants, meaning that they do not change in the course of the program. In our game, for example, the game name Monster Attack could be a constant, as could the maximum health amount, which is the number 100. We must be able to use them in the main() function or any other function in our program, so they are placed at the top of the code file. They live in the global scope of the program. Such constants are declared with the keyword static, as follows:

// see Chapter 2/code/constants1.rs 
static MAX_HEALTH: i32 = 100; 
static GAME_NAME: &str = "Monster Attack"; 
 
fn main() { 
} 

Names of constants must be in uppercase, underscores can be used to separate word parts. Their type must also be indicated; the variable MAX_HEALTH is a 32-bit integer (i32) and the variable GAME_NAME is a string...

Constants that have been initialized have a value. Values exist in different types: 70 is an integer, 3.14 is a float, and Z and θ are the type of a character. Characters are Unicode values that take four bytes of memory each. Godzilla is a string of type &str (which is Unicode UTF8 by default), true and false are the type of Boolean values. Integers can be written in different formats:

• Hexadecimal format with 0x, like 0x46 for 70.
• Octal format with 0o, like 0o106 for 70.
• Binary format with 0b, like 0b1000110.

• Underscores can be used for readability, as in 1_000_000. Sometimes the compiler will urge you to indicate more explicitly the type of number with a suffix, for example (the number after u or i is the number of memory bits used, namely: 8, 16, 32, or 64).
• The 10usize denotes an unsigned integer of machine word size (usize), which can...

Storing all values in constants is not an option. It is not good because constants live as long as the program and moreover can't change, and often we want to change values. In Rust, we can bind a value to a variable by using a let binding.

// see Chapter 2/code/bindings.rs 
fn main() { 
  let energy = 5; // value 5 is bound to variable energy 
} 

Unlike in many other languages, such as Python or Go, the semicolon,;, is needed here to end the statement. Otherwise, the compiler throws an error, as follows:

error: expected one of `.`, `;`, or an operator, found `}`

We also want to create bindings only when they are used in the rest of the program, but don't worry, the Rust compiler warns us about that. The warning looks like the following:

    
values.rs:2:6: 2:7 warning: unused variable: `energy`, #[warn(unused_variables)] on by default
  ...

All variables defined in the program bindings.rs have local scope delimited by the { } of the function which happens to be the main() function here, but this applies to any function. After the ending, }, they go out of scope and their memory allocation is freed.

We can even make a more limited scope inside a function by defining a code block as all code contained within a pair of curly braces { }, as in the following snippet:

// see Chapter 2/code/scope.rs 
fn main() { 
  let outer = 42; 
   { // start of code block 
        let inner = 3.14; 
        println!("block variable: {}", inner); 
        let outer = 99; // shadows the first outer variable 
        println!("block variable outer: {}", outer); 
    } // end of code block 
    println!("outer variable: {}", outer); 
} 

The preceding code gives the following...