FerrousPath

Glosario

101 términos del plan de estudios. Cada entrada muestra el término en los dos idiomas y enlaza a la lección que lo introduce.

A

ABI
Application Binary Interface: las reglas a nivel de máquina para llamar funciones y disponer los datos, que dos fragmentos de código compilado deben compartir.Lección: FFI — hablar con C →
Abstracción de coste ceroenZero-cost abstraction
Una abstracción que se compila a código tan rápido como el que escribirías a mano sin ella.Lección: Clausuras e iteradores →
Aliasing
Dos punteros que se refieren a la misma memoria. La regla de Rust es aliasing XOR mutación: muchos lectores o un único escritor.Lección: Modelos de aliasing: Stacked Borrows, Tree Borrows y procedencia →
AlineaciónenAlignment
El requisito de que la dirección de un valor sea múltiplo de cierta potencia de dos. Para cumplirlo se insertan bytes de relleno.Lección: Layout de memoria y representación →
async / await
Sintaxis para escribir código que puede pausarse mientras espera E/S sin bloquear un hilo. Una async fn devuelve un futuro.Lección: Async y await →
AtómicoenAtomic
Un tipo como AtomicUsize cuyas operaciones ocurren de forma indivisible, de modo que los hilos pueden compartirlo sin cerrojo.Lección: Atómicos y orden de memoria →

B

Borrow checker (verificador de préstamos)enBorrow checker
La fase del compilador que rechaza los programas en los que una referencia podría sobrevivir a su valor o en los que un valor se modifica mientras está compartido.Lección: Referencias y préstamos →

C

Canal (channel)enChannel
Una cola para enviar valores de un hilo o tarea a otro en lugar de compartir memoria.Lección: Hilos y estado compartido →
Cargo
La herramienta de compilación y gestor de paquetes de Rust. Compila el proyecto, descarga dependencias, ejecuta las pruebas y genera la documentación.Lección: Primeros pasos →
Carrera de datos (data race)enData race
Dos hilos que acceden a la misma memoria a la vez, al menos uno escribiendo, sin sincronización. El Rust seguro lo impide en tiempo de compilación.Lección: Hilos y estado compartido →
Clausura (closure)enClosure
Una función anónima que puede capturar variables del ámbito donde se define: |x| x + offset.Lección: Clausuras e iteradores →
Clone
Una duplicación explícita, y posiblemente costosa, de un valor; se pide con .clone().Lección: Propiedad (ownership) →
CoherenciaenCoherence
La garantía de que en todo el programa hay como máximo una implementación de un trait para cada tipo.Lección: Resolución de traits y coherencia →
Coincidencia de patrones (pattern matching)enPattern matching
Comparar un valor con patrones y desestructurarlo a la vez, con match, if let o let else. Un match debe cubrir todos los casos.Lección: Enums y coincidencia de patrones →
Comparar e intercambiar (CAS)enCompare-and-swap (CAS)
Una operación atómica que escribe un valor nuevo solo si el valor actual coincide con el esperado. La pieza básica del código lock-free.Lección: Atómicos y orden de memoria →
Comportamiento indefinido (UB)enUndefined behaviour (UB)
Un error del programa para el que el lenguaje no da ninguna garantía: el compilador puede suponer que nunca ocurre. Solo es posible mediante código unsafe incorrecto.Lección: Rust unsafe →
Conteo de referenciasenReference counting
Propiedad compartida mediante un contador: Rc<T> dentro de un hilo, Arc<T> entre hilos. El valor se libera cuando el contador llega a cero.Lección: Punteros inteligentes y mutabilidad interior →
Copy
Un trait marcador para los tipos que al asignarse se duplican bit a bit en lugar de moverse, como los enteros y bool.Lección: Propiedad (ownership) →
Corrección (soundness)enSoundness
La propiedad de que ningún uso de una API desde código seguro puede causar comportamiento indefinido. Una abstracción unsafe debe ser sound.Lección: Rust unsafe →
Crate
La unidad de compilación de Rust: una biblioteca o un ejecutable. Los crates son lo que se publica y se descarga desde crates.io.Lección: Módulos, crates y Cargo →

D

Derive
El atributo #[derive(…)], que genera para un tipo la implementación estándar de un trait como Debug o Clone.Lección: Traits →
Despacho dinámicoenDynamic dispatch
Elegir en tiempo de ejecución qué implementación de un método se llama, mediante una vtable. La alternativa, el despacho estático, se resuelve al compilar.Lección: Trait objects y despacho dinámico →
Drop (liberación)enDrop
La limpieza automática de un valor cuando su dueño sale de ámbito. El trait Drop permite que un tipo ejecute código en ese momento.Lección: Propiedad (ownership) →
Drop check
El análisis que garantiza que un destructor no puede observar datos que ya han sido liberados.Lección: Drop, drop check y PhantomData →

E

EdiciónenEdition
Una revisión opcional del lenguaje (2015, 2018, 2021, 2024). Crates de ediciones distintas se pueden seguir usando juntos.Lección: Módulos, crates y Cargo →
Ejecutor (executor)enExecutor
El componente del runtime que sondea los futuros hasta que terminan. Tokio es el más utilizado.Lección: Async y await →
El operador ?enThe ? operator
Retorna antes de tiempo de la función con el error (o None) si lo hay; en caso contrario, extrae el valor.Lección: Manejo de errores →
Elisión de lifetimesenLifetime elision
Las reglas que permiten al compilador completar los lifetimes evidentes en las firmas de función para que no haya que escribirlos.Lección: Lifetimes →
Enlace (binding)enBinding
Un nombre asociado a un valor mediante let. Los enlaces son inmutables salvo que se declaren con let mut.Lección: Variables y tipos →
Enum (enumeración)enEnum
Un tipo cuyo valor es exactamente una de varias variantes, cada una de las cuales puede llevar sus propios datos.Lección: Enums y coincidencia de patrones →
ExpresiónenExpression
Código que se evalúa y produce un valor. En Rust if, match y los bloques son expresiones; un punto y coma final convierte la expresión en sentencia.Lección: Funciones y control de flujo →

F

FFI
Foreign Function Interface: llamar a código escrito en otro lenguaje, normalmente C, o ser llamado desde él.Lección: FFI — hablar con C →
Futuro (future)enFuture
Un valor que representa un cómputo que quizá no ha terminado. No hace nada hasta que un ejecutor lo sondea (poll).Lección: Async y await →

G

GenéricosenGenerics
Código escrito una sola vez sobre parámetros de tipo, como Vec<T> o fn max<T: Ord>(…).Lección: Genéricos →
Genéricos constantes (const generics)enConst generics
Parámetros genéricos que son valores en lugar de tipos, como en [T; N].Lección: Programación a nivel de tipos →

H

Hilo (thread)enThread
Una secuencia de ejecución independiente planificada por el sistema operativo; se lanza con std::thread::spawn.Lección: Hilos y estado compartido →

I

Inlining (expansión en línea)enInlining
Sustituir una llamada a función por el cuerpo de la función, lo que elimina el coste de la llamada y permite más optimizaciones.Lección: Ingeniería del rendimiento →
IteradorenIterator
Un valor que produce una secuencia de elementos, uno a uno, mediante next(). Adaptadores como map y filter son perezosos.Lección: Clausuras e iteradores →

L

Layout (disposición en memoria)enLayout
El tamaño, la alineación y los desplazamientos de los campos de un tipo en memoria. Rust puede reordenar los campos salvo que pidas #[repr(C)].Lección: Layout de memoria y representación →
Lifetime (tiempo de vida)enLifetime
La región del código durante la cual una referencia es válida. Anotaciones como &'a str relacionan los lifetimes de entradas y salidas; nunca cambian cuánto vive nada.Lección: Lifetimes →
Lifetimes no léxicos (NLL)enNon-lexical lifetimes (NLL)
El modelo del borrow checker desde 2018: un préstamo dura hasta su último uso, no hasta el final del bloque que lo contiene.Lección: El borrow checker por dentro: NLL y Polonius →
Lock-free (sin cerrojos)enLock-free
Un algoritmo concurrente en el que siempre hay algún hilo que progresa, construido sobre operaciones atómicas en lugar de cerrojos.Lección: Estructuras de datos lock-free →
Lógica de separaciónenSeparation logic
Una lógica de programas para razonar sobre la propiedad de la memoria, en la que las aserciones describen partes disjuntas del heap.Lección: RustBelt: demostrar que el código unsafe es correcto →

M

Macro declarativaenDeclarative macro
Una macro definida con macro_rules! que reconoce patrones de tokens y los expande en código.Lección: Macros declarativas →
Macro proceduralenProcedural macro
Una macro escrita como una función de Rust que recibe tokens y devuelve tokens en tiempo de compilación. Las macros #[derive(…)] son las más comunes.Lección: Macros procedurales →
MétodoenMethod
Una función definida en un bloque impl cuyo primer parámetro es self, &self o &mut self.Lección: Structs y métodos →
MIR
Mid-level Intermediate Representation: la forma simplificada del programa, como grafo de flujo de control, sobre la que se ejecutan el borrow checking y muchas optimizaciones.Lección: Arquitectura del compilador →
Miri
Un intérprete de Rust que detecta muchos tipos de comportamiento indefinido mientras ejecuta tus pruebas.Lección: Rust unsafe →
Modelo de memoria débilenWeak memory model
Una descripción de los órdenes sorprendentes de lecturas y escrituras que los procesadores y compiladores reales permiten entre hilos.Lección: Memoria débil y teoría de la concurrencia →
MóduloenModule
Un espacio de nombres dentro de un crate, declarado con mod. Los módulos controlan con pub qué elementos son visibles desde fuera.Lección: Módulos, crates y Cargo →
MonomorfizaciónenMonomorphization
La forma en que el compilador implementa los genéricos: genera una copia especializada del código para cada tipo concreto que se usa.Lección: Genéricos →
Montículo (heap)enHeap
Memoria reservada en tiempo de ejecución para datos cuyo tamaño puede cambiar o que deben sobrevivir a la función actual, como el contenido de un String o un Vec.Lección: Propiedad (ownership) →
Movimiento (move)enMove
Transferir la propiedad de un valor a otro enlace o función. El origen ya no se puede usar después.Lección: Propiedad (ownership) →
Mutabilidad interiorenInterior mutability
Modificar datos a través de una referencia compartida, con las reglas de préstamo comprobadas en tiempo de ejecución (RefCell, Mutex) o vueltas innecesarias (Cell, atómicos).Lección: Punteros inteligentes y mutabilidad interior →
Mutex
Un cerrojo que permite que solo un hilo a la vez acceda a los datos que protege. En Rust los datos viven dentro del Mutex<T>.Lección: Hilos y estado compartido →

N

no_std
Un atributo de crate que prescinde de la biblioteca estándar y conserva solo core, para plataformas sin sistema operativo.Lección: no_std y Rust embebido →

O

Objeto trait (trait object)enTrait object
Un valor de tipo dyn Trait usado detrás de un puntero. El tipo concreto se borra y los métodos se buscan en tiempo de ejecución.Lección: Trait objects y despacho dinámico →
Optimización de nichoenNiche optimisation
Usar un patrón de bits inválido para un tipo para guardar el discriminante de un enum, de modo que Option<&T> ocupa lo mismo que &T.Lección: Layout de memoria y representación →
Option
El enum estándar para un valor que puede faltar: Some(valor) o None. Rust no tiene null.Lección: Enums y coincidencia de patrones →
Orden de memoria (memory ordering)enMemory ordering
El argumento de las operaciones atómicas (Relaxed, Acquire, Release, SeqCst) que indica qué garantías de visibilidad entre hilos necesitas.Lección: Atómicos y orden de memoria →

P

Pánico (panic)enPanic
Un error irrecuperable que deshace la pila y normalmente termina el hilo. Indica un bug, no un fallo esperado.Lección: Manejo de errores →
PhantomData
Un marcador de tamaño cero que indica al compilador que un tipo posee o toma prestado lógicamente un T que en realidad no almacena.Lección: Subtipado y varianza →
Pila (stack)enStack
Memoria para valores cuyo tamaño se conoce en tiempo de compilación. Se libera automáticamente cuando la función retorna.Lección: Propiedad (ownership) →
Pin
Pin<P> garantiza que el valor tras el puntero no volverá a moverse. Los futuros autorreferenciales dependen de ello.Lección: Pin y tipos autorreferenciales →
Polonius
La formulación de nueva generación del borrow checker, que rastrea de dónde puede provenir cada referencia y acepta más programas correctos.Lección: El borrow checker por dentro: NLL y Polonius →
Préstamo (borrowing)enBorrowing
Usar un valor a través de una referencia sin tomar su propiedad.Lección: Referencias y préstamos →
Problema ABAenABA problem
Un compare-and-swap tiene éxito porque un valor pasó de A a B y volvió a A, ocultando que llegó a cambiar.Lección: Estructuras de datos lock-free →
Procedencia (provenance)enProvenance
La información, más allá de la dirección, sobre a qué reserva de memoria tiene permitido acceder un puntero.Lección: Modelos de aliasing: Stacked Borrows, Tree Borrows y procedencia →
Propiedad (ownership)enOwnership
La regla de que cada valor tiene exactamente un dueño y se libera cuando ese dueño sale de ámbito. Así Rust libera memoria sin recolector de basura.Lección: Propiedad (ownership) →
Prueba de documentación (doc test)enDoc test
Un ejemplo de código dentro de un comentario de documentación /// que cargo test compila y ejecuta.Lección: Pruebas y documentación →
Prueba unitariaenUnit test
Una función marcada con #[test], normalmente en un módulo #[cfg(test)] junto al código que comprueba. cargo test las ejecuta.Lección: Pruebas y documentación →
Puntero crudo (raw pointer)enRaw pointer
*const T o *mut T: un puntero sin garantías de validez ni de aliasing. Desreferenciarlo requiere unsafe.Lección: Rust unsafe →
Puntero gordo (fat pointer)enFat pointer
Un puntero de dos palabras: la dirección más una longitud (en los slices) o un puntero a la vtable (en los trait objects).Lección: Layout de memoria y representación →
Puntero inteligenteenSmart pointer
Un tipo que es dueño de los datos a los que apunta y añade comportamiento, como Box<T>, Rc<T> o Arc<T>.Lección: Punteros inteligentes y mutabilidad interior →

R

RAII
Resource Acquisition Is Initialization: ligar la liberación de un recurso (memoria, archivo, cerrojo) al ámbito del valor que lo posee.Lección: Propiedad (ownership) →
ReferenciaenReference
Un puntero cuya validez está garantizada. &T es compartida y de solo lectura; &mut T es exclusiva y permite escribir.Lección: Referencias y préstamos →
Regla del huérfano (orphan rule)enOrphan rule
Solo puedes implementar un trait para un tipo si tu crate define el trait o el tipo. Evita que las implementaciones de distintos crates entren en conflicto.Lección: Traits avanzados →
Resolutor de traits (trait solver)enTrait solver
La parte del compilador que decide si un tipo implementa un trait y qué implementación se aplica.Lección: Resolución de traits y coherencia →
Restricción de trait (trait bound)enTrait bound
Un requisito sobre un parámetro de tipo, escrito T: Trait, que indica qué traits debe implementar el tipo.Lección: Traits →
Result
El enum estándar para una operación que puede fallar: Ok(valor) o Err(error).Lección: Manejo de errores →
RustBelt
El proyecto de investigación que dio la primera demostración verificada por máquina de que el sistema de tipos de Rust es correcto, incluidos tipos de la biblioteca estándar construidos con código unsafe.Lección: RustBelt: demostrar que el código unsafe es correcto →

S

Send y SyncenSend and Sync
Traits marcadores de seguridad entre hilos. Un tipo Send puede moverse a otro hilo; un tipo Sync puede compartirse por referencia entre hilos.Lección: Hilos y estado compartido →
Slice (rebanada)enSlice
Una vista prestada de una secuencia contigua de elementos: &[T] para arrays y vectores, &str para texto.Lección: Referencias y préstamos →
Sombreado (shadowing)enShadowing
Declarar un enlace nuevo con el mismo nombre que uno anterior. El anterior sigue existiendo, pero ya no se puede nombrar.Lección: Variables y tipos →
Stacked Borrows / Tree Borrows
Modelos operacionales propuestos que definen con exactitud qué usos de punteros se permiten en código unsafe. Miri comprueba los programas contra ellos.Lección: Modelos de aliasing: Stacked Borrows, Tree Borrows y procedencia →
String y &strenString and &str
String es texto UTF-8 con dueño y de tamaño variable; &str es un slice prestado de texto UTF-8.Lección: Colecciones y cadenas →
Struct (estructura)enStruct
Un tipo que agrupa campos con nombre. El comportamiento se añade en bloques impl aparte.Lección: Structs y métodos →

T

Tipo afínenAffine type
Un tipo cuyos valores pueden usarse como máximo una vez. La propiedad de Rust es un sistema de tipos afín: un valor puede moverse una vez o liberarse.Lección: La teoría de tipos de la propiedad →
Tipo asociadoenAssociated type
Un tipo declarado dentro de un trait y elegido por cada implementación, como Iterator::Item.Lección: Traits avanzados →
Tipo de tamaño cero (ZST)enZero-sized type (ZST)
Un tipo que no ocupa memoria, como () o un struct vacío. Solo existe en tiempo de compilación.Lección: Layout de memoria y representación →
Tipo de tamaño dinámico (DST)enDynamically sized type (DST)
Un tipo cuyo tamaño solo se conoce en tiempo de ejecución, como [T], str o dyn Trait. Solo puede usarse detrás de un puntero gordo.Lección: Layout de memoria y representación →
Trait
Un conjunto de métodos que un tipo puede implementar; el mecanismo de Rust para el comportamiento compartido, parecido a una interfaz.Lección: Traits →
Turbofish
La sintaxis ::<T> para indicar argumentos de tipo explícitamente, como en "5".parse::<i32>().Lección: Genéricos →
Typestate (estado en el tipo)enTypestate
Codificar el estado de un objeto en su tipo, de modo que las secuencias de operaciones inválidas no compilan.Lección: Programación a nivel de tipos →

U

Unsafe
La palabra clave que habilita operaciones que el compilador no puede comprobar, como desreferenciar punteros crudos. Quien programa asume la demostración de que son correctas.Lección: Rust unsafe →

V

VarianzaenVariance
Cómo se traslada al tipo completo la relación de subtipado de un parámetro. &'a T es covariante en 'a; &mut T es invariante en T.Lección: Subtipado y varianza →
Vector
Vec<T>: un array de tamaño variable almacenado en el heap.Lección: Colecciones y cadenas →
Verificación formalenFormal verification
Demostrar matemáticamente que un programa cumple su especificación, con herramientas como Kani, Prusti, Creusot o Verus.Lección: Verificación formal de programas en Rust →
Vtable (tabla virtual)enVtable
Una tabla de punteros a función con la implementación de un trait para un tipo. Un puntero dyn Trait lleva un puntero a ella.Lección: Trait objects y despacho dinámico →

W

Waker (despertador)enWaker
El manejador que un futuro usa para avisar al ejecutor de que está listo para volver a ser sondeado.Lección: Async por dentro: construye un ejecutor →
WebAssembly (Wasm)
Un formato binario portable de instrucciones que se ejecuta en navegadores y otros entornos aislados. Rust compila directamente a él.Lección: WebAssembly →