FerrousPath

Chuleta

La sintaxis que usas a diario y lo que te están diciendo los errores de compilación más comunes.

Enlaces y tipos

let x = 5;
Enlace inmutable
let mut x = 5;
Enlace mutable
let x: u64 = 5;
Con anotación de tipo
const MAX: u32 = 10;
Constante en tiempo de compilación
i8 … i128, u8 … u128, isize, usize
Enteros
f32, f64, bool, char
Otros escalares
(i32, &str) [u8; 4] &[u8]
Tupla, array, slice
x as f64 u8::try_from(x)
Conversión con as; conversión comprobada

Propiedad y préstamos

let b = a;
Mueve a (salvo que el tipo sea Copy)
let b = a.clone();
Copia profunda explícita
&a
Préstamo compartido: muchos lectores
&mut a
Préstamo exclusivo: un escritor
fn f(s: &str)
Préstamo en una firma
fn f<'a>(x: &'a str) -> &'a str
El resultado vive tanto como la entrada
drop(a);
Termina la propiedad ahora

Control de flujo y patrones

if c { a } else { b }
Es una expresión
loop { break value; }
Bucle que produce un valor
for x in &v { } for i in 0..n { }
Iteración
match x { 1 | 2 => a, 3..=9 => b, _ => c }
match exhaustivo
if let Some(v) = opt { }
Comprueba un solo patrón
let Some(v) = opt else { return };
Enlaza o sale
while let Some(t) = stack.pop() { }
Itera mientras coincida
Point { x, .. } (a, _) n @ 1..=5 x if x > 0
Desestructuración, enlace, guardas

Option y Result

opt? res?
Propaga None / Err
opt.unwrap_or(d) opt.unwrap_or_default()
Valores por defecto
opt.map(f) opt.and_then(f) opt.filter(p)
Transformar
opt.ok_or(e) res.ok()
Convertir entre ambos
res.map_err(f) res.unwrap_or_else(f)
Tratar errores
opt.take() opt.as_ref() opt.as_mut()
Extraer / prestar el interior
res.expect("why this cannot fail")
Pánico con un motivo

Structs, enums, traits

struct P { x: f64, y: f64 }
Struct
enum Shape { Circle(f64), Rect { w: f64, h: f64 } }
Enum con datos
impl P { fn new() -> Self { … } fn len(&self) -> f64 { … } }
Métodos
trait Area { fn area(&self) -> f64; }
Trait
impl Area for P { … }
Implementación
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
Derivar traits comunes
fn f(x: impl Area) fn f<T: Area>(x: T)
Despacho estático
Box<dyn Area> &dyn Area
Despacho dinámico

Colecciones e iteradores

vec![1, 2, 3] Vec::with_capacity(n)
Vectores
String::from("a") format!("{x}") s.as_str()
Cadenas
HashMap::new() *m.entry(k).or_insert(0) += 1
Mapas y la API entry
v.iter() v.iter_mut() v.into_iter()
&T, &mut T, T
.map(f) .filter(p) .enumerate() .zip(o) .rev() .take(n) .skip(n)
Adaptadores (perezosos)
.collect::<Vec<_>>() .sum() .count() .fold(init, f)
Consumidores
.any(p) .all(p) .find(p) .position(p) .max_by_key(f)
Búsqueda
v.sort() v.sort_by_key(f) v.dedup() v.retain(p)
Operaciones in situ

Punteros inteligentes y concurrencia

Box<T>
Reserva en el heap, un dueño
Rc<T> Arc<T>
Propiedad compartida (un hilo / varios hilos)
Cell<T> RefCell<T>
Mutabilidad interior, un hilo
Mutex<T> RwLock<T> AtomicU64
Mutabilidad interior, varios hilos
Arc<Mutex<T>>
Estado mutable compartido entre hilos
thread::spawn(move || …) thread::scope(|s| …)
Hilos
mpsc::channel()
Paso de mensajes
async fn f() { g().await }
Async; necesita un ejecutor

Cargo

cargo new app cargo init
Crear un proyecto
cargo check
Comprobar tipos rápidamente
cargo run cargo run --release
Compilar y ejecutar
cargo test cargo test name -- --nocapture
Probar
cargo fmt cargo clippy
Formatear y analizar
cargo add serde --features derive
Añadir una dependencia
cargo doc --open
Consultar la documentación
cargo +nightly miri test
Detectar comportamiento indefinido

Cómo leer los errores del compilador

Ejecuta rustc --explain E0382 para ver la explicación completa de cualquier código.

CódigoSignificadoSolución habitual
E0382use of moved valueuso de un valor movidoPresta en lugar de mover, clona o reestructura para que quede un único dueño.
E0499two mutable borrows at oncedos préstamos mutables a la vezTermina el primer préstamo antes de empezar el segundo; divide los datos; usa índices.
E0502mutable borrow while immutably borrowedpréstamo mutable mientras hay uno inmutableTermina de leer antes de escribir, o copia antes el valor.
E0505moved out while borrowedmovido mientras estaba prestadoAsegúrate de que ninguna referencia se usa después del movimiento.
E0506assigned to while borrowedasignado mientras estaba prestadoEl mismo remedio que para E0502.
E0597borrowed value does not live long enoughel valor prestado no vive lo suficienteMueve al dueño a un ámbito exterior, o devuelve un valor con dueño.
E0106missing lifetime specifierfalta un especificador de lifetimeIndica de qué entrada toma prestado la referencia devuelta, o devuelve un valor con dueño.
E0277trait bound not satisfiedno se cumple una restricción de traitAñade la restricción a tu genérico, implementa o deriva el trait, o convierte el tipo.
E0308mismatched typeslos tipos no coincidenBusca un punto y coma de más, una conversión que falta o ramas de tipos distintos.
E0282type annotations neededhacen falta anotaciones de tipoAnota el enlace o usa el turbofish: parse::<i32>().
E0004non-exhaustive patternspatrones no exhaustivosTrata los casos indicados.
E0373closure may outlive borrowed valuela clausura puede sobrevivir al valor prestadoAñade move a la clausura.