在迭代中使用 Rust 中的通用 From-Trait

Question

I try to write a simple postgres(=0.19.0) query function, which converts the Row to the Type which I need.

When I use a non generic Type it works without compile errors:

#[derive(Clone, Debug)]
struct Entry {
  id: u32,
  value: u32,
}

impl<'a> From<&'a Row> for Entry {
  fn from(row: &'a Row) -> Self {
    Entry {
      id: row.get(0),
      value: row.get(1),
    }
  }
}

fn query<'a, T: FromSql<'a>>(client: &mut Client, query_str: &str, params: &[&(dyn ToSql + Sync)]) -> Vec<Entry>  {
  client.query(query_str, params)
    .map(|rows| {
      rows
        .iter()
        .map(|r| {
          Entry::from(r)
        })
        .collect()
    })
    .unwrap_or(vec![] as Vec<Entry>)
}

When I try to convert the same logic in a generic way, I get a compile error.

fn query<'a, T: From<&'a Row>>(client: &mut Client, query_str: &str, params: &[&(dyn ToSql + Sync)]) -> Vec<T>  {
  let rows = client.query(query_str, params)
    .unwrap_or(vec![] as Vec<Row>);
  rows
    .iter()
    .map(|r: &'a Row| {
      T::from(r)
    })
    .collect()
}

I would say that the logic is equal and I can't see differences, but something isn't correct defined with the lifetime.

Did I missed a Trait or something like that?

    |
238 | fn query<'a, T: From<&'a Row>>(client: &mut Client, query_str: &str, params: &[&(dyn ToSql + Sync)]) -> Vec<T> {
    |          -- lifetime `'a` defined here
...
241 |       rows
    |       ^^^^ borrowed value does not live long enough
...
244 |           T::from(r)
    |           ---------- argument requires that `rows` is borrowed for `'a`
...
247 |     })
    |     - `rows` dropped here while still borrowed

Edit:

I simplified the code to this example, perhaps it is more helpful.

fn convert<'a, T: From<&'a abc>>() -> Vec<T> {
    let abcs = vec![abc::new(), abc::new(), abc::new(), abc::new()];
    abcs
        .iter()
        .map(|f| {
            T::from(f)
        })
        .collect()
}

And here is the error:

error[E0597]: `abcs` does not live long enough
  --> src/main.rs:43:5
   |
41 | fn convert<'a, T: From<&'a abc>>() -> Vec<T> {
   |            -- lifetime `'a` defined here
42 |     let abcs = vec![abc::new(), abc::new(), abc::new(), abc::new()];
43 |     abcs
   |     ^^^^ borrowed value does not live long enough
...
46 |             T::from(f)
   |             ---------- argument requires that `abcs` is borrowed for `'a`
...
49 | }
   | - `abcs` dropped here while still borrowed

Answer 1

what you are looking for is called a "Higher-Rank Trait Bound". (see here )

for<'a> can be read as "for all choices of 'a", and basically produces an infinite list of trait bounds that F must satisfy

this seems to be what you want, as you can specify a lifetime that is "smaller" than the lifetime of convert . in your example this would look like:

fn convert< T: for<'a> From<&'a abc>>() -> Vec<T> {
    let abcs = vec![abc::new(), abc::new(), abc::new(), abc::new()];
    abcs
        .iter()
        .map(|f| {
            T::from(f)
        })
        .collect()
}

Answer 2

I've been trying to figure out the problem, but I can't. Have you tried looking for any spelling errors? I don't understand the code, but the reason I'm giving you an answer is because my friend might understand it. Ok, so he says you might have missed a Trait, but he can't tell which one or what the problem is. He suggests to look over it, I've forgot to add code to my programs before, and misspelled stuff. Looking over my code almost always helps me.

Answer 3

When you specify

fn convert<'a, T: From<&'a abc>>() -> Vec<T>

you are basically asserting that T implements From<&abc> only for those abc references that have a lifetime that outlives the function.

You may assume you function as having the following implicit lifetimes (here expressed in pseudocode):

fn convert<'a, T: From<&'a abc>>() -> Vec<T> {
    'b : {
        let abcs = vec![abc::new(), abc::new(), abc::new(), abc::new()];
        abcs
            .iter()
            .map(|f| {
                T::from(f)
            })
            .collect()
    }
}

abcs belongs to an implicit lifetime "'b" that's smaller than 'a , and thus a reference to one of its elements can't satisfy From<&'a abc>> . Given that you have to specify the lifetime when you constrain T: From<&'a abc> , there is no easy way out of this.

It makes sense for the compiler to reject this code because there's no way for it to ensure that From::from from T: From<&'a abc> won't generate a T that doesn't hold the reference it has been created from.

Something like the following would also be accepted by your function

struct X<'a> {
    r: &' abc
}

impl <'a> From<&'a abc> for X<'a> {
    fn from(r: &'a abc) -> Self {
        Self { r }
    }
}

but it would be broken due to convert returning a Vec<X> that contains references to local instances of abc .