--- title: "1.1 Statements and the structure of a program" description: "What statements are, why every Rust program starts at fn main, and a line-by-line dissection of Hello, world." url: "https://learnrust.net/chapter-1/statements-and-program-structure/" last_updated: "2026-06-11" --- # 1.1 Statements and the structure of a program > **Chapter introduction** > > Welcome to the first real programming chapter. Chapter 1 takes a wide, deliberately shallow pass over the core of Rust: enough of each piece for you to write and understand small programs, with the depth deferred to later chapters. Don't expect mastery of anything yet, and don't worry when a lesson says "we'll explain the rest later." That's the design, and the later chapters keep the promise. Starting in this chapter, every lesson ends with a short quiz; do them, even when they look easy. A computer program is a list of instructions, and in Rust the most basic instruction is called a **statement**. A statement makes the program *do* something: create a variable, compute a value, print some text. Statements are the sentences of a programming language, and like sentences end with periods, most Rust statements end with a semicolon `;`. A program is many statements executed in order, top to bottom, one after another. So far, so simple. The next question is where that top is. ## Functions and main Statements don't float around loose. They live inside **functions**: named bundles of statements that run as a group, in order, whenever the function is used. We'll spend all of chapter 2 on functions; for now you only need the most famous one. When you run a Rust program, execution begins at the top of a function named `main`. Statements inside `main` run in order, and when the last one finishes, the program ends. > **Rule** > > Every Rust program must have exactly one function named `main`. No `main`, no program; the build fails before anything runs. ## Dissecting Hello, world You met this program in lesson [0.8](https://learnrust.net/chapter-0/compiling-your-first-program/), where we refused to explain it. Time to pay up. ```rust fn main() { println!("Hello, world!"); } ``` Line 1: `fn` is the keyword that defines a function (Rust spells things tersely; get used to it). `main` is the function's name, the parentheses `()` hold the function's inputs (none here; chapter 2 fills them), and the opening brace `{` begins the function's **body**, the statements that belong to it. Line 2 is the body's one statement, and it does the printing. `println!` is the tool being used: its name comes from "print line", and its job is to write text to the screen, then move to the next line. The text it prints is `"Hello, world!"`, a piece of text data in quotes (text in quotes is called a **string literal**; more in lesson [1.10](https://learnrust.net/chapter-1/literals-and-operators/)). The parentheses hand the text to `println!`, and the semicolon ends the statement. Line 3: the closing brace `}` ends the body of `main`, and with it, the program. So what's that exclamation mark about? The `!` means `println!` is a **macro** rather than a function. For now, here's the working definition: a macro is a supercharged function, used much like a regular one, with the `!` as its name tag. > **Key insight** > > Why does printing need to be "supercharged" at all? Because `println!` accepts things ordinary functions can't, like any number of values to print at once. You'll use macros constantly and write none of them for a very long time; the full story is in chapter 24, and nothing before it depends on those details. When you see `!`, think "macro, called like a function," and read on. ## Syntax errors A programming language has grammar rules, just like English, and the compiler enforces them to the letter. Break one and you get a **syntax error**. Here's a program with a semicolon missing at the end of line 2: ```rust fn main() { println!("Hello") println!("world"); } ``` The compiler refuses, and tells you why: ``` error: expected `;`, found `println` --> src/main.rs:2:22 | 2 | println!("Hello") | ^ help: add `;` here 3 | println!("world"); | ------- unexpected token ``` This is worth reading slowly, because you'll be reading messages like it all week. The first line states the problem: the compiler expected a semicolon and found the word `println` instead. The `-->` line gives the location as file, line, and column. The caret `^` points at the exact spot, and `help:` spells out the fix. Rust's error messages will usually meet you at least this far; many go further and write the corrected code for you. > **Key insight** > > The compiler reports where it *noticed* the problem, which isn't always where the problem *is*. Here the missing semicolon belongs to line 2, but the compiler only became certain something was wrong when line 3 started with an unexpected `println`. If an error location looks innocent, check just above it. The best thing you can do right now is break this program yourself. Type it in correctly, then sabotage it one change at a time: remove a semicolon, delete a brace, misspell `println`, drop a quote. Compile after each. You'll meet half a dozen error messages in five minutes, in the lowest-stakes setting you'll ever meet them. ## Quiz time **Question #1** What is a statement?
Show solution A statement is the smallest instruction that makes a program do something, such as creating a variable or printing text. Most statements in Rust end with a semicolon.
**Question #2** What is a function?
Show solution A named bundle of statements that run as a group, in order, whenever the function is used.
**Question #3** What is the name of the function every Rust program must have, and what is special about it?
Show solution `main`. When the program runs, execution starts at the top of `main`, and the program ends when `main` finishes. Every program must have exactly one.
**Question #4** In `println!`, what does the `!` tell you?
Show solution That `println!` is a macro rather than a regular function. At this point in the course, treat a macro as a supercharged function that's called the same way; chapter 24 explains what's actually super about it.
**Question #5** What is a syntax error?
Show solution A violation of the language's grammar rules, caught by the compiler, which then refuses to build the program. A missing semicolon is the classic example.
**Question #6** Without compiling it, what's wrong with this program? ```rust fn main() { println!("Hi there") } ``` Trick question warning: try compiling it after you've answered.
Show solution It looks like the semicolon mistake from this lesson, but this program actually compiles and runs. When the *last* thing in a function body has no semicolon, Rust treats it as something subtly different from a statement, and it's legal. The why is lesson [1.11](https://learnrust.net/chapter-1/expressions-and-statements/)'s whole job. (The lesson here: with one statement per function body, some semicolon mistakes are forgiven. With two, as in the example above, they're not.)
In the next lesson, we'll cover the second-most-used tool after `println!`: notes to yourself that the compiler ignores entirely. ## Sitemap See the full [sitemap](https://learnrust.net/sitemap.md) for all pages.