CODEWITHSUNDEEP
pointersrust
Augusto Hack
Augusto Hack

Reputation: 2170

Why can't I reuse a funtion's borrowed pointer

I don't understand why rustc gives me this error error: use of moved value: 'f' at compile time, with the following code:

fn inner(f: &fn(&mut int)) {
    let mut a = ~1;
    f(a);
}

fn borrow(b: &mut int, f: &fn(&mut int)) {
    f(b);
    f(b); // can reuse borrowed variable

    inner(f);  // shouldn't f be borrowed?

    // Why can't I reuse the borrowed reference to a function?
    // ** error: use of moved value: `f` **
    //f(b);
}

fn main() {
    let mut a = ~1;
    print!("{}", (*a));
    borrow(a, |x: &mut int| *x+=1);
    print!("{}", (*a));
}

I want to reuse the closure after I pass it as argument to another function. I am not sure if it is a copyable or a stack closure, is there a way to tell?

That snippet was for rustc 0.8. I managed to compile a different version of the code with the latest rustc (master: g67aca9c), changing the &fn(&mut int) to a plain fn(&mut int) and using normal functions instead of a closure, but how can I get this to work with a closure?

Upvotes: 1

Views: 371

Answers (1)

Chris Morgan
Chris Morgan

Reputation: 90752

The fact of the matter is that &fn is not actually a borrowed pointer in the normal sense. It's a closure type. In master, the function types have been fixed up a lot and the syntax for such things has changed to |&mut int|—if you wanted a borrowed pointer to a function, for the present you need to type it &(fn (...)) (&fn is marked obsolete syntax for now, to help people migrating away from it, because it's a completely distinct type).

But for closures, you can then go passing them around by reference: &|&mut int|.

Upvotes: 1

Related Questions