Pasando un cierre dos veces sin que se mueva.

Question

Estoy experimentando con cierres:

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

Pasando Klido a Call_it () dos veces causa un error del compilador a cuenta del valor de cierre se mueve:

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);
                           ^~~~~~~

El compilador realmente hace una sugerencia sobre cómo resolver el problema, pero no he descubierto una manera de aplicarla con éxito.

¿Alguna sugerencia?: D

Answer 1

Nota: `Cierre 'se movió aquí porque tiene tipo" || ", que es un cierre de pila no copiable (capturándolo en un nuevo cierre, por ejemplo, | x | F (x)`, para anular)

Esto significa que escribiría || closure() en lugar de closure: está pasando en un nuevo cierre que llama a su primer cierre.

Answer 2

(Actualización: No hagas esto, podría ser rechazado en un futuro cercano. Un &mut || probablemente funcionará bien ahora y en el futuro. Ver discusión y enlaces en los comentarios sobre esta respuesta.)

Otro enfoque potencial (aunque un poco más feo para leer):

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);