Primitivas - Rust By Example
Description: Rust by Example (RBE) is a collection of runnable examples that illustrate various Rust concepts and standard libraries.

## Keyboard shortcuts

Press `←` or `→` to navigate between chapters

Press `S` or `/` to search in the book

Press `?` to show this help

Press `Esc` to hide this help

# 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`