Page Title

Font Size

Introduction to Rust

Part 4 Data Types

Just like any other programming language, Rust has 2 subsets of data-types:

Scalar
Compound

Scalar Data Types

Scalar data types represent a single value, like a number or true or false. Rust has the following 4 primary scalar types

Integer types

An integer is a number without a fractional componenet. In Rust, there are in all, 12 integer types, 6 of which represent signed integers (can be negative or positive) and 6 which represent unsigned integers (can only be positive). Signed integers start with i, and unsigned with u and both are followed by a prefix that represents their size. Here is a table of all integer types and their min-max values.

Length	Signed	Unsigned
8-bit	`i8`	`u8`
16-bit	`i16`	`u16`
32-bit	`i32`	`u32`
64-bit	`i64`	`u64`
128-bit	`i128`	`u128`
arch	`isize`	`usize`

The size of isize and usize types depends upon your system. If you have a 32-bit system, they are of 32-bit and so on. Signed integers are stored using the two's complement representation

Each integer data type in Rust (and any other programming language) has a certain range of numbers it can store. For example, the i8 type has can store numbers ranging from -128 to 127. Any signed integer data type can store numbers from -2^(n-1) till (2^(n-1) - 1), where n is the number of bits that the type uses (example- in case of i8, n = 8). Whereas any unsigned integer data type can store numbers from 0 till (2ⁿ - 1). So for example, i8 can store numbers from -2^(8-1) = -2⁷ = -128, up till 2^(8-1) - 1 = 2⁷ - 1 = 127

You are allowed to use _ in between the number literals to provide better readability. Example:


let number = 100_000_000;

You are allowed to specify the integer variant of the number explicitly by adding the type as a prefix at the end. Example:


let number = 1234u32;

In Rust, integer literals can be written in many forms, which are given in the following table

Number Literal	Example
Decimal	`100_000_000_u32`
Hexadecimal	`0xff123a`
Octal	`0o77`
Binary	`0b1100_0100`
Byte	`b'a'`

You should totally check out this secion in the book - The Rust Programming Language - to learn about what Rust does in case of integer overflow - Integer overflow

Type annotations

Although, the Rust compiler has the ability to accurately infer a variables data type at compile time, sometimes the compiler fails to do so (we'll talk about such cases later). In such cases, the compiler throws an error and asks you to specify the type yourself. This is also useful if we want to force the compiler to use the specified type as the type for the variable. For example, by default, the compiler stores numbers as i32, but a lot of times we want the compiler to store the number as a different variant of integer types. To specify types manually, we use type annotations. Type annotations are given using the following syntax

let variable_name: type_name = value;

Example:

let number: u32 = 1; // now number is u32

Not only does this give you more control of data types, it also increases the readability considerably.
When you have types like, vectors (scrolll to the bottom to learn about vectors), which can work with generics (we'll get to generics but basically which can work with any data type), you need to specify the type of the elements along with the compound type like so

let variable_name: type<inner_type1, inner_type2....> = value;

Example:

let v: Vec<i32> = Vec::new();

You can also replace one or more inner type names with an underscore, and most of the times, the compiler will be able to determine it itself

let v: Vec<_> = Vec::new();

Floating point types

A floating point number is a number having a fractional component. Rust has 2 variants of floating point numbers - f32 (32-bit floating point) and f64 (64-bit floating point). The default variant of floating point numbers is f64, but using type annotations, you can force the compiler to use f32.


let float1 = 12.13; // f64 by default
let float2: f32 = 12.13; // f32 
let float3 = 12.13f32 // also f32
println!(
	"float1 = {}, float2 = {}, float3 = {}",
	float1, float2, float3
);

The boolean type

The bool type in Rust represents either a true or false value. We will see more uses of this type when we learn about if-else statements

let boolean: bool = true;

Arithmetic operations

The following arithmetic operations can be performed on integers and floats in Rust

Operator	Explanation	Example
`=`	Assign	`variable = expr`
`+`	Addition	`expr + expr`
`+=`	Addition and assignment	`variable += expr`
`-`	Subtraction	`expr - expr`
`-`	Negation	`-expr`
`-=`	Subtraction and assignment	`variable -= expr`
`*`	Multiplication	`expr * expr`
`*=`	Multiplication and assignment	`variable *= expr`
`/`	Division and assignment	`expr / expr`
`/=`	Division and assignment	`variable /= expr`

Example:


let var1 = 12;
let var2 = 2;
println!(
	"Add: {}, Sub: {}, Mul: {}, Div: {}: Double: {}",
	var1 + var2,
	var1 - var2,
	var1 * var2,
	var1 / var2,
	var1 * 2
);

Type casting in Rust

Rust is very strict with its types. In most languages, the compiler implicitly casts floats to intd and vice-versa when needed. The compiler also casts data types with bigger sizes to small or vice-versa (for example long to int). But Rust is stricter with such casting. In Rust, the compiler does no implicit casting between integer or float variants. So, where in C++, you can add long or float to int, you cannot add i64 or f32 to i32. Let's take an example


let unsigned32_bit_integer: u32 = 1;
let unsigned64_bit_integer: u64 = 1;
let float32_bit: f32 = 1.0;
let float64_bit: f64 = 1.0;
let signed32_bit_integer: i32 = 1;
let signed64_bit_integer: i64 = 1;
println!("unsigned32_bit_integer + unsigned64_bit_integer= {}",
		   unsigned32_bit_integer + unsigned64_bit_integer);
println!("unsigned32_bit_integer + float32_bit= {}",
		   unsigned32_bit_integer + float32_bit);
println!("signed32_bit_integer + signed64_bit_integer= {}",
		   signed32_bit_integer + signed64_bit_integer);
println!("signed32_bit_integer + float32_bit= {}",
		   signed32_bit_integer + float32_bit);
println!("float32_bit + float64_bit = {}",
		   float32_bit + float64_bit);
println!("unsigned32_bit_integer + signed32_bit_integer = {}",
		   unsigned32_bit_integer + signed32_bit_integer);

Click the "Run" button, then click "Run" in the Rust Playground iframe to run the code. You get 8 errors for adding things 5 times!

Each time you add a float to an unsigned or signed integer, it gives 1 error with the message error[E0277]: cannot add `fx` to `(u|i)y`.

And each time you add an unsigned or signed integer to an unsigned or signed integer, it gives 2 errors saying

error[E0308]: mismatched types- implying that it expects the same type on either side of the addition operator
error[E0277]: cannot add `(u|i)x` to `(u|i)y`- implying the type on the right-hand-side of the addition operator cannot be added to the one on the left-hand-side. Rust has operator overloading just like C++, C# etc. and this means that the + operator is not overloaded for the types

For this reason, we have to explicitly cast the types to be able to perform operations between them. Casting between almost all integral types is possible. Casting is done using the following syntax

initial_type as final_type

Let's rewrite the above code and make it work using explicit casting. Run the code below and see the output


let unsigned32_bit_integer: u32 = 1;
let unsigned64_bit_integer: u64 = 1;
let float32_bit: f32 = 1.0;
let float64_bit: f64 = 1.0;
let signed32_bit_integer: i32 = 1;
let signed64_bit_integer: i64 = 1;
println!("unsigned32_bit_integer + (unsigned64_bit_integer as u32) = {}",
		   unsigned32_bit_integer + (unsigned64_bit_integer as u32));
println!("unsigned32_bit_integer + (float32_bit as u32) = {}",
		   unsigned32_bit_integer + (float32_bit as u32));
println!("signed32_bit_integer + (signed64_bit_integer as i32) = {}",
		   signed32_bit_integer + (signed64_bit_integer as i32));
println!("signed32_bit_integer + (float32_bit as i32) = {}",
		   signed32_bit_integer + (float32_bit as i32));
println!("float32_bit + (float64_bit as f32) = {}",
		   float32_bit + (float64_bit as f32));
println!("unsigned32_bit_integer + (signed32_bit_integer as u32) = {}",
		   unsigned32_bit_integer + (signed32_bit_integer as u32));

There you go! Everything works!

The `char` type

Till now we saw numbers, but to store letters and other characters, we use the char type. A character is specified by enclosing it in single quotes. In Rust, a character is 4 bytes, compared to 1 byte in C++, and thus the char type in Rust has a much larger range, which means it can store much more characters than C++ (even more than the characters defined in ASCII). Example:


let character = 'a';
// characters can also be casted as u8, u16 or u32
let ordinalu8 = character as u8;
let ordinalu16 = character as u16;
let ordinalu32 = character as u32;
// print the values
println!("character = {}", character);
println!("as u8 = {}", ordinalu8);
println!("as u16 = {}", ordinalu16);
println!("as u32 = {}", ordinalu32);

Compound types

Compound types are types that can stores groups of data. There are 2 primitive compund types in Rust

Array

Arrays allow you to store numerous values and access them using a single variable. Just like arrays in any other statically-typed language, arrays in Rust are of a fixed length and allow values of only 1 type.

Arrays are declared by enclosing values of the same type, separated by comma, in square brackets.

let arr = [1, 2, 3, 4, 5];

To access an element inside the array, we write the array, followed by the (position we want to acces - 1) enclosed in square brackets


let arr = [1, 2, 3, 4, 5]	;
// I want to access the 3rd element	
println!("3rd element of array is {}", arr[2]);
// position we want = 3
// position we want - 1 = 2
// Output: 3rd element of the array is 3

To give type annotations for the array, you need to give the type as well as the number of elements in the array in the following manner

let arr: [char; 5] = ['A', 'B', 'C', 'D', 'E'];

You can also populate the array with a single value at the time of its declaration in the following way

let arr = [10; 5];

This will create an array of 5 elements, each of which is 10

Printing an array is different from printing an integral or floating point or character type. As I said in the "Variables and Mutability" part, printing a value using the println!("{}", arg) requires the Display trait to be implemented. But compound types and most types in the standard library in Rust have the Debug trait implemented instead. To print types with the Debug trait, you need to change the {} inside the string literal to {:?}. Example:


let arr: [i32; 5] = [10; 5];
println!("arr = {:?}", arr);
// Output: arr = [10, 10, 10, 10, 10]

You can also use {:#?} instead of {:?} to pretty-print a value, that is, to display a value with nice formatting added by Rust itself


let arr: [i32; 3] = [1, 2, 3];
println!("{:#?}", arr);

The above code outputs


[
	1,
	2,
	3
]

Tuple

Tuples are compound types with a fixed length, just like arrays. But unlike arrays, each element of the tuple may not be of the same type. Tuples are useful when you want to link groups of values with different data types together. Tuples are declared by enclosing the values separated by comma in parentheses.

let tup = (12, 'a', true);

You can also give type annotations by enclosing the types separated by comma in parentheses.

let tup: (i32, char, bool) = (12, 'a', true)

To access an element of a tuple at a specific index, use the following syntax:


let tup: (i32, u8, char) = (1, 2, 'z');
let first: i32 = tup.0; // indexes start at 0
let second: u8 = tup.1;
let third = tup.2;
println!("tup = ({}, {}, {})",
		   first, second, third);

You can also assign specific elements of the tuple by pattern matching, which is similar to tuple unpacking/destructuring in Python and JavaScript.


let tup: (i32, u8, char) = (1, 2, 'z');
let (first, second, third) = tup;
println!("tup = ({}, {}, {})",
		   first, second, third);

Some extra types

The String type

Before we get into the String type, let's talk about the str type. We'll keep the details for later (because you first need to understand some more concepts), but basically, when you enclose something in double quotes, for example, "Rust is great!", it gets a type of str. However, thinking that it is the same as the string type in other languages would be wrong. The str type is NOT known as string in Rust, it is known as 'String Slice'. Also, you cannot use a value of type str, you can ONLY get a 'reference' to it. And that is the reason why I have kept this type for later, because we haven't reached those concepts yet. From memory's perspective, you can think of it as the char * type in C/C++, but it has some considerable differences.

Working with str can be a bit hard sometimes. So just like most other languages, Rust offers a wrapper over the str type in its standard library. This wrapper is the String type. String is a struct (we'll get to that soon), which has associated functions, methods, and properties. To create a new, empty String, we use the new function. new is an associated function of the String (also known as static method in other languages), so to access it we use :: in the following way.


// type annotations are optional
let s: String = String::new();
println!("{}", s);

We can also create a String from a value of str by using the from associated function (static method)


let str1: &str = "Hello";	
let s1 = String::from(str1);
// this is also fine
let s2 = String::from("World");
println!("{}, {}!", s1, s2);

String is much more convenient to use because you do not need references to it, to be able to use it.

The `Vec` type

The Vec (same as vector in C++) type, is basically the same as array, but unlike arrays, it can grow and shrink in size. To create a new Vec, use the new associated function


let v = Vec::new();
// or with type annotations
let v: Vec<char> = Vec::new();
// the above line creates a Vector of char

To add elements to the end of the vector, use the push method.
NOTE 1: A vector supports elements of only a single type. If you pass in a value of a wrong type in the push method, it will result in error
NOTE 2: push is a method, that is, it is called on an instance, while new is an associated function, which is called on the type itself. Methods are accessed using the dot-syntax (type-name.method-name)
NOTE 3: Vec has the Debug trait implemented, so it can be printed to the screen


let v: Vec<char> = Vec::new();
v.push('A');
v.push('B');
v.push('C');
// uncomment the following line to get an error
// v.push(0);
println!("{:?}", v);

You can also pass in values at the time of declaration using the vec! macro


let v: Vec<_> = vec![1, 2, 3, 4, 5];
println!("{:?}", v);

Introduction to Rust

Part 4

Data Types

Scalar Data Types

Integer types

Type annotations

Floating point types

The boolean type

Arithmetic operations

Type casting in Rust

The char type

Compound types

Array

Tuple

Some extra types

The String type

The Vec type

Useful links

The `char` type

The `Vec` type

Introduction to Rust - Data Types - Part 4