Glossary

This page isn't for reading cover to cover — it's for jumping: every term link in the chapters lands on an anchor here. Use it to do two things:

• Look a term up in its group (language / memory / abstraction / concurrency / project / LLM) and get a one-sentence definition.
• Most entries carry a chapter reference — follow it to the place that explains the term in full.

Anchor rules (the whole book links by them)

Every heading is its own anchor: lowercase English, hyphens between words — for example ownership and borrow checker. The Chinese edition lives at /glossary with identical structure and identical anchors. Three symbol-bearing terms follow the same rule: no_std, crates.io, and Cargo.lock anchor to #no-std, #crates-io, and #cargo-lock — underscores and dots both become hyphens.

Language Core

A · Language Core — The first layer of vocabulary you meet when reading Rust; most of it is worked through in Chapters 4–7 group by group. Three entries — closure, iterator, and Vec/HashMap — never get a section of their own: the chapters explain them inline where they're used (the map_err closure in Chapter 6, the .map/.collect pipeline in Chapter 14); come back here whenever you forget one.

let binding

let binding — Binds a value to a name with let; immutable by default.

mutability

mutability — Only mut allows in-place change; immutability is the default, not an omission.

shadowing

shadowing — A new let with the same name covers the old binding, and the type may change.

function

function — fn name(param: Type) -> ReturnType; parameter and return types are always explicit.

expression vs statement

expression vs statement — Expressions produce values (if, match, and blocks all do); statements only do work.

primitive types

primitive types — Integers (the u/i families), floats, bool, char, and the unit type ().

string slice

string slice — &str: a read-only view over UTF-8 bytes; it owns nothing.

String

String — The owned, growable UTF-8 string.

enum

enum — One type, one of several known variants; Option and Result are both enums.

struct

struct — An aggregate of named fields; its methods live in an impl block.

pattern matching

pattern matching — match / if let take a value apart by shape and bind variables; the compiler enforces exhaustiveness.

Option

Option — Option<T>: Some(v) or None — the stand-in for null.

Result

Result — Result<T, E>: Ok(v) or Err(e) — the carrier of recoverable errors.

question mark operator

question mark operator — ?: on error, return early with it; on success, unwrap and move on.

closure

closure — An anonymous function that captures its environment: |x| x + 1.

iterator

iterator — A lazy sequence plus the map / filter / collect pipeline; what a for loop runs on.

Vec and HashMap

Vec and HashMap — The two workhorse containers: a dynamic array and a hash map.

Memory Model

B · Memory Model — Where data lives, who owns it, and when it goes away; the spine of Chapter 5.

ownership

ownership — Every value has exactly one owner; when the owner leaves scope, the value is dropped.

move

move — Assignment or passing a value hands ownership over; the old name stops working.

borrowing

borrowing — Take a reference (&T read-only, &mut T writable) instead of taking ownership.

borrow checker

borrow checker — Enforces "many readers or one writer" at compile time; it stops data races, not you.

clone

clone — An explicit deep copy; a .clone() is always someone's deliberate decision to copy.

lifetime

lifetime — An annotation of how long a reference is valid; mostly inferred — just learn to recognize 'a.

heap and stack

heap and stack — The stack holds fixed-size data and call frames, the heap holds dynamic data; ownership decides when heap data is freed.

Drop

Drop — The cleanup callback that runs when a value leaves scope — Rust's shape of RAII.

Abstraction

C · Abstraction — Pulling behavior contracts out of concrete types; Chapters 6–7, where jackdaw's spine, trait Provider, grows.

trait

trait — A contract of behavior: a set of method signatures, implemented with impl Trait for Type.

derive

derive — #[derive(Debug, Clone)] has the compiler implement common traits for you.

generics

generics — Programming over "any type that meets the contract": fn f<T: Trait>, struct S<T>.

trait object

trait object — Box<dyn Trait>: one pointer that, at runtime, points at any implementer.

monomorphization

monomorphization — The compiler stamps out specialized code for each concrete type; this is where the speed comes from.

smart pointer

smart pointer — Pointers like Box, Rc, Arc that own data and manage its lifetime.

Arc

Arc — Atomic Reference Counting: the smart pointer for sharing ownership across threads.

Mutex

Mutex — The lock that admits one thread at a time; stored bound to the data it guards.

Concurrency and Async

D · Concurrency and Async — The words you need to serve many requests at once; introduced in Chapter 7, load-bearing in Chapters 12–14.

async fn

async fn — An async fn returns a Future and yields at each await.

Future

Future — A description of a value that arrives later; it does nothing until you await it.

runtime

runtime — The scheduler that drives Futures to completion; the standard library ships none, and Tokio is the de facto standard.

spawn

spawn — Hand an async task to the runtime to run concurrently.

mpsc channel

mpsc channel — A multi-producer, single-consumer queue for passing messages between tasks.

Send and Sync

Send and Sync — Marker traits for "safe to move / share across threads"; when they show up in an error, think "a data race just got blocked."

Stream

Stream — The async cousin of an iterator; an SSE response body is a Stream.

Project and Ecosystem

E · Project and Ecosystem — The Cargo world and the shipping pipeline; structure in Chapters 8–9, tests and releases in Chapter 15.

Cargo

Cargo — Build tool plus package manager; one command for building, testing, and dependencies.

manifest

manifest — Cargo.toml: the project's metadata and dependency declarations; Chapter 8 reads it line by line.

crate

crate — One compilation unit: a binary (executable) or a library (consumed by others).

package and module

package and module — A package is the crates.io publish unit; mod layers code inside a crate, use pulls in paths.

workspace

workspace — A way to organize multiple crates that share one target/ and one lockfile.

crates.io

crates.io — The official package registry; docs.rs builds API docs for every version automatically.

semver

semver — 1.6.3 = major.minor.patch; ^ / ~ state compatibility ranges.

Cargo.lock

Cargo.lock — Pins dependency versions exactly so builds reproduce.

feature

feature — An optional compile-time switch on a dependency, trimming it to what you need.

serialization

serialization — Converting in-memory data to and from TOML/JSON; jackdaw does it with serde (Chapters 6 and 11).

edition

edition — The language-level evolution unit (2015/2018/2021/2024); orthogonal to the compiler version.

fmt and clippy

fmt and clippy — cargo fmt makes formatting uniform; cargo clippy catches unidiomatic code.

tests

tests — #[test]: unit tests live next to the code in #[cfg(test)], integration tests in tests/.

mock

mock — A fake implementation that stands in for a real dependency (say, a real HTTP provider) during tests.

CI

CI — Checks that run automatically on push or PR; GitHub Actions defines them in YAML.

profile

profile — dev compiles fast, release optimizes; artifacts land under target/.

cross compilation

cross compilation — Building a binary for another platform from this one.

no_std

no_std — Environments (embedded, kernels) with no standard library — possibly not even an allocator.

FFI

FFI — The boundary where Rust and C call each other; the export surface of system-level libraries.

LLM Engineering

F · LLM Engineering — The jargon of the agent → gateway → provider chain; defined in Chapter 2, built in jackdaw across Chapters 10–14.

LLM

LLM — Large language model (a.k.a. model): predicts the next token from the token history; APIs reference it by model id.

provider

provider — Whoever serves a model API: OpenAI, Anthropic, OpenRouter, a local vLLM, and so on.

agent

agent — A program driving a model in a loop: send messages, run tools, feed results back, until the task is done.

tool call

tool call — The model's structured request "call this function for me"; the agent executes it and posts the result back.

token

token — The unit models process text in, roughly a word or a piece of one; billing and context both count in tokens.

context window

context window — The cap on how many tokens a model can see at once.

prompt

prompt — The user input; the system prompt is the hidden instruction that sets the model's role and behavior.

messages

messages — The structured conversation history, each entry tagged with a role (system / user / assistant / tool).

streaming

streaming — Server-sent events (SSE): the server pushes chunks as they're ready; no waiting for the full answer.

gateway

gateway — The always-on local forwarding service: one front door, many providers behind it; what jackdaw is (Chapter 14).

routing

routing — Deciding, by reference or by rule, which model serves this request.

routing group

routing group — group/<id> bundles several models under one name, with a strategy and failover (Chapter 13).

failover

failover — When the upstream fails, automatically try the next one on the list.

rotate

rotate / round-robin — Start each request at the next member in turn, spreading the load.

environment variable

environment variable — Process-level configuration; the standard home for secrets — never in code, never in config files.

API key

API key — The credential for paid APIs; jackdaw's config stores the variable's name and reads the value at runtime.

endpoint

endpoint — The address a service listens on, like 127.0.0.1:3426/v1/chat/completions.

OpenAI compatible

OpenAI compatible — The de facto standard chat-API shape; many services implement it, and jackdaw speaks it on both sides.

Wrapping up

• 77 terms in six groups, matching the book's layers; each of these 77 terms carries a link at its first appearance in the chapters, and those links land here.
• Group order is learning order: language and memory → abstraction and concurrency → project → LLM engineering.
• The Chinese edition has the same structure and the same anchors at /glossary; whichever language you start from, the links hold.