Glossary

Pass an error back to the caller, or keep the value and continue.

The machine-level rules for how functions pass arguments and lay out data.

The number that says where a byte is in memory.

The rule that a value must start at an address divisible by some number.

Asking for a piece of heap memory.

A common habit that looks reasonable but causes problems later.

A crate with one catch-all error type for applications.

A value you pass to a function when you call it.

A fixed number of values of one type, side by side.

A check that panics if something isn't true.

A constant that belongs to a type or trait.

A function inside impl that isn't called on a value, like String::new.

A type a trait lets each implementation choose, like Iterator's Item.

The library that runs async tasks: it polls futures and wakes them when their I/O is ready.

A future handed to the runtime to run on its own, like a very light thread.

Writing code that can wait for many slow things at once without a thread for each.

Writing a new file and then renaming it over the old one, so readers never see a half-written file.

A number the hardware can update in one indivisible step, safely from many threads.

A note to the compiler written #[...], such as #[test].

Checking who someone is.

Checking what someone is allowed to do.

At a method call, Rust adds the & or &mut the receiver needs.

The list of function calls that led to a panic.

A crate that builds a program you can run; it has a main function.

A way of storing data as compact bytes instead of readable text.

A collection that always gives you its largest item first.

The link between a name and a value.

One on-off switch, written 0 or 1.

One impl that covers every type meeting a bound.

Code between { and }, whose last expression is its value.

The part of the compiler that enforces the borrowing rules.

A change to a library that can stop code that uses it from compiling or working.

A marker that pauses the program at a line so you can look around.

A map that keeps its keys in sorted order.

A set that keeps its values in sorted order.

Reading or writing in big chunks through a memory buffer instead of one small system request at a time.

Debug (fast to build, checked) or release (optimized) settings for a build.

A Rust program Cargo runs before compiling your crate, to generate code or find native libraries.

Building a complicated value step by step with chained method calls, then finishing it.

Whether stopping a future halfway can lose data or leave things half-done.

How much space a String or Vec has reserved, used or not.

How a closure holds a variable it uses: by borrowing it, borrowing it mutably, or taking it.

Rust's build tool and package manager.

Checks the code for errors without building a program.

An optional part of a crate that you switch on in Cargo.toml.

The file recording the exact dependency versions a build used.

The file that describes a Cargo project and its dependencies.

Converting a number to another type with as.

One Unicode character, four bytes wide.

A byte position where one character ends and the next begins.

A program started by another program, which waits for it or talks to it.

A tool that points out likely mistakes and clumsy code.

An explicit deep copy of a value.

A small unnamed function you can write inline and store in a variable.

A note in the source that the compiler ignores.

One saved snapshot of a repository, with a message.

A program that translates source code into a program the computer can run.

An optional part of a toolchain, like rustfmt or Clippy.

Making progress on several jobs over the same period, taking turns if needed.

A way for a thread to sleep until another thread says something has changed.

Choosing which code to compile for each target, with #[cfg], cfg! and cfg_select!.

The order that decides which setting wins when a file, an environment variable, and a flag disagree.

A set of open database connections that requests borrow and give back.

Generics over a value, like an array's length, instead of a type.

A named value fixed when the program is compiled.

A function that builds and returns a new value of a type.

A method that runs an iterator to the end (or until it has an answer) and returns a result.

A packaged filesystem with a program and everything it needs, that runs the same anywhere.

Automatically checking every change with builds and tests before it is merged.

Types whose values are copied, not moved, on assignment.

The browser rule that decides which other websites may call your API from their pages.

Small fast memory next to the processor; reading nearby data is much faster than far-away data.

A unit of Rust code the compiler builds at once: a program or a library.

The file the compiler starts from when building a crate: src/main.rs or src/lib.rs.

The public site where Rust libraries are published.

Building a program on one kind of machine for another kind.

A reference to something that no longer exists.

Doing the same work on many pieces of data at once, on several CPU cores.

Two accesses to the same data at once, at least one writing, with nothing coordinating them.

A numbered script that changes the database's structure, applied once and in order.

A group of changes that either all happen or none do.

Two programs or threads each waiting for the other, forever.

The programmer-facing way to print a value, with {:?}.

A program that runs yours and can pause it at a line so you can look around.

A macro written as patterns that expand into code.

A trait method with a body that implementors get for free.

Another crate your project uses.

Handing a component the things it depends on, instead of letting it create them itself.

Following a reference to the value it points to.

Asking the compiler to write standard behavior for a type.

The clean-up code that runs when a value is dropped.

Taking a value apart into its pieces with a pattern.

A message from the compiler: an error, warning, note, or help.

The system that turns names like example.com into IP addresses.

A /// comment that becomes documentation.

Example code in a doc comment that cargo test runs.

Giving the same memory back twice.

What happens to a value when its owner goes away: it is cleaned up.

A trait simple enough to be used as a trait object.

Choosing which function to call while the program runs.

A type whose size is only known while the program runs, like str or [T].

A set of language rules a project opts into, like 2024.

Moving a crate to a newer edition, mostly automatically.

HashMap's way to insert-or-update a key in one lookup.

A type whose value is one of several named variants.

How an enum's variant name is recorded in serialized data.

A named setting the operating system hands to every program it starts, like PATH.

The list of errors from what went wrong down to why.

A code like E0382 that names a kind of compile error.

A message added to an error to say what the program was doing.

An enum with one variant per way an operation can fail.

Handing an error up to the function that called you.

The standard trait that marks a type as an error.

A file your operating system can start as a program.

Covering every possible case.

The number a program hands back when it ends; 0 means success.

Code that produces a value.

A handler argument that pulls one piece of data out of the request, like the path or the JSON body.

A pointer that carries a second word of information, like a length or a vtable.

One named value inside a struct.

The small number the kernel gives a program for an open file or pipe.

Information about a file rather than its contents: size, times, type, permissions.

Who may read, write, or run a file, as the operating system records it.

A picture of where a program spent its time, with wide bars for costly functions.

A number with a fractional part, stored approximately.

The three traits that say how often a closure can be called and what it may do to its captures.

The way code in one language calls functions written in another.

The {} pattern that says how println! and format! show values.

The part of a macro pattern that says what kind of code a variable matches, like expr or ident.

Conversions that can never lose information.

A named block of code you can call with arguments.

A value that points to a named function, written with the type fn(i32) -> i32.

The trait for a value that will be ready later; async functions return one.

Throwing huge numbers of random, broken inputs at code to find crashes.

A runtime system that frees memory nobody uses any more.

An associated type that takes its own type or lifetime parameters.

A trait with a type parameter, so a type can implement it several times.

Code written once for many types, with the type left as a parameter.

Stopping a server by finishing the requests already in progress instead of cutting them off.

What a reader sees as one character, which may be several chars.

A library that gives the same programming interface to different chips' hardware.

A recipe that turns a key into a number used to find its slot quickly.

A collection that looks values up by key.

A collection of unique values with fast membership tests.

A small endpoint that tells an orchestrator whether the service is alive and ready.

Memory for data whose size or lifetime isn't fixed in advance.

A bound that must hold for every lifetime, written for<'a>.

The three-digit number in an HTTP response that says how the request went.

Running code only if a value matches one pattern.

The block where a type's methods are defined.

Shorthand for "some type that implements this trait."

The position of an element, counting from 0.

A type for whole numbers, like i32 or u8.

A test in the tests/ folder that uses your library the way another crate would.

Changing something through a shared reference, with the safety check done a different way.

The trait that turns a value into an iterator; for loops call it.

A link in documentation written with a Rust path, like [Vec], that rustdoc turns into a real link.

The number that identifies a machine on a network.

A value that hands out items one at a time, like a Vec's elements.

A method that wraps an iterator to change what it produces, like map or filter.

The trait with one required method, next, that every iterator implements.

A program an editor runs to understand your code as you type.

Creating a value the first time it's needed instead of at startup.

An iterator does no work until something asks it for the next item.

An iterator-like type whose items borrow from the iterator itself, so only one can be held at a time.

Binding a pattern, or leaving the function if it doesn't match.

A crate meant to be called by other code, with src/lib.rs and no main.

The stretch of the program in which a reference is valid.

A requirement that a type's references stay valid for at least a given lifetime.

The rules that let you leave lifetime names out of most signatures.

A name like 'a in a signature that links how long references must stay valid.

The system tool that joins compiled machine code into one executable.

A check that warns about suspicious code that still compiles.

How seriously the compiler treats a lint: allow, warn, deny, or forbid.

The code generator rustc uses to produce machine code.

The value lock() returns; the lock stays held for as long as it exists.

Always taking several locks in the same agreed order, so two threads can't each hold what the other needs.

How important a log message is: error, warn, info, debug, or trace.

A name for a loop, so break or continue can pick which loop.

The numeric instructions a processor actually executes.

Code that writes code; its name ends with !, like println!.

Variables a macro creates can't clash with variables at the place it's used.

An empty type used only as a label inside another type, like Km in Distance.

Choosing what to do by comparing a value against patterns.

An extra if condition on a match arm.

Where a running program keeps its values.

Memory that is never given back.

The rule for which other memory changes a thread is guaranteed to see around an atomic operation.

A file the operating system shows to a program as if it were memory.

A function attached to a type, called with dot syntax.

Code that runs around every request, like logging or timeouts.

A tool that runs Rust code step by step and reports undefined behavior it finds.

A named section of a crate that groups related code and controls what is visible outside it.

The compiler making a separate copy of generic code for each type it is used with.

Handing a value's ownership to another variable or function.

A closure marked move, which takes ownership of every variable it uses.

A queue for sending values from any number of threads to one receiving thread.

A small C standard library that lets Rust build fully static Linux programs.

Allowed to change after it is set.

A reference that lets you change the value it points to.

A lock that lets only one thread at a time use the data inside it.

How the compiler renames functions to encode extra information, which C can't read.

The type of code that never finishes, like panic! or an endless loop.

A one-field tuple struct that gives a value its own type.

Using a value a type can never hold to store an enum's tag for free.

Rust code that runs without the operating-system parts of the standard library.

An attribute that says more variants or fields may be added later, so adding them isn't a breaking change.

A pointer the other side may pass around but never look inside.

A return type the caller knows only by the traits it implements.

A standard for collecting traces, metrics, and logs across services.

Making +, ==, or [] work for your own types.

A value that might be missing: Some(value) or None.

A dependency that is only built when a feature asks for it.

A library that maps database rows to objects and writes the SQL for you.

You may implement a trait for a type only if the trait or the type is yours.

Text as the operating system stores it, which may not be valid UTF-8.

When a calculation's result is too big for its type.

Which variable is responsible for a value and cleaning it up.

A Cargo project: a Cargo.toml plus its source files.

Unused bytes the compiler adds so fields line up.

When a program stops because something went wrong it can't recover from.

Doing several things at the very same instant, on different CPU cores.

A value a function receives when it is called.

Turning text into a value such as a number.

Moving one field out of a value, leaving the rest.

Storing a password as a slow, salted fingerprint instead of the password itself.

The address of a file or folder.

The character between folder names in a path: / on macOS and Linux, \ on Windows.

The list of folders a terminal searches for a command you type.

A shape a value is compared against, like 1..=9 or _.

A zero-size field that tells the compiler a type uses a type parameter it doesn't store.

A future that is promised it won't be moved in memory again, so it can safely point into itself.

A number from 0 to 65535 that picks which program on a machine gets a network message.

The names every Rust file can use without importing them.

A query sent with placeholders, with the values sent separately.

The column that uniquely identifies each row in a table.

A queue where the most important item leaves first, not the oldest.

A Rust function that runs at compile time and writes code.

A tool that measures where a running program spends its time or memory.

A set of instructions a computer can carry out.

A test that checks a rule holds for hundreds of random inputs instead of a few chosen examples.

A library that assembles SQL from Rust method calls, with values bound safely.

A span of numbers written a..b or a..=b.

A pointer with no borrow checking: it may be null, dangling, or aliased.

Making an item available from a second, usually shorter, path.

A lock that lets many readers in at once, or one writer alone.

Moving data to a bigger heap block.

The self parameter: how a method gets the value it is called on.

A function calling itself.

A way to use a value without taking ownership of it.

Keeping a count of how many owners share a value and freeing it when the count reaches zero.

Values that point to each other with counted references, so none of them is ever freed.

A pattern that might not match.

Stable, beta, or nightly: how finished the Rust you install is.

The � symbol put in place of bytes that aren't valid UTF-8.

A folder whose history of snapshots Git keeps.

The outcome of something that can fail: Ok(value) or Err(error).

The type of value a function gives back.

A fixed block of memory used in a circle, so the front can move without shifting anything.

A website that compiles and runs small Rust programs for you.

The program that gives editors Rust errors, completion, and navigation.

The oldest Rust release a project promises to build with.

The Rust compiler.

Rust's tool that turns doc comments into HTML pages.

The tool that formats Rust code in the standard style.

The installer and version manager for Rust.

The conditions a caller must guarantee before calling an unsafe function.

The part of the program where a name can be used.

A public trait that other crates can use but not implement.

A version numbering scheme where the number says whether an update can break your code.

The two marker traits that say whether a type may be moved to, or shared with, another thread.

An #[serde(...)] line that changes how a type or field is written and read.

Turning a value into text or bytes to store or send it, and back again.

Declaring a new variable with the same name as an old one.

A function's name, parameters, and return type.

A view of part of an array, Vec, or String.

A constructor that checks its input and refuses to build an invalid value.

A type that acts like a reference but also owns or manages what it points to.

All the code from other people that ends up in your program through its dependencies.

The guarantee that no safe code can use an API to cause undefined behavior.

The text of a program as a person writes it.

An attack where user input is pasted into a query and changes what the query does.

Combining rows from two tables that match on a column.

A sort that keeps equal items in their original order.

Memory for a function's local variables, freed when it returns.

One function call's space on the stack.

Using more stack than the program has.

A program's second output stream, for problems.

The text typed into a running program.

The library of basic types and tools every Rust program gets.

A thread that never gets its turn, even though the program as a whole keeps running.

Code that does something but produces no value.

A value stored at one fixed place for the whole run.

Choosing which function to call at compile time.

A reference that is valid for the whole run of the program, like a string literal.

Putting library code into the program file itself, instead of loading it from the system when the program starts.

Growable text the program owns.

Text written in quotes in your code.

A named type grouping named fields.

Building a struct from another with ..other; unlisted fields are moved or copied from it.

Making sure every task a function starts is finished or cancelled before the function returns.

Logging named fields a machine can search, not just sentences.

A trait that must already be implemented before another one can be.

A request a program makes to the operating system, such as "open this file".

A block's last expression, with no semicolon, which becomes its value.

Where Cargo puts everything it builds.

The name of the machine a build is for, like x86_64-pc-windows-msvc.

A connection that delivers bytes reliably and in order between two programs.

A value made in the middle of an expression that is dropped at the end of the statement.

A text window where you type commands and read their output.

A function that checks other code and fails if it's wrong.

A stand-in for a real dependency, used so a test can run without it.

The data or setup a test needs before it runs, like a temporary folder with files in it.

A crate that writes the Error and Display boilerplate for your error types.

The encryption layer that keeps a connection private and proves the server is who it claims to be.

One installed version of the Rust tools.

A named stretch of work, like one request, that log events are attached to.

A named set of abilities a type can have, like Debug or Clone.

A requirement that a type parameter support some trait.

A value used only through a trait, whatever its real type.

Conversions that report failure instead of losing data.

A real terminal window a person is looking at, rather than a file or another program.

A fixed group of values of possibly different types.

A struct whose fields have positions instead of names.

The ::<Type> that names a type after a name, as in parse::().

The kind of value something is, like i32 or String.

A second, shorter name for an existing type, written with the type keyword.

A colon and a type written after a name, like : bool.

Hiding a value's real type behind a trait.

The compiler working out a type you didn't write.

Using types to make illegal state changes fail to compile.

Publishing a harmful package under a name one typo away from a popular one.

Sending single messages that may be lost, duplicated, or arrive out of order, with no connection.

Code whose result the language doesn't promise.

The number Unicode gives one character.

The empty value (), meaning "nothing to report".

A short message the operating system sends a running program, like "stop" when you press Ctrl-C.

A block of code where you take on proving some memory rules yourself.

What a panic does on the way out, dropping every frame's values.

Take the value out of an Option or Result, panicking if there isn't one.

Using memory after it has been given back.

A line that brings a name into scope so you can write it without its full path.

A text encoding that uses 2 or 4 bytes per character, used by Windows, Java, C#, and JavaScript.

The way Rust stores text: each character takes 1 to 4 bytes.

A name bound to a value.

Whether a longer-lived type can stand in for a shorter-lived one inside a bigger type.

One of the possible forms of an enum.

A queue you can push to and pop from at both ends quickly.

The version range a Cargo.toml line allows, like "1.4" meaning 1.4.0 up to (not including) 2.0.0.

Who is allowed to use an item: only its own module, the whole crate, or anyone.

A table of function pointers a trait object uses to find its methods.

A compiler message about code that compiles but looks wrong.

The tool that generates the glue between Rust compiled to Wasm and JavaScript.

A pointer to a shared value that doesn't keep the value alive.

A compact, portable program format that browsers and other hosts can run safely.

A connection that stays open so a server and a browser can both send messages at any time.

A tidy place after a signature to list trait bounds.

The pattern _, which matches anything.

The folder a terminal command runs in.

A set of crates built together that share one Cargo.lock and one target folder.

Marking a published crate version so new projects won't pick it, without deleting it.

A convenience that compiles to code as fast as writing it out by hand.

A type whose values take 0 bytes, like a unit struct.