Rust / impl

Bienvenidos sean a este post, hoy hablaremos sobre la implementacion en el lenguaje.

Como dijimos esta instruccion es una implementacion de alguna funcionalidad para un tipo, tambien se lo puede considerar como una funcion dentro de una funcion, cuando hablamos de implementaciones (impl) inherentes estan son independientes, en cambio cuando son implementaciones de trait pueden ser para implementar trait en otros tipos o inclusivo en otros trait, veamos como es su sintaxis:

impl nombre
{
	fn funcion (&self) ...
}

Siempre comienza con impl seguido del nombre que lo identifica donde luego tendremos una funcion relacionada a esta implementacion, recuerdan que en este post hablamos sobre unit-like struct, un struct sin ningun elemento en su interior, para poder implementar elementos en este tipo de struct usaremos a impl, si en las funciones tomamos como primer argumento a:

• self
• &self
• &mut self

Esto nos permitira poder llamar a traves de la sintaxis llamada de metodo, Foo::bar, para los impl tambien podemos usar a los genericos que vimos en este post de la siguiente forma:

impl <T> nombre<T>
{
	fn funcion (&self) ...
}

Esto es para indicarle que nuestras implementaciones seran de tipo genericas, y como para finalizar con la teoria tambien podemos implementar ciclos de vida a las implementaciones:

impl <'T> miFuncion<'T>(a: &'T as i32) { ... }

Volvemos a usar el operador de ciclos de vida y debemos pasarlo tanto en el impl como en la funcion para indicar que lo usaremos como tal, y en la funcion lo usamos para indicarlo que lo usaremos internamente, hasta aqui tenemos toda la teoria pero vamos a implementarlo (nunca mejor dicho) en un ejemplo.

Para ello crearemos un nuevo ejemplo que llamaremos implemento, una vez generado iremos al archivo main.rs y modificaremos el codigo creado automaticamente por el siguiente:

main.rs

struct Par
{
	x: f64,
	y: u64
}

impl Par
{
	fn mostrar(&self)
	{
		println!("x = {}, y = {}", self.x, self.y);
	}
}

fn main() 
{
	let par = Par { x: 3.14, y: 3 };
	par.mostrar();
}

Primero definiremos un struct que poseera dos campos (x e y), luego tenemos una implementacion donde le pasaremos el mismo nombre que el struct para que el codigo sepa que esta implementacion es para ese struct, dentro de esta implementacion tenemos una funcion llamada mostrar que tiene como argumento al self, esto nos servira para poder acceder a los valores del struct, dentro de la funcion usamos un println para mostrar los valores de x e y, luego en el main solo tenemos un objeto creado del struct al cual le pasamos los valores para los dos objetos y lo siguiente sera llamar al metodo mostrar del objeto anteriormente creado, compilemos y veamos su salida:

tinchicus@dbn001vrt:~/lenguajes/rust/implemento$ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.02s
     Running `target/debug/implemento`
x = 3.14, y = 3
tinchicus@dbn001vrt:~/lenguajes/rust/implemento$

Como pueden ver funciono perfectamente, obviamente esta es la implementacion mas basica de impl pero en los proximos posts iremos agregando mas elementos para poder utilizarlo de una forma mas compleja.

En resumen, hoy hemos visto impl, que es, para que sirve, como nos beneficia, como nos permite una mejor flexibilidad, sus distintas formas de utilizarlo y por ultimo un ejemplo simple para poder verlo en accion, espero les haya sido de utilidad sigueme en tumblr, Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.