What Rust doesn't have

Syntax · Lesson 4

Some things you reach for by habit do not exist in Rust: x++, a ? b : c, null, C-style for, default arguments, classes, exceptions, goto. Each one fails with a compiler message, and each has a Rust way. This page lists them, with the real error and what to write instead.

Coming from Goi++ is a statement in Go, and Rust has no ++ at all. Much else matches: Go has no ternary operator, no function overloading by type, no default arguments and no mixing of typed number types either. What you give up is nil, goto, defer, for cond {} and the if err != nil boilerplate: Rust has Option, labeled break, Drop, while and ?. Watch the break inside a switch: in Rust it leaves the loop.

Coming from KotlinYou are used to a lot of this already: if is an expression, there is no ternary operator, and T? is a checked null. What Rust takes away is ++, ?., ?: and !! (Option has map, unwrap_or and unwrap), default and named arguments, open classes with inheritance, and exceptions (Result and ? replace try/catch).

Coming from PythonPython has no x++ either, so x += 1 is already your habit. What is new is that an if needs a bool (an empty list or a 0 is not false), a call has no keyword arguments and a definition has no default values, // starts a comment, and/or/not/elif are &&/||/!/else if, a name has one type, and braces replace the indentation.

Coming from TypeScriptx++, a ? b : c, null and undefined, ??, truthiness (if (name)), throw and optional parameters all have a different Rust form: x += 1, if a { b } else { c }, Option, unwrap_or, an explicit test, Result and ?, and a struct. Careful: u?.name is valid Rust, and it is not a safe call but an early return. Rust also does not turn a number into another number type for you.

Coming from Javai++, ?:, null, new, this, extends, function overloading, switch that falls through, finally and checked or unchecked exceptions all have a different Rust form. Java widens int to long on its own; Rust makes you write the conversion. A break in a switch inside a loop leaves the switch in Java; in Rust it leaves the loop.

Coming from C#i++, ?:, ?., new, this, : BaseClass, function overloads, optional and named arguments, and try/catch have a different Rust form, and null becomes Option. C# widens int to long on its own; Rust makes you write the conversion. A break in a switch inside a loop leaves the switch in C#; in Rust it leaves the loop.

Coming from Ci++, ?:, for (i = 0; i < n; i++), NULL, a switch that falls through, goto, (double)n, -> and #define do not exist or fail in Rust, as does if (n) on a number. A global you assign without unsafe fails to compile too, and C's silent number conversions (int n = 3.9;) need an explicit as. A break; at the end of a ported case compiles and leaves the loop.

Coming from C++Everything in the C list, plus classes with inheritance, function overloads, default arguments, constructors and exceptions: Rust has none of them. A struct holds data, an impl block holds methods, a trait shares behaviour (and impl Add is your operator+), a Drop runs where a destructor would, and a Result carries a failure. auto is let.

The quick comparison

Rustsrc/main.rsRun ↗Copy

// What other languages write with ?:, i++, null and switch, written in Rust.
fn size(n: i32) -> &'static str {
    match n {
        1 | 2 => "small",
        3 => "medium",
        _ => "large",
    }
}

fn first_even(items: &[i32]) -> Option<i32> {
    for &x in items {
        if x % 2 == 0 {
            return Some(x);
        }
    }
    None
}

fn main() {
    let mut total = 0;
    for i in 0..4 {
        total += i;
    }
    let label = if total > 5 { "big" } else { "small" };
    println!("total: {total} ({label})");
    println!("size: {} {}", size(2), size(9));
    match first_even(&[3, 5, 8]) {
        Some(n) => println!("first even: {n}"),
        None => println!("no even number"),
    }
    println!("none: {}", first_even(&[1, 3]).unwrap_or(-1));
    let wide = total as i64 * 1_000_000_000;
    println!("wide: {wide}");
}

$ cargo run

total: 6 (big)
size: small large
first even: 8
none: -1
wide: 6000000000

GoKotlinPythonTypeScriptJavaC#CC++

Copy

package main

import "fmt"

// What other languages write with ?:, i++, null and switch, written in Go.
func size(n int) string {
  switch n {
  case 1, 2:
    return "small"
  case 3:
    return "medium"
  default:
    return "large"
  }
}

func firstEven(items []int) (int, bool) {
  for _, x := range items {
    if x%2 == 0 {
      return x, true
    }
  }
  return 0, false
}

func main() {
  total := 0
  for i := 0; i < 4; i++ {
    total += i
  }
  label := "small"
  if total > 5 {
    label = "big"
  }
  fmt.Printf("total: %d (%s)\n", total, label)
  fmt.Printf("size: %s %s\n", size(2), size(9))
  if n, ok := firstEven([]int{3, 5, 8}); ok {
    fmt.Printf("first even: %d\n", n)
  } else {
    fmt.Println("no even number")
  }
  n, ok := firstEven([]int{1, 3})
  if !ok {
    n = -1
  }
  fmt.Printf("none: %d\n", n)
  wide := int64(total) * 1_000_000_000
  fmt.Printf("wide: %d\n", wide)
}

$ go run main.go

total: 6 (big)
size: small large
first even: 8
none: -1
wide: 6000000000

// What other languages write with ?:, i++, null and switch, written in Kotlin.
fun size(n: Int): String = when (n) {
    1, 2 -> "small"
    3 -> "medium"
    else -> "large"
}

fun firstEven(items: List<Int>): Int? {
    for (x in items) {
        if (x % 2 == 0) return x
    }
    return null
}

fun main() {
    var total = 0
    for (i in 0 until 4) {
        total += i
    }
    val label = if (total > 5) "big" else "small"
    println("total: $total ($label)")
    println("size: ${size(2)} ${size(9)}")
    val even = firstEven(listOf(3, 5, 8))
    if (even != null) println("first even: $even") else println("no even number")
    println("none: ${firstEven(listOf(1, 3)) ?: -1}")
    val wide = total.toLong() * 1_000_000_000
    println("wide: $wide")
}

$ kotlinc Main.kt -include-runtime -d main.jar && java -jar main.jar

total: 6 (big)
size: small large
first even: 8
none: -1
wide: 6000000000

# What other languages write with ?:, i++, null and switch, written in Python.
from typing import Optional


def size(n: int) -> str:
    if n in (1, 2):
        return "small"
    if n == 3:
        return "medium"
    return "large"


def first_even(items: list[int]) -> Optional[int]:
    for x in items:
        if x % 2 == 0:
            return x
    return None


total = 0
for i in range(4):
    total += i
label = "big" if total > 5 else "small"
print(f"total: {total} ({label})")
print(f"size: {size(2)} {size(9)}")
even = first_even([3, 5, 8])
if even is not None:
    print(f"first even: {even}")
else:
    print("no even number")
none = first_even([1, 3])
print(f"none: {-1 if none is None else none}")
wide = total * 1_000_000_000
print(f"wide: {wide}")

$ python3 main.py

total: 6 (big)
size: small large
first even: 8
none: -1
wide: 6000000000

// What other languages write with ?:, i++, null and switch, written in TypeScript.
function size(n: number): string {
  switch (n) {
    case 1:
    case 2:
      return "small";
    case 3:
      return "medium";
    default:
      return "large";
  }
}

function firstEven(items: number[]): number | undefined {
  for (const x of items) {
    if (x % 2 === 0) return x;
  }
  return undefined;
}

let total = 0;
for (let i = 0; i < 4; i++) {
  total += i;
}
const label = total > 5 ? "big" : "small";
console.log(`total: ${total} (${label})`);
console.log(`size: ${size(2)} ${size(9)}`);
const even = firstEven([3, 5, 8]);
if (even !== undefined) {
  console.log(`first even: ${even}`);
} else {
  console.log("no even number");
}
console.log(`none: ${firstEven([1, 3]) ?? -1}`);
const wide = total * 1_000_000_000;
console.log(`wide: ${wide}`);

$ tsc --strict --module nodenext --types node main.ts && node main.js

total: 6 (big)
size: small large
first even: 8
none: -1
wide: 6000000000

import java.util.List;
import java.util.Optional;

public class Main {
    // What other languages write with ?:, i++, null and switch, written in Java.
    static String size(int n) {
        return switch (n) {
            case 1, 2 -> "small";
            case 3 -> "medium";
            default -> "large";
        };
    }

    static Optional<Integer> firstEven(List<Integer> items) {
        for (int x : items) {
            if (x % 2 == 0) {
                return Optional.of(x);
            }
        }
        return Optional.empty();
    }

    public static void main(String[] args) {
        int total = 0;
        for (int i = 0; i < 4; i++) {
            total += i;
        }
        String label = total > 5 ? "big" : "small";
        System.out.println("total: " + total + " (" + label + ")");
        System.out.println("size: " + size(2) + " " + size(9));
        Optional<Integer> even = firstEven(List.of(3, 5, 8));
        if (even.isPresent()) {
            System.out.println("first even: " + even.get());
        } else {
            System.out.println("no even number");
        }
        System.out.println("none: " + firstEven(List.of(1, 3)).orElse(-1));
        long wide = (long) total * 1_000_000_000;
        System.out.println("wide: " + wide);
    }
}

$ javac Main.java && java Main

total: 6 (big)
size: small large
first even: 8
none: -1
wide: 6000000000

// What other languages write with ?:, i++, null and switch, written in C#.
static string Size(int n) => n switch
{
    1 or 2 => "small",
    3 => "medium",
    _ => "large",
};

static int? FirstEven(int[] items)
{
    foreach (var x in items)
    {
        if (x % 2 == 0) return x;
    }
    return null;
}

var total = 0;
for (var i = 0; i < 4; i++)
{
    total += i;
}
var label = total > 5 ? "big" : "small";
Console.WriteLine($"total: {total} ({label})");
Console.WriteLine($"size: {Size(2)} {Size(9)}");
var even = FirstEven(new[] { 3, 5, 8 });
if (even is not null)
{
    Console.WriteLine($"first even: {even}");
}
else
{
    Console.WriteLine("no even number");
}
Console.WriteLine($"none: {FirstEven(new[] { 1, 3 }) ?? -1}");
long wide = (long)total * 1_000_000_000;
Console.WriteLine($"wide: {wide}");

$ dotnet run

total: 6 (big)
size: small large
first even: 8
none: -1
wide: 6000000000

#include <stdio.h>

// What other languages write with ?:, i++, null and switch, written in C.
const char *size(int n) {
    switch (n) {
    case 1:
    case 2:
        return "small";
    case 3:
        return "medium";
    default:
        return "large";
    }
}

// Returns a pointer to the first even number, or NULL when there is none.
const int *first_even(const int *items, int len) {
    for (int i = 0; i < len; i++) {
        if (items[i] % 2 == 0) {
            return &items[i];
        }
    }
    return NULL;
}

int main(void) {
    int total = 0;
    for (int i = 0; i < 4; i++) {
        total += i;
    }
    const char *label = total > 5 ? "big" : "small";
    printf("total: %d (%s)\n", total, label);
    printf("size: %s %s\n", size(2), size(9));
    int a[] = {3, 5, 8};
    const int *even = first_even(a, 3);
    if (even != NULL) {
        printf("first even: %d\n", *even);
    } else {
        printf("no even number\n");
    }
    int b[] = {1, 3};
    const int *none = first_even(b, 2);
    printf("none: %d\n", none != NULL ? *none : -1);
    long long wide = (long long)total * 1000000000LL;
    printf("wide: %lld\n", wide);
    return 0;
}

$ gcc -Wall -Wextra main.c -o main && ./main

total: 6 (big)
size: small large
first even: 8
none: -1
wide: 6000000000

#include <iostream>
#include <optional>
#include <vector>

// What other languages write with ?:, i++, null and switch, written in C++.
const char *size(int n) {
    switch (n) {
    case 1:
    case 2:
        return "small";
    case 3:
        return "medium";
    default:
        return "large";
    }
}

std::optional<int> first_even(const std::vector<int> &items) {
    for (int x : items) {
        if (x % 2 == 0) {
            return x;
        }
    }
    return std::nullopt;
}

int main() {
    int total = 0;
    for (int i = 0; i < 4; i++) {
        total += i;
    }
    const char *label = total > 5 ? "big" : "small";
    std::cout << "total: " << total << " (" << label << ")\n";
    std::cout << "size: " << size(2) << " " << size(9) << "\n";
    auto even = first_even({3, 5, 8});
    if (even) {
        std::cout << "first even: " << *even << "\n";
    } else {
        std::cout << "no even number\n";
    }
    std::cout << "none: " << first_even({1, 3}).value_or(-1) << "\n";
    long long wide = static_cast<long long>(total) * 1000000000LL;
    std::cout << "wide: " << wide << "\n";
}

$ g++ -std=c++20 -Wall -Wextra main.cpp -o main && ./main

total: 6 (big)
size: small large
first even: 8
none: -1
wide: 6000000000

What's different

• Rust has no x++ and no a ? b : c. Write x += 1, and if a { b } else { c }, which is an expression.
• There is no null. A value that may be missing has the type Option<T>, and the compiler makes you handle None.
• Numbers do not convert on their own: i32 plus i64 is an error. Write as, From or try_from.
• No switch fallthrough, no exceptions for ordinary errors, no default or named arguments, no function overloading by parameter type, no classes and no goto. Each has a Rust form, shown on this page. A break in a match inside a loop leaves the loop.

Gotcha

Writing x++

Looks fine: in Go, Kotlin, TypeScript, Java, C#, C and C++ it runs fine. Rust won't compile it.

Works in Go. In Rust it's just a rule.Works in Kotlin. In Rust it's just a rule.Python refuses this too. Same idea, different words.Works in TypeScript. In Rust it's just a rule.Works in Java. In Rust it's just a rule.Works in C#. In Rust it's just a rule.Works in C. In Rust it's just a rule.Works in C++. In Rust it's just a rule.

Rustsrc/main.rs✗ won't compileCopy

fn main() {
    let mut count = 0;
    for _ in 0..3 {
        count++;
    }
    println!("count: {count}");
}

Go✓Kotlin✓Python✗TypeScript✓Java✓C#✓C✓C++✓

Copy

package main

import "fmt"

func main() {
  count := 0
  for i := 0; i < 3; i++ {
    count++
  }
  fmt.Printf("count: %d\n", count)
}

$ go run main.go✓ runs

count: 3

fun main() {
    var count = 0
    for (i in 0 until 3) {
        count++
    }
    println("count: $count")
}

$ kotlinc Main.kt -include-runtime -d main.jar && java -jar main.jar✓ runs

count: 3

count = 0
for _ in range(3):
    count++
print(f"count: {count}")

$ python3 main.py✗ refuses too

  File "main.py", line 3
    count++
           ^
SyntaxError: invalid syntax

let count = 0;
for (let i = 0; i < 3; i++) {
  count++;
}
console.log(`count: ${count}`);

$ tsc --strict --module nodenext --types node main.ts && node main.js✓ runs

count: 3

public class Main {
    public static void main(String[] args) {
        int count = 0;
        for (int i = 0; i < 3; i++) {
            count++;
        }
        System.out.println("count: " + count);
    }
}

$ javac Main.java && java Main✓ runs

count: 3

var count = 0;
for (var i = 0; i < 3; i++)
{
    count++;
}
Console.WriteLine($"count: {count}");

$ dotnet run✓ runs

count: 3

#include <stdio.h>

int main(void) {
    int count = 0;
    for (int i = 0; i < 3; i++) {
        count++;
    }
    printf("count: %d\n", count);
    return 0;
}

$ gcc -Wall -Wextra main.c -o main && ./main✓ runs

count: 3

#include <iostream>

int main() {
    int count = 0;
    for (int i = 0; i < 3; i++) {
        count++;
    }
    std::cout << "count: " << count << "\n";
}

$ g++ -std=c++20 -Wall -Wextra main.cpp -o main && ./main✓ runs

count: 3

What does the compiler say? Guess first, then open.

$ cargo build

error: Rust has no postfix increment operator
 --> src/main.rs:4:14
  |
4 |         count++;
  |              ^^ not a valid postfix operator
  |
help: use `+= 1` instead
  |
4 -         count++;
4 +         count += 1;

What happens in Go

Go prints 3. count++ is a statement, not an expression, so x := count++ is an error in Go. ++count does not exist.

What happens in Kotlin

Kotlin prints 3. count++ and ++count both work, and can sit inside a larger expression.

What happens in Python

Python refuses with a SyntaxError: it has no ++ operator, so write count += 1. It is the one language here with no ++. Note that ++count and --count are legal in Python and do nothing: they read as +(+count) and -(-count).

What happens in TypeScript

TypeScript prints 3. count++ and ++count work, as in JavaScript, and --count decrements. In Rust --count compiles and negates twice.

What happens in Java

Java prints 3. count++ and ++count work, also inside expressions such as a[i++].

What happens in C#

C# prints 3. count++ and ++count work, also inside expressions.

What happens in C

C prints 3. count++ works, also inside expressions such as a[i++].

What happens in C++

C++ prints 3. count++ and ++count work, and they can be overloaded for your own types.

What Rust sees

Rust has no ++ or -- operator. count++ is not a statement the parser knows, and the compiler stops with a message that says so and shows count += 1.

Why Rust says no

The compiler recognises the habit and names it: "Rust has no postfix increment operator". The fix is count += 1. Python is the other language here with no ++ operator. Elsewhere ++ is part of the language: Go allows it only as a statement, and the others also allow it inside larger expressions.

The fix

Compiles and runs.

Rust, fixedsrc/main.rsRun ↗Copy

fn main() {
    let mut count = 0;
    for _ in 0..3 {
        count += 1;
    }
    println!("count: {count}");
}

$ cargo run

count: 3

The toolkit

This page lists habits that fail in Rust, with the real compiler message and what to write instead. A message with no error code means the parser did not know the syntax; a code such as E0308 means the syntax was fine and the types were not. Outputs come from Linux on 64-bit ARM with Rust 1.99.1.

Two warnings. When the parser gets lost it names the token where it gave up, and the cause is that token or the one before. And a help: line is a guess: count += 1 is the fix, but goto done gets “write goto.done” and while item = items.next() gets “compare with ==”. Read a guess before you apply it.

Three words recur: Option is a value that may be missing (Option), Result is a success or an error (Errors), and match is Rust’s switch (Match).

Your habits, in Rust

Your own list comes first; the shared list is for everyone.

Coming from Go

You write in Go	In Rust
i++, i-- (statements in Go)	i += 1;, i -= 1;
for i := 0; i < n; i++ {}, for i := range n {}	for i in 0..n {}
for cond {}, for {}	while cond {}, loop {}
for _, v := range xs {}	for v in &xs {}
var p *User, nil; v, ok := m[k]	Option: if let Some(v) = m.get(&k) {}
switch { case x > 5: }	if x > 5 {} else {}, or match with a guard: _ if x > 5 =>
break in a switch in a loop leaves the switch	in a match it leaves the loop
defer f.Close()	the value is dropped when its scope ends
goto retry	loop with continue, a labeled break, return
User{Name: "a"}, the rest zero	name every field, or end with ..Default::default()
type Dog struct{ Animal } (embedding)	a field animal: Animal, and you write the forwarding
any type with the right methods fits an interface	impl Speaker for Dog is required
v, err := f(); if err != nil { return err }	let v = f()?;, which also converts the error type if needed
d * 2 with a float64 d	d * 2.0

Go and Rust agree on five things, each an error in Go too: no ternary, no overloading by type, no default arguments, no mixing of int32 and int64, and an if that needs a bool. The bare number differs: Go lets 2 become a float, Rust does not.

The loops, one function each; read the first error of each:

Rustsrc/main.rs✗ won't compileCopy

fn three_clause() {
    for i := 0; i < 3; i++ {
        println!("{i}");
    }
}

fn while_style(mut n: i32) {
    for n > 0 {
        n -= 1;
    }
}

fn range_style(xs: Vec<i32>) {
    for _, x := range xs {
        println!("{x}");
    }
}

fn main() {}

$ cargo build

error: expected one of `@` or `|`, found `:`
 --> src/main.rs:2:11
  |
2 |     for i := 0; i < 3; i++ {
  |           ^ expected one of `@` or `|`

error: missing `in` in `for` loop
 --> src/main.rs:2:10
  |
2 |     for i := 0; i < 3; i++ {
  |          ^
  |
help: try adding `in` here
  |
2 |     for i in := 0; i < 3; i++ {
  |           ++

error: expected expression, found `:`
 --> src/main.rs:2:11
  |
2 |     for i := 0; i < 3; i++ {
  |           ^ expected expression
  |
help: maybe write a path separator here
  |
2 |     for i ::= 0; i < 3; i++ {
  |            +

error: missing `in` in `for` loop
 --> src/main.rs:8:10
  |
8 |     for n > 0 {
  |          ^
  |
help: try adding `in` here
  |
8 |     for n in > 0 {
  |           ++

error: expected expression, found `>`
 --> src/main.rs:8:11
  |
8 |     for n > 0 {
  |           ^ expected expression

error: unexpected `,` in pattern
  --> src/main.rs:14:10
   |
14 |     for _, x := range xs {
   |          ^
   |
help: try adding parentheses to match on a tuple
   |
14 |     for (_, x) := range xs {
   |         +    +
help: maybe write a path separator here
   |
14 |     for _, x ::= range xs {
   |               +

Then four keywords. A tagless switch { reads as the start of a struct literal, which is why an error mentions a struct:

Rustsrc/main.rs✗ won't compileCopy

fn deferred() {
    defer println!("done");
}

fn tagless(x: i32) {
    switch {
        case x > 5:
            println!("big");
    }
}

fn swap() {
    let (mut a, mut b) = (1, 2);
    a, b = b, a;
}

fn jump() {
    goto done;
}

fn main() {}

$ cargo build

error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `println`
 --> src/main.rs:2:11
  |
2 |     defer println!("done");
  |           ^^^^^^^ expected one of 8 possible tokens

error: expected one of `,`, `:`, or `}`, found `x`
 --> src/main.rs:7:14
  |
6 |     switch {
  |     ------ while parsing this struct
7 |         case x > 5:
  |         ---- ^ expected one of `,`, `:`, or `}`
  |         |
  |         while parsing this struct field

error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `,`
  --> src/main.rs:14:6
   |
14 |     a, b = b, a;
   |      ^ expected one of 8 possible tokens

error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `done`
  --> src/main.rs:18:10
   |
18 |     goto done;
   |          ^^^^ expected one of 8 possible tokens
   |
help: you might have meant to write a field access
   |
18 |     goto.done;
   |         +

error[E0422]: cannot find struct, variant or union type `switch` in this scope
 --> src/main.rs:6:5
  |
6 |     switch {
  |     ^^^^^^ not found in this scope

The break that compiles and behaves differently: Go’s leaves the switch, so the loop goes on and n is 4. In Rust it leaves the loop and n is 2 (see No fall-through):

Gomain.goCopy

package main

import "fmt"

func main() {
  n := 0
  for i := 0; i < 5; i++ {
    switch i {
    case 2:
      break
    default:
      n++
    }
  }
  fmt.Printf("n: %d\n", n)
}

$ go run main.go

n: 4

There is no defer. A value is dropped when its scope ends, in reverse order of creation, and a type can run code then:

Rustsrc/main.rsRun ↗Copy

struct Noisy(&'static str);

impl Drop for Noisy {
    fn drop(&mut self) {
        println!("drop {}", self.0);
    }
}

fn main() {
    let _a = Noisy("a");
    let _b = Noisy("b");
    println!("end of main");
}

$ cargo run

end of main
drop b
drop a

A struct literal must name every field, a type with the right methods does not satisfy a trait until the impl is written, and a bare 2 is not a float:

Rustsrc/main.rs✗ won't compileCopy

struct User {
    name: String,
    age: u32,
}

fn main() {
    let u = User {
        name: String::from("Ada"),
    };
    println!("{}", u.name);
}

$ cargo buildWhat is E0063?

error[E0063]: missing field `age` in initializer of `User`
 --> src/main.rs:7:13
  |
7 |     let u = User {
  |             ^^^^ missing `age`

Rustsrc/main.rs✗ won't compileCopy

trait Speaker {
    fn speak(&self) -> String;
}

struct Dog;

impl Dog {
    fn speak(&self) -> String {
        "woof".to_string()
    }
}

fn talk<T: Speaker>(t: &T) -> String {
    t.speak()
}

fn main() {
    println!("{}", talk(&Dog));
}

$ cargo buildWhat is E0277?

error[E0277]: the trait bound `Dog: Speaker` is not satisfied
  --> src/main.rs:18:25
   |
18 |     println!("{}", talk(&Dog));
   |                    ---- ^^^^ unsatisfied trait bound
   |                    |
   |                    required by a bound introduced by this call
   |
help: the trait `Speaker` is not implemented for `Dog`
  --> src/main.rs:5:1
   |
 5 | struct Dog;
   | ^^^^^^^^^^
help: this trait has no implementations, consider adding one
  --> src/main.rs:1:1
   |
 1 | trait Speaker {
   | ^^^^^^^^^^^^^
note: required by a bound in `talk`
  --> src/main.rs:13:12
   |
13 | fn talk<T: Speaker>(t: &T) -> String {
   |            ^^^^^^^ required by this bound in `talk`

Rustsrc/main.rs✗ won't compileCopy

fn main() {
    let d = 1.5;
    let doubled = d * 2;
    println!("{doubled}");
}

$ cargo buildWhat is E0277?

error[E0277]: cannot multiply `{float}` by `{integer}`
 --> src/main.rs:3:21
  |
3 |     let doubled = d * 2;
  |                     ^ no implementation for `{float} * {integer}`
  |
  = help: the trait `Mul<{integer}>` is not implemented for `{float}`
  = help: the following other types implement trait `Mul<Rhs>`:
            `&f128` implements `Mul<f128>`
            `&f128` implements `Mul`
            `&f16` implements `Mul<f16>`
            `&f16` implements `Mul`
            `&f32` implements `Mul<f32>`
            `&f32` implements `Mul`
            `&f64` implements `Mul<f64>`
            `&f64` implements `Mul`
          and 57 others

Go inserts the ; at a line end; Rust does not:

Rustsrc/main.rs✗ won't compileCopy

fn main() {
    let a = 1
    let b = 2
    println!("{}", a + b)
}

$ cargo build

error: expected `;`, found keyword `let`
 --> src/main.rs:2:14
  |
2 |     let a = 1
  |              ^ help: add `;` here
3 |     let b = 2
  |     --- unexpected token

error: expected `;`, found `println`
 --> src/main.rs:3:14
  |
3 |     let b = 2
  |              ^ help: add `;` here
4 |     println!("{}", a + b)
  |     ------- unexpected token

Coming from Java

You write in Java	In Rust
i++, a[i++]	i += 1;, or a block that ends in the value
ok ? a : b	if ok { a } else { b }
null, Optional<T>	Option<T>, which has no null underneath
new Point(1, 2), this.x	Point { x: 1, y: 2 } or Point::new(1, 2); self.x
class Dog extends Animal, implements Speak	a struct, and impl Speak for Dog
public void bump(), final, @Override	pub fn bump(&mut self); let is final; no @Override
show(int) next to show(String)	two names, or one trait implemented for each type
try, catch, throw; checked exceptions	Result and ?; unchecked ones are panic!
finally, try-with-resources	the value is dropped when its scope ends
static int count in a class	a static outside any type
new Point() with zeroed fields	name every field, or end with ..Default::default()
long big = i;, (long) x	i64::from(i), x as i64
case 1: falls through	1 | 2 =>
break in a switch in a loop leaves the switch	in a match it leaves the loop

Java 14’s case 1, 2 -> is already close to a match arm. The difference is break: in a switch it leaves the switch and n ends at 4; in Rust it leaves the loop and n is 2 (see No fall-through).

JavaMain.javaCopy

public class Main {
    public static void main(String[] args) {
        int n = 0;
        for (int i = 0; i < 5; i++) {
            switch (i) {
                case 2:
                    break;
                default:
                    n++;
            }
        }
        System.out.println("n: " + n);
    }
}

$ javac Main.java && java Main

n: 4

One trait implemented for each type gives the call that overloading would:

Rustsrc/main.rsRun ↗Copy

trait Show {
    fn show(&self) -> String;
}

impl Show for i32 {
    fn show(&self) -> String {
        format!("int {self}")
    }
}

impl Show for &str {
    fn show(&self) -> String {
        format!("text {self}")
    }
}

fn main() {
    println!("{}", 1.show());
    println!("{}", "a".show());
}

$ cargo run

int 1
text a

public void is a parse error, and a static cannot sit inside an impl:

Rustsrc/main.rs✗ won't compileCopy

struct Counter {
    n: u32,
}

impl Counter {
    public void bump(&mut self) {
        self.n += 1;
    }
}

impl Counter {
    static count: u32 = 0;
}

fn main() {}

$ cargo build

error: expected one of `!` or `::`, found `void`
 --> src/main.rs:6:12
  |
5 | impl Counter {
  |              - while parsing this item list starting here
6 |     public void bump(&mut self) {
  |            ^^^^ expected one of `!` or `::`
...
9 | }
  | - the item list ends here

error: associated `static` items are not allowed
  --> src/main.rs:12:5
   |
12 |     static count: u32 = 0;
   |     ^^^^^^^^^^^^^^^^^^^^^^

finally becomes Drop, and an unfilled struct field is an error (..Default::default() fills it in):

Rustsrc/main.rsRun ↗Copy

struct Noisy(&'static str);

impl Drop for Noisy {
    fn drop(&mut self) {
        println!("drop {}", self.0);
    }
}

fn main() {
    let _a = Noisy("a");
    let _b = Noisy("b");
    println!("end of main");
}

$ cargo run

end of main
drop b
drop a

Rustsrc/main.rs✗ won't compileCopy

struct User {
    name: String,
    age: u32,
}

fn main() {
    let u = User {
        name: String::from("Ada"),
    };
    println!("{}", u.name);
}

$ cargo buildWhat is E0063?

error[E0063]: missing field `age` in initializer of `User`
 --> src/main.rs:7:13
  |
7 |     let u = User {
  |             ^^^^ missing `age`

The C-style for and do are in Operators and loops; new, this and extends are under No classes.

Coming from Kotlin

You write in Kotlin	In Rust
i++, a[i++]	i += 1;, or a block that ends in the value
name?.length	name.as_ref().map(|s| s.len()); ?. is not Rust
name ?: "anon", name!!	name.unwrap_or("anon"), name.unwrap()
val x = f() ?: return	let Some(x) = f() else { return };
Point(1, 2) (no new)	Point { x: 1, y: 2 } or Point::new(1, 2)
open class, : Animal(), sealed class	a struct and a trait; enum for a sealed set
data class and copy(x = 1)	#[derive(...)] and Point { x: 1, ..p }
area(3, height = 4), default values	a struct ending in ..Default::default(), or an Option parameter
try, catch, throw	Result and ?; panic! for bugs
when (x) { 1, 2 -> }	match x { 1 | 2 => }
break in a when in a loop leaves the loop	the same in a match

Kotlin and Rust agree on the last row (n is 2) and on explicit number conversions. The new part is ?: it is an early return, not a safe call. Written like Kotlin’s ?., it fails with an error about the function’s return type, which says nothing about what you meant:

Rustsrc/main.rs✗ won't compileCopy

fn safe_call(name: Option<String>) -> usize {
    let n = name?.len();
    n
}

fn elvis(name: Option<String>) -> usize {
    name?.len() ?: 0
}

fn not_null() {
    let name: Option<String> = Some("a".to_string());
    let n = name!!.len();
}

fn main() {}

$ cargo build

error: Rust has no ternary operator
 --> src/main.rs:7:5
  |
7 |     name?.len() ?: 0
  |     ^^^^^^^^^^^^^^^^
  |
help: use an `if-else` expression instead
  |
7 -     name?.len() ?: 0
7 +     if name?.len() {} else { 0 }

error: expected one of `(`, `[`, or `{`, found `!`
  --> src/main.rs:12:18
   |
12 |     let n = name!!.len();
   |                  ^ expected one of `(`, `[`, or `{`

error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
 --> src/main.rs:2:17
  |
1 | fn safe_call(name: Option<String>) -> usize {
  | ------------------------------------------- this function should return `Result` or `Option` to accept `?`
2 |     let n = name?.len();
  |                 ^ cannot use the `?` operator in a function that returns `usize`

?: is read as the ternary operator, and its help: is wrong. A real ?. chain is in the exercise “A ?. chain” below.

KotlinMain.ktCopy

fun main() {
    var n = 0
    for (i in 0 until 5) {
        when (i) {
            2 -> break
            else -> n++
        }
    }
    println("n: $n")
}

$ kotlinc Main.kt -include-runtime -d main.jar && java -jar main.jar

n: 2

Coming from C#

You write in C#	In Rust
i++, a[i++]	i += 1;, or a block that ends in the value
ok ? a : b	if ok { a } else { b }
string? s = null, ?., ??	Option<String>, .map(...), .unwrap_or(...)
int.TryParse(s, out var n)	s.parse::<i32>().ok(), an Option
new Point(1, 2), this.X	Point { x: 1, y: 2 } or Point::new(1, 2); self.x
class Dog : Animal	a struct and a trait
Show(int) next to Show(string); operator +	two names, or a trait; impl Add for Point
Area(3, height: 4), optional parameters	a struct ending in ..Default::default(), or an Option parameter
try, catch, finally, throw	Result and ?; panic! for bugs; Drop for cleanup
using var f = ...	the value is dropped when its scope ends
long big = i;	i64::from(i)
case 1: must not fall through (CS0163)	1 | 2 =>
break in a switch in a loop leaves the switch	in a match it leaves the loop

C# refuses fall-through too. The difference is break: in a switch it leaves the switch (n is 4), in a match it leaves the loop (n is 2, see No fall-through):

C#Program.csCopy

var n = 0;
for (var i = 0; i < 5; i++)
{
    switch (i)
    {
        case 2:
            break;
        default:
            n++;
            break;
    }
}
Console.WriteLine($"n: {n}");

$ dotnet run

n: 4

operator + becomes a trait; the last exercise builds one.

Coming from Python

You write in Python	In Rust
x += 1 (Python has no x++)	x += 1;
++x, --x do nothing in Python	++x is an error; --x also does nothing
a if c else b	if c { a } else { b }
for i in range(n)	for i in 0..n {}
if items:, if name:	if !items.is_empty() {}: the condition must be a bool
7 // 2, -7 // 2	// is a comment; 7 / 2 is 3, -7 / 2 is -3
2 ** 10	2_i32.pow(10)
1 < x < 5, x in xs	1 < x && x < 5, xs.contains(&x)
and, or, not, elif, :	&&, ||, !, else if, { }
x = 1 then x = "a"	a variable has one type
area(width=3, height=4), def area(w, h=1)	positional arguments; a struct or an Option for a default
try, except, raise	Result and ?; panic! for bugs

// is the Python habit that does not fail loudly: it starts a comment, so a // b is just a:

Rustsrc/main.rs✗ won't compileCopy

fn main() {
    let q = 7 // 2;
    println!("{q}");
}

$ cargo build

error: expected `;`, found `println`
 --> src/main.rs:2:14
  |
2 |     let q = 7 // 2;
  |              ^ help: add `;` here
3 |     println!("{q}");
  |     ------- unexpected token

Rustsrc/main.rsRun ↗Copy

fn floor_div(a: i32, b: i32) -> i32 {
    let _ = b;
    a // b
}

fn main() {
    println!("floor_div(7, 2): {}", floor_div(7, 2));
}

$ cargo run

floor_div(7, 2): 7

Integer / truncates toward zero; floor division has to be written out (see the exercise “Floor division” below). The other operators fail at once, usually with a good help::

Rustsrc/main.rs✗ won't compileCopy

fn power() -> i32 {
    2 ** 10
}

fn between(x: i32) -> bool {
    1 < x < 5
}

fn member(v: Vec<i32>) -> bool {
    2 in v
}

fn identity(x: Option<i32>) -> bool {
    x is None
}

fn flag() -> bool {
    True
}

fn main() {}

$ cargo build

error: comparison operators cannot be chained
 --> src/main.rs:6:7
  |
6 |     1 < x < 5
  |       ^   ^
  |
help: split the comparison into two
  |
6 |     1 < x && x < 5
  |           ++++

error: expected one of `.`, `;`, `?`, `}`, or an operator, found keyword `in`
  --> src/main.rs:10:7
   |
10 |     2 in v
   |       ^^ expected one of `.`, `;`, `?`, `}`, or an operator

error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `is`
  --> src/main.rs:14:7
   |
14 |     x is None
   |       ^^ expected one of 8 possible tokens

error[E0425]: cannot find value `True` in this scope
  --> src/main.rs:18:5
   |
18 |     True
   |     ^^^^ not found in this scope
   |
help: you may want to use a bool value instead
   |
18 -     True
18 +     true

error[E0614]: type `{integer}` cannot be dereferenced
 --> src/main.rs:2:8
  |
2 |     2 ** 10
  |        ^^^^ can't be dereferenced

Some errors have detailed explanations: E0425, E0614.

A name has one type for its life, so the second assignment is a type mismatch:

Rustsrc/main.rs✗ won't compileCopy

fn main() {
    let x = 1;
    x = "a";
    println!("{x}");
}

$ cargo buildWhat is E0308?

error[E0308]: mismatched types
 --> src/main.rs:3:9
  |
2 |     let x = 1;
  |             - expected due to this value
3 |     x = "a";
  |         ^^^ expected integer, found `&str`

The words of Python’s blocks:

Rustsrc/main.rs✗ won't compileCopy

fn elif(x: i32) {
    if x > 1 {
        println!("big");
    } elif x > 0 {
        println!("small");
    }
}

fn both(a: bool, b: bool) -> bool {
    a and b
}

fn invert(a: u8) -> u8 {
    ~a
}

fn main() {}

$ cargo build

error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `x`
 --> src/main.rs:4:12
  |
4 |     } elif x > 0 {
  |            ^ expected one of 8 possible tokens

error: `and` is not a logical operator
  --> src/main.rs:10:7
   |
10 |     a and b
   |       ^^^
   |
   = note: unlike in e.g., Python and PHP, `&&` and `||` are used for logical operators
help: use `&&` to perform logical conjunction
   |
10 -     a and b
10 +     a && b

error: `~` cannot be used as a unary operator
  --> src/main.rs:14:5
   |
14 |     ~a
   |     ^
   |
help: use `!` to perform bitwise not
   |
14 -     ~a
14 +     !a

and is answered with && and ~ with !; elif, not and the : after a condition are not named.

Coming from TypeScript

You write in TypeScript	In Rust
x++, a[i++]	x += 1;, or a block that ends in the value
c ? a : b	if c { a } else { b }
u?.name	valid Rust, but not a safe call: it is ? and then .name, an early return
a ?? 5	a.unwrap_or(5)
null, undefined	Option<T>, None
if (name), if (items)	if !name.is_empty() {}: the condition must be a bool
function f(x: number), (x) => x + 1	fn f(x: f64), |x| x + 1
throw, try, catch	Result and ?; panic! for bugs
switch falls through without break	1 | 2 =>
break in a switch in a loop leaves the switch	in a match it leaves the loop
a missing ; is repaired for you	a missing ; is an error

u?.name compiles, but it means “if u is None, return None from this function now, else take .name”. Inside a function that does not return an Option, it is an error about the return type:

Rustsrc/main.rsRun ↗Copy

struct User {
    name: String,
}

fn name_of(user: Option<User>) -> Option<String> {
    let name = user?.name;
    Some(name)
}

fn main() {
    println!("none: {:?}", name_of(None));
    let ada = User {
        name: "Ada".to_string(),
    };
    println!("some: {:?}", name_of(Some(ada)));
}

$ cargo run

none: None
some: Some("Ada")

Syntax that does not exist, then habits that look right:

Rustsrc/main.rs✗ won't compileCopy

fn coalesce(a: Option<i32>) -> i32 {
    a ?? 5
}

fn strict(a: i32) -> bool {
    a === 1
}

fn each(v: Vec<i32>) {
    for x of v {
        println!("{x}");
    }
}

fn main() {}

$ cargo build

error: expected one of `.`, `;`, `?`, `}`, or an operator, found `5`
 --> src/main.rs:2:10
  |
2 |     a ?? 5
  |          ^ expected one of `.`, `;`, `?`, `}`, or an operator

error: invalid comparison operator `===`
 --> src/main.rs:6:7
  |
6 |     a === 1
  |       ^^^
  |
help: `===` is not a valid comparison operator, use `==`
  |
6 -     a === 1
6 +     a == 1

error: missing `in` in `for` loop
  --> src/main.rs:10:11
   |
10 |     for x of v {
   |           ^^
   |
help: try using `in` here instead
   |
10 -     for x of v {
10 +     for x in v {

Rustsrc/main.rs✗ won't compileCopy

fn main() {
    let a = 1;
    let same = a == "1";
    let nothing = undefined;
    let v = vec![1, 2];
    let n = v.length;
}

$ cargo buildWhat is E0425?

error[E0425]: cannot find value `undefined` in this scope
 --> src/main.rs:4:19
  |
4 |     let nothing = undefined;
  |                   ^^^^^^^^^ not found in this scope

error[E0277]: can't compare `{integer}` with `&str`
 --> src/main.rs:3:18
  |
3 |     let same = a == "1";
  |                  ^^ no implementation for `{integer} == &str`
  |
  = help: the trait `PartialEq<&str>` is not implemented for `{integer}`
  = help: the following other types implement trait `PartialEq<Rhs>`:
            f128
            f16
            f32
            f64
            i128
            i16
            i32
            i64
          and 8 others

error[E0609]: no field `length` on type `Vec<{integer}>`
 --> src/main.rs:6:15
  |
6 |     let n = v.length;
  |               ^^^^^^ unknown field

Some errors have detailed explanations: E0277, E0425, E0609.

function f gets “write fn instead of function”, and (x) => gets a wrong help (>=). A missing ; is not repaired:

Rustsrc/main.rs✗ won't compileCopy

fn main() {
    let a = 1
    let b = 2
    println!("{}", a + b)
}

$ cargo build

error: expected `;`, found keyword `let`
 --> src/main.rs:2:14
  |
2 |     let a = 1
  |              ^ help: add `;` here
3 |     let b = 2
  |     --- unexpected token

error: expected `;`, found `println`
 --> src/main.rs:3:14
  |
3 |     let b = 2
  |              ^ help: add `;` here
4 |     println!("{}", a + b)
  |     ------- unexpected token

The second error is the same mistake on the next line. In TypeScript a break leaves only the switch (n is 4; in Rust 2, see No fall-through):

TypeScriptmain.tsCopy

let n = 0;
for (let i = 0; i < 5; i++) {
  switch (i) {
    case 2:
      break;
    default:
      n++;
  }
}
console.log(`n: ${n}`);

$ tsc --strict --module nodenext --types node main.ts && node main.js

n: 4

Coming from C

You write in C	In Rust
i++, a[i++], *p++	i += 1;, or a block that ends in the value
ok ? a : b	if ok { a } else { b }
for (int i = 0; i < n; i++), do { } while (c);	for i in 0..n {}, loop with a break
for (;;), while (1)	loop {}; while 1 is an error: it needs a bool
NULL, if (p), if (n), while (*s)	Option<&T>, if let Some(p) = p {}, if n != 0 {}
int n = 3.9;, long l = i;, double d = 3;	3.9 as i32, i64::from(i), 3.0
#define MAX 10, #include <stdio.h>	const MAX: i32 = 10;; no header to include
printf("%d\n", n)	println!("{}", n)
a case that ends in break;	the break; ends the loop: delete it
switch that falls through	1 | 2 =>
goto retry	loop with continue; return or ? to leave; the value is dropped when its scope ends
int visits; assigned anywhere	see “No mutable globals”

One of these compiles and is quietly wrong, so it comes first. A break; ported from the end of a case is legal in a match inside a loop, and it leaves the loop (n is 4 in C, 2 in Rust; see No fall-through):

Cmain.cCopy

#include <stdio.h>

int main(void) {
    int n = 0;
    for (int i = 0; i < 5; i++) {
        switch (i) {
        case 2:
            break;
        default:
            n++;
        }
    }
    printf("n: %d\n", n);
    return 0;
}

$ gcc -Wall -Wextra main.c -o main && ./main

n: 4

Coming from C++

You write in C++	In Rust
i++, a[i++], *p++	i += 1;, or a block that ends in the value
ok ? a : b	if ok { a } else { b }
for (int i = 0; i < n; i++), do { } while (c);, for (;;)	for i in 0..n {}, loop with a break, loop {}
new P(1), delete p	Box::new(P { x: 1 }) (Ownership); no delete
P(int x), ~P()	a function P::new(x); the value is dropped when its scope ends
class Dog : public Animal, virtual	a struct and a trait; dyn Trait for run-time dispatch (Trait objects)
operator+	impl Add for P
overloads, default arguments	two names, or a trait; a struct ending in ..Default::default()
try, catch, throw	Result and ?; panic! for bugs
nullptr, std::optional<T>	Option<&T>, Option<T>
int n = 3.9;, long l = i;, double d = 3;	3.9 as i32, i64::from(i), 3.0
a case that ends in break;	the break; ends the loop: delete it
goto retry	loop with continue; the value is dropped when its scope ends
int visits; assigned anywhere	see “No mutable globals”

The silent one first: a break; at the end of a ported case, inside a loop, leaves the loop (n is 4 in C++, 2 in Rust).

C++main.cppCopy

#include <iostream>

int main() {
    int n = 0;
    for (int i = 0; i < 5; i++) {
        switch (i) {
        case 2:
            break;
        default:
            n++;
        }
    }
    std::cout << "n: " << n << "\n";
}

$ g++ -std=c++20 -Wall -Wextra main.cpp -o main && ./main

n: 4

auto gets a precise help (let); new P(1) is read as a name and a stray P:

Rustsrc/main.rs✗ won't compileCopy

fn automatic() {
    auto x = 5;
    println!("{x}");
}

fn heap() {
    let p = new P(1);
    delete p;
}

fn main() {}

$ cargo build

error: invalid variable declaration
 --> src/main.rs:2:5
  |
2 |     auto x = 5;
  |     ^^^^
  |
help: write `let` instead of `auto` to introduce a new variable
  |
2 -     auto x = 5;
2 +     let x = 5;

error: expected one of `!`, `.`, `::`, `;`, `?`, `else`, `{`, or an operator, found `P`
 --> src/main.rs:7:17
  |
7 |     let p = new P(1);
  |                 ^ expected one of 8 possible tokens

operator+ is a trait. The compiler says so when the trait is missing:

Rustsrc/main.rs✗ won't compileCopy

struct P {
    x: i32,
}

fn main() {
    let a = P { x: 1 };
    let b = P { x: 2 };
    let c = a + b;
}

$ cargo buildWhat is E0369?

error[E0369]: cannot add `P` to `P`
 --> src/main.rs:8:15
  |
8 |     let c = a + b;
  |             - ^ - P
  |             |
  |             P
  |
note: an implementation of `Add` might be missing for `P`
 --> src/main.rs:1:1
  |
1 | struct P {
  | ^^^^^^^^ must implement `Add`
  ... (notes pointing into the standard library trimmed)

Rustsrc/main.rsRun ↗Copy

use std::ops::Add;

#[derive(Debug, Clone, Copy)]
struct Point {
    x: i32,
    y: i32,
}

impl Add for Point {
    type Output = Point;

    fn add(self, other: Point) -> Point {
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

fn main() {
    let sum = Point { x: 1, y: 2 } + Point { x: 3, y: 4 };
    println!("sum: {sum:?}");
}

$ cargo run

sum: Point { x: 4, y: 6 }

Coming from C or C++

The C-style for and do are in Operators and loops. The syntax habits, then the type habits:

Rustsrc/main.rs✗ won't compileCopy

struct P {
    x: i32,
}

fn arrow(p: &P) -> i32 {
    p->x
}

fn cast(n: i32) -> f64 {
    (double)n
}

fn forever() {
    for (;;) {
        break;
    }
}

fn always() {
    while (1) {
        break;
    }
}

fn print_it() {
    printf("%d\n", 5);
}

fn main() {}

$ cargo build

error: `->` is not valid syntax for field accesses and method calls
 --> src/main.rs:6:6
  |
6 |     p->x
  |      ^^
  |
  = help: the `.` operator will automatically dereference the value, except if the value is a raw pointer
help: try using `.` instead
  |
6 -     p->x
6 +     p.x

error: expected one of `.`, `;`, `?`, `}`, or an operator, found `n`
  --> src/main.rs:10:13
   |
10 |     (double)n
   |             ^ expected one of `.`, `;`, `?`, `}`, or an operator

error: expected pattern, found `;`
  --> src/main.rs:14:10
   |
14 |     for (;;) {
   |          ^ expected pattern

error[E0308]: mismatched types
  --> src/main.rs:20:11
   |
20 |     while (1) {
   |           ^^^ expected `bool`, found integer

error[E0425]: cannot find function `printf` in this scope
  --> src/main.rs:26:5
   |
26 |     printf("%d\n", 5);
   |     ^^^^^^ not found in this scope
   |
help: you may have meant to use the `print` macro
   |
26 -     printf("%d\n", 5);
26 +     print!("%d\n", 5);
   |

Some errors have detailed explanations: E0308, E0425.

Rustsrc/main.rs✗ won't compileCopy

fn main() {
    let d: f64 = 3;
    let n: i32 = 3.9;
    let digit = '7' - '0';
    let p = NULL;
}

$ cargo buildWhat is E0425?

error[E0425]: cannot find value `NULL` in this scope
 --> src/main.rs:5:13
  |
5 |     let p = NULL;
  |             ^^^^ not found in this scope

error[E0308]: mismatched types
 --> src/main.rs:2:18
  |
2 |     let d: f64 = 3;
  |            ---   ^ expected `f64`, found integer
  |            |
  |            expected due to this
  |
help: use a float literal
  |
2 |     let d: f64 = 3.0;
  |                   ++

error[E0308]: mismatched types
 --> src/main.rs:3:18
  |
3 |     let n: i32 = 3.9;
  |            ---   ^^^ expected `i32`, found floating-point number
  |            |
  |            expected due to this

error[E0369]: cannot subtract `char` from `char`
 --> src/main.rs:4:21
  |
4 |     let digit = '7' - '0';
  |                 --- ^ --- char
  |                 |
  |                 char

Some errors have detailed explanations: E0308, E0369, E0425.

Rustsrc/main.rs✗ won't compileCopy

#define MAX 10

fn main() {}

$ cargo build

error: expected one of `!` or `[`, found `define`
 --> src/main.rs:1:2
  |
1 | #define MAX 10
  |  ^^^^^^ expected one of `!` or `[`

# starts an attribute in Rust (a note to the compiler). printf is not found, and its help suggests print!("%d"), which would not format the number: Rust uses {}. A goto that retries is a loop with continue; one that cleans up is the drop at the end of the scope, as a C++ destructor runs:

Rustsrc/main.rsRun ↗Copy

fn main() {
    let mut tries = 0;
    let result = loop {
        tries += 1;
        if tries < 3 {
            continue;
        }
        break tries * 10;
    };
    println!("tries: {tries}, result: {result}");
}

$ cargo run

tries: 3, result: 30

Rustsrc/main.rsRun ↗Copy

struct Noisy(&'static str);

impl Drop for Noisy {
    fn drop(&mut self) {
        println!("drop {}", self.0);
    }
}

fn main() {
    let _a = Noisy("a");
    let _b = Noisy("b");
    println!("end of main");
}

$ cargo run

end of main
drop b
drop a

The shared list

You try	Rust way	Error	Learn more
x++, x--	x += 1;	syntax error	Operators and loops
c ? a : b	if c { a } else { b }	syntax error	Statements and expressions
null, nil, undefined	Option<T>	E0425, E0308	Option
i32 with i64, n * 1.5	as, From, try_from	E0308, E0277	Numbers and types
if x on text, a list, a number	an explicit test	E0308	Statements and expressions
break in a switch arm	in a match inside a loop it ends the loop	compiles	Match
throw, catch	Result, ?	syntax error	Errors
f(width = 3), default values	a struct, an Option parameter	E0425, E0061	Methods
two functions, one name	two names, or a trait	E0428	Methods
class, extends, new, this	struct, a trait, self	syntax error, E0423, E0424, E0425	Methods
s[0]	s.chars(), s.as_bytes()	E0277	Strings
a global assigned anywhere	an atomic or a Mutex	E0594, E0133	Shared state

Operators and loops

Four habits, one function each so that one run shows every message:

Rustsrc/main.rs✗ won't compileCopy

fn increment() {
    let mut count = 0;
    count++;
}

fn prefix() {
    let mut count = 0;
    ++count;
}

fn decrement() {
    let mut count = 10;
    count--;
}

fn ternary(n: i32) -> &'static str {
    n % 2 == 0 ? "even" : "odd"
}

fn main() {}

$ cargo build

error: Rust has no postfix increment operator
 --> src/main.rs:3:10
  |
3 |     count++;
  |          ^^ not a valid postfix operator
  |
help: use `+= 1` instead
  |
3 -     count++;
3 +     count += 1;

error: Rust has no prefix increment operator
 --> src/main.rs:8:5
  |
8 |     ++count;
  |     ^^ not a valid prefix operator
  |
help: use `+= 1` instead
  |
8 -     ++count;
8 +     count += 1;

error: Rust has no postfix decrement operator
  --> src/main.rs:13:10
   |
13 |     count--;
   |          ^^ not a valid postfix operator
   |
help: use `-= 1` instead
   |
13 -     count--;
13 +     count -= 1;

error: Rust has no ternary operator
  --> src/main.rs:17:5
   |
17 |     n % 2 == 0 ? "even" : "odd"
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
help: use an `if-else` expression instead
   |
17 -     n % 2 == 0 ? "even" : "odd"
17 +     if n % 2 == 0 { "even" } else { "odd" }

Each message says what to write. a[i++] has no one-token form: write the increment as its own statement, or as a block that ends in the value, { let v = a[i]; i += 1; v }.

Coming from Java, C#, C or C++

The C-style for and do get no useful help, and the one offered is wrong. A Rust for is for pattern in expression, and do is a reserved word:

Rustsrc/main.rs✗ won't compileCopy

fn counted() {
    for (int i = 0; i < 3; i++) {
        println!("{i}");
    }
}

fn run_once() {
    let mut n = 0;
    do {
        n += 1;
    } while (n < 3);
}

fn main() {}

$ cargo build

error: expected one of `)`, `,`, `@`, `if`, or `|`, found `i`
 --> src/main.rs:2:14
  |
2 |     for (int i = 0; i < 3; i++) {
  |              ^ expected one of `)`, `,`, `@`, `if`, or `|`
  |
help: there is a keyword `if` with a similar name
  |
2 |     for (int if = 0; i < 3; i++) {
  |               +

error: expected one of `)`, `,`, `@`, `if`, or `|`, found `=`
 --> src/main.rs:2:16
  |
2 |     for (int i = 0; i < 3; i++) {
  |                ^ expected one of `)`, `,`, `@`, `if`, or `|`

error: expected expression, found reserved keyword `do`
 --> src/main.rs:9:5
  |
9 |     do {
  |     ^^ expected expression

Coming from Go, Java, Kotlin, C#, TypeScript, C or C++

These are the replacements, each backed by a run. (1..=10) includes 10, .rev() runs a range backwards, .step_by(3) takes every third value, and .enumerate() pairs each item with its position (see Iterators). while let repeats while the pattern fits: pop takes the last item off a Vec (Vectors) and gives None when it is empty. A loop with a break at the bottom tests after its body, as do { } while does.

Rustsrc/main.rsRun ↗Copy

fn main() {
    // count 0, 1, 2
    for i in 0..3 {
        println!("i: {i}");
    }

    // count down from 10 in steps of 3
    for i in (1..=10).rev().step_by(3) {
        println!("down: {i}");
    }

    // the position and the item
    let items = ["a", "b"];
    for (i, item) in items.iter().enumerate() {
        println!("item {i}: {item}");
    }

    // repeat while there is a value
    let mut stack = vec![1, 2, 3];
    while let Some(top) = stack.pop() {
        println!("popped: {top}");
    }

    // run the body first, then test
    let mut n = 0;
    loop {
        n += 1;
        if n >= 3 {
            break;
        }
    }
    println!("n: {n}");
}

$ cargo run

i: 0
i: 1
i: 2
down: 10
down: 7
down: 4
down: 1
item 0: a
item 1: b
popped: 3
popped: 2
popped: 1
n: 3

Coming from Go, C or C++

For goto, the common jobs have their own forms: a retry is a loop with continue, and leaving nested loops is a labeled break:

Rustsrc/main.rsRun ↗Copy

fn main() {
    let grid = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
    let mut found = None;
    'search: for (row, cells) in grid.iter().enumerate() {
        for (col, &cell) in cells.iter().enumerate() {
            if cell == 5 {
                found = Some((row, col));
                break 'search;
            }
        }
    }
    println!("found: {found:?}");
}

$ cargo run

found: Some((1, 1))

--x is not a decrement

++x is a syntax error, like x++. --x is valid, and its meaning depends on the language. In Rust it is -(-x), as in Python, so count is unchanged. In C, C++, Java, C#, Kotlin and TypeScript it decrements, and Go rejects it. A lint (a check for suspicious code) named double_negations, on by default, warns about it:

Rustsrc/main.rsRun ↗Copy

#![allow(double_negations)]

fn main() {
    let count = 5;
    let after = --count;
    println!("count: {count}");
    println!("--count: {after}");
}

$ cargo run

count: 5
--count: 5

On an unsigned number it is an error instead (E0600), because an unsigned value cannot be negated:

Rustsrc/main.rs✗ won't compileCopy

fn main() {
    let count = 5u32;
    let after = --count;
    println!("{after}");
}

$ cargo buildWhat is E0600?

error[E0600]: cannot apply unary operator `-` to type `u32`
 --> src/main.rs:3:18
  |
3 |     let after = --count;
  |                  ^^^^^^ cannot apply unary operator `-`
  |
  = note: unsigned values cannot be negated

error[E0600]: cannot apply unary operator `-` to type `u32`
 --> src/main.rs:3:17
  |
3 |     let after = --count;
  |                 ^^^^^^^ cannot apply unary operator `-`
  |
  = note: unsigned values cannot be negated

No null

A value that may be missing has the type Option<T> (Option). String has no missing state, and None belongs to Option, so it does not fit where a String is declared:

Rustsrc/main.rs✗ won't compileCopy

fn main() {
    let a = null;
    let b: String = None;
    let c: Option<i32> = 5;
    println!("{a} {b} {c:?}");
}

$ cargo buildWhat is E0425?

error[E0425]: cannot find value `null` in this scope
 --> src/main.rs:2:13
  |
2 |     let a = null;
  |             ^^^^ not found in this scope
  |
help: consider importing this function
  |
1 + use std::ptr::null;

error[E0308]: mismatched types
 --> src/main.rs:3:21
  |
3 |     let b: String = None;
  |            ------   ^^^^ expected `String`, found `Option<_>`
  |            |
  |            expected due to this
  |
  = note: expected struct `String`
               found enum `Option<_>`

error[E0308]: mismatched types
 --> src/main.rs:4:26
  |
4 |     let c: Option<i32> = 5;
  |            -----------   ^ expected `Option<i32>`, found integer
  |            |
  |            expected due to this
  |
  = note: expected enum `Option<i32>`
             found type `{integer}`
help: try wrapping the expression in `Some`
  |
4 |     let c: Option<i32> = Some(5);
  |                          +++++ +

Some errors have detailed explanations: E0308, E0425.

The first message carries a trap. std::ptr::null makes a raw pointer, which the Reference describes as “without safety or liveness guarantees”. Following the hint does not give you an Option; it gives a different error:

Rustsrc/main.rs✗ won't compileCopy

use std::ptr::null;

fn main() {
    let a = null;
    println!("{a}");
}

$ cargo buildWhat is E0277?

error[E0277]: `fn() -> *const _ {null::<_>}` doesn't implement `std::fmt::Display`
 --> src/main.rs:5:15
  |
5 |     println!("{a}");
  |               ^^^ `fn() -> *const _ {null::<_>}` cannot be formatted with the default formatter
  |
  = help: the trait `std::fmt::Display` is not implemented for fn item `fn() -> *const _ {null::<_>}`
  = note: in format strings you may be able to use `{:?}` (or `{:#?}` for pretty-print) instead

Raw pointers exist for talking to other languages, and dereferencing one is an unsafe operation. In ordinary code, do not follow that hint.

Numbers do not convert themselves

Rust does not turn one number type into another for you, not even a safe widening such as i32 to i64, or an integer into a float. A comparison (small == other) is E0308 too:

Rustsrc/main.rs✗ won't compileCopy

fn main() {
    let small: i32 = 5;
    let big: u64 = small;
    let other: i64 = 5;
    println!("{big} {}", small == other);
}

$ cargo buildWhat is E0308?

error[E0308]: mismatched types
 --> src/main.rs:3:20
  |
3 |     let big: u64 = small;
  |              ---   ^^^^^ expected `u64`, found `i32`
  |              |
  |              expected due to this
  |
help: you can convert an `i32` to a `u64` and panic if the converted value doesn't fit
  |
3 |     let big: u64 = small.try_into().unwrap();
  |                         ++++++++++++++++++++

error[E0308]: mismatched types
 --> src/main.rs:5:35
  |
5 |     println!("{big} {}", small == other);
  |                          -----    ^^^^^ expected `i32`, found `i64`
  |                          |
  |                          expected because this is `i32`
  |
help: you can convert `small` from `i32` to `i64`, matching the type of `other`
  |
5 |     println!("{big} {}", i64::from(small) == other);
  |                          ++++++++++     +

Rustsrc/main.rs✗ won't compileCopy

fn main() {
    let n = 3;
    let scaled = n * 1.5;
    println!("{scaled}");
}

$ cargo buildWhat is E0277?

error[E0277]: cannot multiply `{integer}` by `{float}`
 --> src/main.rs:3:20
  |
3 |     let scaled = n * 1.5;
  |                    ^ no implementation for `{integer} * {float}`
  |
  = help: the trait `Mul<{float}>` is not implemented for `{integer}`
  = help: the following other types implement trait `Mul<Rhs>`:
            `&f128` implements `Mul<f128>`
            `&f128` implements `Mul`
            `&f16` implements `Mul<f16>`
            `&f16` implements `Mul`
            `&f32` implements `Mul<f32>`
            `&f32` implements `Mul`
            `&f64` implements `Mul<f64>`
            `&f64` implements `Mul`
          and 57 others

The help shows two fixes: i64::from(small) when no value can be lost, and try_into() when it might not fit. as is the third, and it cuts or rounds without a check (Declarations and types). For the float: f64::from(n) * 1.5.

Coming from Python, TypeScript, C or C++

Only a bool is true

The page on statements showed if n { } failing for a number. The rule holds for text, lists and Option too:

Rustsrc/main.rs✗ won't compileCopy

fn main() {
    let name = String::from("Ada");
    let items: Vec<i32> = Vec::new();
    let found = Some(3);
    let count = 4;
    if name {
        println!("has a name");
    }
    if items {
        println!("has items");
    }
    if found {
        println!("found");
    }
    if !count {
        println!("zero");
    }
}

$ cargo buildWhat is E0308?

error[E0308]: mismatched types
 --> src/main.rs:6:8
  |
6 |     if name {
  |        ^^^^ expected `bool`, found `String`

error[E0308]: mismatched types
 --> src/main.rs:9:8
  |
9 |     if items {
  |        ^^^^^ expected `bool`, found `Vec<i32>`
  |
  = note: expected type `bool`
           found struct `Vec<i32>`

error[E0308]: mismatched types
  --> src/main.rs:12:8
   |
12 |     if found {
   |        ^^^^^ expected `bool`, found `Option<{integer}>`
   |
   = note: expected type `bool`
              found enum `Option<{integer}>`
help: use `Option::is_some` to test if the `Option` has a value
   |
12 |     if found.is_some() {
   |             ++++++++++

error[E0308]: mismatched types
  --> src/main.rs:15:8
   |
15 |     if !count {
   |        ^^^^^^ expected `bool`, found integer

The last error is a Rust detail: ! is logical NOT on a bool but bitwise NOT on integers, so !count is a number, not a bool:

Rustsrc/main.rsRun ↗Copy

fn main() {
    println!("!true: {}", !true);
    println!("!5i32: {}", !5i32);
    println!("!0u8: {}", !0u8);
}

$ cargo run

!true: false
!5i32: -6
!0u8: 255

Assignment as a condition fails as if x = 1 did on the statements page; the fix for a loop is while let:

Rustsrc/main.rs✗ won't compileCopy

fn main() {
    let mut items = vec![1, 2, 3].into_iter();
    let mut item;
    while item = items.next() {
        println!("{item:?}");
    }
}

$ cargo buildWhat is E0308?

error[E0308]: mismatched types
 --> src/main.rs:4:11
  |
4 |     while item = items.next() {
  |           ^^^^^^^^^^^^^^^^^^^ expected `bool`, found `()`
  |
help: you might have meant to compare for equality
  |
4 |     while item == items.next() {
  |                 +

No fall-through, and break in a match

A match arm runs on its own, so there is nothing to fall through to; several values share an arm with |. A break in an arm leaves the enclosing loop, as 2 => break does here:

Rustsrc/main.rsRun ↗Copy

fn main() {
    let mut n = 0;
    for i in 0..5 {
        match i {
            2 => break,
            _ => n += 1,
        }
    }
    println!("n: {n}");
}

$ cargo run

n: 2

In Go, Java, C#, C, C++ and TypeScript the same program with a switch leaves only the switch and counts to 4 (your own list above runs it). Rust and Kotlin agree on 2. Neither warns.

No exceptions

throw and catch are not Rust syntax, so the parser stops:

Rustsrc/main.rs✗ won't compileCopy

fn throws(n: i32) -> i32 {
    if n < 0 {
        throw "negative";
    }
    n
}

fn catches() {
    try {
        println!("work");
    } catch (e) {
        println!("failed");
    }
}

fn main() {}

$ cargo build

error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `"negative"`
 --> src/main.rs:3:15
  |
3 |         throw "negative";
  |               ^^^^^^^^^^ expected one of 8 possible tokens

error: keyword `catch` cannot follow a `try` block
  --> src/main.rs:11:7
   |
11 |     } catch (e) {
   |       ^^^^^
   |
   = help: try using `match` on the result of the `try` block instead

try is reserved for an experimental feature: the parser accepts a try { } block and stable refuses it (E0658). It is not an exception handler:

Rustsrc/main.rs✗ won't compileCopy

fn main() {
    try {
        println!("work");
    }
}

$ cargo buildWhat is E0658?

error[E0658]: `try` expression is experimental
 --> src/main.rs:2:5
  |
2 | /     try {
3 | |         println!("work");
4 | |     }
  | |_____^
  |
  = note: see issue #154391 <https://github.com/rust-lang/rust/issues/154391> for more information

error[E0277]: a `try` block must return `Result` or `Option` (or another type that implements `Try`)
 --> src/main.rs:4:5
  |
4 |     }
  |     ^ could not wrap the final value of the block as `()` doesn't implement `Try`
  |
  = help: the nightly-only, unstable trait `Try` is not implemented for `()`

Some errors have detailed explanations: E0277, E0658.

A function that can fail returns a Result, and ? passes the failure up to the caller (Errors). A bug is a panic!, which ends the thread. std::panic::catch_unwind exists, but its documentation says “It is not recommended to use this function for a general try/catch mechanism.”

Rustsrc/main.rsRun ↗Copy

use std::num::ParseIntError;

fn double(text: &str) -> Result<i32, ParseIntError> {
    let n = text.parse::<i32>()?;
    Ok(n * 2)
}

fn main() {
    println!("double 21: {:?}", double("21"));
    println!("double x: {:?}", double("x"));
}

$ cargo run

double 21: Ok(42)
double x: Err(ParseIntError { kind: InvalidDigit })

No default or named arguments, no function overloading

width = 3 inside a call is an assignment, so the compiler looks for a variable called width; the message does not say “named arguments”. A default value in the parameter list is recognised and refused:

Rustsrc/main.rs✗ won't compileCopy

fn area(width: u32, height: u32) -> u32 {
    width * height
}

fn main() {
    println!("{}", area(width = 3, height = 4));
    println!("{}", area(3));
}

$ cargo buildWhat is E0425?

error[E0425]: cannot find value `width` in this scope
 --> src/main.rs:6:25
  |
6 |     println!("{}", area(width = 3, height = 4));
  |                         ^^^^^ not found in this scope

error[E0425]: cannot find value `height` in this scope
 --> src/main.rs:6:36
  |
6 |     println!("{}", area(width = 3, height = 4));
  |                                    ^^^^^^ not found in this scope

error[E0061]: this function takes 2 arguments but 1 argument was supplied
 --> src/main.rs:7:20
  |
7 |     println!("{}", area(3));
  |                    ^^^^--- argument #2 of type `u32` is missing
  |
note: function defined here
 --> src/main.rs:1:4
  |
1 | fn area(width: u32, height: u32) -> u32 {
  |    ^^^^             -----------
help: provide the argument
  |
7 |     println!("{}", area(3, /* u32 */));
  |                          +++++++++++

Some errors have detailed explanations: E0061, E0425.

Rustsrc/main.rs✗ won't compileCopy

fn area(width: u32, height: u32 = 1) -> u32 {
    width * height
}

fn main() {
    println!("{}", area(3, 1));
}

$ cargo build

error: parameter defaults are not supported
 --> src/main.rs:1:33
  |
1 | fn area(width: u32, height: u32 = 1) -> u32 {
  |                                 ^^^

Two functions with one name are an error, and Methods shows the version for methods:

Rustsrc/main.rs✗ won't compileCopy

fn show(n: i32) -> String {
    format!("int {n}")
}

fn show(s: &str) -> String {
    format!("text {s}")
}

fn main() {
    println!("{}", show(1));
    println!("{}", show("a"));
}

$ cargo buildWhat is E0428?

error[E0428]: the name `show` is defined multiple times
 --> src/main.rs:5:1
  |
1 | fn show(n: i32) -> String {
  | ------------------------- previous definition of the value `show` here
...
5 | fn show(s: &str) -> String {
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^ `show` redefined here
  |
  = note: `show` must be defined only once in the value namespace of this module

error[E0308]: mismatched types
  --> src/main.rs:11:25
   |
11 |     println!("{}", show("a"));
   |                    ---- ^^^ expected `i32`, found `&str`
   |                    |
   |                    arguments to this function are incorrect
   |
note: function defined here
  --> src/main.rs:1:4
   |
 1 | fn show(n: i32) -> String {
   |    ^^^^ ------

Some errors have detailed explanations: E0308, E0428.

The Rust forms are a struct with #[derive(Default)] (fields start as 0, false or empty) and a literal that ends in ..Default::default(), which fills every field not written; or an Option parameter, where None means “use the default”:

Rustsrc/main.rsRun ↗Copy

#[derive(Default)]
struct Window {
    width: u32,
    height: u32,
    border: bool,
}

fn describe(w: &Window) -> String {
    format!("{}x{} border={}", w.width, w.height, w.border)
}

fn scaled(width: u32, factor: Option<u32>) -> u32 {
    width * factor.unwrap_or(1)
}

fn main() {
    let sized = Window {
        width: 80,
        height: 24,
        ..Default::default()
    };
    let bordered = Window {
        border: true,
        ..Default::default()
    };
    println!("sized: {}", describe(&sized));
    println!("bordered: {}", describe(&bordered));
    println!("scaled: {} {}", scaled(3, None), scaled(3, Some(4)));
}

$ cargo run

sized: 80x24 border=false
bordered: 0x0 border=true
scaled: 3 12

This is more code than height=1; a type with many settings usually gets a builder (Methods). “No overloading” is narrow: a trait can be implemented for several types and called the same way, and impl Add overloads +.

Coming from Java, Kotlin, C#, TypeScript, C++ or Python

No classes, no new, no this

A struct holds the data and an impl block its methods (Structs, Methods). There is no class and no extends; each error is the parser meeting an unknown word:

Rustsrc/main.rs✗ won't compileCopy

class Point {
    x: i32,
}

fn main() {}

$ cargo build

error: expected one of `!` or `::`, found `Point`
 --> src/main.rs:1:7
  |
1 | class Point {
  |       ^^^^^ expected one of `!` or `::`

Rustsrc/main.rs✗ won't compileCopy

struct Animal {
    name: String,
}

struct Dog extends Animal {
    tricks: u32,
}

fn main() {}

$ cargo build

error: expected `where`, `{`, `(`, or `;` after struct name, found `extends`
 --> src/main.rs:5:12
  |
5 | struct Dog extends Animal {
  |            ^^^^^^^ expected `where`, `{`, `(`, or `;` after struct name

Shared behaviour comes from a trait, a list of methods a type promises to have (Traits); No inheritance shows how it replaces a base class.

Coming from Java, C# or TypeScript

new is not a keyword, so new Point(1, 2) is a syntax error. By convention Point::new(1, 2) is a plain function that returns a Point:

Rustsrc/main.rs✗ won't compileCopy

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = new Point(1, 2);
    println!("{}", p.x);
}

$ cargo build

error: expected one of `!`, `.`, `::`, `;`, `?`, `else`, `{`, or an operator, found `Point`
 --> src/main.rs:7:17
  |
7 |     let p = new Point(1, 2);
  |                 ^^^^^ expected one of 8 possible tokens

this becomes self, which a method lists as its first parameter. A braced struct is not a function, so Point(1, 2) is E0423 and the help gives the struct literal:

Rustsrc/main.rs✗ won't compileCopy

struct Point {
    x: i32,
    y: i32,
}

impl Point {
    fn bump(&mut self) {
        this.x += 1;
    }

    fn x() -> i32 {
        self.x
    }
}

fn main() {
    let p = Point(1, 2);
    println!("{}", p.x);
}

$ cargo buildWhat is E0425?

error[E0425]: cannot find value `this` in this scope
 --> src/main.rs:8:9
  |
8 |         this.x += 1;
  |         ^^^^
  |         |
  |         not found in this scope
  |         help: you might have meant to use `self` here instead

error[E0424]: cannot find value `self` in this scope
  --> src/main.rs:12:9
   |
11 |     fn x() -> i32 {
   |        - this function doesn't have a `self` parameter
12 |         self.x
   |         ^^^^ `self` value is a keyword only available in methods with a `self` parameter
   |
   = note: a module named `self` exists in another namespace
help: add a `self` receiver parameter to make the associated `fn` a method
   |
11 |     fn x(&self) -> i32 {
   |          +++++

error[E0423]: cannot find function, tuple struct or tuple variant `Point` in this scope
  --> src/main.rs:17:13
   |
 1 | / struct Point {
 2 | |     x: i32,
 3 | |     y: i32,
 4 | | }
   | |_- `Point` defined here
...
17 |       let p = Point(1, 2);
   |               ^^^^^^^^^^^
   |
   = note: a struct named `Point` exists in another namespace
help: use struct literal syntax instead of calling
   |
17 -     let p = Point(1, 2);
17 +     let p = Point{x: 1, y: 2};
   |

Some errors have detailed explanations: E0423, E0424, E0425.

Indexing text

s[0] does not compile for a string, and the note names the way out: s.chars().next() is an Option<char>, s.as_bytes()[0] a byte:

Rustsrc/main.rs✗ won't compileCopy

fn main() {
    let word = String::from("hello");
    let first = word[0];
    println!("{first}");
}

$ cargo buildWhat is E0277?

error[E0277]: the type `str` cannot be indexed by `{integer}`
 --> src/main.rs:3:22
  |
3 |     let first = word[0];
  |                      ^ string indices are ranges of `usize`
  |
  = help: the trait `SliceIndex<str>` is not implemented for `{integer}`
  = note: you can use `.chars().nth()` or `.bytes().nth()`
          for more information, see chapter 8 in The Book: <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
  ... (notes pointing into the standard library trimmed)

No mutable globals

A static is a global with one fixed place in memory. A plain one cannot be assigned. static mut can, but every read or write needs an unsafe block (a block where you promise the compiler you checked what it cannot):

Rustsrc/main.rs✗ won't compileCopy

static VISITS: u32 = 0;

fn main() {
    VISITS += 1;
    println!("{VISITS}");
}

$ cargo buildWhat is E0594?

error[E0594]: cannot assign to immutable static item `VISITS`
 --> src/main.rs:4:5
  |
1 | static VISITS: u32 = 0;
  | ------------------ this `static` cannot be written to
...
4 |     VISITS += 1;
  |     ^^^^^^^^^^^ cannot assign

Rustsrc/main.rs✗ won't compileCopy

static mut VISITS: u32 = 0;

fn main() {
    VISITS += 1;
}

$ cargo buildWhat is E0133?

error[E0133]: use of mutable static is unsafe and requires unsafe block
 --> src/main.rs:4:5
  |
4 |     VISITS += 1;
  |     ^^^^^^ use of mutable static
  |
  = note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior

Inside unsafe it compiles, but edition 2024 denies even printing the value:

Rustsrc/main.rs✗ won't compileCopy

static mut VISITS: u32 = 0;

fn main() {
    unsafe {
        VISITS += 1;
        println!("{}", VISITS);
    }
}

$ cargo build

error: creating a shared reference to mutable static
 --> src/main.rs:6:24
  |
6 |         println!("{}", VISITS);
  |                        ^^^^^^ shared reference to mutable static
  |
  = note: shared references to mutable statics are dangerous; it's undefined behavior if the static is mutated or if a mutable reference is created for it while the shared reference lives
  = help: use a type that relies on "interior mutability" instead; to read more on this, visit <https://doc.rust-lang.org/reference/interior-mutability.html>
  = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
  = note: `#[deny(static_mut_refs)]` (part of `#[deny(rust_2024_compatibility)]`) on by default

For a counter that several threads may change, use an atomic: a number whose changes happen as one step. For larger values use a Mutex (Shared state). Every atomic method takes an Ordering, which says how much other memory the operation makes visible to other threads. Ordering::Relaxed keeps the counter itself exact and orders nothing else, which is all a plain counter needs; the Ordering docs explain the stronger ones.

Rustsrc/main.rsRun ↗Copy

use std::sync::atomic::{AtomicU32, Ordering};

static VISITS: AtomicU32 = AtomicU32::new(0);

fn visit() -> u32 {
    VISITS.fetch_add(1, Ordering::Relaxed) + 1
}

fn main() {
    visit();
    visit();
    println!("visits: {}", visit());
    println!("loaded: {}", VISITS.load(Ordering::Relaxed));
}

$ cargo run

visits: 3
loaded: 3

Going deeper

Where this costs you

• Numeric code that mixes widths, such as sizes (usize) and counters (i32), has more as and from calls.
• Without inheritance, shared behaviour comes from a trait, or a type holds the other as a field.

Practice

Try it

Each exercise is a small program with checks in main. Open it in the Playground, replace the todo!(), and run it until it prints all checks passed. Each is labelled with the readers it suits; the first two suit everybody, and the second asks you to read.

A mean with no division by zero (everyone)

Divide an i64 by a u32 after converting both yourself, and return None when there are no readings, so no NaN appears.

Starterexercises/average.rsCopy

// The mean of `count` readings that add up to `total`.
// Rust will not mix an i64 and a u32 in one division: convert both yourself.
// With no readings there is no mean, so return None instead of a NaN.
fn average(total: i64, count: u32) -> Option<f64> {
    todo!("rule out count == 0, then divide as floats")
}

fn main() {
    assert_eq!(average(7, 2), Some(3.5));
    assert_eq!(average(-7, 2), Some(-3.5));
    assert_eq!(average(0, 4), Some(0.0));
    assert_eq!(average(0, 0), None);
    assert_eq!(average(5, 0), None);
    println!("all checks passed");
}

Open in the Rust Playground ↗Run it first: it stops at todo!() with not yet implemented and a hint, and the compiler warns that the parameter is unused. Both are expected. Replace the todo!() with your code and run it again until it prints all checks passed.

Show a solution

One solutionexercises/average.solution.rsRun ↗Copy

// The mean of `count` readings that add up to `total`.
// Rust will not mix an i64 and a u32 in one division: convert both yourself.
// With no readings there is no mean, so return None instead of a NaN.
fn average(total: i64, count: u32) -> Option<f64> {
    if count == 0 {
        return None;
    }
    Some(total as f64 / f64::from(count))
}

fn main() {
    assert_eq!(average(7, 2), Some(3.5));
    assert_eq!(average(-7, 2), Some(-3.5));
    assert_eq!(average(0, 4), Some(0.0));
    assert_eq!(average(0, 0), None);
    assert_eq!(average(5, 0), None);
    println!("all checks passed");
}

$ cargo run

all checks passed

Read this: what does it give? (everyone)

Reading, not writing: say what a loop with a break inside a match, -7 / 2, and a ? give, for None, an empty string and a real one. The checks run the real code and name the item you misread, not the right answer.

Starterexercises/read-habits.rsCopy

// Read this program. Replace each `todo!()` with what the marked call gives, then run
// until the checks print `all checks passed`.
fn tally() -> i32 {
    let mut total = 0;
    for i in 0..6 {
        match i {
            1 | 2 => total += 10,
            3 => break,
            _ => total += 1,
        }
    }
    total
}

fn halves() -> (i32, i32) {
    (-7 / 2, 7 / 2)
}

fn city_len(city: Option<&str>) -> Option<usize> {
    let c = city?;
    Some(c.len())
}

/// Hint: how many times does the loop body run, and what does `break` leave?
fn tally_is() -> i32 {
    todo!("how many times does the loop body run, and what does `break` leave?")
}

/// Hint: the value of `halves()`: integer division with a negative number
fn halves_are() -> (i32, i32) {
    todo!("the value of `halves()`: integer division with a negative number")
}

/// Hint: what does `city_len(None)` give? Look at what `?` does
fn no_city_gives() -> Option<usize> {
    todo!("what does `city_len(None)` give? Look at what `?` does")
}

/// Hint: what does `city_len(Some(""))` give? Is an empty string a missing value?
fn empty_city_gives() -> Option<usize> {
    todo!("what does `city_len(Some(\"\"))` give? Is an empty string a missing value?")
}

/// Hint: what does `city_len(Some("Oslo"))` give?
fn oslo_gives() -> Option<usize> {
    todo!("what does `city_len(Some(\"Oslo\"))` give?")
}

fn check<T: PartialEq + std::fmt::Debug>(call: &str, said: T, truth: T) {
    assert!(said == truth, "misread `{call}`: you said {said:?}");
    println!("ok: {call} = {said:?}");
}

fn main() {
    check("tally()", tally_is(), tally());
    check("halves()", halves_are(), halves());
    check("city_len(None)", no_city_gives(), city_len(None));
    check(
        "city_len(Some(\"\"))",
        empty_city_gives(),
        city_len(Some("")),
    );
    check(
        "city_len(Some(\"Oslo\"))",
        oslo_gives(),
        city_len(Some("Oslo")),
    );
    println!("all checks passed");
}

Open in the Rust Playground ↗Run it first: it stops at todo!() with not yet implemented and a hint, and the compiler warns that the parameter is unused. Both are expected. Replace the todo!() with your code and run it again until it prints all checks passed.

Show a solution

One solutionexercises/read-habits.solution.rsRun ↗Copy

// Read this program. Replace each `todo!()` with what the marked call gives, then run
// until the checks print `all checks passed`.
fn tally() -> i32 {
    let mut total = 0;
    for i in 0..6 {
        match i {
            1 | 2 => total += 10,
            3 => break,
            _ => total += 1,
        }
    }
    total
}

fn halves() -> (i32, i32) {
    (-7 / 2, 7 / 2)
}

fn city_len(city: Option<&str>) -> Option<usize> {
    let c = city?;
    Some(c.len())
}

/// Hint: how many times does the loop body run, and what does `break` leave?
fn tally_is() -> i32 {
    21
}

/// Hint: the value of `halves()`: integer division with a negative number
fn halves_are() -> (i32, i32) {
    (-3, 3)
}

/// Hint: what does `city_len(None)` give? Look at what `?` does
fn no_city_gives() -> Option<usize> {
    None
}

/// Hint: what does `city_len(Some(""))` give? Is an empty string a missing value?
fn empty_city_gives() -> Option<usize> {
    Some(0)
}

/// Hint: what does `city_len(Some("Oslo"))` give?
fn oslo_gives() -> Option<usize> {
    Some(4)
}

fn check<T: PartialEq + std::fmt::Debug>(call: &str, said: T, truth: T) {
    assert!(said == truth, "misread `{call}`: you said {said:?}");
    println!("ok: {call} = {said:?}");
}

fn main() {
    check("tally()", tally_is(), tally());
    check("halves()", halves_are(), halves());
    check("city_len(None)", no_city_gives(), city_len(None));
    check(
        "city_len(Some(\"\"))",
        empty_city_gives(),
        city_len(Some("")),
    );
    check(
        "city_len(Some(\"Oslo\"))",
        oslo_gives(),
        city_len(Some("Oslo")),
    );
    println!("all checks passed");
}

$ cargo run

ok: tally() = 21
ok: halves() = (-3, 3)
ok: city_len(None) = None
ok: city_len(Some("")) = Some(0)
ok: city_len(Some("Oslo")) = Some(4)
all checks passed

Coming from Go or Python

A switch without a subject (Go, Python)

Turn a chain of tests (switch { case n < 0: ... }, or if/elif) into one match with guards. The boundaries 0 and 10 are the checks.

Starterexercises/classify.rsCopy

// A subject-less switch (or an if / elif chain):
//
//   switch {
//   case n < 0:  return "negative"
//   case n == 0: return "zero"
//   case n < 10: return "small"
//   default:     return "large"
//   }
//
// Write it as one match with guards: an arm can end in `if condition`.
fn classify(n: i32) -> &'static str {
    todo!("a match with guard arms: _ if n < 0 => ...")
}

fn main() {
    assert_eq!(classify(-5), "negative");
    assert_eq!(classify(0), "zero");
    assert_eq!(classify(9), "small");
    assert_eq!(classify(10), "large");
    assert_eq!(classify(i32::MAX), "large");
    println!("all checks passed");
}

Open in the Rust Playground ↗Run it first: it stops at todo!() with not yet implemented and a hint, and the compiler warns that the parameter is unused. Both are expected. Replace the todo!() with your code and run it again until it prints all checks passed.

Show a solution

One solutionexercises/classify.solution.rsRun ↗Copy

// A subject-less switch (or an if / elif chain):
//
//   switch {
//   case n < 0:  return "negative"
//   case n == 0: return "zero"
//   case n < 10: return "small"
//   default:     return "large"
//   }
//
// Write it as one match with guards: an arm can end in `if condition`.
fn classify(n: i32) -> &'static str {
    match n {
        _ if n < 0 => "negative",
        0 => "zero",
        _ if n < 10 => "small",
        _ => "large",
    }
}

fn main() {
    assert_eq!(classify(-5), "negative");
    assert_eq!(classify(0), "zero");
    assert_eq!(classify(9), "small");
    assert_eq!(classify(10), "large");
    assert_eq!(classify(i32::MAX), "large");
    println!("all checks passed");
}

$ cargo run

all checks passed

Coming from Java, C#, TypeScript, C or C++

A switch that falls through (Java, C#, TypeScript, C, C++)

Translate a switch whose cases fall into each other into a match. Each arm must give its own total. Levels 0 and 4 test the arm that matches nothing.

Starterexercises/fall-through.rsCopy

// A C switch that falls through, and nothing else:
//
//   int mask = 0;
//   switch (level) {
//   case 3: mask |= 4;
//   case 2: mask |= 2;
//   case 1: mask |= 1; break;
//   }
//
// Rust arms never fall through into the next one. Return the same mask.
fn mask(level: u32) -> u32 {
    todo!("one match arm per level, each giving its own total")
}

fn main() {
    assert_eq!(mask(3), 7);
    assert_eq!(mask(2), 3);
    assert_eq!(mask(1), 1);
    assert_eq!(mask(0), 0);
    assert_eq!(mask(4), 0);
    println!("all checks passed");
}

Open in the Rust Playground ↗Run it first: it stops at todo!() with not yet implemented and a hint, and the compiler warns that the parameter is unused. Both are expected. Replace the todo!() with your code and run it again until it prints all checks passed.

Show a solution

One solutionexercises/fall-through.solution.rsRun ↗Copy

// A C switch that falls through, and nothing else:
//
//   int mask = 0;
//   switch (level) {
//   case 3: mask |= 4;
//   case 2: mask |= 2;
//   case 1: mask |= 1; break;
//   }
//
// Rust arms never fall through into the next one. Return the same mask.
fn mask(level: u32) -> u32 {
    match level {
        3 => 7,
        2 => 3,
        1 => 1,
        _ => 0,
    }
}

fn main() {
    assert_eq!(mask(3), 7);
    assert_eq!(mask(2), 3);
    assert_eq!(mask(1), 1);
    assert_eq!(mask(0), 0);
    assert_eq!(mask(4), 0);
    println!("all checks passed");
}

$ cargo run

all checks passed

Coming from Python, TypeScript, Kotlin, C# or C++

A default argument (Python, TypeScript, Kotlin, C#, C++)

Write greet(name, greeting) where the greeting is an Option. Only None means “use Hello”: an empty greeting is still a greeting.

Starterexercises/greeting.rsCopy

// Other languages write greet(name, greeting = "Hello"). Rust has no default arguments,
// so the caller passes an Option and the function supplies the default.
// An empty greeting is still a greeting: only None means "use the default".
fn greet(name: &str, greeting: Option<&str>) -> String {
    todo!("use unwrap_or on the Option, then format! the result")
}

fn main() {
    assert_eq!(greet("Ada", None), "Hello, Ada!");
    assert_eq!(greet("Ada", Some("Hi")), "Hi, Ada!");
    assert_eq!(greet("Ada", Some("")), ", Ada!");
    assert_eq!(greet("", None), "Hello, !");
    println!("all checks passed");
}

Open in the Rust Playground ↗Run it first: it stops at todo!() with not yet implemented and a hint, and the compiler warns that the parameter is unused. Both are expected. Replace the todo!() with your code and run it again until it prints all checks passed.

Show a solution

One solutionexercises/greeting.solution.rsRun ↗Copy

// Other languages write greet(name, greeting = "Hello"). Rust has no default arguments,
// so the caller passes an Option and the function supplies the default.
// An empty greeting is still a greeting: only None means "use the default".
fn greet(name: &str, greeting: Option<&str>) -> String {
    let greeting = greeting.unwrap_or("Hello");
    format!("{greeting}, {name}!")
}

fn main() {
    assert_eq!(greet("Ada", None), "Hello, Ada!");
    assert_eq!(greet("Ada", Some("Hi")), "Hi, Ada!");
    assert_eq!(greet("Ada", Some("")), ", Ada!");
    assert_eq!(greet("", None), "Hello, !");
    println!("all checks passed");
}

$ cargo run

all checks passed

Coming from Python

In Python, greeting or "Hello" would replace the empty greeting too.

Coming from TypeScript

In TypeScript, greeting || "Hello" would replace the empty greeting too.

Coming from TypeScript, Kotlin or C#

A `?.` chain (TypeScript, Kotlin, C#)

Find the length of a user’s city, where the user, the address and the city can each be missing, in a function that returns an Option. The ? of this page does the work of ?..

Starterexercises/chain.rsCopy

// user?.address?.city?.length ?? 0, in other languages, becomes a function that
// returns an Option and uses `?`: each `?` returns None from the function when its
// value is missing. An empty city is still a city, so its length is Some(0).
struct Address {
    city: Option<String>,
}

struct User {
    address: Option<Address>,
}

fn city_len(user: Option<&User>) -> Option<usize> {
    todo!("user?.address.as_ref()?.city.as_ref().map(...)")
}

fn main() {
    let home = User {
        address: Some(Address {
            city: Some("Paris".to_string()),
        }),
    };
    let nowhere = User { address: None };
    let unnamed = User {
        address: Some(Address { city: None }),
    };
    let empty = User {
        address: Some(Address {
            city: Some(String::new()),
        }),
    };
    assert_eq!(city_len(Some(&home)), Some(5));
    assert_eq!(city_len(None), None);
    assert_eq!(city_len(Some(&nowhere)), None);
    assert_eq!(city_len(Some(&unnamed)), None);
    assert_eq!(city_len(Some(&empty)), Some(0));
    println!("all checks passed");
}

Open in the Rust Playground ↗Run it first: it stops at todo!() with not yet implemented and a hint, and the compiler warns that the parameter is unused. Both are expected. Replace the todo!() with your code and run it again until it prints all checks passed.

Show a solution

One solutionexercises/chain.solution.rsRun ↗Copy

// user?.address?.city?.length ?? 0, in other languages, becomes a function that
// returns an Option and uses `?`: each `?` returns None from the function when its
// value is missing. An empty city is still a city, so its length is Some(0).
struct Address {
    city: Option<String>,
}

struct User {
    address: Option<Address>,
}

fn city_len(user: Option<&User>) -> Option<usize> {
    let address = user?.address.as_ref()?;
    let city = address.city.as_ref()?;
    Some(city.len())
}

fn main() {
    let home = User {
        address: Some(Address {
            city: Some("Paris".to_string()),
        }),
    };
    let nowhere = User { address: None };
    let unnamed = User {
        address: Some(Address { city: None }),
    };
    let empty = User {
        address: Some(Address {
            city: Some(String::new()),
        }),
    };
    assert_eq!(city_len(Some(&home)), Some(5));
    assert_eq!(city_len(None), None);
    assert_eq!(city_len(Some(&nowhere)), None);
    assert_eq!(city_len(Some(&unnamed)), None);
    assert_eq!(city_len(Some(&empty)), Some(0));
    println!("all checks passed");
}

$ cargo run

all checks passed

Coming from Python

Floor division (Python)

Python’s // rounds toward minus infinity; Rust’s / truncates toward zero. Write floor_div. The negative cases are the checks.

Starterexercises/floor-div.rsCopy

// Python's `//` rounds toward minus infinity: -7 // 2 is -4.
// Rust's `/` on integers cuts toward zero: -7 / 2 is -3.
// Write floor_div for a divisor that is not zero.
fn floor_div(a: i32, b: i32) -> i32 {
    todo!("a / b, minus one if inexact and the signs differ")
}

fn main() {
    assert_eq!(floor_div(7, 2), 3);
    assert_eq!(floor_div(-7, 2), -4);
    assert_eq!(floor_div(7, -2), -4);
    assert_eq!(floor_div(-7, -2), 3);
    assert_eq!(floor_div(6, 3), 2);
    assert_eq!(floor_div(-6, 3), -2);
    assert_eq!(floor_div(0, 5), 0);
    println!("all checks passed");
}

Open in the Rust Playground ↗Run it first: it stops at todo!() with not yet implemented and a hint, and the compiler warns that the parameter is unused. Both are expected. Replace the todo!() with your code and run it again until it prints all checks passed.

Show a solution

One solutionexercises/floor-div.solution.rsRun ↗Copy

// Python's `//` rounds toward minus infinity: -7 // 2 is -4.
// Rust's `/` on integers cuts toward zero: -7 / 2 is -3.
// Write floor_div for a divisor that is not zero.
fn floor_div(a: i32, b: i32) -> i32 {
    let quotient = a / b;
    if a % b != 0 && ((a < 0) != (b < 0)) {
        quotient - 1
    } else {
        quotient
    }
}

fn main() {
    assert_eq!(floor_div(7, 2), 3);
    assert_eq!(floor_div(-7, 2), -4);
    assert_eq!(floor_div(7, -2), -4);
    assert_eq!(floor_div(-7, -2), 3);
    assert_eq!(floor_div(6, 3), 2);
    assert_eq!(floor_div(-6, 3), -2);
    assert_eq!(floor_div(0, 5), 0);
    println!("all checks passed");
}

$ cargo run

all checks passed

Coming from C++, C#, Kotlin or Python

An operator (C++, C#, Kotlin, Python)

Implement + for a small point type with a trait, so that a + b works and a and b can still be used afterwards.

Starterexercises/operator-add.rsCopy

use std::ops::Add;

// C++: Point operator+(Point a, Point b). In Rust the operator is a trait:
// `impl Add for Point` defines what `a + b` means.
#[derive(Debug, Clone, Copy, PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

impl Add for Point {
    type Output = Point;

    fn add(self, other: Point) -> Point {
        todo!("add the two x values and the two y values")
    }
}

fn main() {
    let a = Point { x: 1, y: 2 };
    let b = Point { x: 3, y: 4 };
    assert_eq!(a + b, Point { x: 4, y: 6 });
    // a and b are Copy, so they can still be used after the sum.
    assert_eq!(a + a, Point { x: 2, y: 4 });
    assert_eq!(b + Point { x: -3, y: -4 }, Point { x: 0, y: 0 });
    println!("all checks passed");
}

Open in the Rust Playground ↗Run it first: it stops at todo!() with not yet implemented and a hint, and the compiler warns that the parameter is unused. Both are expected. Replace the todo!() with your code and run it again until it prints all checks passed.

Show a solution

One solutionexercises/operator-add.solution.rsRun ↗Copy

use std::ops::Add;

// C++: Point operator+(Point a, Point b). In Rust the operator is a trait:
// `impl Add for Point` defines what `a + b` means.
#[derive(Debug, Clone, Copy, PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

impl Add for Point {
    type Output = Point;

    fn add(self, other: Point) -> Point {
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

fn main() {
    let a = Point { x: 1, y: 2 };
    let b = Point { x: 3, y: 4 };
    assert_eq!(a + b, Point { x: 4, y: 6 });
    // a and b are Copy, so they can still be used after the sum.
    assert_eq!(a + a, Point { x: 2, y: 4 });
    assert_eq!(b + Point { x: -3, y: -4 }, Point { x: 0, y: 0 });
    println!("all checks passed");
}

$ cargo run

all checks passed

Read more

• The Rust Reference: Operator expressions (the table for ! and -), Loop expressions (labels), Match expressions, Static items and Pointer types.
• The Rust Book, chapter 3.5: Control Flow, 6.1: Defining an Enum (Option), 9: Error Handling, 10.2: Traits and 18.1: Characteristics of Object-Oriented Languages, for what replaces inheritance.
• catch_unwind, ptr::null, Default, atomic, Ordering and Add in the standard library docs.
• Rust by Example: Nesting and labels, match and Casting.