Notebook

Taller Rust¶

A continuación se propone un taller para complementar el tutorial realizado para este lenguaje, puede descargar rust e instalarlo localmente o realizar el taller directamente en este notebook

Teniendo en cuenta el siguiente ejemplo donde se modifica el tipo de una variable, realice un ejercicio donde declare una variable entera con el valor que usted quiera y luego se declare como un decimal que contenga su raiz cuadrada

In [8]:

// se crea un literal de string
let variable = "UNAL";
:vars
// se redeclara la variable para que contenga el tamaño del string declarado anteriormente
let variable = variable.len();
// el tipo de la variable cambio
:vars

println!("variable {}", variable);

Out[8]:

Variable	Type
variable	&str

Out[8]:

Variable	Type
variable	usize

variable 4

Cual es el error del siguiente programa, corrijalo

In [9]:

static LANGUAGE: &str = "Rust";
const THRESHOLD: i32 = 10;

fn is_big(n: i32) -> bool {
   
    n > THRESHOLD
}

fn main() {
    let n = 16;

    println!("This is {}", LANGUAGE);
    println!("The threshold is {}", THRESHOLD);
    println!("{} is {}", n, if is_big(n) { "big" } else { "small" });

    THRESHOLD = 5;
   
}

    THRESHOLD = 5;
    ^^^^^^^^^^^^^ left-hand of expression not valid
invalid left-hand side expression

Corra el siguiente ejemplo e interactúe con el alcance de las variables dentro del bloque, corrija los errores. Ahora trate de pasar la variable short_lived_binding al alcance del main.

In [13]:

// This binding lives in the main function
    let long_lived_binding = 1;

    // This is a block, and has a smaller scope than the main function
    {
        // This binding only exists in this block
        let short_lived_binding = 2;
        tmp = short_lived_binding;
        println!("inner short: {}", short_lived_binding);

        // This binding *shadows* the outer one
        let long_lived_binding = 5_f32;

        println!("inner long: {}", long_lived_binding);
    }
    // End of the block

    // Error! `short_lived_binding` doesn't exist in this scope
    println!("outer short: {}", short_lived_binding);

    println!("outer long: {}", long_lived_binding);
    
    // This binding also *shadows* the previous binding
    let long_lived_binding = 'a';
    
    println!("outer long: {}", long_lived_binding);

inner short: 2
inner long: 5
outer short: 2
outer long: 1
outer long: a

Out[13]:

()

Dentro del siguiente ejemplo se ve el manejo de arreglos y tuplas. Dado el ultimo arreglo de strings, genere una tupla que contenga el segundo string del arreglo junto con su tupla

In [22]:

// Creacion de tuplas

let x: (i32, f64) = (500, 6.4);
let quinientos = x.0;
let seis_punto_cuatro = x.1;

println!("El valor de la tupla es: {:?}", x);
println!("El valor de la tupla es: ({}, {})", quinientos, seis_punto_cuatro);

:vars

 let arr = [1, 2, 3, 4, 5];
// iterar sobre el arreglo utilizando el metodo iter(),
for v in arr.iter() {
    println!(" {}  ", v) ;
}
// tambien se pueden acceder a los valores de un arreglo consultando su indice

println!(" Valor en la tercera posicion {}", arr[2]);



let names = ["Pepe", "Juan", "Manuela", "Andrea"];

let tup;

println!( "Tupla que contiene el segundo nombre, junto con su tamaño {?:} ", tup);

El valor de la tupla es: (500, 6.4)
El valor de la tupla es: (500, 6.4)

Out[22]:

Variable	Type
seis_punto_cuatro	f64
x	( i32 , f64 )
arr	[i32; 5]
quinientos	i32

println!( "Tupla que contiene el segundo nombre, junto con su tamaño {?:} ", tup);
                                                                       expected `}` in format string
println!( "Tupla que contiene el segundo nombre, junto con su tamaño {?:} ", tup);
                                                                     ^ because of this opening brace
invalid format string: expected `'}'`, found `'?'`

En el siguiente ejemplo se evidencia la comunicacion entre dos hilos, el hilo generado le envia un valor al hilo principal. Cuando el hilo principal recive el valor, imprime este valor y algunos multiplos de dicho valor. Modifique el codigo para que calcule la sumatoria de 1 a 100, donde el hilo generado calcule la mitad de la sumatoria y luego se lo envie al hilo principal. El hilo principal calcula la otra mitad

Problema adicional trate de modificar el codigo para generar mas hilos y dividir el calculo de la sumatoria entre la cantidad de hilos generados

In [21]:

use std::thread;
use std::sync::mpsc;

    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let val = 3;
        tx.send(val).unwrap();
    });

    let received = rx.recv().unwrap();
    
    println!("Got: {}", received);
    for i in (1..4) {
        println!("{} * Got = {}", i, i*(received) );
    }

Got: 3
1 * Got = 3
2 * Got = 6
3 * Got = 9

Out[21]:

()