Expected bound lifetime parameter, found concrete lifetime [E0271]

by

First thing’s first, if you want a quick answer, you should put some effort into writing a minimal, compilable example so that people don’t have to guess whether or not a potential solution is going to work or not. Like this:

enum WireType {}

fn from_gpb(source: &Vec<u8>) {
    let mut field_handler = |tag, wire_type, source, position| -> usize {
        let tag: u32 = tag;
        let wire_type: WireType = wire_type;
        let source: &Vec<u8> = source;
        let position: usize = position;
        panic!();
    };
    read_message(source, field_handler);
}

fn read_message<F>(source: &Vec<u8>, field_handler: F)
where
    F: Fn(u32, WireType, &Vec<u8>, usize) -> usize,
{
    panic!();
}

The rest of this answer is based on the above which appears to replicate your problem:

error[E0631]: type mismatch in closure arguments
  --> src/lib.rs:11:5
   |
4  |     let mut field_handler = |tag, wire_type, source, position| -> usize {
   |                             ------------------------------------------- found signature of `fn(u32, WireType, &std::vec::Vec<u8>, usize) -> _`
...
11 |     read_message(source, field_handler);
   |     ^^^^^^^^^^^^ expected signature of `for<'r> fn(u32, WireType, &'r std::vec::Vec<u8>, usize) -> _`
   |
note: required by `read_message`
  --> src/lib.rs:14:1
   |
14 | / fn read_message<F>(source: &Vec<u8>, field_handler: F)
15 | | where
16 | |     F: Fn(u32, WireType, &Vec<u8>, usize) -> usize,
17 | | {
18 | |     panic!();
19 | | }
   | |_^

error[E0271]: type mismatch resolving `for<'r> <[closure@src/lib.rs:4:29: 10:6] as std::ops::FnOnce<(u32, WireType, &'r std::vec::Vec<u8>, usize)>>::Output == usize`
  --> src/lib.rs:11:5
   |
11 |     read_message(source, field_handler);
   |     ^^^^^^^^^^^^ expected bound lifetime parameter, found concrete lifetime
   |
note: required by `read_message`
  --> src/lib.rs:14:1
   |
14 | / fn read_message<F>(source: &Vec<u8>, field_handler: F)
15 | | where
16 | |     F: Fn(u32, WireType, &Vec<u8>, usize) -> usize,
17 | | {
18 | |     panic!();
19 | | }
   | |_^

The simplest thing to do is to allow the compiler to properly infer the closure type:

fn from_gpb_closure_inference(source: &Vec<u8>) {
    read_message(source, |tag, wire_type, source, position| -> usize {
        let tag: u32 = tag;
        let wire_type: WireType = wire_type;
        let source: &Vec<u8> = source;
        let position: usize = position;
        panic!();
    });
}

Closure inference only really works properly when the closure is provided directly as an argument to a function. In theory, the two should be equivalent, but they aren’t.

The other thing you can do is kind-of trick the compiler into doing the inference without actually using the closure:

fn constrain_handler<F>(f: F) -> F
where
    F: Fn(u32, WireType, &Vec<u8>, usize) -> usize,
{
    f
}

fn from_gpb_constrain(source: &Vec<u8>) {
    let mut field_handler = constrain_handler(|tag, wire_type, source, position| -> usize {
        let tag: u32 = tag;
        let wire_type: WireType = wire_type;
        let source: &Vec<u8> = source;
        let position: usize = position;
        panic!();
    });
    read_message(source, field_handler);
}

In this case, the constrain_handler function is just getting the compiler to nail down the type of the closure, allowing it to be used (or not) later on.

More Related Contents:

  1. What are non-lexical lifetimes?
  2. What does “Sized is not implemented” mean?
  3. Deriving a trait results in unexpected compiler error, but the manual implementation works
  4. How do I implement Copy and Clone for a type that contains a String (or any type that doesn’t implement Copy)?
  5. Mutably borrow one struct field while borrowing another in a closure
  6. How do I convert a Vector of bytes (u8) to a string?
  7. Can I write an Iterator that mutates itself and then yields a reference into itself?
  8. How to update-or-insert on a Vec?
  9. Lifetime troubles sharing references between threads
  10. How do I include the end value in a range?
  11. How do I specify lifetime parameters in an associated type?
  12. How do I invoke a system command and capture its output?
  13. How to return a string (or similar) from Rust in WebAssembly?
  14. Can I destructure a tuple without binding the result to a new variable in a let/match/for statement?
  15. How to format output to a byte array with no_std and no allocator?
  16. What is the right way to allocate data to pass to an FFI call?
  17. Efficiently insert or replace multiple elements in the middle or at the beginning of a Vec?
  18. Read large files line by line in Rust [duplicate]
  19. Why is it discouraged to accept a reference &String, &Vec, or &Box as a function argument?
  20. What makes `impl Trait` as an argument “universal” and as a return value “existential”?
  21. How to represent shared mutable state?
  22. What does “missing lifetime specifier” mean when storing a &str in a structure?
  23. Why can Serde not derive Deserialize for a struct containing only a &Path?
  24. How do I specify that a struct field must implement a trait?
  25. How do I print an integer in binary with leading zeros?
  26. How does Rust’s type inference work across multiple statements?
  27. Why does Valgrind not detect a memory leak in a Rust program using nightly 1.29.0?
  28. What is the null pointer optimization in Rust?
  29. Is there any way to restrict a generic type to one of several types?
  30. How to pass rustc flags to cargo?

Leave a Comment