Siguiendo con Rust y su implementación a conceptos de orientación a objetos, veamos como implementa polimorfismo sin el concepto de herencia tradicional, sino con traits.
La documentación oficial de Rust explica el polimorfismo en Rust con un ejemplo. Crea una herramienta de interfaz gráfica de usuario (GUI) de ejemplo que recorre una lista de elementos, llamando a un método de dibujo. Este metodo puede dibujar diferentes tipos como Button o TextField.
No implementaremos una biblioteca GUI completa para este ejemplo, pero mostraremos cómo encajarían las piezas. En el momento de escribir la biblioteca, no podemos conocer ni definir todos los tipos que otros programadores podrían querer crear. Pero sabemos que la interfaz gráfica de usuario necesita realizar un seguimiento de muchos valores de diferentes tipos, y necesita llamar a un método de dibujo en cada uno de estos valores con tipos diferentes. No necesita saber exactamente qué sucederá cuando llamemos al método de dibujo, solo que el valor tendrá ese método disponible para que lo llamemos.
Para hacer esto en un lenguaje con herencia, podríamos definir una clase llamada Componente que tenga un método llamado dibujar. Las otras clases, como Button, Image y SelectBox, heredarían de Component y, por lo tanto, heredarían el método de dibujo. Cada uno podría redefinir el método de dibujo para definir su comportamiento personalizado, y la ventana podría tratar todos los tipos como si fueran instancias de componentes y llamar a dibujar sobre ellos. Pero debido a que Rust no tiene herencia, necesitamos otra forma de estructurar la biblioteca de interfaz gráfica.
Para implementar el comportamiento que queremos que tenga la interfaz gráfica de usuario, definiremos un traits llamado Dibujar que tendrá un método llamado dibujar:
pub trait Draw {
fn draw(&self);
}
Ahora definimos la ventana que tiene que ser capaz de dibujar diferentes tipos de componentes. Para eso la ventana va tener un vector de componentes. Y definimos un componente como una caja o Box que contiene un tipo dinámico que implementa el trait Draw :
pub struct Screen {
pub components: Vec<Box<dyn Draw>>,
}
Recordemos que en Rust la definición de un "objeto" esta dividida en sus datos y sus métodos. Ahora definamos los métodos:
impl Screen {
pub fn run(&self) {
for component in self.components.iter() {
component.draw();
}
}
}
Alguien atento, podria decir porque no utilizamos genericos con ventana de este modo :
pub struct Screen<T: Draw> {
pub components: Vec<T>,
}
impl<T> Screen<T>
where
T: Draw,
{
pub fn run(&self) {
for component in self.components.iter() {
component.draw();
}
}
}
Pero el problema aquí es que no se va a poder utilizar Screen con diferentes componentes. Si tipamos a Screen con Button por ejemplo, solo va poder tener Buttons y no es lo que queremos. Hago esta aclaración porque con este contraejemplo se ve la función de la caja o Box, que es permitirnos diferentes componentes que implementan Draw.
Ahora agregaremos algunos tipos que implementan Draw:
pub struct Button {
pub width: u32,
pub height: u32,
pub label: String,
}
impl Draw for Button {
fn draw(&self) {
// code to actually draw a button
}
}
//------------------------------
struct SelectBox {
width: u32,
height: u32,
options: Vec<String>,
}
impl Draw for SelectBox {
fn draw(&self) {
// code to actually draw a select box
}
}
Y por último ver la magia en acción:
use gui::{Button, Screen};
fn main() {
let screen = Screen {
components: vec![
Box::new(SelectBox {
width: 75,
height: 10,
options: vec![
String::from("Yes"),
String::from("Maybe"),
String::from("No"),
],
}),
Box::new(Button {
width: 50,
height: 10,
label: String::from("OK"),
}),
],
};
screen.run();
}
Como vemos llamamos a run de screen que llamará a draw.
Al especificar Box <dyn Draw> como el tipo de valores en el vector de componentes, hemos definido que Screen pueda aceptar diferentes tipos en dibujar pero todos deben implementar Draw sino tirra error en tiempo de compilación:
use gui::Screen;
fn main() {
let screen = Screen {
components: vec![Box::new(String::from("Hi"))],
};
screen.run();
}
Esto no compila porque String no es un Draw :
$ cargo run
Compiling gui v0.1.0 (file:///projects/gui)
error[E0277]: the trait bound `std::string::String: gui::Draw` is not satisfied
--> src/main.rs:5:26
|
5 | components: vec![Box::new(String::from("Hi"))],
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `gui::Draw` is not implemented for `std::string::String`
|
= note: required for the cast to the object type `dyn gui::Draw`
error: aborting due to previous error
For more information about this error, try `rustc --explain E0277`.
error: could not compile `gui`.
To learn more, run the command again with --verbose.
Dejo link:
https://doc.rust-lang.org/book/ch17-02-trait-objects.html
