Aprende Rust, el lenguaje más amado por la comunidad

Rust es el lenguaje de programación más amado de todos; según la encuesta de Stackoverflow 2021 y lo ha sido por más de 6 años consecutivos.

En esta serie de blogs sobre Rust hablaremos de sus características, sus ventajas, sus limitaciones y sobre todo haremos un par de proyectos que puedas usar como referencia y portafolio.

Hola soy Hector Pulido y soy fiel creyente que un lenguaje de programación no debe alterar la lógica que tenemos los desarrolladores de software, pero es que al ver a Rust me brillan los ojitos, quiero decir, es un lenguaje de programación con el poder de C++ pero con una filosofía parecida a la de Python 🤩.

¿Qué es Rust?

Rust es un lenguaje de programación relativamente nuevo, fue diseñado inicialmente por Graydon Hoare en Mozilla research por la lejana época de 2006, fue lanzado finalmente en 2010. Ha crecido mucho en la industria ahora mismo es muy utilizado en Microsoft, Discord, Platzi (💚) y otras empresas, además de proyectos como Deno, Exa, Tor ¡y mucho más!

Te contamos: cómo usar Discord

Aquí algunas razones para aprender Rust

1. Es un lenguaje enfocado en seguridad, velocidad y concurrencia, todo al mismo tiempo.
2. Es un lenguaje moderno que toma lo mejor de muchos otros lenguajes, como temas de la programación funcional de Haskell o F#, los tipos de datos de C, el manejo de la memoria de C++, manejo de errores de Erlang, etc.
3. Su ecosistema es extremadamente robusto y cuenta con uno de los mejores manejadores de paquetes de todos.
4. NO HAY GARBAGE COLLECTOR (inserte meme de “agradecido con el de arriba”).
5. Rust te OBLIGA a escribir tu código de tal manera que no hayan fugas de memoria y te obliga a que tu código siga las buenas prácticas.

Instalando Rust

Si te encuentras en windows:

1. Por favor revisa que tengas instalado Visual C++ Build Tools 2013 o superior
2. Puedes descargar e instalar la última version desde aqui: https://static.rust-lang.org/rustup/dist/i686-pc-windows-gnu/rustup-init.exe
3. Sigue las instrucciones y al terminar revisa que las variables de entorno estén correctamente seteadas en %USERPROFILE%\.cargo\bin

Linux, macOS y otros sistemas basados en Unix;

1. Corre este comando en tu shell curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
2. Sigue las instrucciones
3. Revisa que las variables de entorno estén correctamente seteadas en $HOME/.cargo/bin

Para revisar que tu instalación sea correcta puedes usar el comando rustc --version si obtienes algo como esto: “rustc 1.52.1 (9bc8c42bb 2021-05-09)” significa que puedes continuar.

Nuestro primer programa en Rust

1. Para crear un proyecto en Rust, hay varias formas, nosotros usaremos la mejor, para esto abre una consola en tu computador y escribe: cargo new mi_primer_programa_en_rust
2. Vas a encontrar una estructura parecida a esta:

 |- Cargo.toml
 |- src
 | |- main.rs
 |- .git
 | |- ...
 |- .gitignore

Cargo nos ha generado nuestro proyecto ¡que ya contiene un hola mundo!, si abrimos el archivo main.rs encontraremos lo siguiente:

fn main() {
    println!("Hello, world!");
}

Tal como parece, es un hola mundo en Rust, Si vienes de otros lenguajes notarás fácilmente el patrón, fn main es el nombre de la función inicial, en este caso no soporta parámetros y va con llaves.

println! es un macro, por ahora, digamos que un macro es como una función pero con esteroides, macro esta permite mostrar texto en pantalla, en este caso se escribe “Hello, world!”.

vamos a modificarlo un poco para introducir conceptos nuevos:

fn main() {
    let nombre: String = String::from("Juan");
    mostrar_nombre(nombre);
}

fn mostrar_nombre(nombre_entrada: String) {
    println!("Hello, {}!", nombre_entrada);
}

Tomate un segundo para identificar los cambios:

1. let nombre: String = ... es una variable, es decir, una caja en donde se puede guardar un valor de un tipo específico, en este caso una String con el valor “Juan”. Rust tiene muchos tipos, u8, u16, u32, u64, i8, i16, i32, i64, f32, f64, char, bool, String y varios más, en próximos posts los estaremos viendo.
2. String::from("Juan"); Es una función de la clase String que devuelve un String si le entregamos una cadena de caracteres.
3. Más adelante estamos definiendo una nueva función (ademas de main) fn mostrar_nombre(nombre_entrada: String) { esta función se llama mostrar_nombre y recibe como parámetro un String llamado nombre_entrada.
4. Esta función hace un llamado a println! que ya lo vimos antes, solamente que en este caso, println! no muestra simplemente “Hello, world!” si no que muestra la cadena “Hello,” ademas de el parámetro nombre_entrada.
5. llamamos a la función “mostrar_nombre” de esta forma mostrar_nombre(nombre);, recibe un parámetro, así que se lo ponemos dentro de los paréntesis.

Para ejecutar nuestro programa simplemente ve a la consola, escribe cargo run y presiona enter.

deberías ver algo parecido a esto:

   Compiling mi_primer_programa_en_rust v0.1.0 (/home/.../mi_primer_programa_en_rust)
    Finished dev [unoptimized + debuginfo] target(s) in 0.27s
     Running `target/debug/mi_primer_programa_en_rust`
Hello, Juan!

Antes de continuar te reto a cambiar el nombre de “Juan” por tu nombre (y si te llamas Juan pon otra cosa, te estoy vigilando…) y lo corras de nuevo.

¿Qué puedes hacer con Rust?

La comunidad de rust es muy activa y está muy pendiente de que que frameworks y librerías son creadas dia con dia, tienen este concepto de “Are we yet?” que son páginas webs en donde recopilan librerías de temas en específicas

1. ¿Es Rust apto para páginas webs? ¡Si! y es tremendamente rapido https://www.arewewebyet.org/
2. ¿Podemos hacer videojuegos? Más o menos, tenemos los bloques, trae tu propio pegamento https://arewegameyet.rs/
3. ¿Podemos hacer Machine learning? Hay mucha experimentacion en esta area http://www.arewelearningyet.com/

¿Subimos un poco el nivel? Reto para usar Rust

Quiero decirte que si no entendiste lo anterior no pasa nada, tenemos un curso totalmente gratuito en donde puedes aprender las bases de la programación, puedes empezar por ahí y luego seguir con este tutorial.

Vamos a hacer una calculadora, aprenderemos sobre operaciones matemáticas, I/0, paquetes de Rust y por supuesto, no podría ser un post mio sin un poco de ¡REGEX!.

Para buscar un paquete podemos irnos a crates.io encontrar el paquete que necesitemos, en este caso, regex.

Los paquetes suelen mostrar cómo instalarse, pero todos son muy parecidos, añadir al “Cargo.toml” la dependencia, regex = "1.5" en mi caso, quedaria asi.

[package]
name = "mi_primer_programa_en_rust"
version = "0.1.0"
....

[dependencies]
regex = "1.5"

Este es el código de una calculadora semántica, es decir; como las calculadoras científicas, en donde introduces una expresión y te devuelve el resultado, sin que tu elijas el tipo de operación.

use regex::Regex;

fn main() {
    let re = Regex::new(r"(\d+)\s?\+\s?(\d+)").unwrap();

    loop {
        let mut expresion = String::new();
        println!("Escribe tu suma :");
        std::io::stdin().read_line(&mut expresion).unwrap();
        let caps = re.captures(expresion.as_str()).unwrap();
        let izquierda: i32 = caps.get(1).unwrap().as_str().parse().unwrap();
        let derecha: i32 = caps.get(2).unwrap().as_str().parse().unwrap();
        let suma = izquierda + derecha;
        println!("Resultado: {}", suma);
    }
}

Si lo ejecutamos podemos ver algo como esto:

Escribe tu suma :
1+1
Resultado: 2
Escribe tu suma :
12 + 22
Resultado: 34
Escribe tu suma :
99+ 1
Resultado: 100

Puedo ver tu cara, ya lo se, no te preocupes, me quedaré contigo hasta que lo tengamos hayamos entendido todo, vamos paso por paso.

1. la línea use regex::Regex; sirve para importar una librería, en este caso Regex
2. let re = Regex::new(r"(\d+)\s?\+\s?(\d+)").unwrap(); es una variable que contiene un Regex, fijate como no definimos el tipo, por que en este caso es obvio que es tipo Regex, a veces no será obvio, el compilador se asegurara de hacernoslo saber
3. El Regex (\d+)\s?\+\s?(\d+) es sencillo, y aunque este no es un tutorial de Regex, te puedo decir que básicamente busca un patrón de la forma “Número, puede haber un espacio, signo de +, puede haber un espacio, Número” el trabajo de nuestro código es sumar los dos números, si quieres aprender regex te recomiendo el curso de platzi al respecto (con el que yo mismo aprendí sobre Regex https://platzi.com/cursos/expresiones-regulares/)
4. loop { inicia un bucle infinito, el equivalente de un while True: en python
5. let mut expresion = String::new(); Inicializamos una variable de tipo string, implícita, vacía con una cosilla muy interesante, tiene un mut este mut quiere decir que podemos modificar esa variable y es que si, las variables en Rust no se pueden modificar a menos que pongamos el mut, una de las tantas particularidades del lenguaje que lo hace increíble
6. std::io::stdin().read_line(&mut expresion).unwrap(); Esta línea Lee lo que escribamos en la consola y devuelve el resultado a expresion, por cierto, ¿ves ese .unwrap()? es parte de la magia de rust, .read_line(&mut expresion) puede devolvernos o un error o un valor de string, el .unwrap() toma la respuesta positiva en caso de que todo haya salido bien.
7. let caps = re.captures(expresion.as_str()).unwrap(); es una variable que ejecuta los match del regex en expresion, de nuevo, tomamos solo el valor sin error.
8. let izquierda: i32 = caps.get(1).unwrap().as_str().parse().unwrap(); Tomamos el valor de la izquierda (o el primer número) con caps.get(1).unwrap() luego eso lo pasamos a str (no confundir con String) con .as_str() luego con .parse() lo pasamos a i32 (entero de 32 bits) y con .unwrap() sacamos solo el valor sin error. Nótese que en este caso el tipo de la variable SI es necesario por que el .parse() devuelve tipos genéricos
9. Hacemos lo mismo con el valor derecho
10. let suma = izquierda + derecha; Guardamos la suma en una nueva variable, de nuevo no es necesario el tipo, por que es una suma entre i32. Entre las operaciones matemáticas que podemos hacer están: Suma (+), Resta (-), Multiplicación (*), División (/) y módulo(%).
11. println!("Resultado: {}", suma); Mostramos el resultado y el código se repite, para salir podemos presionar “CTRL + C”

Esto es solo el principio, en las próximas semanas estaré subiendo mas contenido sobre Rust. Ahora el reto para ti, cambia el código para que soporte restas, estoy seguro que puedes hacerlo, ¡comparte tu respuesta en la caja de comentarios!