How to Store Closures in Structs in Rust

You cannot store closures directly in structs because their size is unknown at compile time; instead, store a Box<dyn Fn(...)> or a Box<dyn FnOnce(...)> to heap-allocate the closure.

use std::thread;

pub struct ThreadPool {
    threads: Vec<thread::JoinHandle<()>>,
    // Store the closure on the heap using a trait object
    executor: Box<dyn FnOnce() + Send + 'static>,
}

impl ThreadPool {
    pub fn new(size: usize, executor: Box<dyn FnOnce() + Send + 'static>) -> ThreadPool {
        assert!(size > 0);
        let mut threads = Vec::with_capacity(size);
        for _ in 0..size {
            // create threads
        }
        ThreadPool { threads, executor }
    }

    pub fn execute<F>(&self, f: F)
    where
        F: FnOnce() + Send + 'static,
    {
        // Use the stored executor or pass f directly
    }
}

Note: If you need to store multiple different closures, use Vec<Box<dyn FnOnce() + Send + 'static>> or a similar collection of trait objects.

Closures are anonymous functions that can capture variables from their surrounding code, but Rust doesn't know how much memory they need until the program runs. To store them in a struct, you must put them on the heap using a smart pointer like Box, which acts like a box that holds the function regardless of its size. This allows your struct to hold the closure safely while keeping the struct's size fixed.