Descripción general del lenguaje Rust

Edición Rust 2024 — lenguaje de sistemas | seguridad de la memoria sin GC | concurrencia intrépida | abstracciones de costo cero

paradigma

Multiparadigma: imperativo, funcional, orientado a objetos (rasgos), orientado a datos. Tipificación estática con inferencia completa, sistema de tipos nominales, tipos de datos algebraicos. Compilación vía LLVM. El verificador de préstamos aplica la seguridad de la memoria en el momento de la compilación.

Tipos

Categoría Tipos
Firmado entero i8 i16 i32 i64 i128 isize
entero sin firmar u8 u16 u32 u64 u128 usize
flotador f32 f64
booleano bool
carbón char (escalar Unicode de 4 bytes)
Unidad ()
rebanada &[T] &mut [T]
matriz [T; N]
tupla (T1, T2, ...)
Referencia &T &mut T
puntero crudo *const T *mut T
Opción Option<T>
Resultado Result<T, E>
cuerda String &str
Caja Box<T> (asignación de montón)
vec Vec<T> (matriz dinámica)
Punteros inteligentes Rc<T> Arc<T> Cell<T> RefCell<T>
Puntero de función fn(T) -> U
Cierre |args| body (tipo único por cierre)
objeto rasgo dyn Trait
nunca ! (divergente)

Declaraciones

construir Sintaxis Notas
Función fn name(params) -> Ret { body }
Método fn name(&self, params) -> Ret { body } en impl bloquear
variable let x = expr; Inmutable por defecto
Mutable let mut x = expr;
Desestructurar let (a, b) = tuple;
constante const NAME: T = expr; Tiempo de compilación, en línea
estática static NAME: T = expr; dirección fija
estructura struct Name { field: T } Campos con nombre
estructura tupla struct Name(T1, T2);
estructura de la unidad struct Name;
enumeración enum Name { Variant, Var(T) } TDA
unión union Name { f1: T1, f2: T2 } Inseguro
rasgo trait Name { fn method(&self); }
implícito impl Type { fn ... }
rasgo implícito impl Trait for Type { fn ... }
Escriba alias type Alias = T;
Importar use crate::module::Item;
Macro macro_rules! name { ... }
Módulo mod name;
caja extern crate name; (edición 2015)

Propiedad y endeudamiento

Each value has exactly one owner.
Ownership can be moved (assignment, function call).
References (&T) borrow without taking ownership.
Mutable references (&mut T) are exclusive — only one at a time.
References must never outlive their referent (lifetimes).

Reglas de préstamo

Controlar el flujo

construir Sintaxis Notas
si if cond { ... } else { ... } expresión
si-deja if let Pattern(expr) = val { ... } Deestructura + partido
mientras while cond { ... }
mientras-deja while let Some(v) = opt { ... }
Para for x in iter { ... } Utiliza IntoIterator
Bucle loop { ... } Infinito (puede break con valor)
partido match expr { Pattern => body, ... } exhaustivo
descanso break; / break val;
Continuar continue;
Regresar return expr; La expresión al final del bloque también regresa

Patrones de coincidencia

Pattern        := Literal | Identifier | _ | ref | mut | @ binding
                 | Tuple(x, y) | Struct { field } | Enum::Variant(x)
                 | x | y (OR) | x @ y (bind) | .. (rest)
                 | ... (inclusive range) | ..= (inclusive range)
Guards         := Pattern if condition => body

Operadores

Categoría Operadores
Aritmética + - * / %
Comparación == != < > <= >=
Lógico && || !
Bit a bit & | ^ ! << >>
compuesto += -= *= /= %= &= |= ^= <<= >>=
Rango .. ..= .. (medio abierto) ..= (inclusive)
Deref *expr
Referencia &expr &mut expr
signo de interrogación expr? (devolución anticipada en Err/None)
pez turbo ::<T> (anotación de tipo en genéricos)
Atributo #[attr] #![attr]

Sistema de rasgos

Rasgos estándar (seleccionados)

rasgo Propósito
Clone Copia profunda (x.clone())
Copy Copia bit a bit (implícita, voluntaria)
Drop destructor
Default Valor predeterminado
Debug Formatear con {:?}
Display Formato orientado al usuario {}
Eq / PartialEq Comparación de igualdad
Ord / PartialOrd Comparación de pedidos
Hash hash
Iterator fn next(&mut self) -> Option<Item>
IntoIterator Convertir en iterador
From / Into Conversión de tipo
TryFrom / TryInto Conversión falible
Deref Desreferencia implícita
AsRef / AsMut Conversión de referencia
Borrow / BorrowMut Préstamo como otro tipo
Send / Sync Marcadores de seguridad de hilo
Sized Tamaño conocido en tiempo de compilación
Fn FnMut FnOnce Rasgos de cierre

impl Trait / dyn Trait

Genéricos

fn id<T: Display>(x: T) -> T { x }
struct Pair<T, U> { first: T, second: U }
enum Option<T> { Some(T), None }
impl<T: Clone> Pair<T, T> { fn duplicate(&self) -> Self { ... } }

Modelo de memoria

Asignación

Punteros inteligentes

concurrencia

Primitivo Ubicación
std::thread::spawn Creación de hilos
std::sync::mpsc Canales multiproductor y un solo consumidor
crossbeam::channel Canales multiproductor, multiconsumidor (externos)
Mutex<T> RwLock<T> Primitivas de sincronización
Arc<T> Conteo de referencias atómicas
std::sync::Barrier Condvar Coordinación
async/await (desde 1.39) Async/await con futuros
tokio / async-std Tiempos de ejecución asíncronos (externos)
std::sync::Once OnceLock LazyLock Inicialización única

Biblioteca estándar (módulos seleccionados)

Módulo Contenidos
std::io Read Write BufRead BufReader BufWriter Stdin Stdout
std::fs File read write create_dir remove_file metadata
std::net TcpStream TcpListener UdpSocket IpAddr
std::collections Vec HashMap HashSet BTreeMap BTreeSet LinkedList VecDeque BinaryHeap
std::path Path PathBuf
std::env args var current_dir temp_dir
std::process Command Output Child exit
std::time Duration Instant SystemTime
std::sync Mutex RwLock Arc Barrier Condvar Once mpsc
std::thread spawn sleep park yield_now current
std::ffi CString CStr OsString OsStr
std::os Extensiones específicas de plataforma
std::ptr read write null NonNull addr_of addr_of_mut

Manejo de errores

// Recoverable: Result<T, E>
fn div(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 { Err("division by zero".into()) }
    else { Ok(a / b) }
}
let r = div(10, 2)?;  // early return on Err

// Unrecoverable: panic!
panic!("something went wrong");

// Expected/unexpected split
// Result for recoverable, panic for programmer errors

Rust inseguro

unsafe { ... } Los bloques permiten:

El verificador de préstamos todavía se aplica dentro de unsafe.

Pruebas

#[test]
fn test_addition() {
    assert_eq!(2 + 2, 4);
    assert!(true);
    assert_ne!(1, 2);
}

Atributos de prueba

#[test] #[should_panic] #[ignore] #[cfg(test)] #[bench]

Cadena de herramientas

Componente Propósito
rustc Compilador (LLVM backend)
cargo Administrador de paquetes, sistema de compilación
rustup Administrador de cadena de herramientas
rustfmt formateador de código
clippy Linter
rust-analyzer servidor LSP
cargo-doc Generador de documentación
cargo-test corredor de prueba
cargo-bench Puntos de referencia
cargo-clippy controles de pelusa

Ediciones

Edición Cambios clave
2015 Edición estable inicial
2018 Duraciones no léxicas, cambios en el sistema de módulos, impl Trait, dyn Trait
2021 Cambios de preludio, IntoIterator para matrices, campo de edición Cargo.toml obligatorio
2024 impl Trait en todas partes, gen bloques, unsafe atributos, if let cadenas estables, nunca teclear ! estable

Compilación

rustc file.rs                    # compile
cargo new project                # new project
cargo build                      # debug build
cargo build --release            # release build
cargo run                        # build + run
cargo test                       # run tests
cargo doc --open                 # generate docs
cargo check                      # type-check without codegen

Objetivos

x86_64-unknown-linux-gnu aarch64-unknown-linux-gnu x86_64-pc-windows-msvc x86_64-apple-darwin wasm32-unknown-unknown wasm32-wasi thumbv7em-none-eabihf (más de 100 objetivos)

Interoperabilidad C

// FFI declaration
extern "C" {
    fn printf(fmt: *const u8, ...) -> i32;
}

// Linking
#[link(name = "m")]
extern "C" { fn sqrt(x: f64) -> f64; }

// ABI types
// i32 → c_int, u64 → c_ulonglong, *const T → *const c_void