Início / coding / Perguntas / 79450222
Accepted
Lingxuan Ye
Asked: 2025-02-19 12:57:05 +0800 CST

Existe uma maneira de limitar `U` em `Fn(&T) -> U` com o tempo de vida que `&T` tem quando `U` é uma referência?

  • 772

Aqui está o código:

fn main() {
    let foo: Foo<i32> = Foo(42);
    let bar: Foo<i64> = foo.map_ref(|x| *x as i64); // OK
    let baz: Foo<&i32> = foo.map_ref(|x| x); // Error
}

struct Foo<T>(T);

impl<T> Foo<T> {
    fn map_ref<U, F>(&self, f: F) -> Foo<U>
    where
        F: Fn(&T) -> U,
    {
        Foo(f(&self.0))
    }
}

Falha ao compilar quando Ué referência:

error: lifetime may not live long enough
 --> src\main.rs:4:48
  |
4 |     let baz: Foo<&i32> = foo.map_ref(|x: &i32| x); // Error
  |                                          -   - ^ returning this value requires that `'1` must outlive `'2`
  |                                          |   |
  |                                          |   return type of closure is &'2 i32
  |                                          let's call the lifetime of this reference `'1`
  |
help: dereference the return value
  |
4 |     let baz: Foo<&i32> = foo.map_ref(|x: &i32| *x); // Error
  |                                                +

Tentei introduzir um tempo de vida genérico 'ae Foo::map_refnão tenho ideia do que fazer a seguir.

rust

1 respostas

  1. Best Answer

    Para este exemplo simples, você nem precisa anotar U. Em vez disso, você pode ajudar o compilador esclarecendo que o tempo de vida do Fparâmetro 's deve ser/será pelo menos tão longo quanto a referência a self:

    impl<T> Foo<T> {
    fn map_ref<'a, U, F>(&'a self, f: F) -> Foo<U>
    where
        F: Fn(&'a T) -> U,
    {
        Foo(f(&self.0))
    }
}

    Quando você chama foo.map_ref(f), o que realmente acontece por baixo dos panos é Foo::<T>::map_ref(&foo, f): chamar um método cria uma referência ao objeto no qual o método é chamado. Então agora, quando chamamos map_refe damos a ele um closure, o closure recebe um parâmetro cujo tempo de vida é o mesmo comprimento que o implicitamente criado &foo.

    Veja aqui no Rust Playground . Espero que isso responda à sua pergunta. :-)

    EDIT: Em resposta ao seu comentário sobre o HRTB : sim, você está absolutamente certo. Fé desaçucarado em for <'b> Fn(&'b T) -> U. Isso significa que o traço vinculado a Fse torna, " Fdeve ser uma função que pode ser chamada com uma referência de qualquer tempo de vida 'b." Ou, se quisermos usar os mesmos nomes da mensagem de erro, "qualquer tempo de vida '1. "

    Na verdade, você pode ver essa desaçucaração acontecer diretamente dentro do seu IDE usando o rust-analyzer, ativando as dicas de elisão de tempo de vida:

    O traço vinculado a F é anotado por uma dica embutida no VS Code, onde for<'1> aparece logo antes de Fn(&T) -> U. O parâmetro self de map_ref também é anotado com o tempo de vida '0.

    ( rust-analyzer.inlayHints.lifetimeElisionHints.enableno VS Code).

    Com isso em mente, vamos reanalisar a mensagem de erro que o compilador lhe deu:

    let baz: Foo<&i32> = foo.map_ref(|x: &i32| x); // Error
                                     -   - ^ returning this value requires that `'1` must outlive `'2`
                                     |   |
                                     |   return type of closure is &'2 i32
                                     let's call the lifetime of this reference `'1`

    Pessoalmente, acho a introdução de um segundo '2tempo de vida um pouco confusa ao considerar por que isso é um erro... mas isso sou só eu. A maneira como eu explicaria isso a alguém é dizendo, "você está tentando usar '1in no tipo de retorno do seu fechamento, o que força '1a aparecer em U; mas, de fora de map_ref, não há como saber quanto tempo '1é. fpoderia ter sido chamado com uma referência a uma variável local, pelo que sabemos!" Nesse caso, é como se estivéssemos pedindo ao compilador para "estender" o tempo de vida dessa variável local para que possamos manter um Foo<U>around apontando para ela. Obviamente, isso vai contra o sistema de descarte do Rust.

    A razão pela qual precisamos anotar 'aexplicitamente é simplesmente porque este exemplo está fora das regras de elisão de tempo de vida. Todas as referências precisam de um tempo de vida, é só que o compilador nos deixa pular a escrita delas às vezes, de acordo com algumas regras . FO parâmetro de . precisa de algo, mas o compilador não vai usar &selfo tempo de vida de automaticamente; fazer isso seria excessivamente conservador para a maioria dos casos de uso (já que fnow não pode ser chamado com uma referência a uma variável local, por exemplo).

    • 3

relate perguntas