Rust / Primer crate

Bienvenidos sean a este post, hoy crearmos nuestro primer crate.

En el post anterior vimos una descripcion basica de que es un crate, a que equivale en otros lenguajes y como podemos crearlo, dijimos que en lugar de tener un archivo main.rs sera uno llamado lib.rs, tambien las distintas formas que podemos implementarlo, hoy nos centraremos en ver como crear nuestro primer crate y como poder utilizarlo, para esto utilizaremos un viejo proyecto de mi blog creado para C++ pero lo adaptaremos a Rust, primero vamos a crear el crate con el siguiente comando:

$ cargo new convlib --lib

Una vez creada nuestra libreria o crate iremos al directorio src donde crearemos tres nuevos archivos:

• longitud.rs
• masa.rs
• volumen.rs

Estos archivos se encargaran de almacenar las distintas funciones que dispondremos para poder hacer todas las conversiones que dispondremos, comencemos con el primer archivo donde agregaremos el siguiente codigo:

longitud.rs

pub fn cm_a_in(c: f32) -> String
{
	let m: f32 = c / 2.54f32;
	format!("{}cm equivale a {}in", c, m)
}

pub fn km_a_ml(k: f32) -> String
{
	let m: f32 = k / 1.61f32;
	format!("{}km equivale a {}ml", k, m)
}

pub fn in_a_cm(i: f32) -> String
{
	let m: f32 = i * 2.54f32;
	format!("{}in equivale a {}cm", i, m)
}

pub fn ml_a_km(m: f32) -> String
{
        let n: f32 = m / 1.61f32;
        format!("{}km equivale a {}ml", m, n)
}

Este modulo se encargara de contener las funciones para hacer conversiones de longitud, si recuerdan cuando trabajamos con multiples archivos en este post mencionamos que debemos usar la palabra pub para que definirlos como publicos y se pueda acceder a las funciones, struct, etc, para este caso lo volvemos a usar para no tener errores al momento de compilarlo, en estas funciones basicamente convertiremos los cm (centimetros) a in (pulgadas) y de km (kilometros) a ml (millas), tambien en sentido contrario, todas las funciones son muy similares por lo tanto explicaremos una sola:

pub fn cm_a_in(c: f32) -> String
{
	let m: f32 = c / 2.54f32;
	format!("{}cm equivale a {}in", c, m)
}

Aprovechando lo que vimos en este post haremos lo mismo, es decir que recibiremos un tipo de dato pero devolveremos uno de tipo String, para ello recibiremos un dato de tipo f32, dentro del bloque definiremos una variable que sera tambien de tipo f32 donde emplearemos la formula que se encarga de convertir el valor informado en cm a pulgadas, lo siguiente sera usar un format para devolver un valor de tipo String donde enviaremos un mensaje con el dato recibido y el obtenido con la conversion, el resto son basicamente lo mismo pero para las operaciones comentadas anteriormente, si observan la unica diferencia es para las funciones de in a cm y de ml a km donde en lugar de dividir usamos la multiplicacion pero estructuralmente son todas iguales, pasemos al archivo volumen.rs y agreguemos el siguiente codigo:

volumen.rs

pub fn li_a_gl(l: f32) -> String
{
	let m: f32 = l / 4.55f32;
	format!("{} litros equivale a {} galones", l, m)
}

pub fn gl_a_li(g: f32) -> String
{
	let m: f32 = g * 4.55f32;
	format!("{} galones equivale a {} litros", g, m)
}

pub fn pt_a_li(p: f32) -> String
{
        let m: f32 = p * 0.557f32;
        format!("{} pintas equivale a {} litros", p, m)
}

Como pueden ver son tres funciones exactamente iguales a las del otro archivo pero estas estaran mas orientadas a otro tipo de conversion, esta nos permitira convertir de litros a galones, de galones a litros y por ultimo la mas importante de todas como es de pintas (si es una medida del sistema britanico) a litros, por lo tanto si queres conocer cuantos litros tomaste en base a la cantidad de pintas con esta simple funcion podras enterarte, de nada 😄, con esto debemos pasar al ultimo archivo, masa.rs, y le agregaremos el siguiente codigo:

masa.rs

pub fn kg_a_lb(k: f32) -> String
{
	let m: f32 = k / 0.45f32;
	format!("{}kg equivale a {}lb", k, m)
}

pub fn lb_a_kg(l: f32) -> String
{
	let m: f32 = l * 0.45f32;
	format!("{}lb equivale a {}kg", l, m)
}

Volvemos a utilizar funciones iguales a las anteriores pero esta vez las usaremos para convertir kg (kilogramos) a lb (libras) y viceversa, con esto tenemos nuestras funciones para poder hacer distintos tipos de conversiones de unidades metricas, solo nos resta agregar el siguiente codigo en lib.rs:

lib.rs

pub mod longitud;
pub mod volumen;
pub mod masa;

Simplemente establecemos los tres modulos que tendremos disponibles en la libreria, recuerden dos cosas:

• El nombre que pasemos debe coincidir con el archivo sin la extension
• Deben usar el pub para que pueda ser accesible desde afuera

Por ultimo veamos como es la estructura de nuestra libreria:

.
├── Cargo.lock
├── Cargo.toml
└── src
    ├── lib.rs
    ├── longitud.rs
    ├── masa.rs
    └── volumen.rs

A diferencia de los codigos que estuvimos trabajando hasta ahora para compilarlo solo podemos usar:

$ cargo build

Con esto lo compilaran y crearan la libreria que podemos utilizar en otros codigos, veamos como es nuestra nueva estructura:

.
├── Cargo.lock
├── Cargo.toml
├── src
│   ├── lib.rs
│   ├── longitud.rs
│   ├── masa.rs
│   └── volumen.rs
└── target
    ├── CACHEDIR.TAG
    └── debug
        ├── build
        ├── deps
        │   ├── convlib-5a9fdc27ccfdd263.d
        │   ├── libconvlib-5a9fdc27ccfdd263.rlib
        │   └── libconvlib-5a9fdc27ccfdd263.rmeta
        ├── examples
        ├── incremental
        │   └── convlib-1etv48xilgea8
        │       ├── s-g92wcdv0j9-br2mxo-1rao1repr0ics
        │       │   ├── 1noivpov7d9f6074.o
        │       │   ├── 27zdxeh4fzyeq63q.o
        │       │   ├── 2khlx0lqcsgm4qwt.o
        │       │   ├── 4lbby1py7n439j5o.o
        │       │   ├── dep-graph.bin
        │       │   ├── nijse1aqr4um64l.o
        │       │   ├── query-cache.bin
        │       │   └── work-products.bin
        │       └── s-g92wcdv0j9-br2mxo.lock
        ├── libconvlib.d
        └── libconvlib.rlib

Con esto ya tenemos disponible a nuestra nueva dependencia y la tendremos disponibles para nuestros futuros proyectos pero eso lo veremos en el proximo post.

En resumen, hoy hemos visto como podemos crear un crate, hemos utilizado una de las estructuras que hemos visto en el post anterior, hemos analizado su codigo y tambien hemos visto su estructura antes y despues de compilado, 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.