This course provides the best approach to learn Rust, starting from the basics and advancing to complex topics. It is an introduction to Rust for beginners aspiring to become skilled Rust developers.

The word is out: developers love Rust. It's rapidly becoming a top choice for systems and embedded programmers, and the demand for Rust developers is rising. Known for its performance, reliability, and productivity—especially compared to C++—Rust is a powerful language to master. If you're a systems developer, it's a fantastic next step.
In this course, you'll learn Rust by actively engaging in coding. You’ll start with a simple "Hello world" program and cover essential concepts like arrays, strings, vectors, enums, structures, traits, generics, functions, and logic. You'll also dive into advanced topics such as lifetime and memory management.
By the end of this course, you'll have a solid foundation in Rust programming and be well-prepared to take on more advanced concepts, making it ideal for Rust beginners looking to become proficient Rust developers.

Rust Programming Language

# What Is a Loop Label?
A loop label assigns an identifier to a loop.

# Syntax
Write a label and colon before the loop.

# Example
The code below prints the multiplication table of 1 to 5 except 3. See how specifying a loop label helps you to skip the table of 3.

fn main() {
 'outer:for i in 1..5 { //outer loop
    println!("Muliplication Table : {}", i);
   'inner:for j in 1..5 { // inner loop
        if i == 3 { continue 'outer; } // Continues the loop over `i`.
        if j == 2 { continue 'inner; } // Continues the loop over `j`.
        println!("{} * {} = {}", i, j, i * j);
   }
 }
}

## Explanation

**Outer `for` Loop**
* A `for` loop is defined on **line 2**.
* The loop has a label `outer` . It takes `i` as an iterator that iterates over values from 1 to 4.

**Inner `for` Loop**
* A `for` loop is defined on **line 3**
* The loop has a label `inner`. It takes `j` as an iterator that iterates over values from 1 to 5.
* For each `i` the inner loop iterate j times and prints the product `i * j`.
* When the outer loop increments `i` to 3 and the inner loop starts from `j = 1`, the condition `i == 3` is found to be true and the `continue 'outer` statement causes execution to be transferred to the next iteration of the outer loop on **line 2**. The variable `i` is incremented to 4 and the execution continues. 

* When the value of `j` increments to 2, then the 2nd iteration of the inner loop gets skipped and `continue 'inner`  causes the execution to be transferred to the next iteration of the inner loop on **line 4**. The variable `j` is incremented to 3 and the execution continues.


This lesson discusses loop labels in Rust.

Introduction to Rust

Rust Programs

Rust Variables

Rust Data Types

Rust Operators

Rust if and if let Expressions

Rust Loops

Rust Functions

Rust Strings

Rust Vectors

Rust Structs

Conclusion

Rust Exam

Loop Labels

What Is a Loop Label?