Tipos de datos

Todo valor en Rust es de un tipo específico. Rust necesita saber ese tipo al momento de compilar el programa, y muchas veces puede inferir el tipo. En otras ocasiones debemos indicarlo explícitamente, y si no lo hacemos produciremos un error de compilación.

Hay dos categorías:

Escalares

Un tipo escalar representa un valor único, y existen cuatro tipos escalares: enteros, punto flotantes, booleanos, y caracteres.

Enteros

Un entero es un número sin una parte fraccional. Pueden tener signo o no, y ser de 8 a 128 bits. Si tiene signos, el tipo empieza con i y si no tiene signo empieza con u.

Tamaños y signo

El tipo empieza con i y u, y continúa con el tamaño en bits, desde 8 hasta 128 bits: i8, u8, i16, u16, y así sucesivamente hasta i128 y u128.

Se usa complemento a dos para representar los números negativos.

Punto flotante

Hay dos tipos primitivos de punto flotante: f32 (32 bits, precisión simple) y f64 (64 bits, doble precisión). Si no se especifica el tipo, se asume por defecto que es f64. Se usa el estándar IEEE-754 de punto flotante.

fn main(){
    let pi = 3.14; // se asume tipo f64
    let as: f32 = 3.14; // esta variable es de tipo f32
}

Booleanos

Una variable booleana puede ser o true o false, y ocupa un byte de almacenamiento.

fn main(){
    let bandera = true;
    let otra_bandera: bool = false;
}

Caracteres

Para almacenar letras, se puede usar char, y se define con comilla única (no doble comilla o comillas que son para las cadenas de caracteres). Los caracteres ocupan 4 bytes de almacenamiento.

fn main(){
    let p = 'p';
}

Compuestos

Los tipos compuestos agrupan varios valores en un sólo tipo. Existen dos: tuples y arreglos.

Tuples

Agrupan diferentes tipos en un sólo tipo compuesto. Tienen un tamaño definido: no se pueden modificar de tamaño una vez creados.

Se crean usando paréntesis y separando la lista de valores con comas. Cada posición es un tipo, y no necesitan ser iguales.

fn main(){
     let tuple: (i32, char) = (12,'d');
     println!("El valor es {}",tuple.1);
}

La salida del programa sería d. (tuple.0 se refiere al i32, y tuple.1 al caracter).

Otra forma es asignar parte de ese tuple a una variable, de la siguiente manera:

fn main(){
     let tuple: (i32, char) = (12,'d');
     let (a,b)=tuple;
     println!("El valor es {}",b);
}