Primitivas

Rust proporciona acceso a una amplia variedad de primitivas. Algunos ejemplos son:

Tipos Escalares

• Enteros con signo: i8, i16, i32, i64, i128 y isize (el tamaño del puntero)
• Enteros sin signo: u8, u16, u32, u64, u128 y usize (el tamaño del puntero)
• Punto flotante: f32, f64
• char Valores de Unicode escalares como 'a', 'α' y '∞' (4 bytes cada uno)
• bool puede ser true o falso
• El tipo unitario (), cuyo único posible valor es la tupla vacía: ()

A pesar de que el valor de un tipo de unidad es una tupla, no se considera untipo de compuesto porque no contiene múltiples valores.

Tipos Compuestos

• Arreglos como [1, 2, 3]
• Tuplas como (1, true)

Las variables siempre pueden llevar anotación de tipos. Los números también pueden seranotados a través de un sufijo o por default. Los enteros usan como default i32 y los flotantes usan a f64. Tenga en cuenta que Rust puede también puede inferir tipos.

fn main() {
    // Las variables pueden llevar anotaciónes de tipo.
    let logical: bool = true;

    let a_float: f64 = 1.0;  // Anotación regular
    let an_integer   = 5i32; // Anotación con sufijo

    // O se usará un default.
    let default_float   = 3.0; // `f64`
    let default_integer = 7;   // `i32`

    // Un tipo también se puede inferir por context.
    let mut inferred_type = 12; // El tipo i64 se puede inferir de otra línea.
    inferred_type = 4294967296i64;

    // Una mariable mutable puede cambiar.
    let mut mutable = 12; // `i32` Mutable
    mutable = 21;

    // Error! El tipo de la variable no se puede cambiar.
    mutable = true;

    // Las variables se puede sobreescribir con sombreo.
    let mutable = true;

    /* Tipos compuestos - Arreglo y Tupla */

    // La declaración del tipo de Arreglo consiste del tipo T y la longitud como [T; longitud].
    let my_array: [i32; 5] = [1, 2, 3, 4, 5];

    // Tuple is a collection of values of different types
    // and is constructed using parentheses ().
    let my_tuple = (5u32, 1u8, true, -5.04f32);
}

Ver también

the std library, mut, inference, y shadowing