“Expected fn item, found a different fn item” when working with function pointers

by

Function item vs. function pointer

When you refer to a function by its name, the type you get is not a function pointer (e.g. fn(u32) -> bool). Instead, you get an a zero-sized value of the function’s item type (e.g. fn(u32) -> bool {foo}).

The value is zero-sized because it doesn’t store the actual function pointer. The type perfectly identifies the function, so there is no need to store actual data in the type. This has several advantages, mostly about easier optimizations. A function pointer is like you would expect from other languages: it stores an address to the function.

A function pointer refers to the function via stored address; a function item refers to the function via type information.

A function item can be coerced to a function pointer in many situations, for example: as argument to a function and in let _: fn(u32) -> bool = foo; statements. Additionally, you can explicitly cast a function item to a function pointer: foo as fn(u32) -> bool.

You can read more about this topic in the reference on function items, function pointers and coercion.

Solution to your problem

In your case, the compiler isn’t smart enough to figure out that you want the function pointers from your foo and bar instead of function items. When you call call_both(foo, bar) the compiler sets the generic type F to be fn(u32) -> bool {foo}, because that’s the type of the first argument. And then it complains that the second argument doesn’t have the same type.

You can fix that by explicitly specifying the F parameter:

call_both::<fn(u32) -> bool>(foo, bar);
call_both::<fn(_) -> _>(foo, bar);       // <-- even this works

After specifying the type, the compiler can correctly coerce the arguments to a function pointer. You could also as-cast the first argument to fn(u32) -> bool explicitly.

You can fix your second example by explicitly stating the function pointer type, too:

let mut x: fn(u32) -> bool = foo;
x = bar;

In general: specifying the function pointer type somewhere to trigger the coercion will work.

More Related Contents:

  1. How do I create a heterogeneous collection of objects?
  2. Is it possible to control the size of an array using the type parameter of a generic?
  3. How do I stop iteration and return an error when Iterator::map returns a Result::Err?
  4. Are polymorphic variables allowed?
  5. Does println! borrow or own the variable?
  6. How do I pass disjoint slices from a vector to different threads?
  7. Why does Iterator::take_while take ownership of the iterator?
  8. Efficiently mutate a vector while also iterating over the same vector
  9. Why is it possible to implement Read on an immutable reference to File?
  10. Compare enums only by variant, not value
  11. What does “mismatched types: expected `()`” mean when using an if expression?
  12. How do I read the entire body of a Tokio-based Hyper request?
  13. How do I ‘pass down’ feature flags to subdependencies in Cargo?
  14. When returning the outcome of consuming a StdinLock, why was the borrow to stdin retained?
  15. How does Rust pattern matching determine if the bound variable will be a reference or a value?
  16. Using generic trait methods like .into() when type inference is impossible
  17. Why does an enum require extra memory size?
  18. Why does Rust disallow mutable aliasing?
  19. How to store rusqlite Connection and Statement objects in the same struct in Rust? [duplicate]
  20. Why can’t I reuse a &mut reference after passing it to a function that accepts a generic type?
  21. print! macro not executed until pressing Enter
  22. How can I override a constant via a compiler option?
  23. Why am I getting “parameter is never used [E0392]”?
  24. Creating a vector of zeros for a specific size
  25. What is the difference between immutable and const variables in Rust?
  26. Why does the Rust compiler request I constrain a generic type parameter’s lifetime (error E0309)?
  27. Cannot pass self as callback parameter due to double borrowing
  28. How do I create a HashMap with type erased keys?
  29. How to print structs and arrays?
  30. Can Rust optimise away the bit-wise copy during move of an object someday?

Leave a Comment