How to have a function that takes a parameter that is to a function using a function signature in Rust?

fn test<T>(fn(T) -> T, y: T) -> T {
    return test(fn(T) -> T, fn(y));
}

Hello, I have a function here in rust that needs to take in the function signature fn(T) -> T as the first parameter, and y of type T. This is a generic function. How do I allow this function to take in that parameter? I keep getting the:

expected identifier, found keyword `fn`

error.

Thanks.

I tried to add a r# to escape the identitifer but that didnt work.

There are several ways, depending on what you mean by "function". The closest to what you have right now is this.

fn test<T>(my_function: fn(T) -> T, y: T) -> T {
    ...
}

Like any argument, an argument which happens to be a function must be given a name. This function can be called with a function pointer as its first argument. That is, if you define a function at the top-level of a module or a trivial closure (one that doesn't actually close around variables), then you can use it to call test. However, you cannot use nontrivial closures. If you want to do so, you need to use one of three closure traits.

FnOnce is the strongest closure trait. An FnOnce takes its closure values by value and can be called once. When it's done, it drops the things it closed over by value. Essentially, FnOnce can be thought of as having this signature (an approximation since Rust doesn't have variadic generics):

trait FnOnce<Args...> {
  fn call(self, Args...);
}

FnMut is the next strongest. It can handle mutable closure values by reference and can modify its values. As such, it cannot be called multiple times concurrently (like a &mut, we can only have one active reference to its self at a time). It can be thought of like so.

trait FnMut<Args...> {
  fn call(&mut self, Args...);
}

Finally, Fn can be called from anywhere, any number of times, and any number of times concurrently. It cannot modify its closure values. Its signature is basically

trait Fn<Args...> {
  fn call(&self, Args...);
}

Note that in these examples, the only difference is the type of self. FnOnce has self by value, FnMut takes &mut self, and Fn takes &self.

To use each of these, your signature would look like one of the following

fn test<T, F: FnOnce(T) -> T>(my_function: F, y: T) -> T { ... }
fn test<T, F: FnMut(T) -> T>(my_function: F, y: T) -> T { ... }
fn test<T, F: Fn(T) -> T>(my_function: F, y: T) -> T { ... }

So which one should we use? You have four options: The fn concrete type or one of the three traits FnOnce, FnMut, or Fn. The traits are hierarchical in nature. Every Fn is an FnMut, and every Fn is an FnOnce. Additionally, every function pointer fn is a Fn, since the empty closure can never be modified and hence we should never need mutable state inside it. So, to summarize,

• FnOnce is an incredibly powerful guarantee. Use it if you can. If you're only calling the function once, use this one.
• FnMut can be called concurrently. If you're not using the function across multiple threads and are not calling the function in a way that may be recursive (may call itself as part of its own execution), then use FnMut.
• Fn is the weakest trait in terms of guarantees. Use this one if you can't use either of the above.
• fn restricts you to actual function pointers, not closures. This should be used if you're writing a C-style interface or need FFI compatibility, since C doesn't understand Rust closures.