Relational operators in Rust

Introduction

Relational operators help us compare two values to see how they relate, like if one is bigger or smaller than the other.

Checking if a number is greater than another to decide what to do next.

Comparing ages to see who is older.

Finding out if two values are equal before continuing a task.

Making sure a score is less than a limit before allowing a player to continue.

Deciding if a temperature is within a safe range.

Syntax

Rust

value1 < value2
value1 > value2
value1 <= value2
value1 >= value2
value1 == value2
value1 != value2

Use == to check if two values are equal.

Use != to check if two values are not equal.

Examples

This checks if a is less than b. It is true because 5 is less than 10.

Rust

let a = 5;
let b = 10;
let result = a < b; // true

This checks if x is equal to y. It is true because both are 7.

Rust

let x = 7;
let y = 7;
let result = x == y; // true

This checks if m is not equal to n. It is true because 3 is not 8.

Rust

let m = 3;
let n = 8;
let result = m != n; // true

Sample Program

This program checks if a person is old enough to enter by comparing age with limit. It also prints if the score is passing by comparing score with passing_score.

Rust

fn main() {
    let age = 20;
    let limit = 18;

    if age >= limit {
        println!("You are allowed to enter.");
    } else {
        println!("You are not allowed to enter.");
    }

    let score = 85;
    let passing_score = 60;

    println!("Did you pass? {}", score >= passing_score);
}

Important Notes

Relational operators always return a boolean: true or false.

Use parentheses to group comparisons if combining with other operators.

Summary

Relational operators compare two values and return true or false.

Common operators: <, >, <=, >=, ==, !=.

They help make decisions in your program based on value comparisons.

Practice

1. Which of the following relational operators in Rust checks if two values are not equal?

easy

A. !=

B. ==

C. <=

D. >=

Solution

1. Step 1: Understand the meaning of relational operators

   Relational operators compare two values and return true or false based on the comparison.

2. Step 2: Identify the operator for 'not equal'

   The operator '!=' means 'not equal to' in Rust.

3. Final Answer:

   != -> Option A

4. Quick Check:

   Not equal operator = != [OK]

Hint: Remember '!=' means not equal in most languages [OK]

Common Mistakes:

• Confusing '!=' with '=='
• Using '<>' which is not valid in Rust
• Mixing up '<=' and '>='

2. Which of the following is the correct syntax to check if variable a is greater than or equal to variable b in Rust?

easy

A. a =>= b

B. a => b

C. a =< b

D. a >= b

Solution

1. Step 1: Recall Rust relational operator syntax

   Rust uses '>=' to check if left value is greater than or equal to right value.

2. Step 2: Identify correct syntax among options

   Only 'a >= b' matches the correct Rust syntax.

3. Final Answer:

   a >= b -> Option D

4. Quick Check:

   Greater or equal operator = >= [OK]

Hint: Greater or equal is '>=' not '=>' [OK]

Common Mistakes:

• Using '=>' instead of '>='
• Swapping '=' and '<' in operators
• Confusing assignment '=' with comparison

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

let x = 10;
let y = 20;
println!("{}", x < y);

medium

A. true

B. 20

C. 10

D. false

Solution

1. Step 1: Understand the comparison operation

   The code compares if x (10) is less than y (20), which is true.

2. Step 2: Determine the printed output

   Since the condition is true, the printed output will be 'true'.

3. Final Answer:

   true -> Option A

4. Quick Check:

   10 < 20 = true [OK]

Hint: Compare values carefully; 10 is less than 20 [OK]

Common Mistakes:

• Confusing output with variable values
• Thinking it prints the smaller number
• Mixing up < and > operators

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

let a = 5;
let b = 10;
if a <> b {
    println!("Not equal");
}

medium

A. Variables a and b must be mutable

B. The operator '<>' is invalid in Rust

C. Missing semicolon after println!

D. The if statement needs parentheses

Solution

1. Step 1: Check the relational operator used

   The operator '<>' is not a valid relational operator in Rust.

2. Step 2: Confirm correct operator for not equal

   Rust uses '!=' to check if two values are not equal.

3. Final Answer:

   The operator '<>' is invalid in Rust -> Option B

4. Quick Check:

   Not equal operator = !=, not <> [OK]

Hint: Use '!=' for not equal, not '<>' [OK]

Common Mistakes:

• Using '<>' from other languages
• Forgetting Rust requires '!='
• Assuming parentheses needed in if condition

5. Given a list of integers, which Rust expression correctly checks if all elements are greater than 0 using relational operators?

hard

A. numbers.iter().filter(|&x| x > 0)

B. numbers.iter().any(|&x| x > 0)

C. numbers.iter().all(|&x| x > 0)

D. numbers.iter().map(|&x| x > 0)

Solution

1. Step 1: Understand the requirement

   We want to check if all elements in the list are greater than 0.

2. Step 2: Identify the correct iterator method

   'all' returns true only if every element satisfies the condition x > 0.

3. Step 3: Confirm the closure syntax

   The closure '|&x| x > 0' correctly compares each element to 0.

4. Final Answer:

   numbers.iter().all(|&x| x > 0) -> Option C

5. Quick Check:

   Check all elements > 0 with 'all' method [OK]

Hint: Use 'all' to check every element meets condition [OK]

Common Mistakes:

• Using 'any' which checks only one element
• Using 'filter' which returns iterator, not bool
• Using 'map' which transforms elements, not checks