The course on one page

• Say what a program is in one sentence

• Create a Rust project with cargo new

• Print text with println! and fill holes with {}

Errors met: E0425

• Combine println! and format! into one small program

• Find the error code, the file, the line and the column in a compiler message

Errors met: E0308

• your own functions (fn)fn print_banner() {
• &str (text a function can read)fn greeting(name: &str) -> String {

Errors met: E0061

• Predict what a short program prints, or which error stops it, without running it

• letlet bot = "Chatterbox";

• mutlet mut messages_seen = 0;

Errors met: E0384

• number types (i32, u32, usize, f64…)let max_len: usize = 200;
• true / falselet quiet: bool = false;

• Work out how many values fit in a number of bits, and read a type name like u32 or i8

• String (text that can grow)let mut message = String::from("Hello");
• calling a method (value.method())message.push_str(", world");

• constconst BOT: &str = "Chatterbox";
• tuples (.0, .1)println!("major {}, minor {}", version.0, version.1);

• Predict what a short program with names, numbers and text prints, or why it stops

• if / elseif message.is_empty() {

• matchmatch message {

• loops (for, while, loop)while retries > 0 {

• use (bringing a name in)use std::io;

• Predict which branch, arm or loop turn runs in a short program

• Say what the stack and the heap are, and which values go where

• State the one-key rule in your own words

• Explain what a move is in terms of the one key

Errors met: E0382

• borrowing with &let loud = shout(&msg);

Errors met: E0502

• &mut (a borrow that can change)fn record(log: &mut String, msg: &str) {

Errors met: E0499

• slices ([a..b])let cmd = &msg[..4];

• Say, for each line of a short program, who owns a value and who is only borrowing it

• structstruct Message {

• impl and selfimpl Message {

• enumenum Command {

• Option (Some / None)fn find_command_arg(line: &str) -> Option<&str> {
• .unwrap()io::stdin().read_line(&mut name_line).unwrap();

• if let, | in patterns, #[derive(Debug)]while let Some(i) = rest.find(' ') {

Errors met: E0004

• Tell a struct from an enum, and pick the right one for a new piece of data

• Veclet mut names: Vec<String> = Vec::new();

• .iter() and .enumerate()for (i, text) in history.iter().enumerate() {

• HashMapuse std::collections::HashMap;

• closures (|x| …)let double = |n: u32| n * 2;

• iterator steps (.map, .filter, .collect, .sum)let lengths = history.iter().map(|m| {

• Pick a Vec or a HashMap by the question you ask: by position or by name

• Result (Ok / Err)Ok(n) => println!("count is {n}"),

• the ? operatorlet n = arg.trim().parse::<u32>()?;

• tests (#[test])#[cfg(test)]

• Format a project with cargo fmt and check it with cargo fmt --check

• Predict whether a program with Result and ? compiles, and what it prints, without running it

• mod, pub and crate::mod message {

Errors met: E0616

• files (std::fs)match fs::read_to_string(path) {

• generics (<T>)fn last_n<T>(items: &[T], n: usize) -> &[T] {

Errors met: E0369

• trait, dyn and Boxtrait Replier {

• lifetimes ('a)fn longer<'a>(a: &'a str, b: &'a str) -> &'a str {

Errors met: E0106

• Predict whether a program with modules, generics, traits or lifetimes compiles, and what it prints

• serde (JSON)use serde::{Deserialize, Serialize};

• reqwest and environment variablesHttp(reqwest::Error),

• Run your program's own tests with cargo test

• Predict what serde writes for a struct or a list, and when reading JSON fails

• async, .await and tokioasync fn greet(name: &str) -> String {

Errors met: E0728

• tasks and channels (spawn, mpsc)use tokio::sync::mpsc;

Errors met: E0373

• Ask a chat API for a streamed answer and recognise the server-sent event lines it sends back

• select! and Ctrl-Ctokio::select! {

• Predict when an async fn runs, what tokio::join! hands back, and when a channel closes