Concurrency

In multi-threaded programming, concurrent execution allows tasks to be performed simultaneously, making programs faster and more efficient. Rust's std::thread module facilitates this by enabling the creation and management of threads in a straightforward and safe manner.

In this challenge, you will implement a function concurrent_add that spawns threads to add a specified value to each element of a list. Each thread will handle one element of the list, returning the result of the addition. By leveraging threads, you'll distribute the workload across multiple cores for concurrent execution.

Your Task

Your task is to implement the function concurrent_add that takes a list of items (Vec<T>) and a number (T) as inputs. For each item in the list, the function should spawn a new thread that adds the given number to the item. The function will return a vector of JoinHandle<T> representing the handles to all the threads, allowing the results to be retrieved later.

Requirements

The function should accept a Vec<T> and a value of type T.
T can be, integer, floating-point, or any other number type in Rust.
The function should return a vector of JoinHandle<T>.

Hints

Click here to reveal hints

The std::thread::spawn function creates a new thread to execute a given closure.
The std::ops::Add trait allows addition between two values of the same type.
In order for a type to be passed to threads safely, they must implement the Send trait.
The type should also have a lifetime of 'static to make sure the thread can not outlive the data it references.
Ensure the type T implements Copy since threads require ownership of their inputs.

Editor not available on Mobile!

In order to solve the challenge, please visit this page on a desktop computer.

Solutions

StevenCanDrink

2 days ago

5.49ms

90.02kb

use std::{ ops::Add, thread::{ self, JoinHandle } };
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
    where T: 'static + Send + Add<Output = T> + Copy
{
    // Implement the function here
    items
        .into_iter()
        .map(|v| thread::spawn(move || v + num))
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10.0, 20.0, 30.0, 40.0, 50.0];
        let handles = concurrent_add(list.clone(), 5.0);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.0);
        }
    }
}

Chih Ying Yen

xavierforge

3 days ago

4.90ms

90.52kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where 
    T: Copy + Send + Add<Output = T> + 'static
{
    // Implement the function here
    let mut handles = vec![];
    for idx in 0..items.len() {
        let item = items[idx];
        let handle = thread::spawn(move || item + num);
        handles.push(handle);
    }
    handles
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

amdfxlucas

5 days ago

7.19ms

90.02kb

use std::thread;
pub fn concurrent_add<T: Clone + std::ops::Add<Output = T> + std::marker::Send + 'static>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> {
    
    items.iter().cloned().map( move|x|{
        let off = num.clone();
         std::thread::spawn( ||{ (off + x)} )}
          ).collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

undefeated_

boyboi86

7 days ago

5.11ms

90.03kb

use std::{thread, 
          ops::Add,
          marker::Send};
pub fn concurrent_add<T: 'static + Add<Output=T> + Send + Copy>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> {
    // Implement the function here
    items
    .iter()
    .map(|&x| {thread::spawn(move || x + num)})
    .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

GunGraveCpp

8 days ago

5.19ms

90.02kb

use std::thread;
use std::ops::Add;
use std::marker::Send;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> where T: 'static + Send + Copy + Add<Output = T> {
     items
        .into_iter().map(|x|{thread::spawn(move ||{x + num})}).collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

toto

11 days ago

6.53ms

90.02kb

use std::{ops::Add, thread};
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: 'static + Send + Copy + Add<Output = T>,
{
    // Implement the function here
    items
        .into_iter()
        .map(|item| thread::spawn(move || item + num))
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

toto

11 days ago

5.69ms

90.52kb

use std::{ops::Add, thread};
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: 'static + Send + Copy + Add<Output = T>,
{
    let mut thread_list = Vec::new();
    // Implement the function here
    for item in items {
        thread_list.push(thread::spawn(move || item + num))
    }
    thread_list
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Lvfalue

13 days ago

5.44ms

90.03kb

use std::thread::{JoinHandle, spawn};
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<JoinHandle<T>> 
where
    T: Send + Copy + 'static + Add<Output = T>,
{
    // Implement the function here
    items.into_iter().map(|item| spawn(move || item + num)).collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

manu3618

13 days ago

5.55ms

90.02kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T: Add<Output=T> + Copy + Send + Sync + 'static>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> {
    // Implement the function here
    items.iter().map(|&x| {thread::spawn(move ||{x+num})}).collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

visanr

17 days ago

5.49ms

90.02kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where T: Add<Output=T> + Send + Copy + 'static
{
    items
        .into_iter()
        .map(
            move |item| {
                thread::spawn(move || { item + num})
            }
        ).collect()
    // Implement the function here
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

AtlasVakyrie

22 days ago

4.87ms

90.03kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> 
where
    T: Copy + Send + Add<Output=T> + 'static
{
    // Implement the function here
    items
        .into_iter()
        .map(
            move |item| std::thread::spawn(
                move || item + num
            )
        )
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Luka Bračun

lbracun

22 days ago

6.27ms

90.03kb

use std::{ops::Add, thread};
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: Copy + Add<Output = T>,
    T::Output: Send + 'static,
{
    items
        .into_iter()
        .map(move |item| std::thread::spawn(move || item + num))
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

bzdula

22 days ago

5.07ms

90.03kb

use std::{ops::Add, thread};
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: Send + Copy + Sync + Add<Output = T> + 'static,
    T::Output: Send + 'static,
{
    items
        .into_iter()
        .map(move |item| std::thread::spawn(move || item + num))
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Wouter

WouterMartens

a month ago

6.01ms

90.02kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: Copy + Send + Add<Output = T> + 'static,
{
    items
        .iter()
        .map(|&item| thread::spawn(move || item + num))
        .collect()
}
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

m1031

monorail103

a month ago

35.30ms

90.03kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> 
where
    T:Add<Output = T> + Send + Copy + 'static,
{
    // Implement the function here
    items.into_iter().map(|item| thread::spawn(move || item + num)).collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Daniel Mestas

miel-codeai

a month ago

5.28ms

90.03kb

use std::{ops::Add, thread};
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: Copy + Add<Output = T> + Send + 'static,
{
    items
        .iter()
        .map(|&e| std::thread::spawn(move || e + num))
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

slaws

a month ago

6.36ms

90.52kb

use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> 
where
T: std::ops::Add<Output = T> + Send + Copy + 'static
{
    // Implement the function here
    let mut vjh: Vec<thread::JoinHandle<T>> = Vec::new();
    for i in items {
        vjh.push(thread::spawn(move || {
            i + num
        }))
    } 
    vjh
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Baron Curtin

baroncurtin2

a month ago

5.17ms

90.02kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T: Add<Output = T> + Copy + Send + 'static>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> {
    items
        .iter()
        .map(|&x| {
            thread::spawn(move || x + num)
        })
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

medzernik

a month ago

5.54ms

90.02kb

use std::thread;
pub fn concurrent_add<T: std::ops::Add<Output = T> + Send + Copy + 'static>(items: Vec<T>, num: T) 
-> Vec<thread::JoinHandle<T>> {
    items.iter().map(|&x| std::thread::spawn(move|| x + num)).collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Evrins Hu

evrins

a month ago

5.08ms

90.02kb

use std::ops::Add;
use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: Add<Output = T> + Copy + Send + 'static,
{
    // Implement the function here
    items
        .iter()
        .map(|&item| thread::spawn(move || item + num))
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

johndoe30bc

a month ago

6.39ms

90.60kb

use std::{ops::Add, thread};
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: Add<Output = T> + Copy + Send + 'static,
{
    let mut result = Vec::with_capacity(items.len());
    for item in items {
        result.push(thread::spawn(move || item + num));
    }
    result
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Procybit

a month ago

5.66ms

90.06kb

use std::{ops::Add, thread};
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: Add<Output = T> + Copy + Send + 'static,
{
    items
        .iter()
        .map(|&x| thread::spawn(move || x + num))
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Miguel Ángel Allende

maallende

a month ago

5.73ms

91.63kb

use std::{ops::Add, thread};
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<<T as Add<T>>::Output>>
where
    T: Add<T> + Copy + Send + std::fmt::Debug + 'static,
    <T as Add<T>>::Output: Send + 'static,
{
    items.into_iter().map(|item| {
        thread::spawn(move || {
            println!("Thread spawned for item: {:?}", item);
            item + num
        })
    }).collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Cristian Prieto

cprieto

a month ago

8.66ms

90.06kb

use std::{ops::Add, thread};
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: Send + Copy + Add<Output = T> + 'static,
{
    items
        .into_iter()
        .map(|value| thread::spawn(move || num + value))
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

xxxxsk

a month ago

5.45ms

90.03kb

use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where T: std::ops::Add<Output = T> + Copy + 'static + Send
    {
    // Implement the function here
    items.iter().map(|&item| {
        thread::spawn(move || { item + num} )
    }).collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

FredoPo

a month ago

5.99ms

90.52kb

use std::{ops::Add, thread::{self, spawn}};
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
    where T: Add<Output = T> + Send + Copy + 'static {
    // Implement the function here
    let mut handles = vec![];
    for item in items {
        handles.push(spawn(move || {item + num}));
    }
    handles
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Evgenii Grigorenko

grevgeny

a month ago

5.51ms

90.02kb

use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> 
where 
    T: std::ops::Add<Output = T> + Send + Copy + 'static
{
    items.into_iter().map(|item: T| {
        std::thread::spawn(move || {
            item + num
        })
    }).collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

brucecox01

a month ago

5.56ms

90.03kb

use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> 
where
    T: std::ops::Add<Output=T> + Send + Copy + std::marker::Sync + 'static,
{
    // Implement the function here
    items.into_iter().map(|x| std::thread::spawn(move || x + num)).collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Krzysztof Atłasik

katlasik

2 months ago

5.43ms

90.06kb

use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> 
where
    T: std::ops::Add<Output = T> + Send + Copy + 'static
{
    // Implement the function here
    items.into_iter()
        .map(|item| {
            thread::spawn(move || item + num)
        })
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Tengz Mao

MaoX-Yu

2 months ago

5.59ms

90.03kb

use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> 
where
    T: std::ops::Add<Output = T> + Send + Copy + 'static
{
    // Implement the function here
    items.into_iter()
        .map(|item| {
            thread::spawn(move || item + num)
        })
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Ushakov Andrey

stdstring

2 months ago

5.04ms

90.03kb

use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where T: std::ops::Add<Output = T> + std::marker::Send + Copy + 'static
{
    // Implement the function here
    items.into_iter().map(|x| {thread::spawn(move || x + num)}).collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Philippe Massicotte

PMassicotte

2 months ago

5.07ms

90.02kb

use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: std::ops::Add<Output = T> + Send + 'static + Clone,
{
    items
        .into_iter()
        .map(|item| {
            let num = num.clone();
            thread::spawn(move || item + num)
        })
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            // join() returns the value the thread returned
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Enes

enesscevik

2 months ago

5.00ms

90.02kb

use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where T : std::ops::Add<Output = T> + std::marker::Send + Copy + 'static
{
    // Implement the function here
    items.into_iter().map(|n| {
        thread::spawn(move || n + num)
    }).collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

0x0f1

Paul4673

2 months ago

5.03ms

90.03kb

use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> 
where T : std::ops::Add<Output = T> + std::marker::Send + 'static + Copy
{
    // Implement the function here
    items.into_iter().map(|n| {
        thread::spawn(move || n + num )
    }).collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

vanos001

2 months ago

5.66ms

90.58kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> 
where
    T : Add<Output = T> + std::marker::Send + Copy + 'static,
{
    // Implement the function here
    // print!("{}",isize::BITS);
    let mut res = Vec::with_capacity(items.len());
    for i in items{
        res.push(thread::spawn(move || i + num))
    }
    return res;
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

vanos001

2 months ago

5.60ms

90.58kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> 
where
    T : Add<Output = T> + std::marker::Send + Copy + 'static,
{
    // Implement the function here
    let mut res = Vec::with_capacity(items.len());
    for i in items{
        res.push(thread::spawn(move || i + num))
    }
    return res;
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

vanos001

2 months ago

5.95ms

90.58kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> 
where
    T : Add<Output = T> + std::marker::Send + Copy + 'static,
{
    // Implement the function here
    let mut res = Vec::with_capacity(items.len());
    for i in items{
        res.push(thread::spawn(move || i + num))
    }
    return res;
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

vanos001

2 months ago

4.99ms

90.52kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> 
where
    T : Add<Output = T> + std::marker::Send + Copy + 'static,
{
    // Implement the function here
    let mut res = Vec::new();
    for i in items{
        res.push(thread::spawn(move || i + num))
    }
    return res;
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

whhc

2 months ago

6.86ms

90.02kb

use std::{ops::Add, thread};
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: Add<Output = T> + Send + Copy + 'static,
{
    items
        .into_iter()
        .map(|item| thread::spawn(move || item + num))
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

whhc

2 months ago

4.91ms

90.52kb

use std::{ops::Add, thread};
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: Add<Output = T> + Send + Copy + 'static,
{
    let mut handles = vec![];
    for item in items {
        let handle = thread::spawn(move || item + num);
        handles.push(handle);
    }
    handles
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

alexsavio

2 months ago

5.37ms

90.52kb

use std::thread;
use std::marker::{Send, Copy};
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> 
where
    T: Add<Output = T> + Send + Copy + 'static
{
    let mut handles = vec![];
    for item in items {
        let handle = std::thread::spawn(move || {
            item + num 
        });
        handles.push(handle);           
    }
    handles
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

ikatlinsky

2 months ago

7.30ms

90.52kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: 'static + Send + Copy + Add<Output = T>,
{
    let mut handles = vec![];
    for item in items {
        let handle = thread::spawn(move || {
            item + num
        });
        handles.push(handle);
    }
    return handles;
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

diucicd

2 months ago

5.63ms

90.52kb

use std::thread;
pub fn concurrent_add<T: Copy + Send + 'static + std::ops::Add<Output = T>>(
    items: Vec<T>,
    num: T,
) -> Vec<thread::JoinHandle<T>> {
    // Implement the function here
    let mut handles = Vec::new();
    for item in items {
        let handle = thread::spawn(move || item + num);
        handles.push(handle);
    }
    handles
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Seth Wood

seth-wood

2 months ago

4.94ms

90.03kb

use std::ops::Add;
use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<<T as Add<T>>::Output>>
where
    T: Add<T> + Copy + Send + 'static, // T must implement Add, be Copy (for num), Send and 'static (for threads)
    <T as Add<T>>::Output: Send + 'static, // The result of addition must also be Send and 'static
{
    // Implement the function here
    items
        .into_iter()
        .map(|item| {
            // item is moved into the closure
            // num is copied into the closure environment because T is Copy
            thread::spawn(move || item + num)
        })
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Sergey Matyash

matiaspub

2 months ago

6.47ms

90.03kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: 'static + Send + Copy + Add<Output = T>
{
    items
        .into_iter()
        .map(|i| thread::spawn(move || i + num))
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

LeonardoPinheiro23

2 months ago

5.03ms

90.02kb

use std::{ops::Add, thread};
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: 'static + Send + Add<Output = T> + Copy {
    items
        .into_iter()
        .map(|element| thread::spawn(move || element + num))
        .collect()
}
// Example Usage
fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10.0, 20.0, 30.0, 40.0, 50.0];
        let handles = concurrent_add(list.clone(), 5.0);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.0);
        }
    }
}

Tommytto

3 months ago

15.36ms

90.02kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> 
where
    T: Add<Output = T> + Copy + Send + 'static,
{
    // Implement the function here
    items.iter().map(|&item| {
        let num = num;
        thread::spawn(move || item + num)
    }).collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Tommytto

3 months ago

33.85ms

90.02kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> 
where
    T: Add<Output = T> + Copy + Send + 'static,
{
    // Implement the function here
    items.iter().map(|&item| {
        let num = num;
        thread::spawn(move || item + num)
    }).collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

sjmellor

3 months ago

6.09ms

90.40kb

use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: std::ops::Add<Output = T> + std::marker::Send + 'static + Copy,
{
    // Implement the function here
    let mut handles: Vec<thread::JoinHandle<T>> = Vec::new();
    for item in items {
        handles.push(thread::spawn(move || { item + num }));
    }
    handles
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

ggnne

3 months ago

8.19ms

90.04kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> 
where
    T: Add<Output = T> + Clone + Send + 'static {
    items.into_iter().map(|item| thread::spawn({let num = num.clone(); move || item + num})).collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}