Estoy tratando de descubrir cómo enviar una función a través de un canal y cómo evitar la clonación adicional para ejecutar la función en el otro extremo. Si elimino la operación de clonación adicional dentro del cierre, aparece el siguiente error:

error: cannot move out of captured outer variable in an 'Fn' closure

Ignorando el hecho de que este código no hace absolutamente nada y hace uso de una estática mutable globalSender<T>, representa lo que estoy tratando de lograr al proporcionar los errores de compilación adecuados. Este código esno destinado a ser corrido, solo compilado.

use std::ops::DerefMut;
use std::sync::{Arc, Mutex};
use std::collections::LinkedList;
use std::sync::mpsc::{Sender, Receiver};

type SafeList = Arc<Mutex<LinkedList<u8>>>;
type SendableFn = Arc<Mutex<(Fn() + Send + Sync + 'static)>>;
static mut tx: *mut Sender<SendableFn> = 0 as *mut Sender<SendableFn>;

fn main() {
    let list: SafeList = Arc::new(Mutex::new(LinkedList::new()));
    loop {
        let t_list = list.clone();
        run(move || {
            foo(t_list.clone());
        });
    }
}

fn run<T: Fn() + Send + Sync + 'static>(task: T) {
    unsafe {
        let _ = (*tx).send(Arc::new(Mutex::new(task)));
    }
}

#[allow(dead_code)]
fn execute(rx: Receiver<SendableFn>) {
    for t in rx.iter() {
        let mut guard = t.lock().unwrap();
        let task = guard.deref_mut();
        task();
    }
}

#[allow(unused_variables)]
fn foo(list: SafeList) { }

¿Existe un mejor método para evitar ese error y / u otra forma en que debería enviar funciones a través de canales?