FerrousPath

Glossary

101 terms from the curriculum. Each entry shows the term in both languages and links to the lesson that introduces it.

A

ABA problemesProblema ABA
A compare-and-swap succeeds because a value changed from A to B and back to A, hiding the fact that it changed at all.Lesson: Lock-free data structures →
ABI
Application Binary Interface: the machine-level rules for calling functions and laying out data that two compiled pieces of code must agree on.Lesson: FFI — talking to C →
Affine typeesTipo afín
A type whose values may be used at most once. Rust’s ownership is an affine type system: a value can be moved once or dropped.Lesson: The type theory of ownership →
Aliasing
Two pointers referring to the same memory. Rust’s rule is aliasing XOR mutation: many readers or one writer.Lesson: Aliasing models: Stacked Borrows, Tree Borrows and provenance →
AlignmentesAlineación
The requirement that a value’s address be a multiple of some power of two. Padding bytes are inserted to satisfy it.Lesson: Memory layout and representation →
Associated typeesTipo asociado
A type declared inside a trait and chosen by each implementation, such as Iterator::Item.Lesson: Advanced traits →
async / await
Syntax for writing code that can pause while waiting for I/O without blocking a thread. An async fn returns a future.Lesson: Async and await →
AtomicesAtómico
A type such as AtomicUsize whose operations happen indivisibly, so threads can share it without a lock.Lesson: Atomics and memory ordering →

B

BindingesEnlace (binding)
A name attached to a value with let. Bindings are immutable unless declared with let mut.Lesson: Variables and types →
Borrow checkeresBorrow checker (verificador de préstamos)
The compiler pass that rejects programs where a reference could outlive its value or where a value is mutated while shared.Lesson: References and borrowing →
BorrowingesPréstamo (borrowing)
Using a value through a reference without taking ownership of it.Lesson: References and borrowing →

C

Cargo
Rust’s build tool and package manager. It compiles your project, downloads dependencies, runs tests and builds documentation.Lesson: Getting started →
ChannelesCanal (channel)
A queue for sending values from one thread or task to another instead of sharing memory.Lesson: Threads and shared state →
Clone
An explicit, possibly expensive duplication of a value, requested with .clone().Lesson: Ownership →
ClosureesClausura (closure)
An anonymous function that can capture variables from the scope where it is defined: |x| x + offset.Lesson: Closures and iterators →
CoherenceesCoherencia
The guarantee that there is at most one implementation of a trait for any given type in the whole program.Lesson: Trait solving and coherence →
Compare-and-swap (CAS)esComparar e intercambiar (CAS)
An atomic operation that writes a new value only if the current value equals an expected one. The basic building block of lock-free code.Lesson: Atomics and memory ordering →
Const genericsesGenéricos constantes (const generics)
Generic parameters that are values rather than types, as in [T; N].Lesson: Type-level programming →
Copy
A marker trait for types that are duplicated bit-for-bit on assignment instead of moved, such as integers and bool.Lesson: Ownership →
Crate
The unit of compilation in Rust: one library or one executable. Crates are what you publish to and download from crates.io.Lesson: Modules, crates and Cargo →

D

Data raceesCarrera de datos (data race)
Two threads accessing the same memory at the same time, at least one of them writing, with no synchronisation. Safe Rust rules it out at compile time.Lesson: Threads and shared state →
Declarative macroesMacro declarativa
A macro defined with macro_rules! that matches patterns of tokens and expands them into code.Lesson: Declarative macros →
Derive
The #[derive(…)] attribute, which generates a standard trait implementation such as Debug or Clone for a type.Lesson: Traits →
Doc testesPrueba de documentación (doc test)
A code example inside a /// documentation comment that cargo test compiles and runs.Lesson: Testing and documentation →
DropesDrop (liberación)
The automatic clean-up of a value when its owner goes out of scope. The Drop trait lets a type run code at that moment.Lesson: Ownership →
Drop check
The analysis that ensures a destructor cannot observe data that has already been dropped.Lesson: Drop, drop check and PhantomData →
Dynamic dispatchesDespacho dinámico
Choosing which method implementation to call at run time, through a vtable. The alternative, static dispatch, is resolved at compile time.Lesson: Trait objects and dynamic dispatch →
Dynamically sized type (DST)esTipo de tamaño dinámico (DST)
A type whose size is only known at run time, such as [T], str or dyn Trait. It can only be used behind a fat pointer.Lesson: Memory layout and representation →

E

EditionesEdición
An opt-in revision of the language (2015, 2018, 2021, 2024). Crates on different editions still link together.Lesson: Modules, crates and Cargo →
EnumesEnum (enumeración)
A type whose value is exactly one of several variants, each of which may carry its own data.Lesson: Enums and pattern matching →
ExecutoresEjecutor (executor)
The runtime component that polls futures until they complete. Tokio is the most widely used one.Lesson: Async and await →
ExpressionesExpresión
Code that evaluates to a value. In Rust if, match and blocks are expressions; a trailing semicolon turns an expression into a statement.Lesson: Functions and control flow →

F

Fat pointeresPuntero gordo (fat pointer)
A pointer two words wide: the address plus a length (for slices) or a vtable pointer (for trait objects).Lesson: Memory layout and representation →
FFI
Foreign Function Interface: calling code written in another language, usually C, or being called by it.Lesson: FFI — talking to C →
Formal verificationesVerificación formal
Proving mathematically that a program meets its specification, with tools such as Kani, Prusti, Creusot or Verus.Lesson: Formal verification of Rust programs →
FutureesFuturo (future)
A value representing a computation that may not have finished yet. It does nothing until an executor polls it.Lesson: Async and await →

G

GenericsesGenéricos
Code written once over type parameters, such as Vec<T> or fn max<T: Ord>(…).Lesson: Generics →

H

HeapesMontículo (heap)
Memory allocated at run time for data whose size can change or that must outlive the current function, such as the contents of a String or Vec.Lesson: Ownership →

I

InliningesInlining (expansión en línea)
Replacing a function call with the body of the function, which removes call overhead and enables further optimisation.Lesson: Performance engineering →
Interior mutabilityesMutabilidad interior
Mutating data through a shared reference, with the borrowing rules checked at run time (RefCell, Mutex) or made unnecessary (Cell, atomics).Lesson: Smart pointers and interior mutability →
IteratoresIterador
A value that produces a sequence of items one at a time through next(). Adapters such as map and filter are lazy.Lesson: Closures and iterators →

L

LayoutesLayout (disposición en memoria)
The size, alignment and field offsets of a type in memory. Rust may reorder fields unless you ask for #[repr(C)].Lesson: Memory layout and representation →
LifetimeesLifetime (tiempo de vida)
The region of code during which a reference is valid. Annotations such as &'a str relate the lifetimes of inputs and outputs; they never change how long anything lives.Lesson: Lifetimes →
Lifetime elisionesElisión de lifetimes
The rules that let the compiler fill in obvious lifetimes in function signatures so you do not have to write them.Lesson: Lifetimes →
Lock-freeesLock-free (sin cerrojos)
A concurrent algorithm in which some thread always makes progress, built on atomic operations instead of locks.Lesson: Lock-free data structures →

M

Memory orderingesOrden de memoria (memory ordering)
The argument to atomic operations (Relaxed, Acquire, Release, SeqCst) that says which guarantees about visibility across threads you need.Lesson: Atomics and memory ordering →
MethodesMétodo
A function defined in an impl block whose first parameter is self, &self or &mut self.Lesson: Structs and methods →
MIR
Mid-level Intermediate Representation: the simplified control-flow-graph form of a program on which borrow checking and many optimisations run.Lesson: Compiler architecture →
Miri
An interpreter for Rust that detects many kinds of undefined behaviour while running your tests.Lesson: Unsafe Rust →
ModuleesMódulo
A namespace inside a crate, declared with mod. Modules control which items are visible from outside through pub.Lesson: Modules, crates and Cargo →
MonomorphizationesMonomorfización
How the compiler implements generics: it generates a separate, specialised copy of the code for each concrete type used.Lesson: Generics →
MoveesMovimiento (move)
Transferring ownership of a value to another binding or function. The source can no longer be used afterwards.Lesson: Ownership →
Mutex
A lock that lets only one thread at a time access the data it protects. In Rust the data lives inside the Mutex<T>.Lesson: Threads and shared state →

N

Niche optimisationesOptimización de nicho
Using a bit pattern that is invalid for a type to store an enum discriminant, so that Option<&T> is the same size as &T.Lesson: Memory layout and representation →
no_std
A crate attribute that drops the standard library and keeps only core, for targets with no operating system.Lesson: no_std and embedded Rust →
Non-lexical lifetimes (NLL)esLifetimes no léxicos (NLL)
The borrow checker’s model since 2018: a borrow lasts until its last use, not until the end of the enclosing block.Lesson: Inside the borrow checker: NLL and Polonius →

O

Option
The standard enum for a value that may be absent: Some(value) or None. Rust has no null.Lesson: Enums and pattern matching →
Orphan ruleesRegla del huérfano (orphan rule)
You may implement a trait for a type only if your crate defines the trait or the type. It keeps implementations from conflicting across crates.Lesson: Advanced traits →
OwnershipesPropiedad (ownership)
The rule that every value has exactly one owner, and the value is dropped when that owner goes out of scope. It is how Rust frees memory without a garbage collector.Lesson: Ownership →

P

PanicesPánico (panic)
An unrecoverable error that unwinds the stack and normally ends the thread. It signals a bug, not an expected failure.Lesson: Error handling →
Pattern matchingesCoincidencia de patrones (pattern matching)
Testing a value against patterns and destructuring it at the same time, with match, if let or let else. A match must cover every case.Lesson: Enums and pattern matching →
PhantomData
A zero-sized marker that tells the compiler a type logically owns or borrows a T it does not actually store.Lesson: Subtyping and variance →
Pin
Pin<P> guarantees the value behind the pointer will not be moved again. Self-referential futures depend on it.Lesson: Pin and self-referential types →
Polonius
The next-generation borrow checker formulation, which tracks where each reference may have come from and accepts more correct programs.Lesson: Inside the borrow checker: NLL and Polonius →
Procedural macroesMacro procedural
A macro written as a Rust function that receives tokens and returns tokens at compile time. #[derive(…)] macros are the most common kind.Lesson: Procedural macros →
ProvenanceesProcedencia (provenance)
The information, beyond its address, about which allocation a pointer is allowed to access.Lesson: Aliasing models: Stacked Borrows, Tree Borrows and provenance →

R

RAII
Resource Acquisition Is Initialization: tying the release of a resource (memory, file, lock) to the scope of the value that owns it.Lesson: Ownership →
Raw pointeresPuntero crudo (raw pointer)
*const T or *mut T: a pointer with no guarantees about validity or aliasing. Dereferencing one requires unsafe.Lesson: Unsafe Rust →
ReferenceesReferencia
A pointer that is guaranteed to be valid. &T is shared and read-only; &mut T is exclusive and writable.Lesson: References and borrowing →
Reference countingesConteo de referencias
Shared ownership through a counter: Rc<T> within one thread, Arc<T> across threads. The value is dropped when the count reaches zero.Lesson: Smart pointers and interior mutability →
Result
The standard enum for an operation that can fail: Ok(value) or Err(error).Lesson: Error handling →
RustBelt
The research project that gave the first machine-checked proof that Rust’s type system is sound, including standard-library types built on unsafe code.Lesson: RustBelt: proving unsafe code sound →

S

Send and SyncesSend y Sync
Marker traits for thread safety. Send types can be moved to another thread; Sync types can be shared between threads by reference.Lesson: Threads and shared state →
Separation logicesLógica de separación
A program logic for reasoning about ownership of memory, in which assertions describe disjoint parts of the heap.Lesson: RustBelt: proving unsafe code sound →
ShadowingesSombreado (shadowing)
Declaring a new binding with the same name as an earlier one. The old binding still exists but can no longer be named.Lesson: Variables and types →
SliceesSlice (rebanada)
A borrowed view into a contiguous run of elements: &[T] for arrays and vectors, &str for text.Lesson: References and borrowing →
Smart pointeresPuntero inteligente
A type that owns the data it points to and adds behaviour, such as Box<T>, Rc<T> or Arc<T>.Lesson: Smart pointers and interior mutability →
SoundnessesCorrección (soundness)
The property that no use of an API from safe code can cause undefined behaviour. An unsafe abstraction must be sound.Lesson: Unsafe Rust →
StackesPila (stack)
Memory for values whose size is known at compile time. It is released automatically when a function returns.Lesson: Ownership →
Stacked Borrows / Tree Borrows
Proposed operational models that define exactly which uses of pointers in unsafe code are allowed. Miri checks programs against them.Lesson: Aliasing models: Stacked Borrows, Tree Borrows and provenance →
String and &stresString y &str
String is owned, growable UTF-8 text; &str is a borrowed slice of UTF-8 text.Lesson: Collections and strings →
StructesStruct (estructura)
A type that groups named fields. Behaviour is added in separate impl blocks.Lesson: Structs and methods →

T

The ? operatoresEl operador ?
Returns early from the function with the error (or None) if there is one, and otherwise unwraps the value.Lesson: Error handling →
ThreadesHilo (thread)
An independent sequence of execution scheduled by the operating system, started with std::thread::spawn.Lesson: Threads and shared state →
Trait
A set of methods a type can implement; Rust’s mechanism for shared behaviour, similar to an interface.Lesson: Traits →
Trait boundesRestricción de trait (trait bound)
A requirement on a type parameter, written T: Trait, that says which traits the type must implement.Lesson: Traits →
Trait objectesObjeto trait (trait object)
A value of type dyn Trait used behind a pointer. The concrete type is erased and methods are found at run time.Lesson: Trait objects and dynamic dispatch →
Trait solveresResolutor de traits (trait solver)
The part of the compiler that decides whether a type implements a trait and which implementation applies.Lesson: Trait solving and coherence →
Turbofish
The ::<T> syntax for giving type arguments explicitly, as in "5".parse::<i32>().Lesson: Generics →
TypestateesTypestate (estado en el tipo)
Encoding the state of an object in its type, so that invalid sequences of operations do not compile.Lesson: Type-level programming →

U

Undefined behaviour (UB)esComportamiento indefinido (UB)
A program error for which the language gives no guarantees at all: the compiler may assume it never happens. Only possible through incorrect unsafe code.Lesson: Unsafe Rust →
Unit testesPrueba unitaria
A function marked #[test], usually in a #[cfg(test)] module next to the code it checks. cargo test runs them.Lesson: Testing and documentation →
Unsafe
The keyword that unlocks operations the compiler cannot check, such as dereferencing raw pointers. The programmer takes over the proof that they are correct.Lesson: Unsafe Rust →

V

VarianceesVarianza
How subtyping of a parameter carries over to the whole type. &'a T is covariant in 'a; &mut T is invariant in T.Lesson: Subtyping and variance →
Vector
Vec<T>: a growable array stored on the heap.Lesson: Collections and strings →
VtableesVtable (tabla virtual)
A table of function pointers for one type’s implementation of a trait. A dyn Trait pointer carries a pointer to it.Lesson: Trait objects and dynamic dispatch →

W

WakeresWaker (despertador)
The handle a future uses to tell the executor it is ready to be polled again.Lesson: Async internals: build an executor →
Weak memory modelesModelo de memoria débil
A description of the surprising orderings of reads and writes that real processors and compilers allow between threads.Lesson: Weak memory and concurrency theory →
WebAssembly (Wasm)
A portable binary instruction format that runs in browsers and other sandboxes. Rust compiles to it directly.Lesson: WebAssembly →

Z

Zero-cost abstractionesAbstracción de coste cero
An abstraction that compiles to code as fast as what you would write by hand without it.Lesson: Closures and iterators →
Zero-sized type (ZST)esTipo de tamaño cero (ZST)
A type that occupies no memory, such as () or an empty struct. It exists only at compile time.Lesson: Memory layout and representation →