Primitive Data Types

Rust's primitive data types work slightly differently to other imperative languages like Python and C.

Rust is statically typed, but the type can be inferred at compile-time, negating the need to specify the type in some cases:

fn main() {
 let i = 10; // i inferred as type i32 (explained below)
 println!("{}", i);
}

Integers require a specification of their bit count, as well as whether they are signed or unsigned:

• u8: unsigned 8-bit integer
• u16: unsigned 16-bit integer
• u32: unsigned 32-bit integer
• ...and so on, up to u128.

• i8: signed 8-bit integer
• i16: signed 16-bit integer
• ...and so on, up to i128.

A defined integer variable that isn't specified with a size or signature (like the first example on this page) will default to i32.

There also exists integer data types that are based on the CPU architecture of the machine executing the code: isize and usize. For example, on a 32-bit architecture, an isize variable would have the same bit count as an i32 variable.

Data types can't always be inferred, such as when the built-in into() method is used to convert a variable of one type to another:

fn main() {
 let x = "10";
 let y = x.into();
println!("{}", y);
}

error[E0283]: type annotations needed
|
3 | let y = x.into();
| type must be known at this point
|
= note: cannot satisfy `_: From<&str>`
= note: required for `&str` to implement `Into<_>`
help: consider giving `y` an explicit type
|
3 | let y: /* Type */ = x.into();

Since there's no information on what type variable y is, the compiler doesn't know how to convert to it from a string variable x.

For trivial problems, such as type mismatches or unclear typing, the Rust compiler and runtime can print direct, contextual suggestions for how to fix the error!

Floating-point numbers can only be two possible sizes in the stable release of Rust:

• f32: 32-bit float
• f64: 64-bit float

There are also f16 and f128 types, but these are currently only available in nightly (experimental) versions of the language.

Exercise:
Fix the typing error with the following code:

There is no "fsize" data type in Rust, but if no type is specified for a float, the compiler will default to f64:

fn main() {
 let f_big = 3.33; // f64
 let f_small: f32 = 3.3; // f32
}

Alternatively, for type annotation, the type of a numerical variable can be specified in its value:

• 2 as an unsigned 16-bit integer: 2u16 or 2_u16
• 35 as a signed 128-bit integer: 35i128 or 35_i128

Similar annotations exist for other types of numeral, like different number bases:

• 10000 == 1_0000
• 20 in binary: 0b00010100 or 0b0001_0100
• 32 in hexadecimal: 0x20
• 70 as a byte: b'F'
• 17 in octal: 0o21

Booleans in Rust are lower-case, and require very little type annotation:

fn main () {
 let t = true; // inferred as bool
}

Expressions involving comparison of numerical values are also evaluated, and assigned as, bools:

fn main() {
 let num = 5;
 let is_zero = (num == 0); // inferred as bool
 println!("{}", is_zero);
}

Variable num isn't zero, so variable is_zero equates to false, with no annotation explicitly needed.

Characters in Rust are representations of Unicode, and accept all kinds of different characters and emoticons:

fn main() {
 let letter = 'b';
 let j: char = 'あ'; // Japanese character
 let c: char = '好'; // Chinese character
}

There are two string types in Rust:

• &str: string slices or literals
• immutable
• String: string structs
• mutable

Aside from having different mutability, these two types behave very differently from each other, and this difference will be fully explained in later chapters.