Rust

``

Visión general

Rust es un lenguaje de programación de sistemas enfocado en seguridad de memoria, concurrencia sin data races y alto rendimiento, sin necesidad de garbage collector. Es ampliamente usado en sistemas, backend, herramientas CLI, WebAssembly, embebidos y software crítico.

Características clave

  • Seguridad de memoria en tiempo de compilación
    • Sistema de ownership, borrowing y lifetimes que previene null pointers, use-after-free y data races.
  • Alto rendimiento
    • Compilación a código nativo con rendimiento comparable a C/C++.
  • Concurrencia segura
    • El modelo de tipos evita condiciones de carrera en tiempo de compilación.
  • Tooling moderno
    • Gestor de paquetes, compilación y testing integrados mediante Cargo.
  • Ecosistema activo
    • Amplia colección de crates para backend, CLI, crypto, WASM, embedded y más.

Casos de uso habituales

  • Sistemas y bajo nivel
    • Sistemas operativos, drivers, runtimes, motores de bases de datos.
  • Backend y servicios
    • APIs de alto rendimiento, microservicios, sistemas distribuidos.
  • CLI y tooling
    • Herramientas rápidas, seguras y portables.
  • WebAssembly
    • Lógica de alto rendimiento ejecutándose en navegador o runtimes WASM.
  • Embedded
    • Firmware seguro para microcontroladores sin sistema operativo.

Documentación oficial

  • The Rust Programming Language (Book)
    • Guía oficial completa desde fundamentos hasta conceptos avanzados.
  • Referencia del lenguaje
    • Especificación formal de sintaxis y semántica.
  • Rustonomicon
    • Uso avanzado y seguro de unsafe.

Instalación

  • Instalación general
    • Installation - The Rust Programming Language-ch01-01-installation.html
  • Instalación en Windows
    • Windows - The rustup book-windows.html

Toolchain y herramientas

  • rustup
    • Gestor de versiones y toolchains de Rust.
  • cargo
    • Compilación, gestión de dependencias, testing y benchmarking.
  • rustfmt
    • Formateo automático de código según estándares oficiales.
  • clippy
    • Linter avanzado con recomendaciones de buenas prácticas.
  • rust-analyzer
    • Soporte IDE: autocompletado, refactorización y análisis estático.

Conceptos fundamentales

  • Ownership
    • Cada valor tiene un único dueño responsable de su liberación.
  • Borrowing
    • Préstamos inmutables o mutables con reglas estrictas.
  • Lifetimes
    • Anotaciones que describen cuánto tiempo viven las referencias.
  • Traits
    • Interfaces para definir comportamiento compartido.
  • Enums y pattern matching
    • Modelado de estados complejos y control de flujo expresivo.
  • Option y Result
    • Manejo explícito de valores opcionales y errores.

Gestión de dependencias

  • crates.io
    • Registro oficial de librerías.
  • Cargo.toml
    • Definición de dependencias, features y perfiles de compilación.
  • Workspaces
    • Organización de proyectos grandes con múltiples crates.

Testing y calidad

  • Tests unitarios
    • Integrados en el propio lenguaje.
  • Tests de integración
    • Ejecutados desde el directorio tests/.
  • Benchmarks
    • Medición de rendimiento con herramientas estándar.
  • Auditoría de dependencias
    • Análisis de seguridad en crates externos.

Seguridad y unsafe

  • Código seguro por defecto
    • La mayoría del código no requiere unsafe.
  • Bloques unsafe
    • Acceso controlado a operaciones de bajo nivel.
  • Buenas prácticas
    • Encapsular unsafe y exponer APIs seguras.

Ecosistema y comunidad

  • Rust Foundation
    • Gobernanza y sostenibilidad del lenguaje.
  • RFCs
    • Propuestas abiertas para evolución del lenguaje.
  • Comunidades
    • Foros, Discord, Reddit y eventos como RustConf.

Integración con otros lenguajes

  • FFI
    • Interoperabilidad con C y otros lenguajes.
  • Bindings
    • Uso de Rust como librería desde otros entornos.
  • WASM
    • Integración con JavaScript y runtimes web.

Rendimiento y optimización

  • Zero-cost abstractions
    • Abstracciones sin penalización en runtime.
  • Perfilado
    • Identificación de cuellos de botella.
  • Control de memoria
    • Asignadores personalizados y estructuras eficientes.

      Rust

Modelo de tipos avanzado

  • Tipos algebraicos
    • Uso extensivo de struct, enum y combinaciones para modelar dominios complejos de forma segura.
  • Tipos genéricos
    • Parametrización de tipos con comprobaciones en tiempo de compilación.
  • Associated types
    • Definición de tipos dependientes dentro de traits para APIs más expresivas.
  • Const generics
    • Parámetros constantes en tipos (por ejemplo tamaños de arrays) verificados en compilación.
  • PhantomData
    • Tipos fantasma para expresar relaciones sin coste en runtime.

Manejo avanzado de errores

  • Propagación con ?
    • Simplificación del flujo de errores sin perder contexto.
  • Errores personalizados
    • Definición de enums de error ricos y tipados.
  • Contexto de error
    • Añadir información semántica sin romper la cadena de errores.
  • No panicking APIs
    • Diseño de librerías que evitan panic! en favor de Result.

Macros

  • Macros declarativas (macro_rules!)
    • Metaprogramación basada en patrones.
  • Macros procedimentales
    • Derive macros para generación automática de código.
    • Attribute macros para modificar comportamiento.
  • Casos de uso
    • Reducción de boilerplate, DSLs y validaciones en compilación.

Asincronía y concurrencia avanzada

  • Modelo async/await
    • Futures evaluados de forma perezosa.
  • Executors
    • Separación entre definición y ejecución de tareas async.
  • Send y Sync
    • Garantías de seguridad entre hilos a nivel de tipos.
  • Canales
    • Comunicación segura entre threads y tareas async.
  • Lock-free programming
    • Estructuras concurrentes sin bloqueos cuando es necesario.

Gestión de memoria avanzada

  • Smart pointers
    • Box, Rc, Arc, RefCell y combinaciones.
  • Interior mutability
    • Mutabilidad controlada respetando el modelo de ownership.
  • Asignadores personalizados
    • Control fino del heap para casos específicos.
  • Stack vs Heap
    • Decisiones explícitas de almacenamiento y coste.

Arquitectura de proyectos

  • Crates binarios y librerías
    • Separación clara entre ejecutables y APIs reutilizables.
  • Módulos
    • Organización jerárquica del código.
  • Features flags
    • Compilación condicional para reducir dependencias y tamaño.
  • Public API design
    • Estabilidad, semver y compatibilidad hacia atrás.

Cross-compilation y plataformas

  • Targets
    • Soporte para múltiples arquitecturas y sistemas operativos.
  • No-std
    • Desarrollo sin librería estándar para entornos restringidos.
  • Embedded HAL
    • Abstracciones comunes para hardware embebido.
  • Linking
    • Integración con toolchains externos.

Web y redes

  • HTTP y networking
    • Clientes y servidores de alto rendimiento.
  • Async IO
    • Entrada/salida no bloqueante eficiente.
  • Web frameworks
    • Arquitecturas basadas en middleware y routing tipado.
  • Seguridad en red
    • TLS, manejo seguro de credenciales y criptografía.

WebAssembly (WASM)

  • Compilación a WASM
    • Targets específicos para navegador y servidores.
  • Interop con JavaScript
    • Llamadas bidireccionales seguras.
  • Optimización de tamaño
    • Eliminación de código muerto y perfiles de compilación.
  • Casos de uso
    • Frontend pesado, plugins y extensiones sandboxed.

Observabilidad y diagnóstico

  • Logging estructurado
    • Logs tipados y contextualizados.
  • Tracing
    • Instrumentación para sistemas distribuidos.
  • Debugging
    • Herramientas y símbolos de depuración.
  • Crash analysis
    • Backtraces y dumps controlados.

Seguridad avanzada

  • Criptografía
    • Implementaciones seguras y revisadas.
  • Auditorías
    • Revisión automática de dependencias vulnerables.
  • Memory safety guarantees
    • Comparativa con lenguajes no seguros.
  • Supply chain
    • Control de versiones y verificación de integridad.

Estabilidad y evolución del lenguaje

  • Edition system
    • Evolución sin romper código existente.
  • SemVer
    • Reglas estrictas de versionado.
  • Nightly vs Stable
    • Uso consciente de features experimentales.
  • RFC process
    • Cómo se introducen nuevas características.

Rendimiento extremo

  • Inlining y monomorfización
    • Especialización del código genérico.
  • Profile-guided optimization
    • Optimización basada en datos reales.
  • SIMD
    • Uso de instrucciones vectoriales.
  • Zero-allocation patterns
    • Diseño de APIs sin asignaciones dinámicas.

Comparativas y posicionamiento

  • Rust vs C/C++
    • Seguridad frente a control manual.
  • Rust vs Go
    • Control de memoria vs simplicidad.
  • Rust vs Java
    • Performance nativa y footprint.
  • Rust como lenguaje estratégico
    • Uso en infraestructura crítica y largo plazo.

Recursos Rust (2025-2026)

Documentación oficial y guías

Cursos y formación actualizados

Recursos gratuitos para aprender Rust

Comunidades y newsletters

  • Rust Lang en Español – Comunidad hispanohablante con recursos, artículos y eventos.
  • This Week in Rust – Newsletter semanal con noticias, lanzamientos y eventos del ecosistema.
  • The Embedded Rustacean – Newsletter especializada en Rust embedded y no_std.

Eventos y conferencias relevantes

  • RustConf – Conferencia principal del ecosistema Rust.
  • RustWeek / RustNation / Tokio RustConf – Eventos regionales e internacionales centrados en Rust.
  • Meetups de Rust – Encuentros locales y virtuales organizados por la comunidad.

Ecosistema y herramientas productivas

  • Tokio – Runtime async de referencia para Rust.
  • async-std – Alternativa async basada en la librería estándar.
  • docs.rs – Documentación generada automáticamente para crates publicados.
  • rust-analyzer – Soporte IDE avanzado para Rust.
  • Cargo – Gestor de paquetes, builds y testing.

Avances del ecosistema Rust (estado 2025)

  • Rust Foundation – Technology Report 2025 – Informe sobre seguridad del supply chain, tooling y adopción industrial.
  • Adopción industrial
    • Uso creciente en sistemas operativos, cloud, blockchain, navegadores y software crítico.
  • Ediciones y estabilidad
    • Consolidación del sistema de ediciones y evolución sin rupturas del lenguaje.

Otras fuentes útiles

Temario base — Libro oficial (The Rust Programming Language)

Fuente oficial del aprendizaje estructurado de Rust.

  1. Introducción a Rust: ¿qué es Rust y por qué usarlo?
  2. Instalación de Rust y configuración del entorno.
  3. Primeros pasos: “Hello, World!” y estructura de un programa.
  4. Conceptos de Ownership (propiedad), Borrowing (préstamos) y Lifetimes (tiempos de vida).
  5. Variables y mutabilidad.
  6. Tipos de datos y anotaciones de tipos.
  7. Funciones, parámetros y retornos.
  8. Control de flujo: if, loop, while, for.
  9. Manejo de errores con Result y Option.
  10. Colecciones: Vec, String, HashMap.
  11. Structs y Enums.
  12. Pattern matching con match.
  13. Traits y genéricos.
  14. Módulos y paquetes con Cargo.
  15. Clases de proyecto y ejecución con Cargo.
  16. Tests, benchmarks y documentación.
  17. Código seguro y uso de unsafe.
  18. Concurrencia y programación asincrónica.

Temario complementario de curso práctico (estilo Udemy / guía aplicada)

  1. Instalación de Rust y configuración de IDE (VSCode, plugins).
  2. Comandos básicos de Cargo y rustup.
  3. Primer proyecto: estructura de carpetas y compilación.
  4. Variables, mutabilidad y shadowing.
  5. Tipos de datos: escalares, compuestos y literales.
  6. Entrada y salida de datos.
  7. Control de flujo y bucles.
  8. Funciones, closures e iteradores.
  9. Propiedad, referencias y borrowing.
  10. Manejo de errores con panic!, Result y combinadores.
  11. Structs, impl y métodos asociados.
  12. Enums y pattern matching avanzado.
  13. Traits, genéricos y bounds.
  14. Vectores, strings y colecciones estándar.
  15. Módulos, crates y dependencias externas.
  16. Lectura y escritura de archivos (I/O).
  17. Concurrencia básica y async/await.
  18. Proyecto práctico final integrador (CLI o aplicación simple).

Temario alternativo práctico (según syllabus de curso genérico)

  1. ¿Qué es Rust? Historia y ventajas.
  2. Preparación del entorno: rustup, cargo, rust-analyzer.
  3. Conceptos fundamentales: variables, tipos y expresiones.
  4. Propiedad y préstamo profundo.
  5. Smart pointers (Box, Rc, Arc).
  6. Gestión de errores: Result, unwrap, propagación con ?.
  7. Manejo de memoria automático y borrow checker.
  8. Métodos, funciones, closures e iteradores.
  9. Concurrencia segura con hilos y async.
  10. Testing, debugging, linting (clippy) y formateo (rustfmt).
  11. Cargo avanzado: workspaces y features.
  12. Integración con C (FFI).
  13. Desarrollo de aplicaciones de red o servicios.
  14. Performance y optimización.

Contenidos sugeridos adicionales (complementarios a 2025)

  • Uso de Rust en WebAssembly (WASM): compilación y modelos de integración.
  • Crates y frameworks relevantes: Tokio (async), Actix / Dioxus (web y GUI).
  • Buenas prácticas de diseño de APIs en Rust.
  • Benchmarking y profiling con herramientas modernas.
  • Desarrollo seguro y auditoría de dependencias.
  • Rust Embedded y no_std para sistemas sin librería estándar.
  • Rust Guide

Temario breve para principiantes (curso gratuito, enfoque progresivo)

  1. Variables y tipos de datos (int, float, bool, char).
  2. Control de flujo: if, bucles.
  3. Ownership, Borrowing y Lifetimes.
  4. Structs, enums, métodos y pattern matching.
  5. Colecciones básicas (Vec, String, HashMap).
  6. Manejo de errores (panic, Result).
  7. Traits, genéricos, closures e iteradores.
  8. Avanzado: smart pointers y concurrencia.

Recursos estructurados en la web (para estudiar cada bloque)

  • Rust oficial (Book) — guía completa, gratuita y siempre actualizada.
  • Rust by Example — aprendizaje basado en ejemplos ejecutables.
  • Rustlings — ejercicios interactivos para practicar sintaxis y conceptos.
  • Comprehensive Rust (Google) — curso intensivo y estructurado.
  • Rust Guide — tutoriales temáticos y listas de conceptos.
    • Rust Guide

      Guía Fundamental de Rust con Ejemplos de Código (2025-2026)

Instalación y primer programa

Hello World

fn main() {
	println!("Hello, world!");
}

`

Variables y mutabilidad

Variables inmutables y mutables

fn main() {
	let x = 10;
	let mut y = 20;

	y += 5;

	println!("x = {}, y = {}", x, y);
}

Shadowing

fn main() {
	let x = 5;
	let x = x + 1;
	let x = x * 2;

	println!("x = {}", x);
}

Tipos de datos

Tipos escalares y compuestos

fn main() {
	let entero: i32 = 42;
	let flotante: f64 = 3.14;
	let booleano: bool = true;
	let caracter: char = 'R';

	let tupla: (i32, f64, char) = (1, 2.5, 'a');
	let array: [i32; 3] = [1, 2, 3];

	println!("{:?} {:?}", tupla, array);
}

Control de flujo

Condicionales y bucles

fn main() {
	let n = 5;

	if n > 0 {
		println!("positivo");
	} else {
		println!("no positivo");
	}

	for i in 0..n {
		println!("i = {}", i);
	}
}

Funciones

Funciones con retorno

fn suma(a: i32, b: i32) -> i32 {
	a + b
}

fn main() {
	let r = suma(2, 3);
	println!("resultado = {}", r);
}

Ownership y Borrowing

Movimiento de ownership

fn main() {
	let s1 = String::from("rust");
	let s2 = s1;

	// println!("{}", s1); // error: ownership movido
	println!("{}", s2);
}

Referencias y préstamos

fn longitud(s: &String) -> usize {
	s.len()
}

fn main() {
	let texto = String::from("hola");
	let len = longitud(&texto);

	println!("{} tiene longitud {}", texto, len);
}

Structs

Definición y uso de structs

struct Usuario {
	nombre: String,
	edad: u8,
}

fn main() {
	let user = Usuario {
		nombre: String::from("Ana"),
		edad: 30,
	};

	println!("{} tiene {} años", user.nombre, user.edad);
}

Enums y pattern matching

Enum con match

enum Estado {
	Activo,
	Inactivo,
}

fn estado_a_texto(e: Estado) -> &'static str {
	match e {
		Estado::Activo => "activo",
		Estado::Inactivo => "inactivo",
	}
}

fn main() {
	let e = Estado::Activo;
	println!("{}", estado_a_texto(e));
}

Option y Result

Uso de Option

fn dividir(a: i32, b: i32) -> Option<i32> {
	if b == 0 {
		None
	} else {
		Some(a / b)
	}
}

fn main() {
	match dividir(10, 2) {
		Some(v) => println!("resultado {}", v),
		None => println!("no se puede dividir"),
	}
}

Manejo de errores con Result

fn dividir(a: i32, b: i32) -> Result<i32, String> {
	if b == 0 {
		Err(String::from("división por cero"))
	} else {
		Ok(a / b)
	}
}

fn main() {
	match dividir(10, 0) {
		Ok(v) => println!("resultado {}", v),
		Err(e) => println!("error: {}", e),
	}
}

Colecciones

Vectores

fn main() {
	let mut numeros = Vec::new();
	numeros.push(1);
	numeros.push(2);

	for n in &numeros {
		println!("{}", n);
	}
}

HashMap

use std::collections::HashMap;

fn main() {
	let mut edades = HashMap::new();
	edades.insert("Ana", 30);
	edades.insert("Luis", 25);

	for (nombre, edad) in edades {
		println!("{}: {}", nombre, edad);
	}
}

Traits

Definición e implementación

trait Describible {
	fn describir(&self) -> String;
}

struct Producto {
	nombre: String,
	precio: f64,
}

impl Describible for Producto {
	fn describir(&self) -> String {
		format!("{} cuesta {}", self.nombre, self.precio)
	}
}

fn main() {
	let p = Producto {
		nombre: String::from("Libro"),
		precio: 9.99,
	};

	println!("{}", p.describir());
}

Concurrencia básica

Hilos (threads)

use std::thread;

fn main() {
	let handle = thread::spawn(|| {
		for i in 1..5 {
			println!("hilo: {}", i);
		}
	});

	handle.join().unwrap();
}

Programación asincrónica

async / await con Tokio

#[tokio::main]
async fn main() {
	let resultado = tarea_async().await;
	println!("{}", resultado);
}

async fn tarea_async() -> i32 {
	42
}

Testing

Test unitario básico

fn suma(a: i32, b: i32) -> i32 {
	a + b
}

#[cfg(test)]
mod tests {
	use super::*;

	#[test]
	fn test_suma() {
		assert_eq!(suma(2, 3), 5);
	}
}

Uso de unsafe (caso mínimo)

Bloque unsafe controlado

fn main() {
	let mut x = 5;
	let r = &mut x as *mut i32;

	unsafe {
		*r += 1;
	}

	println!("{}", x);
}

Guía Avanzada de Rust con Ejemplos de Código (2025-2026)

Lifetimes explícitos

Función con lifetimes anotados

fn mayor<'a>(a: &'a str, b: &'a str) -> &'a str {
	if a.len() > b.len() {
		a
	} else {
		b
	}
}

fn main() {
	let x = String::from("rust");
	let y = String::from("lenguaje");
	println!("{}", mayor(&x, &y));
}

`

Traits avanzados

Traits con métodos por defecto y bounds

trait Resumen {
	fn resumen(&self) -> String {
		String::from("Sin resumen")
	}
}

trait Imprimible: Resumen {
	fn imprimir(&self) {
		println!("{}", self.resumen());
	}
}

struct Articulo {
	titulo: String,
}

impl Resumen for Articulo {
	fn resumen(&self) -> String {
		self.titulo.clone()
	}
}

impl Imprimible for Articulo {}

fn main() {
	let a = Articulo {
		titulo: String::from("Rust avanzado"),
	};

	a.imprimir();
}

Genéricos complejos

Genéricos con múltiples bounds

use std::fmt::Display;

fn mostrar<T: Display + Clone>(valor: T) {
	let copia = valor.clone();
	println!("{}", copia);
}

fn main() {
	mostrar(42);
	mostrar(String::from("Rust"));
}

Associated Types

Uso de associated types en traits

trait Contenedor {
	type Item;

	fn obtener(&self) -> Self::Item;
}

struct Caja(i32);

impl Contenedor for Caja {
	type Item = i32;

	fn obtener(&self) -> Self::Item {
		self.0
	}
}

fn main() {
	let c = Caja(10);
	println!("{}", c.obtener());
}

Const Generics

Tipos con tamaño en tiempo de compilación

struct Buffer<const N: usize> {
	datos: [u8; N],
}

fn main() {
	let b: Buffer<8> = Buffer { datos: [0; 8] };
	println!("tamaño = {}", b.datos.len());
}

Smart pointers e interior mutability

Rc y RefCell

use std::rc::Rc;
use std::cell::RefCell;

fn main() {
	let valor = Rc::new(RefCell::new(5));

	let a = Rc::clone(&valor);
	let b = Rc::clone(&valor);

	*a.borrow_mut() += 10;
	println!("{}", b.borrow());
}

Manejo avanzado de errores

Error personalizado con enum

use std::fmt;

#[derive(Debug)]
enum ErrorApp {
	NoEncontrado,
	PermisoDenegado,
}

impl fmt::Display for ErrorApp {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		match self {
			ErrorApp::NoEncontrado => write!(f, "recurso no encontrado"),
			ErrorApp::PermisoDenegado => write!(f, "permiso denegado"),
		}
	}
}

fn buscar(id: i32) -> Result<String, ErrorApp> {
	if id == 0 {
		Err(ErrorApp::NoEncontrado)
	} else {
		Ok(String::from("dato"))
	}
}

Closures avanzados

Captura por movimiento

fn main() {
	let texto = String::from("hola");

	let closure = move || {
		println!("{}", texto);
	};

	closure();
}

Iteradores personalizados

Implementación de Iterator

struct Contador {
	actual: u32,
	max: u32,
}

impl Iterator for Contador {
	type Item = u32;

	fn next(&mut self) -> Option<Self::Item> {
		if self.actual < self.max {
			self.actual += 1;
			Some(self.actual)
		} else {
			None
		}
	}
}

fn main() {
	let c = Contador { actual: 0, max: 3 };

	for n in c {
		println!("{}", n);
	}
}

Concurrencia avanzada

Canales entre hilos

use std::thread;
use std::sync::mpsc;

fn main() {
	let (tx, rx) = mpsc::channel();

	thread::spawn(move || {
		tx.send("mensaje").unwrap();
	});

	println!("{}", rx.recv().unwrap());
}

Arc y Mutex

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
	let contador = Arc::new(Mutex::new(0));
	let mut handles = vec![];

	for _ in 0..5 {
		let c = Arc::clone(&contador);
		handles.push(thread::spawn(move || {
			let mut num = c.lock().unwrap();
			*num += 1;
		}));
	}

	for h in handles {
		h.join().unwrap();
	}

	println!("contador = {}", *contador.lock().unwrap());
}

Async avanzado

Futures concurrentes con Tokio

use tokio::time::{sleep, Duration};

async fn tarea(id: u32) -> u32 {
	sleep(Duration::from_millis(100)).await;
	id
}

#[tokio::main]
async fn main() {
	let (a, b) = tokio::join!(tarea(1), tarea(2));
	println!("{} {}", a, b);
}

Macros declarativas

macro_rules!

macro_rules! crear_vec {
	( $( $x:expr ),* ) => {
		{
			let mut v = Vec::new();
			$( v.push($x); )*
			v
		}
	};
}

fn main() {
	let v = crear_vec![1, 2, 3];
	println!("{:?}", v);
}

Unsafe avanzado

FFI mínimo con C

extern "C" {
	fn abs(input: i32) -> i32;
}

fn main() {
	unsafe {
		println!("{}", abs(-10));
	}
}

no_std (concepto)

Ejemplo básico sin std

#![no_std]

fn suma(a: i32, b: i32) -> i32 {
	a + b
}

Optimización y control de rendimiento

Evitar asignaciones

fn sumar(slice: &[i32]) -> i32 {
	slice.iter().sum()
}

fn main() {
	let datos = [1, 2, 3, 4];
	println!("{}", sumar(&datos));
}

Rust Cheatsheet (2025-2026)

Estructura básica

Programa mínimo

fn main() {
	println!("Hello, Rust!");
}

`

Variables y constantes

Variables

let x = 5;          // inmutable
let mut y = 10;     // mutable

Constantes

const MAX: i32 = 100;

Tipos de datos

Escalares

let a: i32 = 10;
let b: f64 = 3.14;
let c: bool = true;
let d: char = 'R';

Compuestos

let tupla: (i32, f64) = (1, 2.5);
let array: [i32; 3] = [1, 2, 3];

Control de flujo

Condicional

if x > 0 {
	println!("positivo");
} else {
	println!("no positivo");
}

Bucles

for i in 0..3 {
	println!("{}", i);
}

while x > 0 {
	x -= 1;
}

loop {
	break;
}

Funciones

Definición

fn suma(a: i32, b: i32) -> i32 {
	a + b
}

Ownership y referencias

Movimiento

let s1 = String::from("hola");
let s2 = s1;
// s1 ya no es válido

Referencias

fn len(s: &String) -> usize {
	s.len()
}

Referencia mutable

fn add(s: &mut String) {
	s.push_str("!");
}

Structs

Definición

struct Usuario {
	nombre: String,
	edad: u8,
}

Uso

let u = Usuario {
	nombre: String::from("Ana"),
	edad: 30,
};

Enums

Enum simple

enum Estado {
	Activo,
	Inactivo,
}

Pattern matching

match estado {
	Estado::Activo => println!("on"),
	Estado::Inactivo => println!("off"),
}

Option y Result

Option

let x: Option<i32> = Some(5);

match x {
	Some(v) => println!("{}", v),
	None => println!("vacío"),
}

Result

fn dividir(a: i32, b: i32) -> Result<i32, String> {
	if b == 0 {
		Err(String::from("error"))
	} else {
		Ok(a / b)
	}
}

Operador ?

fn leer() -> Result<i32, std::num::ParseIntError> {
	let n = "10".parse::<i32>()?;
	Ok(n)
}

Colecciones

Vector

let mut v = Vec::new();
v.push(1);

HashMap

use std::collections::HashMap;

let mut m = HashMap::new();
m.insert("a", 1);

Traits

Definición

trait Mostrar {
	fn mostrar(&self);
}

Implementación

impl Mostrar for i32 {
	fn mostrar(&self) {
		println!("{}", self);
	}
}

Genéricos

Función genérica

fn mostrar<T: std::fmt::Display>(v: T) {
	println!("{}", v);
}

Closures

Closure simple

let suma = |a, b| a + b;

Move

let s = String::from("hola");
let c = move || println!("{}", s);

Iteradores

Uso básico

let v = vec![1, 2, 3];
let r: Vec<_> = v.iter().map(|x| x * 2).collect();

Smart pointers

Box

let b = Box::new(5);

Rc

use std::rc::Rc;
let a = Rc::new(1);
let b = Rc::clone(&a);

Arc + Mutex

use std::sync::{Arc, Mutex};

let c = Arc::new(Mutex::new(0));

Concurrencia

Threads

use std::thread;

thread::spawn(|| {
	println!("hilo");
});

Canales

use std::sync::mpsc;

let (tx, rx) = mpsc::channel();
tx.send(1).unwrap();
let v = rx.recv().unwrap();

Async / Await

Función async

async fn tarea() -> i32 {
	42
}

Executor Tokio

#[tokio::main]
async fn main() {
	let v = tarea().await;
	println!("{}", v);
}

Testing

Test unitario

#[test]
fn suma_test() {
	assert_eq!(2 + 2, 4);
}

Macros

macro_rules!

macro_rules! hola {
	() => {
		println!("hola");
	};
}

Unsafe

Bloque unsafe

let mut x = 5;
let p = &mut x as *mut i32;

unsafe {
	*p += 1;
}

Cargo

Comandos comunes

cargo new app
cargo build
cargo run
cargo test
cargo check

Atributos útiles

Derive

#[derive(Debug, Clone)]
struct Punto {
	x: i32,
	y: i32,
}

no_std

Desactivar std

#![no_std]

Glosario de Conceptos Rust

$= dv.current().file.tags.join(“ “)

Conceptos básicos del lenguaje

  • Rust
    • Lenguaje de programación de sistemas enfocado en seguridad, rendimiento y concurrencia.
  • Compilación
    • Proceso mediante el cual el código Rust se transforma en binario nativo.
  • Binario
    • Programa ejecutable generado por el compilador.
  • Crate
    • Unidad básica de compilación en Rust; puede ser una librería o un binario.
  • Package
    • Conjunto de uno o más crates gestionados por Cargo.

Tooling y ecosistema

  • Cargo
    • Gestor de dependencias, compilación, testing y benchmarking.
  • rustup
    • Herramienta para instalar y gestionar versiones de Rust y targets.
  • rustc
    • Compilador oficial de Rust.
  • rustfmt
    • Formateador automático de código.
  • clippy
    • Linter avanzado que detecta errores y malas prácticas.
  • rust-analyzer
    • Motor de análisis para IDEs con autocompletado y refactorización.

Sistema de tipos

  • Tipo
    • Define qué valores puede tomar una variable y qué operaciones son válidas.
  • Inferencia de tipos
    • El compilador deduce tipos sin necesidad de anotarlos explícitamente.
  • Tipos escalares
    • Valores simples como enteros, flotantes, booleanos y caracteres.
  • Tipos compuestos
    • Tipos formados por otros tipos, como tuplas, arrays y structs.
  • Genéricos
    • Código parametrizado por tipos.
  • Bounds
    • Restricciones sobre tipos genéricos.

Ownership y memoria

  • Ownership
    • Regla que define quién es responsable de liberar un valor en memoria.
  • Move
    • Transferencia de ownership de un valor a otra variable.
  • Borrowing
    • Préstamo temporal de un valor mediante referencias.
  • Referencia
    • Acceso a un valor sin tomar su ownership.
  • Referencia mutable
    • Referencia que permite modificar el valor prestado.
  • Lifetimes
    • Anotaciones que indican cuánto tiempo es válida una referencia.
  • Borrow checker
    • Sistema del compilador que valida las reglas de ownership y borrowing.

Estructuras de datos

  • Struct
    • Tipo que agrupa datos relacionados con nombres de campo.
  • Tuple struct
    • Struct con campos sin nombre.
  • Enum
    • Tipo que puede representar múltiples variantes.
  • Pattern matching
    • Mecanismo para desestructurar valores y controlar el flujo.
  • Collection
    • Estructura de datos dinámica como Vec, HashMap o String.

Manejo de errores

  • panic!
    • Finaliza la ejecución del programa ante un error irrecuperable.
  • Option
    • Tipo que representa un valor opcional (Some o None).
  • Result
    • Tipo que representa éxito (Ok) o error (Err).
  • Operador ?
    • Propaga errores de forma concisa.
  • Error personalizado
    • Tipo definido por el usuario para representar fallos específicos.

Traits e interfaces

  • Trait
    • Define un conjunto de métodos que un tipo puede implementar.
  • Implementación (impl)
    • Bloque donde se define el comportamiento de un trait o struct.
  • Trait bound
    • Restricción que exige que un tipo implemente un trait.
  • Associated types
    • Tipos definidos dentro de un trait.
  • Default methods
    • Métodos con implementación por defecto en un trait.

Funciones y closures

  • Función
    • Bloque reutilizable de código con parámetros y retorno.
  • Closure
    • Función anónima que puede capturar variables del entorno.
  • Move closure
    • Closure que toma ownership de los valores capturados.
  • Iterador
    • Abstracción para recorrer secuencias de datos.
  • Adapter
    • Método que transforma un iterador (map, filter, etc.).

Concurrencia y paralelismo

  • Thread
    • Hilo de ejecución del sistema operativo.
  • Send
    • Trait que indica que un tipo puede moverse entre hilos.
  • Sync
    • Trait que indica que un tipo puede compartirse entre hilos.
  • Mutex
    • Primitiva de sincronización para acceso exclusivo.
  • Arc
    • Puntero inteligente para compartir datos entre hilos.
  • Channel
    • Mecanismo de comunicación segura entre hilos.

Programación asíncrona

  • async
    • Marca una función como asíncrona.
  • await
    • Espera el resultado de una operación asíncrona.
  • Future
    • Representa un valor que estará disponible en el futuro.
  • Executor
    • Componente que ejecuta futures.
  • Runtime
    • Infraestructura que gestiona tareas asíncronas (por ejemplo Tokio).

Macros y metaprogramación

  • Macro
    • Código que genera código en tiempo de compilación.
  • macro_rules!
    • Macros declarativas basadas en patrones.
  • Procedural macros
    • Macros que operan sobre el AST del código.
  • Derive macro
    • Macro que genera implementaciones automáticas.

Unsafe y bajo nivel

  • unsafe
    • Bloque que permite operaciones no verificadas por el compilador.
  • Raw pointer
    • Puntero sin garantías de seguridad.
  • FFI
    • Interoperabilidad con otros lenguajes como C.
  • Undefined Behavior
    • Comportamiento no definido que debe evitarse.

Arquitectura y organización

  • Module
    • Espacio de nombres para organizar código.
  • Visibility (pub)
    • Controla qué elementos son accesibles externamente.
  • Workspace
    • Conjunto de crates relacionados.
  • Feature flag
    • Compilación condicional de funcionalidades.
  • SemVer
    • Esquema de versionado semántico.

Testing y calidad

  • Test unitario
    • Verifica una función o módulo aislado.
  • Test de integración
    • Prueba el comportamiento público del crate.
  • Benchmark
    • Medición de rendimiento.
  • Doc test
    • Ejemplo de documentación ejecutable.

Plataformas y despliegue

  • Target
    • Plataforma de compilación (arquitectura + sistema).
  • Cross-compilation
    • Compilar para una plataforma distinta a la local.
  • no_std
    • Uso de Rust sin la librería estándar.
  • WASM
    • Compilación a WebAssembly.