Type mismatches resolving a closure that takes arguments by reference

by

The short version is that there’s a difference between the lifetimes that are inferred if the closure is written inline or stored as a variable. Write the closure inline and remove all the extraneous types:

fn test(points: &[Point]) -> (&Point, f32) {
    let init = points.first().expect("No initial");
    fold(&points, (init, 0.), |(q, max_d), p| {
        let d = 12.;
        if d > max_d {
            (p, d)
        } else {
            (q, max_d)
        }
    })
}

If you truly must have the closure out-of-band, review How to declare a lifetime for a closure argument?.

Additionally, I had to pull the first value from the input array — you can’t return a reference to a local variable. There’s no need for lifetime parameters on the method; they will be inferred.

To actually get the code to compile, you need to provide more information about the fold method. Specifically, you have to indicate that the reference passed to the closure has the same lifetime as the argument passed in. Otherwise, it could just be a reference to a local variable:

fn fold<'a, S, T, F>(item: &'a [S], accum: T, f: F) -> T
where
    F: Fn(T, &'a S) -> T,
{
    f(accum, &item[0])
}

The related Rust issue is #41078.

More Related Contents:

  1. Why can’t I store a value and a reference to that value in the same struct?
  2. What are non-lexical lifetimes?
  3. The compiler suggests I add a ‘static lifetime because the parameter type may not live long enough, but I don’t think that’s what I want
  4. How can I create my own data structure with an iterator that returns mutable references?
  5. Lifetime error when creating a function that returns a value implementing serde::Deserialize
  6. Temporarily move out of borrowed content
  7. Why does linking lifetimes matter only with mutable references?
  8. Why is adding a lifetime to a trait with the plus operator (Iterator + ‘a) needed?
  9. Does println! borrow or own the variable?
  10. Do mutable references have move semantics?
  11. What are move semantics in Rust?
  12. Cannot infer an appropriate lifetime for autoref due to conflicting requirements
  13. When is it useful to define multiple lifetimes in a struct?
  14. Lifetime troubles sharing references between threads
  15. Moved variable still borrowing after calling `drop`?
  16. What is lifetime elision in very simple terms?
  17. “borrowed value does not live long enough” when using the builder pattern
  18. How can this instance seemingly outlive its own parameter lifetime?
  19. How do I specify lifetime parameters in an associated type?
  20. Is it possible to return either a borrowed or owned type in Rust?
  21. How to operate on 2 mutable slices of a Rust array?
  22. When returning the outcome of consuming a StdinLock, why was the borrow to stdin retained?
  23. Why does my variable not live long enough?
  24. Why is the bound `T: ‘a` required in order to store a reference `&’a T`?
  25. Sharing a struct with trait objects as properties across threads
  26. Why can’t I return an &str value generated from a String?
  27. How to fix lifetime error when function returns a serde Deserialize type?
  28. Why does Rust disallow mutable aliasing?
  29. Extend lifetime of variable
  30. Why does the Rust compiler request I constrain a generic type parameter’s lifetime (error E0309)?

Leave a Comment