Untitled

use std::env::Args;
use std::sync::mpsc::{channel, Sender};
use std::thread::JoinHandle;


pub struct Task {
    f: Box<dyn FnOnce()>
}

unsafe impl Send for Task{}

impl Task {
    fn new(f: Box<dyn FnOnce()>) -> Self {
        Task { f }
    }
}

struct SingleThreadExec{
    thread: JoinHandle<()>,
    sender: Sender<Task>
}

impl SingleThreadExec{
    fn new() -> Self {
        let (sender, receiver) = channel::<Task>();
        let thread = std::thread::spawn(move || {
            loop{
                let f = receiver.recv().unwrap();
                (f.f)();
            }
        });

        return SingleThreadExec {
            thread,
            sender
        }
    }

    fn submit<T: FnOnce() + 'static>(&self, task: T) {
        self.sender.send(Task::new(Box::new(task))).unwrap();
    }


    /*
        fn close(self) {
            std::mem::drop(self.sender);
        }
     */
}

fn main() {
    let str = SingleThreadExec::new();

    for i in 0..10{
        str.submit( || {println!("Funziona");});
    }
    str.submit( || {println!("Funziona2");});

    str.thread.join().unwrap();
}