Logical operators in Rust

Introduction

Logical operators help you combine or change true/false values to make decisions in your program.

Checking if two conditions are both true before continuing.

Deciding if at least one condition is true to run some code.

Making sure a condition is not true before doing something.

Combining multiple checks in a simple way.

Controlling the flow of your program based on multiple true/false tests.

Syntax

Rust

&&  // AND operator
||  // OR operator
!   // NOT operator

&& means both sides must be true.

|| means at least one side is true.

! flips true to false and false to true.

Examples

AND: both must be true, here false because one is false.

Rust

let a = true && false;  // a is false

OR: one true is enough, so result is true.

Rust

let b = true || false;  // b is true

NOT: flips true to false.

Rust

let c = !true;  // c is false

Combining NOT and AND: true AND false is false, NOT false is true.

Rust

let d = !(true && false);  // d is true

Sample Program

This program decides what to do based on weather and umbrella using logical operators.

Rust

fn main() {
    let is_sunny = true;
    let have_umbrella = false;

    if is_sunny && !have_umbrella {
        println!("Go outside without umbrella.");
    } else if !is_sunny && have_umbrella {
        println!("Take umbrella because it's not sunny.");
    } else if !is_sunny && !have_umbrella {
        println!("Stay inside, no umbrella and no sun.");
    } else {
        println!("Go outside with umbrella just in case.");
    }
}

Important Notes

Logical operators work with boolean values: true or false.

Use parentheses to group conditions clearly.

Rust uses short-circuit evaluation: it stops checking as soon as the result is known.

Summary

Logical operators combine true/false values to control decisions.

&& means AND, || means OR, and ! means NOT.

They help write clear and simple conditions in your code.

Practice

1. Which logical operator in Rust means AND and returns true only if both conditions are true?

easy

A. !

B. ||

C. &

D. &&

Solution

1. Step 1: Understand the meaning of logical AND

   The AND operator returns true only when both conditions it connects are true.

2. Step 2: Identify Rust's AND operator

   In Rust, the AND operator is written as &&.

3. Final Answer:

   && -> Option D

4. Quick Check:

   AND = && [OK]

Hint: AND operator is double ampersand && in Rust [OK]

Common Mistakes:

• Confusing || (OR) with && (AND)
• Using single & which is bitwise AND
• Mistaking ! for AND

2. Which of the following is the correct syntax to negate a boolean variable flag in Rust?

easy

A. not flag

B. !flag

C. flag!

D. ~flag

Solution

1. Step 1: Recall Rust's NOT operator syntax

   Rust uses the exclamation mark ! before a boolean to negate it.

2. Step 2: Apply negation to variable flag

   Writing !flag returns the opposite boolean value of flag.

3. Final Answer:

   !flag -> Option B

4. Quick Check:

   NOT = ! [OK]

Hint: Negate booleans with ! before the variable [OK]

Common Mistakes:

• Writing negation after the variable (flag!)
• Using 'not' keyword which Rust does not support
• Using ~ which is bitwise NOT, not boolean NOT

3. What is the output of this Rust code?

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

medium

A. Compilation error

B. false

C. true

D. Syntax error

Solution

1. Step 1: Evaluate the expression with operator precedence

   AND (&&) has higher precedence than OR (||), so evaluate b && !a first.
   Here, b = false, a = true, so !a = false.
   Thus, b && !a = false && false = false.

2. Step 2: Evaluate the OR operation

   Now evaluate a || (result) which is true || false.
   This results in true.

3. Final Answer:

   true -> Option C

4. Quick Check:

   Operator precedence: && before || = true [OK]

Hint: Remember && before || in expressions [OK]

Common Mistakes:

• Evaluating || before &&
• Ignoring negation operator precedence
• Assuming false because b is false

4. Identify the error in this Rust code snippet:

let x = true;
let y = false;
if x & y {
    println!("Both true");
}

medium

A. Using & instead of && for logical AND

B. Missing semicolon after println!

C. Incorrect variable names

D. No error, code runs fine

Solution

1. Step 1: Check the operator used in the if condition

   The code uses & which is a bitwise AND operator, not logical AND.

2. Step 2: Identify correct logical AND operator in Rust

   Logical AND requires && to combine boolean values properly.

3. Final Answer:

   Using & instead of && for logical AND -> Option A

4. Quick Check:

   Logical AND needs &&, not & [OK]

Hint: Use && for logical AND, & is bitwise AND [OK]

Common Mistakes:

• Confusing bitwise & with logical &&
• Assuming & works for booleans
• Ignoring compiler warnings about operator types

5. You want to check if a number n is between 10 and 20 inclusive in Rust. Which condition correctly uses logical operators?

hard

A. n >= 10 && n <= 20

B. n >= 10 || n <= 20

C. !(n < 10 && n > 20)

D. n > 10 && n < 20

Solution

1. Step 1: Understand the range condition

   To check if n is between 10 and 20 inclusive, both conditions must be true:
   n >= 10 and n <= 20.

2. Step 2: Combine conditions with logical AND

   Use && to ensure both conditions hold simultaneously.
   So the correct condition is n >= 10 && n <= 20.

3. Final Answer:

   n >= 10 && n <= 20 -> Option A

4. Quick Check:

   Range check uses AND (&&) [OK]

Hint: Use && to combine range checks for inclusive conditions [OK]

Common Mistakes:

• Using || which allows values outside the range
• Using strict > and < instead of >= and <=
• Negating conditions incorrectly