The following is a glossary which aims to give a short definition of many Rust terms. For translations, this also serves to connect the term back to the English original.
Dynamic memory allocation on the heap.
Information that is passed into a function or method.
- Bare-metal Rust:
Low-level Rust development, often deployed to a system without an operating system. See Bare-metal Rust.
See Blocks and scope.
- borrow checker:
The part of the Rust compiler which checks that all borrows are valid.
}. Also called curly brace, they delimit blocks.
The process of converting source code into executable code or a usable program.
To invoke or execute a function or method.
Used to safely pass messages between threads.
- Comprehensive Rust 🦀:
The courses here are jointly called Comprehensive Rust 🦀.
The execution of multiple tasks or processes at the same time.
- Concurrency in Rust:
See Concurrency in Rust.
A value that does not change during the execution of a program.
- control flow:
The order in which the individual statements or instructions are executed in a program.
An unexpected and unhandled failure or termination of a program.
A data type that holds one of several named constants, possibly with an associated tuple or struct.
An unexpected condition or result that deviates from the expected behavior.
- error handling:
The process of managing and responding to errors that occur during program execution.
A task or problem designed to practice and test programming skills.
A reusable block of code that performs a specific task.
- garbage collector:
A mechanism that automatically frees up memory occupied by objects that are no longer in use.
A feature that allows writing code with placeholders for types, enabling code reuse with different data types.
Unable to be changed after creation.
- integration test:
A type of test that verifies the interactions between different parts or components of a system.
A reserved word in a programming language that has a specific meaning and cannot be used as an identifier.
A collection of precompiled routines or code that can be used by programs.
Rust macros can be recognized by a
!in the name. Macros are used when normal functions are not enough. A typical example is
format!, which takes a variable number of arguments, which isn’t supported by Rust functions.
Rust programs start executing with the
A control flow construct in Rust that allows for pattern matching on the value of an expression.
- memory leak:
A situation where a program fails to release memory that is no longer needed, leading to a gradual increase in memory usage.
A function associated with an object or a type in Rust.
A namespace that contains definitions, such as functions, types, or traits, to organize code in Rust.
The transfer of ownership of a value from one variable to another in Rust.
A property in Rust that allows variables to be modified after they have been declared.
The concept in Rust that defines which part of the code is responsible for managing the memory associated with a value.
An unrecoverable error condition in Rust that results in the termination of the program.
A value that is passed into a function or method when it is called.
A combination of values, literals, or structures that can be matched against an expression in Rust.
The data or information carried by a message, event, or data structure.
A set of instructions that a computer can execute to perform a specific task or solve a particular problem.
- programming language:
A formal system used to communicate instructions to a computer, such as Rust.
The first parameter in a Rust method that represents the instance on which the method is called.
- reference counting:
A memory management technique in which the number of references to an object is tracked, and the object is deallocated when the count reaches zero.
A keyword in Rust used to indicate the value to be returned from a function.
A systems programming language that focuses on safety, performance, and concurrency.
- Rust Fundamentals:
Days 1 to 3 of this course.
- Rust in Android:
See Rust in Android.
- Rust in Chromium:
See Rust in Chromium.
Refers to code that adheres to Rust’s ownership and borrowing rules, preventing memory-related errors.
The region of a program where a variable is valid and can be used.
- standard library:
A collection of modules providing essential functionality in Rust.
A keyword in Rust used to define static variables or items with a
A data type storing textual data. See
A composite data type in Rust that groups together variables of different types under a single name.
A Rust module containing functions that test the correctness of other functions.
A separate sequence of execution in a program, allowing concurrent execution.
- thread safety:
The property of a program that ensures correct behavior in a multithreaded environment.
A collection of methods defined for an unknown type, providing a way to achieve polymorphism in Rust.
- trait bound:
An abstraction where you can require types to implement some traits of your interest.
A composite data type that contains variables of different types. Tuple fields have no names, and are accessed by their ordinal numbers.
A classification that specifies which operations can be performed on values of a particular kind in Rust.
- type inference:
The ability of the Rust compiler to deduce the type of a variable or expression.
- undefined behavior:
Actions or conditions in Rust that have no specified result, often leading to unpredictable program behavior.
A data type that can hold values of different types but only one at a time.
- unit test:
Rust comes with built-in support for running small unit tests and larger integration tests. See Unit Tests.
- unit type:
Type that holds no data, written as a tuple with no members.
The subset of Rust which allows you to trigger undefined behavior. See Unsafe Rust.
A memory location storing data. Variables are valid in a scope.