Integer types in Rust - Step-by-Step Execution

Concept Flow - Integer types

Start

↓

Choose integer type

↓

Assign value

↓

Check value fits type range?

No→Error: overflow

Yes↓

Use integer in program

↓

End

This flow shows how Rust integer types are chosen, assigned values, checked for range, and then used safely in programs.

Execution Sample

Rust

fn main() {
    let x: i8 = 100;
    let y: u8 = 200;
    println!("x = {}, y = {}", x, y);
}

This code declares two integers with different types and prints their values.

Execution Table

Step	Action	Variable	Value	Check	Output
1	Declare x as i8	x	uninitialized	N/A
2	Assign 100 to x	x	100	100 fits in i8 (-128 to 127)
3	Declare y as u8	y	uninitialized	N/A
4	Assign 200 to y	y	200	200 fits in u8 (0 to 255)
5	Print values	x,y	100, 200	N/A	x = 100, y = 200
6	End program

💡 Program ends after printing values successfully.

Variable Tracker

Variable	Start	After Step 2	After Step 4	Final
x	uninitialized	100	100	100
y	uninitialized	uninitialized	200	200

Key Moments - 2 Insights

Why can't we assign 130 to an i8 variable?

Because i8 can only hold values from -128 to 127. Assigning 130 would cause an overflow error as shown in step 2 where the check confirms the value fits.

What happens if we assign a negative number to a u8 variable?

u8 only holds values from 0 to 255. Assigning a negative number would cause a compile-time error. Step 4 shows the check for valid range.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of x after step 2?

A 100

B -100

C uninitialized

D Overflow error

💡 Hint

Check the 'Value' column for variable x at step 2 in the execution table.

At which step does the program print the values of x and y?

A Step 3

B Step 4

C Step 5

D Step 6

💡 Hint

Look for the 'Print values' action in the execution table.

If we assign 300 to y (u8), what would happen?

A Value wraps around without error

B Compile-time error due to overflow

C Value stored as 300 successfully

D Runtime error when printing

💡 Hint

Refer to the 'Check' column in the execution table for valid ranges of u8.

Concept Snapshot

Integer types in Rust specify size and sign, e.g., i8 (-128 to 127) and u8 (0 to 255).
Assigning values outside the range causes compile-time errors.
Use type annotations like let x: i8 = 100; to declare.
Rust checks values fit type ranges to prevent overflow.
Printing shows stored values after successful assignment.

Full Transcript

This visual execution trace shows how Rust handles integer types. We start by declaring variables with specific integer types like i8 and u8. Each variable is assigned a value, and Rust checks if the value fits within the allowed range for that type. For example, i8 can hold values from -128 to 127, so assigning 100 is valid. u8 holds 0 to 255, so 200 is valid. If a value does not fit, Rust will give an error to prevent overflow. Finally, the program prints the values of the variables. This step-by-step trace helps beginners see how integer types work and why range checks are important.