Rust for C-Programmers

8.9 Function Pointers and Higher-Order Functions

In Rust, functions themselves can act as values. This means you can pass them as arguments, store them in variables, and even return them from other functions.

8.9.1 Function Pointers

A function pointer in Rust has a type signature specifying its parameter types and return type. For instance, fn(i32) -> i32 refers to a function pointer to a function taking an i32 and returning an i32:

fn add_one(x: i32) -> i32 {
    x + 1
}

fn apply_function(f: fn(i32) -> i32, value: i32) -> i32 {
    f(value)
}

fn main() {
    let result = apply_function(add_one, 5);
    println!("Result: {}", result);
}

Here, apply_function takes a function pointer and applies it to the given value.

8.9.2 Why Use Function Pointers?

Function pointers are useful for parameterizing behavior without relying on traits or dynamic dispatch. They allow passing different functions as arguments, which is valuable for callbacks or choosing a function at runtime.

For example:

fn multiply_by_two(x: i32) -> i32 {
    x * 2
}

fn add_five(x: i32) -> i32 {
    x + 5
}

fn execute_operation(operation: fn(i32) -> i32, value: i32) -> i32 {
    operation(value)
}

fn main() {
    let ops: [fn(i32) -> i32; 2] = [multiply_by_two, add_five];

    for &op in &ops {
        println!("Result: {}", execute_operation(op, 10));
    }
}

Since function pointers involve an extra level of indirection and hinder inlining, they can affect performance in critical code paths.

8.9.3 Functions Returning Functions

In Rust, a function can also return another function. The return type uses the same function pointer notation:

fn choose_operation(op: char) -> fn(i32) -> i32 {
    fn increment(x: i32) -> i32 { x + 1 }
    fn double(x: i32) -> i32 { x * 2 }

    match op {
        '+' => increment,
        '*' => double,
        _ => panic!("Unsupported operation"),
    }
}

fn main() {
    let op = choose_operation('+');
    println!("Result: {}", op(10)); // Calls `increment`
}

Here, choose_operation returns a function pointer to either increment or double, enabling dynamic function selection at runtime.

8.9.4 Higher-Order Functions

A higher-order function is one that takes another function as an argument or returns one. Rust also supports closures, which are more flexible than function pointers because they can capture variables from their surrounding scope. Closures are covered in Chapter 12.