Rust: un vistazo más (2)

Rust al igual que muchos lenguajes de programación "modernos" promete ser la panacea universal para aliviar los problemas del mundo. Un C mejorado, eficiente y con capacidades que los demás lenguajes solo lograrían en sueños. En este post continuaremos con algunos ejemplos de código en este lenguaje.

Como recordatorio:

Compilamos:

rustc programa.rs

Ejecutamos:

./programa

Ejemplo 1. Realizar un aumento a un monto dado de acuerdo a las siguientes condiciones:

• Si el monto original esta entre 25000 y 30000 , aumento del 50%
• Si el monto original esta entre 30001 y 40000 , aumento del 35%
• Si el monto original esta entre 40001 y 50000 , aumento del 25%
• Otro caso, aumento del 15%

aumento.rs

Empezamos con la función main del programa donde invocaremos la función aumento.

/**
  En este programa se validará: edad y monto. Si cumple con las condiciones, se hará un aumento al monto original.
*/
fn main(){
    aumento();
}

Definimos la función aumento, donde se harán las validaciones

// Función aumento
fn aumento(){
    let monto = 30003;
    println!("Monto original: ${}",monto);
    let aumento = match monto{
        25000..=30000 => 
            (monto as f32 * 0.5)+monto as f32,
        30001..=40000 => (monto as f32 *0.35)+monto as f32,
        40001..=50000 => (monto as f32 *0.25)+monto as f32,
        _ => (monto as f32 *0.15)+monto as f32
      };
    println!("Monto final obtenido: ${}",aumento);
}

¿Qué podemos observar en el código?

• Para poder crear variables 'mutables' debemos usar 'mut' en la declaración.
• Podemos convertir un tipo de dato a otro con as, (Ejemplo 34 as i32, 34.0 as f32)
• Rust nos porporciona un patrón de coincidencias (match) similar al switch en otros lenguajes.
• Si el monto coincide con algún rango de valor se hará la operación del aumento del monto original.

Ejemplo 2. Funciones matemáticas en Rust

matematicas.rs

/**

En este programa usaremos las funciones matemáticas de Rust

*/
fn main(){
    println!("\t [Funciones matematicas en Rust]");
    println!("Min: {}",4f64.min(6f64));
    println!("Max: {}",4f64.max(6f64));
    println!("x a Radianes: {}",90f64.to_radians());
    println!("x a Grados: {}",90f64.to_degrees());
    println!("log10(): {}",2f64.log10());
    println!("ln: {}",2f64.ln());
    println!("e^x: {}",2f64.exp());
    println!("Ceilling: {}", 1.45f64.ceil());
    println!("Floor : {}",1.45f64.floor());
    println!("Round: {}",1.45f64.round());
    println!("Cubo: {}",9f64.cbrt());
    println!("Raiz: {}",36f64.sqrt());
    println!("Potencia: {}",3i32.pow(2));
    println!("Absoluto: {}",-23i32.abs());
    println!("Seno: {}",120.98f64.sin());
    println!("Coseno: {}",120.98f64.cos());
    println!("Tangente: {}",120.98f64.tan());
}

¿Qué se puede observar en el código?

• Al igual que lenduajes como C, Rust posee sus propias funciones matemáticas
• Es importante especificar el tipo de dato a utilizar, no es lo mismo i32 que f32.

Ejemplo 3. Enumeraciones en Rust

enumeraciones.rs

enum Cafe{
    CHICO,
    MEDIANO,
    GRANDE,
}

enum Idiomas{
    Ingles,
    Frances,
    Aleman,
    Espanyol,
}

#[derive(Debug)]
enum IpAddr {
    V4(String),
    V6(String),
}

#[derive(Debug)]
enum Auto {
    Ford,
    Toyota,
    Bmw,
    Renault
}

#[derive(Debug)]
enum Programador{
    JUNIOR(f32),
    MIDLEVEL(f32,String),
    SENIOR(f32,String,bool),
}

En Rust también contamos con enumeraciones. Como se puede observar, no dista de mucha diferencia a otros lenguajes como C, C++ y/o Java. Podemos crear funciones para verificar la entrada:

fn programador_tipo(prog:Programador){
    match prog{
        Programador::JUNIOR(c) => println!("Programador Junior"),
        Programador::MIDLEVEL(c,d)=> println!("Programador Mid Level"),
        Programador::SENIOR(c,d,e)=> println!("Programador Senior"),
        _=>{println!("No existe esa categoria!");}
    };
}

fn nacionalidad_auto(auto:Auto){
    match auto{
        Auto::Ford => println!("Ford"),
        Auto::Toyota => println!("Toyota"),
        Auto::Bmw => println!("BMW"),
        Auto::Renault => println!("Renault"),
        _=> {println!("No existe ese auto");}
    };
}

Probando las enumeraciones:

fn main(){
    let mi_cafe: Cafe = Cafe::MEDIANO;
    let mi_idioma: Idiomas = Idiomas::Espanyol;
    println!("\t [ ENUMERACIONES ]");
    print_type_of(&mi_cafe);
    print_type_of(&mi_idioma);
    match mi_cafe{
        Cafe::CHICO => println!("No me gusta mucho el cafe."),
        Cafe::MEDIANO => println!("Me agrada el cafe, pero no tanto."),
        Cafe::GRANDE => println!("Me encanta el cafe!!"),
    };

    match mi_idioma{
        Idiomas::Espanyol => println!("Español"),
        Idiomas::Aleman => println!("Aleman"),
        Idiomas::Frances => println!("Frances"),
        Idiomas::Ingles => println!("Inglés"),
    };

    let home = IpAddr::V4(String::from("127.0.0.1"));
    let loopback = IpAddr::V6(String::from("::1"));
    println!("{:?} : {:?}",home,loopback);
    let mi_auto = Auto::Renault;
    let mi_programador = Programador::MIDLEVEL(30000.0,String::from("Java, C/C++"));
    nacionalidad_auto(Auto::Ford);
    nacionalidad_auto(mi_auto);
    programador_tipo(mi_programador);
    

}

Es importante recordar que Rust es un lenguaje de tipado estático, donde el tipo de dato es importante y no algo opcional.

Ejemplo 4. Crear estructuras, en este caso de un libro. Definiendo título, autor, precio, disponibilidad y editorial.

estructuras.rs

struct Libro{
    titulo: String,
    autor: String,
    disponible: bool,
    precio: f32,
    editorial: String
}

fn main(){
    println!("\t [ ESTRUCTURAS ]");
    let mi_libro = Libro{titulo: String::from("El tablero de Flandes"), autor: String::from("Perez Reverte"), disponible: true,     precio: 120.00,     editorial: String::from("Alfaguara")};
    println!("Titulo: {}",mi_libro.titulo);
}

De igual manera a C, Rust permite crear estructuras de datos, definiendo el campo y su tipo.

En próximos post veremos más ejemplos.

Enlaces:

https://www.rust-lang.org/es
https://lucumr.pocoo.org/2015/5/27/rust-for-pythonistas/

https://blog.logrocket.com/rust-enums-and-pattern-matching/
https://phoenixnap.com/kb/install-rust-ubuntu