Compreendendo os tipos genéricos de Rust

Sempre há níveis de incerteza durante o desenvolvimento de aplicativos, o que pode levar a erros, especialmente se suas funções aceitarem tipos específicos de argumentos. Para reduzir erros devido a incertezas, você pode usar Genéricos. Os genéricos fornecem funcionalidade para criar classes, funções e estruturas de dados para trabalhar com diferentes tipos.

Usando genéricos, você pode criar e definir algoritmos e estruturas de dados que podem operar em vários tipos sem escrever código complexo e implementações separadas para cada tipo. Os genéricos melhoram a reutilização e a eficiência do código, mantendo a segurança e o desempenho do tipo.

Usando tipos genéricos em Rust

O tipo genérico de Rust pode interoperar com outros tipos de dados Rust. Você definirá tipos genéricos com colchetes angulares (<>), seguidos por dois ou mais parâmetros.

Aqui está um genérico definição de estrutura que leva dois parâmetros de tipo genérico:

estruturaApontar {
// T e U são parâmetros de tipo genérico que os campos x e y irão 
// assume na instanciação
 x: T,
 e: U,
}

No Apontar estrutura, T, e você são parâmetros de tipo genérico.

Você pode substituir os parâmetros de tipo genérico por qualquer tipo de dados na instanciação:

fnprincipal() {
deixar meu_ponto = Ponto { x: Corda::de("olá"), você: Corda::de("mundo") };
println!(
"O valor x de my_point é {} e o valor y é {}.",
 meu_ponto.x,
 meu_ponto.y
 );
}

O meu ponto variável é uma instância do Apontar struct inicializado com tipos de string. O compilador Rust infere os tipos concretos de T e você com base nos valores na instanciação.

Limites de Traço para Tipos Genéricos

Os tipos genéricos Rust podem usar limites de características para garantir a segurança do tipo. As características são coleções de métodos que os tipos podem implementar para exibir determinados comportamentos definidos para a característica.

Os limites de característica especificam que um tipo genérico deve implementar uma ou mais características.

Aqui está um exemplo de uma função genérica que retorna o maior de dois valores com um limite de característica que garante que os tipos comparados implementem a característica:

// Máximo é uma característica que define um método para avaliar o máximo de dois
// tipos
característicaMáximo {
fnmáximo(auto, outro: Auto) -> Auto;
}
// Implementa o atributo `Maximum` para todos os tipos que implementam o
// característica `PartialOrd`.
implicarOrdem Parcial> Máximo para V {
fnmáximo(auto, outro: Auto) -> Auto {
// retorna `self` se for maior que `other`; caso contrário, volte
// `outros.`
seauto > outro {
auto
 } outro {
 outro
 }
 }
}
fnprincipal() {
deixar um = 5;
deixar b = 10;
deixar maior = Máximo:: max (a, b);
println!("O maior valor é {}", maior);
}

O Máximo traço tem um máximo método que retorna o maior de dois valores do mesmo tipo. Qualquer tipo que implemente o Ordem Parcial característica implementa o Máximo característica.

O máximo método leva dois valores do Auto tipo - referindo-se ao tipo que implementa o Máximo traço — e compara os valores.

O principal função compara duas variáveis ​​usando o método máximo método e imprime o maior.

Restrições para tipos genéricos

As restrições são semelhantes aos limites de característica, mas permitem especificar requisitos adicionais nos tipos que você está usando como parâmetros de tipo.

Se você deseja criar uma função genérica que aceita tipos para conversão de string, pode usar uma restrição para garantir que o parâmetro de tipo implemente uma característica.

// ToString é um trait com um método de conversão de string
característicaPara sequenciar {
fnpara sequenciar(&auto) -> Corda;
}
// to_string é uma função genérica que recebe um valor de qualquer tipo que
// implementa o atributo ToString
fnpara sequenciarPara sequenciar>(valor: T) -> Corda {
 value.to_string()
}

O para sequenciar O parâmetro de valor deve implementar o Para sequenciar trait, que garante que você pode converter valores do tipo T amarrar com o para sequenciar método.

Tipos genéricos são úteis para trabalhar com características

Os tipos genéricos de ferrugem são poderosos e há áreas para melhorias. Uma área crítica de foco é melhorar o desempenho do código genérico. Atualmente, o sistema de tipos do Rust pode impor sobrecarga no código genérico, diminuindo o desempenho.

Tipos genéricos são benéficos para trabalhar com características. Usando tipos genéricos, você pode criar objetos de característica que funcionam com qualquer tipo implementando uma característica para tornar seus métodos mais flexíveis.