Integers
Variables of Integer data type hold whole number values. There are two subtypes of integer data type in Rust, based on the number of bits occupied by a variable in memory.
Fixed Size Types
The fixed integer types have a specific number of bits in their notation. This notation is a combination of a letter and a number. The former denotes the category of the integer, whether it is, unsigned or signed, and the latter denotes the size of an integer, i.e., 8, 16, 32, 64.

Below is the list of fixed length integer types:

i8: The 8bit signed integer type.

i16: The 16bit signed integer type.

i32: The 32bit signed integer type.

i64: The 64bit signed integer type.

u8: The 8bit unsigned integer type.

u16: The 16bit unsigned integer type.

u32: The 32bit unsigned integer type.

u64: The 64bit unsigned integer type.

Variable Size Types
The integer type in which the particular size depends on the underlying machine architecture.
ðŸ’¡ Why are there so many types of integers and how do you pick a data type? The choice depends on what values a variable is expected to hold. So, a programmer should pick a data type that is not so small that the data is lost. Nor should they pick a data type that is so big that it wastes memory.
isize: The pointersized signed integer type. usize: The pointersized unsigned integer type
Example
The code below defines an integer type both explicitly and implicitly:
 Explicit Definition
The following code explicitly defines the integer variables using the integer type fixed or variable):
fn main() {
//explicitly define an integer
let a:i32 = 24;
let b:u64 = 23;
let c:usize = 26;
let d:isize = 29;
//print the values
println!("a: {}", a);
println!("b: {}", b);
println!("c: {}", c);
println!("d: {}", d);
}
Output
a: 24
b: 23
c: 26
d: 29
Implicit Definition
The following code implicitly defines the integer type of the variable by assigning an integer value to the variable.
fn main() {
//explicitly define an integer
let a = 21;
let b = 1;
let c = 54;
let d = 343434;
//print the variable
println!("a: {}", a);
println!("b: {}", b);
println!("c: {}", c);
println!("d: {}", d);
}
Output
a: 21
b: 1
c: 54
d: 343434
Floating Point
Floatingpoint numbers refer to numbers with a fractional part.
The representation of floatingpoint numbers in a computerâ€™s memory is such that the precision with which a number is stored in memory depends on the number of bits used for storing the variable.
In this respect, there are two subtypes: singleprecision f32 and doubleprecision f64 floatingpoint, with the latter having more bits to store the number.
 f32: The 32bit floating point type.
 f64: The 64bit floating point type.
Example
The code below defines a floatingpoint number both explicitly and implicitly:
 Explicit Definition
The following code explicitly defines the float variable using the float type (f32 or f64)
fn main() {
//explicitly define a float type
let f1:f32 = 32.9;
let f2:f64 = 6789.89;
println!("f1: {}", f1);
println!("f2: {}", f2);
}
Output
f1: 32.9
f2: 6789.89
Implicit Definition
The following code implicitly defines the float type of the variable by assigning a floatingpoint value to the variable:
fn main() {
//implicitly define a float type
let pi = 3.14;
let e = 2.17828;
println!("pi: {}", pi);
println!("e: {}", e);
}
Output
pi: 3.14
e: 2.17828
Quiz
Test your understanding of Numeric Types in Rust!
 What is the data type of the variable below?
let a = 123;
a) Integer
b) Float  Which of the following is an incorrect notation to declare a float type variable?
a) f32
b) f64
c) f128