Threads, Async and Closures

// std
pub fn spawn<F, T>(f: F) -> JoinHandle<T>
where F: FnOnce() -> T + Send + 'static, T: Send + 'static;
// tokio
pub fn spawn<F>(future: F) -> JoinHandle<F::Output>
where F: Future + Send + 'static, F::Output: Send + 'static;

use std::thread;

fn report(lines: Vec<String>) -> usize {
    // let h = thread::spawn(|| lines.len());   // E0373: borrows `lines`
    let h = thread::spawn(move || lines.len()); // the Vec is moved into the thread
    h.join().unwrap()
}

use std::sync::Arc;
use std::thread;

fn fan_out(data: Arc<Vec<u64>>) -> u64 {
    let workers: Vec<_> = (0..4)
        .map(|i| {
            let data = Arc::clone(&data);           // shadowed clone, moved below
            thread::spawn(move || data.iter().skip(i).step_by(4).sum::<u64>())
        })
        .collect();
    let total = workers.into_iter().map(|h| h.join().unwrap()).sum();
    println!("still usable here: {} items", data.len());
    total
}

use std::sync::Arc;
use std::thread;

struct Service { name: String }

impl Service {
    // fn start(&self) { thread::spawn(move || println!("{}", self.name)); }   // E0521: `self` is &Service

    fn start(self: &Arc<Self>) -> thread::JoinHandle<()> {
        let me = Arc::clone(self);                 // own a handle
        thread::spawn(move || println!("{} started", me.name))
    }

    fn start_with_name(&self) -> thread::JoinHandle<()> {
        let name = self.name.clone();              // or own just the field you need
        thread::spawn(move || println!("{name} started"))
    }
}

use std::thread;

fn parallel_sum_and_scale(values: &mut [f64], factor: f64) -> f64 {
    let (left, right) = values.split_at_mut(values.len() / 2);
    thread::scope(|s| {
        s.spawn(|| left.iter_mut().for_each(|x| *x *= factor));   // &mut left
        s.spawn(|| right.iter_mut().for_each(|x| *x *= factor));  // &mut right, disjoint
    });                                                            // both joined here
    values.iter().sum()
}

use std::sync::mpsc;
use std::thread;

fn crawl(urls: Vec<String>) -> Vec<(String, usize)> {
    let (tx, rx) = mpsc::channel();
    for url in urls {
        let tx = tx.clone();
        thread::spawn(move || {
            let len = url.len(); // stand-in for a fetch
            tx.send((url, len)).ok();
        });
    }
    drop(tx); // close the original sender so `rx` ends when workers finish
    rx.into_iter().collect()
}

use std::sync::{Arc, Mutex};

async fn record(state: Arc<Mutex<Vec<u32>>>, v: u32) {
    // let mut g = state.lock().unwrap();
    // g.push(v);
    // flush().await;            // error: future cannot be sent between threads safely
    //                           // (`MutexGuard` is !Send and is still alive here)
    {
        let mut g = state.lock().unwrap();
        g.push(v);
    }                            // guard dropped before the await
    flush().await;
}

async fn flush() {}

fn counters() {
    let mut n = 0;
    let mut inc = || n += 1;      // FnMut: holds &mut n while `inc` is alive
    inc();
    inc();
    // println!("{n}"); inc();    // E0502: `n` read while `inc` (and its &mut n) is still used
    println!("{n}");              // fine: `inc` is not used after this point
}

fn call_twice<F: FnMut()>(mut f: F) { f(); f(); }

fn names() -> Vec<String> {
    let mut out = Vec::new();
    call_twice(|| out.push("x".to_string())); // FnMut is enough; `out` is usable again afterwards
    out
}

fn make_prefixer(prefix: String) -> impl Fn(&str) -> String {
    move |s| format!("{prefix}{s}")            // owns `prefix`
}

fn make_matcher<'a>(words: &'a [&'a str]) -> impl Fn(&str) -> bool + 'a {
    move |s| words.iter().any(|w| *w == s)     // borrows `words` for 'a: lifetime in the return type
}