Ich versuche herauszufinden, wie man eine Funktion über einen Kanal sendet und wie man zusätzliches Klonen vermeidet, um die Funktion am anderen Ende auszuführen. Wenn ich den zusätzlichen Klonvorgang innerhalb des Verschlusses entferne, wird die folgende Fehlermeldung angezeigt:

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

Ignoring die Tatsache, dass dieser Code absolut nichts tut, und nutzt eine globale veränderliche statischeSender<T>, es stellt dar, was ich versuche zu erreichen, während die richtigen Compiler-Fehler angezeigt werden. Dieser Code istnicht zum rennen gedacht, nur kompiliert.

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) { }

Gibt es eine bessere Methode, um diesen Fehler zu umgehen und / oder sollte ich Funktionen auf andere Weise über Kanäle senden?