Passar por um fechamento duas vezes sem que ele se afaste

Question

Estou experimentando fechamentos:

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

Passar klosure para call_it() duas vezes causa um erro do compilador devido ao valor de fechamento ser movido:

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

Na verdade, o compilador faz uma sugestão sobre como resolver o problema, mas não descobri uma maneira de aplicá-lo com êxito.

Alguma sugestão?:D

Answer 1

observação:`closure` foi movido para cá porque tem o tipo `||`, que é um encerramento de pilha não copiável (capture-o em um novo encerramento, por exemplo`| x | f (x) `, para substituir)

Isso significa que você escreveria || closure() em vez de closure:você está passando por um novo fechamento que chama seu primeiro fechamento.

Answer 2

(Atualizar:Não faça isso, pois pode ser proibido em um futuro próximo.A &mut || provavelmente funcionará bem agora e no futuro.Veja a discussão e os links nos comentários desta resposta.)

Outra abordagem potencial (embora um pouco mais feia de ler):

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