Início / coding / Perguntas / 78947381
Accepted
Aleksander Krauze
Asked: 2024-09-04 15:41:07 +0800 CST

Alterar impl Trait para genérico no argumento da função pode ser uma alteração drástica?

  • 772

É possível que mudar o tipo de argumento de função de impl Traitpara genérico seja uma mudança drástica? A Rust Reference afirma que:

Nota: Para parâmetros de função, parâmetros de tipo genérico e impl Traitnão são exatamente equivalentes. Com um parâmetro genérico como <T: Trait>, o chamador tem a opção de especificar explicitamente o argumento genérico para Tno site da chamada usando GenericArgs , por exemplo, foo::<usize>(1). Se impl Traitfor o tipo de qualquer parâmetro de função, então o chamador não pode fornecer nenhum argumento genérico ao chamar essa função. Isso inclui argumentos genéricos para o tipo de retorno ou quaisquer genéricos const.

Portanto, alterar a assinatura da função de uma para outra pode constituir uma alteração drástica para os chamadores de uma função.

Mas dado que, se houver pelo menos um impl Traitparâmetro, então o chamador não pode nomear nenhum argumento genérico, isso não deveria implicar que mudar impl Traitpara <T: Trait>can somente permite que os chamadores nomeiem argumentos genéricos? Como os genéricos já foram inferidos, não podemos também quebrar a inferência de tipo.

EDIT: Eu presumo que cada um impl Traité alterado para um tipo genérico diferente e únicoimpl Trait (sem sobreposição com outros s ou genéricos anteriores). Violar isso seria obviamente quebrar, obrigado a @啊鹿Dizzyi por apontar isso.

Listo aqui uma lista de casos (que acredito ser exaustiva) onde impl Traité alterado para um genérico. Se algum deles puder quebrar downstream, por favor mostre como. E se eu perdi algum caso, por favor explique se ele está quebrando.

  1. Mudando apenasimpl Trait
// before
pub fn foo(_: impl Trait) {}

// after
pub fn foo<T: Trait>(_: T) {}
  1. Muitos impl Trait, mas mudando apenas alguns deles
// before
pub fn foo(_: impl Trait1, _: impl Trait2, _: impl Trait3) {}

// after
pub fn foo<T1: Trait1, T2: Trait2>(_: T1, _: T2, _: impl Trait3) {}
  1. Muitos impl Trait, mudando todos eles
// before
pub fn foo(_: impl Trait1, _: impl Trait2, _: impl Trait3) {}

// after
pub fn foo<T1: Trait1, T2: Trait2, T3: Trait3>(_: T1, _: T2, _: T3) {}
  1. Alguns tipos genéricos, alterando alguns impl Traits, mas deixando pelo menos um
// before
pub fn foo<T1: Trait1>(_: T1, _: impl Trait2, _: impl Trait3) {}

// after
pub fn foo<T1: Trait1, T2: Trait2>(_: T1, _: T2, _: impl Trait3) {}
  1. Alguns tipos genéricos, alterando todos os impl Traits
// before
pub fn foo<T1: Trait1>(_: T1, _: impl Trait2, _: impl Trait3) {}

// after
pub fn foo<T1: Trait1, T2: Trait2, T3: Trait3>(_: T1, _: T2, _: T3) {}
rust

2 respostas

  1. Um dos casos em que isso acontece é quando você quer que a função receba dois argumentos que implementam alguma característica, Traitmas você não se importa se dois dos argumentos são do mesmo tipo ou não.

    Já que quando você define um tipo genérico T, todas as aparências são vinculadas a esse mesmo tipo. E causará erro, portanto, você precisará ter cuidado ao alterar.

    Exemplo

    trait Trait {}

fn foo_impl(_: impl Trait, _: impl Trait) {}
fn foo_generic<T: Trait>(_: T, _: T) {}
fn foo_generic_ok<T1: Trait, T2: Trait>(_: T1, _: T2) {}

impl Trait for i32 {}
impl Trait for f32 {}

fn main() {
    foo_impl(1, 1.0);
    foo_generic(1, 1.0); // <-- this will error
    foo_generic_ok(1, 1.0);
}

    Mensagem de erro

    error[E0308]: mismatched types
  --> ****\src/main.rs:12:20
   |
12 |     foo_generic(1, 1.0);
   |     ----------- -  ^^^ expected `i32`, found floating-point number
   |     |           |
   |     |           expected all arguments to be this `i32` type because they need to match the type of this parameter
   |     arguments to this function are incorrect
   |
note: function defined here
  --> ****\src/main.rs:4:4
   |
4  | fn foo_generic<T: Trait>(_: T, _: T) {}
   |    ^^^^^^^^^^^ -         ----  ---- this parameter needs to match the `i32` type of {unknown}
   |                |         |
   |                |         {unknown} needs to match the `i32` type of this parameter
   |                {unknown} and {unknown} all reference this parameter T

For more information about this error, try `rustc --explain E0308`.
    • 1
  2. Best Answer

    Recentemente editei esta parte da referência, pois estava desatualizada. Você pode ver a atualização na versão noturna (deve atingir a estabilidade amanhã, 5 de setembro).

    Resumindo, 1.63.0 adicionou a possibilidade de especificar genéricos quando impl Traitpresente. Até onde eu sei, você está certo de que não poderia ser uma mudança de quebra. Desde 1.63.0, pode ser uma mudança de quebra se houver pelo menos um genérico existente.

    A versão longa está em PR #1495 .

    • 1

relate perguntas