CODEWITHSUNDEEP
rustrust-0.9
Greg Malcolm
Greg Malcolm

Reputation: 3397

Passing a closure twice without it getting moved away

I'm experimenting with closures:

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

Passing klosure into call_it() twice causes a compiler error on account of the closure value getting moved:

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

The compiler actually makes a suggestion on how to resolve the issue, but I've not figured out a way to successfully apply it.

Any suggestions? :D

Upvotes: 3

Views: 432

Answers (2)

pnkfelix
pnkfelix

Reputation: 3890

(Update: Don't do this, it might be disallowed in the near future. A &mut || will probably work just fine now and in the future. See discussion and links in the comments on this answer.)

Another potential approach (though a bit uglier to read): 

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

Upvotes: 0

Chris Morgan
Chris Morgan

Reputation: 90722

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)

This means that you would write || closure() instead of closure: you are passing in a new closure which calls your first closure.

Upvotes: 2

Related Questions