The || syntax in Rust - also known as a closure

The || syntax in Rust represents the definition of a closure. A closure is a function-like construct that you can define inline and pass around. It allows you to encapsulate a block of code with optional input parameters and a return value.

In the context of the provided code:

let handle1 = thread::spawn(|| {
    for i in 1..5 {
        println!("Thread 1 - Count: {}", i);
        thread::sleep(Duration::from_millis(500)); // Simulate work
    }
});

Key Points about ||:

1. Parameter Declaration:

   • The || part defines the input parameters for the closure.
   • In this case, the closure has no parameters (hence the empty ||).

   Example with parameters:

   let closure = |x: i32| x * 2; // A closure that takes one integer and doubles it.
   println!("{}", closure(5)); // Outputs 10
   

2. Body of the Closure:
   • The block { ... } contains the code that the closure will execute.
3. Anonymous Nature:
   • Closures are anonymous functions, meaning they don't have a name and are typically used in situations where you need a short-lived function.

In the Thread Example

• The closure || { ... } is passed to thread::spawn, which runs the closure in a new thread.
• The closure has no parameters (|| is empty) and performs a task in the thread.

Why Use Closures?

Closures are lightweight, can capture variables from their surrounding environment, and are convenient for tasks like:

• Passing functions to another function (e.g., thread::spawn).
• Inline short-lived computations.

For example, closures can "capture" variables from the enclosing scope:

let x = 10;
let closure = || println!("Value of x: {}", x);
closure(); // Prints: Value of x: 10

This ability to capture variables makes closures very flexible compared to standard functions.