Take the Python course first if you can. This course compares with Python all the way through, and several exercises rewrite functions from the bench code you will already know.

Code runs on the official Rust Playground, so Run and Check need an internet connection and take a few seconds each. In an exercise you write the functions and types; the page adds a main that calls them. Copy gives you the whole program to paste into cargo on your own machine.

There are 8 lessons and 15 exercises, each with a Check, a Hint and the Solution. Progress is kept in this browser.

Rust is a compiled language: a tool called the compiler reads your whole program, checks it, and turns it into machine code before anything runs. That check is strict. It catches whole families of bugs (a value that might be missing, two threads writing the same data, using something after it was freed) before the program ever reaches the bench. The price is that the compiler says no more often than Python does, and learning Rust is mostly learning to read what it says.

Every program starts at fn main(). Press Run: your code is sent to the official Rust Playground, compiled, and run there, so the first run takes a few seconds and needs an internet connection.

Statements end with a semicolon. println! prints a line; the ! marks it as a macro, which you can treat as a function for now. {} is replaced by the next value, and the formatting codes match Python's f-strings: {:.3} three decimals, {:+.1} always show the sign, {:>8} right-align in 8 characters. You can also put a variable name inside: {pout:.2}.

Variables cannot change unless you say so. let x = 5; is fixed. let mut x = 5; can be changed later. This is the first thing that trips everyone up, and the compiler's error tells you exactly where to add mut.

Types. Every value has one fixed type: i32 (32-bit signed integer, the default for whole numbers), u32, u8, i64, usize (sizes and indexes), f64 (the default for decimals), bool, char, and text, which comes in lesson 3. Rust never converts between number types silently. as converts on purpose: code as f64.

A function is written fn name(param: Type) -> ReturnType { body }. Parameter types are required. The last expression in the body, written without a semicolon, is the return value. Lesson 2 goes further; this is enough for the exercises.

In Rust almost everything is an expression that produces a value, including if and blocks in braces. That is why a function can end with a bare value, and why you can write let label = if x > 0 { "on" } else { "off" };. Both branches must give the same type.

Conditions need no brackets but the body always needs braces. There is no truthiness: if count is an error; write if count > 0.

Three loops:

• for i in 0..5 runs 0, 1, 2, 3, 4 (0..=5 includes 5). for x in list walks a collection.
• while cond { } as usual.
• loop { } repeats forever until break, and break value hands a value out of it.

Return early from a function with return x;.

In Python, two names can point at the same list and both change it; lesson 10 of the Python course showed the bug that causes. Rust prevents it with three rules the compiler enforces:

• Every value has exactly one owner (a variable).
• When the owner goes out of scope, the value is freed. No garbage collector, no leaks.
• You can lend a value out as many read-only borrows (&x) as you like, or one writable borrow (&mut x), never both at once.

Assigning or passing a heap value like a String or Vec moves it: the old name can no longer be used. Numbers and other small Copy types are copied instead, so you only meet moves with bigger things.

Text comes in two forms. String is owned text you can grow. &str is a borrowed view of text that lives somewhere else; string literals like "OUTP ON" are &str. A function that only reads text should take &str; it then accepts both.

Borrowing lets a function use a value without taking it: fn len_of(s: &str) or fn total(v: &[f64]) (a borrowed slice of numbers). To let a function change your value, lend it mutably: fn add_point(v: &mut Vec<f64>), called as add_point(&mut readings).

A struct groups named fields, like the data half of a Python class. Behaviour goes in a separate impl block. There is no inheritance; lesson 8 shows what Rust uses instead.

• fn new(...) -> Self is the conventional constructor. It is an ordinary function, called as SignalGenerator::new().
• Methods take &self to read the struct, &mut self to change it, or self to consume it. This is Python's self with the borrowing rules made explicit.
• #[derive(Debug)] above a struct lets {:?} print it.

The Python bench marks a missing reading with -999.0 or NaN, and the walkthroughs spend pages on making sure nobody mistakes those for real data. Rust removes the problem with types.

An enum is a value that is exactly one of several variants, and variants can carry data. match handles every variant, and the compiler refuses to build if you forget one.

The standard library's Option is that pattern made universal: Some(value) or None. A function that might have no answer returns Option<f64>, and the caller cannot use the number without first deciding what None means. There is no -999.0 to forget about.

• match opt { Some(x) => ..., None => ... }
• if let Some(x) = opt { ... } when you only care about one case
• opt.unwrap_or(0.0) for a default
• opt.is_some(), opt.is_none()

Python raises exceptions; Rust returns them. A function that can fail returns Result<T, E>: Ok(value) or Err(error). Like Option, you cannot reach the value without deciding what to do with the error.

The ? operator is the shortcut: let v = text.parse::<f64>()?; means "if this is an error, return it from my function now; otherwise give me the value". It is Python's let-it-propagate behaviour, but visible in the code and in the function's type.

.unwrap() takes the value and crashes on an error. It is fine in quick tests and wrong in bench code.

map_err converts one error into another, here a parse error into a readable String. For larger programs you define an error enum so callers can match on what went wrong, exactly like the Python engine's except ScopeNoTriggerError:.

Vec<T> is Rust's list and HashMap<K, V> its dict. Most loops over them are written as iterator chains: .iter() to walk, then adapters such as .map(), .filter(), .enumerate(), .zip(), and a final step like .sum(), .count(), .max_by() or .collect().

The |r| r.gain parts are closures: small unnamed functions, Python's lambda. They can use variables from around them.

Floats have no total ordering because of NaN, so .max() does not work on f64. Use .max_by(|a, b| a.total_cmp(b)) or f64::max in a fold. This is Rust making you decide about NaN up front, the same problem the Python code solved with x == x.

Rust has no class inheritance. A trait lists methods a type promises to provide, and any struct can implement it. Code then works with "anything that is an Instrument" rather than with one class tree.

• trait Instrument { fn write(&mut self, cmd: &str); } declares it
• impl Instrument for FakeInstrument { ... } provides it
• fn configure<I: Instrument>(inst: &mut I) is generic: one copy compiled per concrete type, as fast as hand-written code
• Box<dyn Instrument> holds any instrument chosen at run time, like Python's duck typing but checked
• A trait can supply default methods built from the required ones, which covers most of what the Python mixins do

1. Install

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
cargo new bench_tools && cd bench_tools
cargo run              # build and run src/main.rs
cargo test             # run #[test] functions
cargo clippy           # the linter: very good at teaching idiomatic Rust

2. Read and practise

• The Rust Programming Language ("the book"): chapters 4 (ownership), 6 (enums), 9 (errors) and 10 (traits) go deeper on this weekend.
• Rustlings: small exercises that run on your machine, in the same spirit as this page.
• Rust by Example for quick lookups.

3. Bench projects to try

1. Port evaluate_limits and get_cal_offset to Rust with Option instead of -999.0, and write #[test]s for them.
2. Talk to a real instrument: the visa-rs crate wraps NI-VISA, or open a raw TCP socket to an instrument's port 5025 with std::net::TcpStream and send *IDN?.
3. Embedded Rust: the Embedded Rust Book and probe-rs run Rust on the same Cortex-M chips as the Assembly course.