Passando una chiusura due volte senza che si allontani

Question

Sto sperimentando con chiusure:

fn call_it(f: ||) {
    f(); 
}
let klosure = || println("closure!");
call_it(klosure);
call_it(klosure); //Blows up here

.

Passando Klosure in Call_it () due volte causa un errore del compilatore a causa del valore di chiusura viene spostato:

closures.rs:16:13: 16:20 error: use of moved value: `klosure`
closures.rs:16     call_it(klosure);
                           ^~~~~~~
closures.rs:15:13: 15:20 note: `closure` moved here because it has type `||`, which is a non-copyable stack closure (capture it in a new closure, e.g. `|x| f(x)`, to override)
closures.rs:15     call_it(klosure);
                           ^~~~~~~

.

Il compilatore effettivamente fa un suggerimento su come risolvere il problema, ma non ho capito un modo per applicarlo con successo.

Qualche suggerimento?: D

Answer 1

.

Nota: `Chiusura` è stato spostato qui perché ha il tipo` || `, che è una chiusura a pila non copiabile (catturarla in una nuova chiusura, ad es.` | X | F (x) `, per sovrascrivere) .

Ciò significa che scriverebbe || closure() anziché closure: stai passando in una nuova chiusura che chiama la prima chiusura.

Answer 2

(Aggiornamento: non farlo, potrebbe essere non consentito nel prossimo futuro. Un &mut || probabilmente funzionerà bene ora e in futuro. Vedi discussione e collegamenti nei commenti su questa risposta.)

Un altro approccio potenziale (anche se un po 'più brutto da leggere):

fn call_it(f_ref: &||) { // now takes a borrowed reference to a closure
    (*f_ref)();
}
let klosure = || println("closure!");
call_it(&klosure);
call_it(&klosure);

.