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.

Practice

1. Which of the following is NOT a scalar data type in Rust?

easy

A. Integer

B. Boolean

C. Array

D. Character

Solution

1. Step 1: Recall scalar data types in Rust

   Scalar types include integers, floats, booleans, and characters, which hold a single value.

2. Step 2: Identify the non-scalar type

   An array holds multiple values and is a compound type, not scalar.

3. Final Answer:

   Array -> Option C

4. Quick Check:

   Scalar types exclude arrays [OK]

Hint: Scalar types hold one value; arrays hold many [OK]

Common Mistakes:

• Confusing arrays with scalar types
• Thinking floats are not scalar
• Mixing compound and scalar types

2. Which of the following is the correct way to declare a boolean variable named is_active set to true in Rust?

easy

A. let is_active: bool = true;

B. let is_active = True;

C. let is_active = 1;

D. let is_active: boolean = true;

Solution

1. Step 1: Check Rust boolean syntax

   Rust uses lowercase true and false for booleans, and the type is bool.

2. Step 2: Validate each option

   let is_active: bool = true; correctly declares is_active as a bool with value true. let is_active = True; uses uppercase True which is invalid. let is_active = 1; assigns an integer, not a boolean. let is_active: boolean = true; uses boolean which is not a Rust type.

3. Final Answer:

   let is_active: bool = true; -> Option A

4. Quick Check:

   Boolean type is bool and value is lowercase true [OK]

Hint: Booleans use lowercase true/false and type bool [OK]

Common Mistakes:

• Using uppercase True/False
• Using wrong type name boolean
• Assigning integers to booleans

3. What will be the output of the following Rust code?

let x: i32 = 10;
let y: f64 = 3.5;
println!("{}", x as f64 + y);

medium

A. 13

B. 13.5

C. Type error

D. 10.0

Solution

1. Step 1: Understand type casting in the code

   The integer x is cast to f64 using as f64, so 10 becomes 10.0.

2. Step 2: Perform the addition

   Adding 10.0 (casted x) and 3.5 (y) results in 13.5.

3. Final Answer:

   13.5 -> Option B

4. Quick Check:

   Cast integer to float, then add floats = 13.5 [OK]

Hint: Cast integers to float before adding floats [OK]

Common Mistakes:

• Forgetting to cast integer
• Expecting integer addition
• Assuming type error without cast

4. Identify the error in the following Rust code snippet:

let letter: char = "a";

medium

A. Missing semicolon

B. char cannot be assigned a letter

C. Variable name is invalid

D. char type must use single quotes, not double quotes

Solution

1. Step 1: Check char literal syntax

   In Rust, char literals must be enclosed in single quotes, e.g., 'a', not double quotes.

2. Step 2: Analyze the code

   The code uses double quotes "a", which is a string slice, not a char. This causes a type mismatch error.

3. Final Answer:

   char type must use single quotes, not double quotes -> Option D

4. Quick Check:

   char literals use single quotes 'a' [OK]

Hint: Use single quotes for char, double quotes for strings [OK]

Common Mistakes:

• Using double quotes for char
• Confusing char with string
• Ignoring type mismatch errors

5. You want to store the temperature reading 36.6 in Rust using scalar types. Which declaration is best and why?

Options:
A) let temp: i32 = 36.6;
B) let temp: char = '36';
C) let temp: bool = true;
D) let temp: f64 = 36.6;

hard

A. let temp: f64 = 36.6; because floats store decimal numbers

B. let temp: char = '36'; because characters store numbers

C. let temp: bool = true; because temperature is true or false

D. let temp: i32 = 36.6; because integers store decimal numbers

Solution

1. Step 1: Understand the data type needed for decimal numbers

   Temperature 36.6 has a decimal part, so it requires a floating-point type like f64.

2. Step 2: Evaluate each option

   let temp: i32 = 36.6; because integers store decimal numbers tries to assign a decimal to an integer, which is invalid. let temp: f64 = 36.6; because floats store decimal numbers correctly uses f64 for decimals. let temp: bool = true; because temperature is true or false uses boolean, which is unrelated. let temp: char = '36'; because characters store numbers uses char with invalid multi-character literal.

3. Final Answer:

   let temp: f64 = 36.6; because floats store decimal numbers -> Option A

4. Quick Check:

   Decimal numbers need float types like f64 [OK]

Hint: Use float types for decimal numbers like temperature [OK]

Common Mistakes:

• Assigning decimals to integers
• Using bool for numeric values
• Using char for multi-digit numbers