Introduction

In this exploration, we continue our introduction to the Rust programming language. In particular, we take a deeper look at variables and data types in Rust.

Variables in Rust

As we learned in the previous exploration, by default variables in Rust are immutable. Immutability means that once we have assigned a value to a variable, we cannot assign it a new value. Thus, the following program fails to compile because it tries to assign a value to the variable foo two times.

We can make variables mutable by adding mut before the name of the variable.

Immutable Variables vs. Constants

Rust also has the notion of constants which are declared using the const keyword instead of the let keyword. The value of a constant must be set to a constant expression, and it cannot be set as the result of a function call. E.g., the following statement declares a constant named PI which is of type float with value 3.14.

const PI : f32 = 3.14;

Shadowing

Rust allows us to declare a new variable with the same name as a previous variable in the same scope, e.g., in the same function. This is called shadowing and the first variable is now shadowed by the second variable. Once a variable has been shadowed when declared the second time, the value of this second variable declaration will appear wherever the variable name is used. Let us look at an example of shadowing which will also motivates its use.

In this program:

We prompt the user to enter an integer. Instead of using the println! macro, we are using the print! macro to print the message to the standard output . print! prints the message without adding a new line. However, calling the print! macro does not automatically flush standard output. To make sure that the output is sent to standard output, in the next statement we call the flush function on stdout. The function unwrap is used for error handling similar to expect.

print!("Enter a positive integer: ");
io::stdout().flush().unwrap();

We read the value entered by the user in the variable user_input via the following lines of code. The function read_line requires a string argument. This means that the input entered by the user is stored as a string in the variable user_input after these lines are executed.

let mut user_input = String::new();
io::stdin().read_line(&mut user_input)
      .expect("Failed to read line");

In the following line of code, we
- convert the string value in the variable user_input to an integer, and
- store it in a variable that is also called user_input but has integer data type.

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

At this point in the program, the original variableuser_input of type string has been shadowed by the variable user_input which is of type integer!

Shadowing a variable is not the same as changing the value of a mutable variable. With shadowing, we declare another variable of the same name as the original variable. Its data type can be the same as the shadowed variable or it can be different.

So why is shadowing useful? With shadowing we can use the same variable name after we convert a value from one data type to another data type. In our example program, without shadowing we would have to use two different variable names, one for the user input when it is a string data type and a different variable name when the string is converted to an integer data type. For example, the names could have been user_input_str and user_input_int. Shadowing allowed us to use the same name user_input when the data type was string and when it is integer.

Data Types & Type Annotation

Rust is a statically-typed language in which the data type of every variable and value is known at compile time. When the compiler can unambiguously infer the data type of a variable, Rust does not require that the data type is specified. However, if many types are possible, then we must add a type annotation to the variable.

Example

In the following declaration of the variable foo, the compiler can infer that the variable foo has data type integer. Therefore, a type annotation is not required and the compiler will accept the following statement.

let foo = 87;

However, the compiler will reject the following statement where we are using the function parse defined on the String data type to convert the string 87 to a number.

let foo = "87".parse().expect("Not a number!");

This is because, the parse function can be used to convert a string to an integer or to a floating-point number. The compiler cannot infer the data type of foo and hence rejects the statement with the following error message:

error[E0282]: type annotations needed
 --> main.rs:2:7
  |
2 |   let foo = "87".parse().expect("Not a number!");
  |       ^^^
  |       |
  |       cannot infer type
  |       consider giving `foo` a type

We can fix the compilation issue by modifying the variable declaration to specify the data type of the variable foo, e.g., by specifying that it is an integer as in the following statement.

let foo : u32 = "87".parse().expect("Not a number!");

Scalar Data Types

In Rust a scalar data type represents a single value. There are four primary scalar types:

Integers

Integers in Rust can be signed or unsigned. The data type annotation for signed integers starts with i and that for unsigned integers starts with u. Furthermore, both signed and unsigned integers have variants based on the number of bits in the integer. The following table summarizes the various integer data types:

Integer Data types
Length	Signed	Unsigned
8-bit	i8	u8
16-bit	i16	u16
32-bit	i32	u32
64-bit	i64	u64
128-bit	i128	u128
Arch dependent	isize	usize

Rust defaults to the data type i32 if a type annotation is not provided for an integer value. The value of isize and usize depends on the architecture of the machine on which the program is running. E.g., isize will be 32-bit long on a 32-bit architecture and 64-bit long on a 64-bit architecture.

Floating-point numbers

There are two floating-point number types, f32 for 32-bit floating-point numbers and f64 for 64-bit floating-point numbers. f64 is the default data type for floating-point numbers.

Booleans

Boolean type has the type annotation bool and has one of two possible values - true or false.

Characters

Character type has the type annotation char. Character literals are specified with single quote, just as in C. E.g.,

let fahrenheit = 'f';
let celsius : char = 'C';

Compound Types

Rust provides two compound types, tuples and arrays, which can group multiple types into one type.

Tuples

A tuple is a fixed length compound type that groups together values of a variety of types into a single type. For example, the following statement defines a variable temp which is a tuple composed of a floating-point number and a character:

let temp: (f32, char) = (98.7, 'F');

We can access elements of a tuple in two ways:

We can access an element directly by using a period, i.e., ., followed by a 0-based index of the value we want to access. For example, temp.0 will correspond to the value 98.7 and temp.1 to the value 'F'.
We can use destructuring where we can break up a tuple into its elements. E.g., let (degrees, unit) = temp; will set the variable degrees to the value 98.7 and the variable unit to the value F.

Arrays

Arrays in Rust are similar to arrays in other programming languages - every element of an array must have the same type, they have a fixed size, and have 0-based index. Type annotation can be optional when declaring an array variable, just like for variables of other types. For examples, the following declarations are equivalent.

let a = [1, 2, 3, 4, 5];
let a : [i32; 5] = [1, 2, 3, 4, 5];

Runtime Checking of Invalid Array Element Access

If a Rust program tries to access an element of an array past its end, a runtime error will occur and the program will fail. This is an example of Rust’s safety principles.

Example

The following Rust program creates an array of size 5, but then tries to access the element at index 5.

Since this index is past the end of the array, the program fails with the following runtime error message.

thread 'main' panicked at 'index out of bounds: the len is 5 but the index is 5', main.rs:5:48

Contrast this Rust program with the following C program which also accesses an element of an array past its end. In the C program, no error is reported either by the compiler or by the C run time. Such coding errors are a common cause of safety issues in C programs that are often exploited to run malware.

Additional Resources

Here are some references to learn more about the topics we discussed in this exploration.

The concepts introduced in this exploration are discussed in Chapter 3 of The Rust Programming Language by Steve Klabnik and Carol Nichols.