Boolean type in Rust - Step-by-Step Execution

Concept Flow - Boolean type

Start

↓

Declare bool variable

↓

Assign true or false

↓

Use in condition or print

↓

Program ends

This flow shows how a boolean variable is declared, assigned true or false, then used in conditions or output.

Execution Sample

Rust

fn main() {
    let is_rust_fun: bool = true;
    println!("Is Rust fun? {}", is_rust_fun);
}

This code declares a boolean variable and prints its value.

Execution Table

Step	Action	Variable	Value	Output
1	Declare variable is_rust_fun	is_rust_fun	uninitialized
2	Assign true to is_rust_fun	is_rust_fun	true
3	Print is_rust_fun value	is_rust_fun	true	Is Rust fun? true
4	Program ends

💡 Program ends after printing the boolean value.

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
is_rust_fun	none	uninitialized	true	true

Key Moments - 2 Insights

Why can't we assign numbers like 0 or 1 directly to a bool variable?

In Rust, bool variables only accept true or false, not numbers. See step 2 in execution_table where true is assigned explicitly.

What happens if we try to print a bool variable without using {} in println!?

Rust requires {} to format bool values in println!. Without it, the code won't compile. Step 3 shows correct usage.

Visual Quiz - 3 Questions

Look at the execution_table at step 2, what value is assigned to is_rust_fun?

A uninitialized

B true

C false

D 0

💡 Hint

Check the 'Value' column at step 2 in execution_table.

At which step does the program print output?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look at the 'Output' column in execution_table.

If we change is_rust_fun to false at step 2, what will the output be at step 3?

A Is Rust fun? true

B Is Rust fun? 0

C Is Rust fun? false

D No output

💡 Hint

Refer to variable_tracker and execution_table step 3 output.

Concept Snapshot

Boolean type in Rust:
- Declared with 'bool' keyword
- Values: true or false only
- Used in conditions and printing
- Cannot assign numbers directly
- Print with println!("{}", var)

Full Transcript

This visual execution shows how Rust handles boolean types. First, a bool variable is declared but uninitialized. Then it is assigned the value true. Next, the program prints the variable's value using println! with the {} placeholder. Finally, the program ends. The variable tracker shows the variable's state changing from uninitialized to true. Key points include that bool only accepts true or false, not numbers, and printing requires proper formatting. The quiz tests understanding of assignment, output step, and changing values.

Practice

1. What values can a Rust bool type hold?

easy

A. Only true or false

B. Any number

C. Any string

D. Only 0 or 1

Solution

1. Step 1: Understand the bool type in Rust

   The bool type in Rust is designed to hold only two values: true or false.

2. Step 2: Compare with other options

   Other options like numbers or strings are not valid for bool. Rust does not treat 0 or 1 as boolean values directly.

3. Final Answer:

   Only true or false -> Option A

4. Quick Check:

   Rust bool = true or false [OK]

Hint: Remember: bool means true or false only [OK]

Common Mistakes:

• Thinking bool can hold numbers
• Confusing bool with integers 0 or 1
• Assuming bool can hold strings

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

easy

A. let is_active: bool = true;

B. bool is_active = true;

C. var is_active = true;

D. let is_active = boolean true;

Solution

1. Step 1: Recall Rust variable declaration syntax

   In Rust, variables are declared with let, and the type follows the variable name with a colon, like let var_name: type = value;.

2. Step 2: Check each option

   let is_active: bool = true; uses correct Rust syntax for a boolean variable. Options B and C use syntax from other languages. let is_active = boolean true; is invalid syntax.

3. Final Answer:

   let is_active: bool = true; -> Option A

4. Quick Check:

   Rust bool variable = let name: bool = value; [OK]

Hint: Use 'let var: bool = true;' to declare booleans [OK]

Common Mistakes:

• Using C-style declarations
• Using 'var' keyword (not Rust)
• Writing 'boolean' instead of 'bool'

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

fn main() {
    let a = true;
    let b = false;
    println!("{}", a && b);
}

medium

A. true

B. 1

C. false

D. Compilation error

Solution

1. Step 1: Understand the boolean AND operator

   The expression a && b returns true only if both a and b are true. Here, a is true and b is false.

2. Step 2: Evaluate the expression

   Since b is false, a && b evaluates to false. The println! macro prints this value.

3. Final Answer:

   false -> Option C

4. Quick Check:

   true AND false = false [OK]

Hint: AND is true only if both are true [OK]

Common Mistakes:

• Assuming true && false is true
• Confusing boolean with integer 1 or 0
• Expecting compilation error

4. Identify the error in this Rust code snippet:

fn main() {
    let flag: bool = True;
    println!("{}", flag);
}

medium

A. Variable name 'flag' is invalid

B. bool type cannot be assigned directly

C. Missing semicolon after println!

D. 'True' should be lowercase 'true'

Solution

1. Step 1: Check boolean literal case sensitivity

   In Rust, boolean literals are lowercase: true and false. Using True causes a compilation error.

2. Step 2: Verify other syntax

   The variable name is valid, semicolon is present after println!, and bool can be assigned directly.

3. Final Answer:

   'True' should be lowercase 'true' -> Option D

4. Quick Check:

   Rust bool literals are lowercase true/false [OK]

Hint: Use lowercase true/false in Rust [OK]

Common Mistakes:

• Writing True or False with uppercase
• Thinking semicolon is missing
• Confusing variable name rules

5. Given a variable score of type i32, which Rust expression correctly sets passed as a boolean indicating if score is 50 or more?

hard

A. let passed: bool = score > 50 || false;

B. let passed: bool = score >= 50;

C. let passed: bool = if score >= 50 { true };

D. let passed: bool = score == true;

Solution

1. Step 1: Understand boolean expressions with comparisons

   The expression score >= 50 returns a boolean true if score is 50 or more, otherwise false.

2. Step 2: Evaluate each option

   let passed: bool = score >= 50; directly assigns the comparison result to passed. let passed: bool = score > 50 || false; is incorrect because score > 50 || false excludes 50 itself. let passed: bool = if score >= 50 { true }; is invalid because the if lacks an else branch and thus doesn't return a value when the condition is false (compilation error). let passed: bool = score == true; compares an integer to a boolean, which is invalid.

3. Final Answer:

   let passed: bool = score >= 50; -> Option B

4. Quick Check:

   Comparison returns bool, assign directly [OK]

Hint: Use comparison directly to get bool result [OK]

Common Mistakes:

• Using if without an else branch for assignment
• Comparing int to bool directly
• Using wrong comparison operators