Etiquetas

Entrada Anterior Comenzando con Rust(I)

En esta entrada vamos a comenzar con Rust para darnos de bruces con algunas de las cosas que más curiosas me parecieron a mí, programador que llevaba tiempo con Python, al comenzar.

Accede a este enlace de Playground de Rust. Puedes ejecutar el programa pulsando en RUN. Siéntete libre de modificar lo que quieras, es tu código.

Si vienes de programar en Python ves las cosas algo raras pero no demasiado raras. No creo que tengas problema si te digo que modifiques el programa para que muestre «Estoy empezando con Rust».

Sencillo, cambio «Hola Mundo» por «Estoy empezando con Rust». Lo ejecuto y ya.

Como, a diferencia de Python, Rust no es un lenguaje interpretado verás que en la salida que se muestra en el trozo de pantalla de salida aparece: 

Compiling playground v0.0.1 (/playground)
    Finished dev [unoptimized + debuginfo] target(s) in 2.82s
     Running `target/debug/playground`

Todos los programas escritos en Rust deben pasar un paso previo antes de poder ser ejecutados: la compilación. En el caso de Rust este programa es rustc que veremos con más detalle en otra entrada. La ventaja que tiene la compilación es que, una vez generado el programa ejecutable ya no necesitarías más a Rust. Bastaría con copiar el fichero ejecutable creado, copiarlo en otra máquina (eso sí, con el mismo sistema operativo que en la que has generado el código. Para virguerías de compilaciones para otros sistemas operativos y procesadores diferentes a los de tu máquina siga, siga, siga…) y ya.

El compilador de Rust es muy tiquismiquis, pero da mucha información de por qué no deja seguir. Prueba ahora a ejecutar esto

  Compiling playground v0.0.1 (/playground)
error: expected `;`, found `println`
 --> src/main.rs:2:18
  |
2 |     let i:u32 = 7
  |                  ^ help: add `;` here
3 |     println!("Estoy empezando con Rust");
  |     ------- unexpected token

Observa como te da la ayuda: en la línea 2 añade un ;

Ha sido fácil. Pero no te lleves la impresión de que todas las líneas en un programa Rust deben terminar con ;, de hecho, las líneas más interesantes son las que no lo tienen, pero sigamos con calma que nos liamos.

En este segundo programa hemos añadido una cosa que igual te sorprende. Bueno, una no, dos. La primera es let, palabra reservada del lenguaje que indica que se va a crear una variable. Fácil.

La segunda es el :u32, ¡uf! si no has visto nada antes de tipos te vas a encontrar perdido. Te recomiendo que pares y estudies el capítulo 3, apartado 2 del libro de Rust. Ya advertí que no iba a ser sencillo.

En Python puedes hacer cosas como esta:

i = 7
i = 34
print(i)

Si intentas algo similar en Rust, algo como esto, el compilador se para y muestra un mensaje:

 |
2 |     let i = 7;
  |         -
  |         |
  |         first assignment to `i`
  |         help: consider making this binding mutable: `mut i`
3 |     i = 12;
  |     ^^^^^^ cannot assign twice to immutable variable

En la ayuda nos dice que consideremos hacer «mutable» a i. Y ¿Cómo se hace eso? el código anterior debes modificarlo para que sea igual a este

Con mut le estamos diciendo al compilador que esa variable podrá ser modificada después de ser creada. De hecho, si hacemos que una variable sea mut y no cambiamos su valor a lo largo del programa el compilador nos avisa (aviso de variable mut sin cambios) aunque ejecuta, la cosa no es tan grave. ¿ O sí?. Tú decides.

|
2 |     let mut i = 7;
  |         ----^
  |         |
  |         help: remove this `mut`
  |
  = note: `#[warn(unused_mut)]` on by default

En algunos programas de Rust puedes encontrarte cosas como las que mostramos aquí Esto nos va a permitir la variable i como i32 y, después de volverle a asignar un valor con let, como cadena de caracteres. El término utilizado para definir este fenómeno es shadowing. Vamos, lo mismo que haces en Python con:

i = 7
print(i)
i="hola"
print(i)

Pero dejas claro que sabes que eso es así, no que utilizas a lo tonto un nombre de variable que, curiosamente, ya habías utilizado antes con un tipo diferente. ¿No te ha pasado nunca?

De momento no escribo más. Te dejo algunos ejercicios para que asientes conocimientos:

Ejercicio 1: ¿Por qué este programa no compila? Ejercicio 1

Ejercicio 2: ¿Y por qué este sí? Ejercicio 2

Ejercicio 3: ¿Por qué este programa muestra en pantalla 255 en vez de 256?¿Qué ocurre si eliminas el saturating_add(1)? Busca información sobre saturating_add y similares Ejercicio 3

Un saludo

Comenzando con Rust (III)