rust concurrent execution of f with parameter i. Tasks are independent and don't return any value.

To achieve concurrent execution of a function f with parameter i in Rust, you can make use of the std::thread module. This module provides functionality for creating and managing threads in Rust.

Here is an example of how you can achieve concurrent execution of f with different parameters using threads:

use std::thread;

fn main() {
    let params = vec![1, 2, 3, 4, 5];

    let handles: Vec<_> = params.into_iter().map(|i| {
        thread::spawn(move || {
            f(i);
        })
    }).collect();

    for handle in handles {
        handle.join().unwrap();
    }
}

fn f(i: i32) {
    // Do something with i
    println!("Thread with parameter {} executed.", i);
}

In this example, we create a vector params containing the parameters 1, 2, 3, 4, 5 that we want to pass to f. We then use the into_iter() method to convert the vector into an iterator, and map() to create a new thread for each parameter.

Inside the map() closure, we use thread::spawn() to create a new thread, and pass the closure move || { f(i); } as an argument. The move keyword is used to move ownership of the parameter i into the closure.

Finally, we collect all the thread handles into a vector handles, and iterate over the handles using a for loop. Inside the loop, we call join() on each handle to wait for the corresponding thread to finish executing.

The function f is defined separately and takes the parameter i. You can replace the body of f with your own code to perform the desired task.

When you run this code, you will see that the function f is executed concurrently with different parameter values, as each thread executes independently.