Scalar data types in Rust - Step-by-Step Execution

Concept Flow - Scalar data types

Start

↓

Declare variable with scalar type

↓

Assign value

↓

Use variable in code

↓

Program runs with scalar data

↓

End

This flow shows how scalar data types are declared, assigned, and used in Rust programs.

Execution Sample

Rust

fn main() {
    let x: i32 = 10;
    let y: f64 = 3.14;
    let z: bool = true;
    println!("x = {}, y = {}, z = {}", x, y, z);
}

This code declares three scalar variables of different types and prints their values.

Execution Table

Step	Action	Variable	Type	Value	Output
1	Declare variable x	x	i32	uninitialized
2	Assign 10 to x	x	i32	10
3	Declare variable y	y	f64	uninitialized
4	Assign 3.14 to y	y	f64	3.14
5	Declare variable z	z	bool	uninitialized
6	Assign true to z	z	bool	true
7	Print values	x,y,z	i32,f64,bool	10,3.14,true	x = 10, y = 3.14, z = true

💡 Program ends after printing all scalar variable values.

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 6	Final
x	uninitialized	10	10	10	10
y	uninitialized	uninitialized	3.14	3.14	3.14
z	uninitialized	uninitialized	uninitialized	true	true

Key Moments - 3 Insights

Why do variables start as 'uninitialized' before assignment?

In Rust, variables must be declared before use but have no value until assigned, as shown in steps 1, 3, and 5 in the execution_table.

Why do we specify types like i32, f64, and bool?

Rust needs to know the exact scalar type to allocate memory and check correctness, as seen in the variable declarations in the execution_table.

What happens if we try to print variables before assigning values?

Rust will give a compile error because variables are uninitialized; the execution_table shows values assigned before printing at step 7.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of variable y after step 4?

A 10

B uninitialized

C 3.14

D true

💡 Hint

Check the 'Value' column for variable y at step 4 in the execution_table.

At which step are all variables assigned a value?

A Step 2

B Step 6

C Step 4

D Step 7

💡 Hint

Look at the 'Value' column for all variables in the execution_table rows.

If we remove the type annotation from variable x, what changes in the execution?

A Rust infers the type, so execution_table values stay the same.

B Variable x becomes uninitialized forever.

C Program will print x as a string.

D Program will fail to compile.

💡 Hint

Rust can infer types if values are assigned immediately; check variable declarations in the execution_sample.

Concept Snapshot

Scalar data types hold single values like numbers or true/false.
Common types: i32 (integer), f64 (float), bool (true/false).
Declare with let and specify type or let Rust infer it.
Assign values before use.
Use println! to display values.
Rust enforces type safety and initialization.

Full Transcript

This visual execution shows how scalar data types work in Rust. We start by declaring variables x, y, and z with types i32, f64, and bool. Initially, variables are uninitialized. Then we assign values: 10 to x, 3.14 to y, and true to z. Finally, we print their values. The execution table tracks each step, showing variable states and output. Key moments clarify why initialization and type annotations matter. The quiz tests understanding of variable values and Rust's type inference. Scalar types hold single pieces of data, essential for Rust programs.