Rust Loops

This chapter explores rust-loops , which are fundamental for executing repetitive tasks efficiently. Loops are powerful constructs that allow programmers to repeat a block of code multiple times under specified conditions or indefinitely. Rust provides three primary looping constructs: loop, while, and for, each suited to different scenarios.

Chapter Goal

• Understand the purpose and functionality of loops in Rust.
• Learn the syntax and use cases of the loop, while, and for constructs.
• Explore practical examples of using loops for repetitive tasks in Rust.

Key Characteristics of Loops in Rust

• Repetition: Loops repeat a block of code until a condition is met or indefinitely.
• Control Flow: Use break to exit a loop or continue to skip an iteration.
• Safety: Rust’s ownership rules and type system ensure safe looping practices.
• Versatility: Supports infinite loops, condition-based loops, and iterator-driven loops.

Best Practices

• Use loop for infinite or dynamically controlled repetition.
• Opt for while when the termination condition depends on a variable.
• Use for for iterating over collections or ranges.
• Avoid infinite loops unless explicitly needed, and always include a termination condition for safety.

Syntax Table

Syntax Explanation

1. Loop Construct

What is Loop?

The loop construct creates an infinite loop. It repeats the block of code indefinitely unless explicitly terminated using a break statement. This makes loop ideal for scenarios where the termination condition is dynamic or based on external input.

Syntax

loop {

    // Code block

    if condition {

        break;

    }

}

Detailed Explanation

• The loop begins execution immediately and runs the block repeatedly.
• Use the break statement within the loop to exit when a condition is met.
• Without a break, the loop runs infinitely, which can be useful for waiting on events or retrying operations.

Example

let mut count = 0;

loop {

    if count == 3 {

        break;

    }

    println!(“Count: {}”, count);

    count += 1;

}

Example Explanation

In this example, the loop increments count until it reaches 3. The break statement then exits the loop, preventing further iterations. This demonstrates how the loop construct can be controlled dynamically.

2. While Construct

What is While?

The while construct repeats a block of code as long as a specified condition evaluates to true. It is useful when the number of iterations is not known in advance but depends on runtime conditions.

Syntax

while condition {

    // Code block

}

Detailed Explanation

• Before each iteration, the condition is evaluated.
• If the condition is true, the loop executes the block.
• The loop exits once the condition evaluates to false.

Example

let mut number = 5;

while number > 0 {

    println!(“Number: {}”, number);

    number -= 1;

}

Example Explanation

In this example, the loop decrements number from 5 to 1, printing its value on each iteration. When number becomes 0, the condition evaluates to false, and the loop terminates.

3. For Construct

What is For?

The for construct iterates over items in a collection, such as arrays, vectors, or ranges. It simplifies the process of accessing and processing each element sequentially.

Syntax

for item in iterable {

    // Code block

}

Detailed Explanation

• Iterates over each element in the specified collection or range.
• Automatically assigns each element to the specified variable during iteration.
• Ensures concise and efficient traversal of elements.

Example

for number in 1..=5 {

    println!(“Number: {}”, number);

}

Example Explanation

This loop iterates over the range 1..=5, printing each number. The range includes all numbers from 1 to 5, demonstrating how the for loop simplifies iteration tasks.

Real-Life Project

Project Name: Fibonacci Sequence Generator

Project Goal: Use loops to generate and print the Fibonacci sequence up to a specified number of terms.

Code for This Project

fn main() {

    let mut a = 0;

    let mut b = 1;

    let terms = 10;




    println!("Fibonacci Sequence:");

    for _ in 0..terms {

        println!("{}", a);

        let temp = a + b;

        a = b;

        b = temp;

    }

}

Save and Run

• Save the code in a file named main.rs.
• Compile using rustc main.rs.
• Run the executable: ./main.

Expected Output

Fibonacci Sequence:

0

1

1

2

3

5

8

13

21

34

Insights

• Loops provide a mechanism for performing repetitive tasks efficiently.
• Each type of loop in Rust serves a distinct purpose, offering flexibility for different scenarios.
• Proper use of loop control statements (break, continue) enhances program logic and safety.

Key Takeaways

• Understand the three primary loop constructs in Rust and their applications.
• Use loop for dynamic and indefinite repetition, while for condition-based loops, and for for iterating over collections.
• Test loops thoroughly to ensure termination conditions are correctly implemented.