Rust Genéricos y Traits
Los genéricos son un mecanismo indispensable en los lenguajes de programación.
En C++ se utilizan "plantillas" para implementar genéricos, mientras que en C no existe un mecanismo de genéricos, lo que dificulta la construcción de proyectos con tipos complejos en C.
El mecanismo de genéricos es un mecanismo que usan los lenguajes de programación para expresar abstracción de tipos. Generalmente se usa para clases con funcionalidad definida pero tipo de datos pendiente, como listas enlazadas, tablas de mapeo, etc.
Definir genéricos en funciones
Este es un método de ordenamiento por selección para números enteros:
Ejemplo
let mut max_index = 0;
let mut i = 1;
while i < array.len() {
if array[i] > array[max_index] {
max_index = i;
}
i += 1;
}
array[max_index]
}
fn main() {
let a = [2, 4, 6, 3, 1];
println!("max = {}", max(&a));
}
Resultado de ejecución:
max = 6
Este es un programa simple para obtener el valor máximo, que puede procesar datos del tipo numérico i32, pero no puede usarse para datos del tipo f64. Mediante el uso de genéricos podemos hacer que esta función pueda utilizarse en varios tipos. Pero en realidad no todos los tipos de datos pueden compararse por tamaño, por lo que el siguiente fragmento de código no está destinado a ejecutarse, sino a describir la sintaxis de los genéricos en funciones:
Ejemplo
let mut max_index = 0;
let mut i = 1;
while i < array.len() {
if array[i] > array[max_index] {
max_index = i;
}
i += 1;
}
array[max_index]
}
Genéricos en estructuras y enumeraciones
Los enums Option y Result que aprendimos anteriormente son genéricos.
Tanto las estructuras como los enums en Rust pueden implementar el mecanismo de genéricos.
struct Point<T> {
x: T,
y: T
}Esta es una estructura de coordenadas de punto; T representa el tipo numérico que describe las coordenadas del punto. Podemos usarla así:
let p1 = Point {x: 1, y: 2};
let p2 = Point {x: 1.0, y: 2.0};Al usarla no se declara el tipo; aquí se utiliza el mecanismo de inferencia automática de tipos, pero no se permiten casos de tipos incompatibles como el siguiente:
let p = Point {x: 1, y: 2.0};Cuando x se vincula con 1, T ya se establece como i32, por lo que no se permite la aparición de un tipo f64. Si queremos que x e y se representen con diferentes tipos de datos, podemos usar dos identificadores genéricos:
struct Point<T1, T2> {
x: T1,
y: T2
}La forma de expresar genéricos en los enums es como Option y Result:
enum Option<T> {
Some(T),
None,
}
enum Result<T, E> {
Ok(T),
Err(E),
}Tanto las estructuras como los enums pueden definir métodos, por lo que los métodos también deberían implementar el mecanismo de genéricos; de lo contrario, las clases genéricas no podrían ser operadas eficazmente por métodos.
Ejemplo
x: T,
y: T,
}
impl<T> Point<T> {
fn x(&self) -> &T {
&self.x
}
}
fn main() {
let p = Point { x: 1, y: 2 };
println!("p.x = {}", p.x());
}
Resultado de ejecución:
p.x = 1
Nota: después de la palabra clave impl debe haber<T>, porque la T que le sigue se basa en ella. Pero también podemos agregar métodos para uno de los tipos genéricos:
impl Point<f64> {
fn x(&self) -> f64 {
self.x
}
}Los genéricos del propio bloque impl no impiden que sus métodos internos tengan capacidad genérica:impl<T, U> Point<T, U> {
fn mixup<V, W>(self, other: Point<V, W>) -> Point<T, W> {
Point {
x: self.x,
y: other.y,
}
}
}El método mixup fusiona la x de un punto Point<T, U> con la y de un punto Point<V, W> para crear un nuevo punto del tipo Point<T, W>.
Traits
El concepto de trait es similar al de interfaz (Interface) en Java, pero no son completamente iguales. Lo que tienen en común los traits y las interfaces es que ambos son una especificación de comportamiento que puede usarse para identificar qué clases tienen qué métodos.
Los traits se representan con la palabra clave trait en Rust:
trait Descriptive {
fn describe(&self) -> String;
}
Descriptive especifica que quien lo implemente debe tenerdescribe(&self) -> Stringmétodo.
Lo usamos para implementar una estructura:
Ejemplo
name: String,
age: u8
}
impl Descriptive for Person {
fn describe(&self) -> String {
format!("{} {}", self.name, self.age)
}
}
El formato es:
impl <特性名> for <所实现的类型名>
En Rust, una misma clase puede implementar múltiples traits, pero cada bloque impl solo puede implementar uno.
Traits por defecto
Esta es la diferencia entre traits e interfaces: las interfaces solo pueden especificar métodos, no definirlos, pero los traits pueden definir métodos como métodos predeterminados. Como son "predeterminados", los objetos pueden redefinir los métodos o no hacerlo y usar los métodos predeterminados:
Ejemplo
fn describe(&self) -> String {
String::from("[Object]")
}
}
struct Person {
name: String,
age: u8
}
impl Descriptive for Person {
fn describe(&self) -> String {
format!("{} {}", self.name, self.age)
}
}
fn main() {
let cali = Person {
name: String::from("Cali"),
age: 24
};
println!("{}", cali.describe());
}
Resultado de ejecución:
Cali 24
Si quitamos el contenido del bloque impl Descriptive for Person, el resultado de ejecución será:
[Object]
Traits como parámetros
En muchos casos necesitamos pasar una función como parámetro, por ejemplo, funciones de devolución de llamada, configuración de eventos de botón, etc. En Java, una función debe pasarse como una instancia de una clase que implemente una interfaz; en Rust, esto se puede lograr pasando un parámetro de trait:
fn output(object: impl Descriptive) {
println!("{}", object.describe());
}
Cualquier objeto que implemente el trait Descriptive puede usarse como parámetro de esta función. La función no necesita saber si el objeto pasado tiene otras propiedades o métodos; solo necesita saber que tiene los métodos especificados por el trait Descriptive. Por supuesto, esta función tampoco puede usar otras propiedades y métodos.
Los parámetros de traits también se pueden implementar con esta sintaxis equivalente:
fn output<T: Descriptive>(object: T) {
println!("{}", object.describe());
}Esto es azúcar sintáctico con un estilo similar a los genéricos, y resulta muy útil cuando varios tipos de parámetros son traits:
fn output_two<T: Descriptive>(arg1: T, arg2: T) {
println!("{}", arg1.describe());
println!("{}", arg2.describe());
}
Cuando un trait se usa como tipo y están involucrados múltiples traits, se puede usar el símbolo+para representarlo, por ejemplo:
fn notify(item: impl Summary + Display) fn notify<T: Summary + Display>(item: T)
Nota:Solo se usa al representar tipos; no significa que se pueda usar en un bloque impl.
Las relaciones de implementación complejas se pueden simplificar con la palabra clave where, por ejemplo:
fn some_function<T: Display + Clone, U: Clone + Debug>(t: T, u: U)
Se puede simplificar a:
fn some_function<T, U>(t: T, u: U) -> i32
where T: Display + Clone,
U: Clone + Debug
Después de conocer esta sintaxis, el caso de "obtener el valor máximo" del capítulo de genéricos puede implementarse realmente:
Ejemplo
fn compare(&self, object: &Self) -> i8;
}
fn max<T: Comparable>(array: &[T]) -> &T {
let mut max_index = 0;
let mut i = 1;
while i < array.len() {
if array[i].compare(&array[max_index]) > 0 {
max_index = i;
}
i += 1;
}
&array[max_index]
}
impl Comparable for f64 {
fn compare(&self, object: &f64) -> i8 {
if &self > &object { 1 }
else if &self == &object { 0 }
else { -1 }
}
}
fn main() {
let arr = [1.0, 3.0, 5.0, 4.0, 2.0];
println!("maximum of arr is {}", max(&arr));
}
Resultado de ejecución:
maximum of arr is 5
Tip:Dado que es necesario declarar que el segundo parámetro de la función compare debe ser del mismo tipo que el tipo que implementa el trait, la palabra clave Self (nótese las mayúsculas) representa el tipo actual en sí (no la instancia).
Traits como valor de retorno
El formato de un trait como valor de retorno es el siguiente:
Ejemplo
Person {
name: String::from("Cali"),
age: 24
}
}
Pero hay un detalle: un trait como valor de retorno solo acepta objetos que implementen dicho trait como valor de retorno, y todos los posibles tipos de retorno en la misma función deben ser exactamente iguales. Por ejemplo, si la estructura A y la estructura B implementan ambas el trait Trait, la siguiente función sería incorrecta:
Ejemplo
if bl {
return A {};
} else {
return B {};
}
}
Implementación condicional de métodos
La funcionalidad de impl es muy poderosa; podemos usarla para implementar métodos de una clase. Pero para las clases genéricas, a veces necesitamos distinguir qué métodos ya ha implementado el tipo genérico al que pertenece para decidir qué métodos debe implementar a continuación:
struct A<T> {}
impl<T: B + C> A<T> {
fn d(&self) {}
}Este código declara que el tipo A<T> solo puede implementar válidamente este bloque impl si T ya ha implementado los traits B y C.
Otras extensiones