How to pass a function as argument in Rust

Question

Given the following rust program:

fn call_twice<A>(val: A, f: fn(A) -> A) -> A {
    f(f(val))
}

fn main() {
    fn double(x: int) -> int {x + x};
    println!("Res is {}", call_twice(10i, double));
    // println!("Res is {}", call_twice(10i, (x: int) -> int {x + x}));
    // ^ this line will fail
}

Why can I pass double as the function, but not inlined? What is a good way to achieve the same behaviour without defining the function somewhere?

Answer 1

2016-04-01 Update:

As of Rust 1.0, the code should look like this:

fn call_twice<A, F>(val: A, mut f: F) -> A
where F: FnMut(A) -> A {
    let tmp = f(val);
    f(tmp)
}

fn main() {
    fn double(x: i32) -> i32 {x + x};
    println!("Res is {}", call_twice(10, double));
    println!("Res is {}", call_twice(10, |x| x + x));
}

The change to the closure parameter is because closure are now unboxed.

Original:

Insofar as I know, you can't define functions inline like that.

What you want is a closure. The following works:

fn call_twice<A>(val: A, f: |A| -> A) -> A {
    let tmp = f(val);
    f(tmp)
}

fn main() {
    fn double(x: int) -> int {x + x};
    println!("Res is {}", call_twice(10i, double));
    println!("Res is {}", call_twice(10i, |x| x + x));
}

There are a few things to note:

1. Functions coerce to closures, but the opposite isn't true.

2. You need to store the result of f(val) in a temporary due to borrowing rules. Short version: you need unique access to a closure to call it, and the borrow checker isn't quite clever enough to realise the two calls are independent in their original positions.

3. Closures are in the process of being replaced by unboxed closures, so this will change in the future, but we're not quite there yet.