Допустим, вы решили изучить Rust

Поначалу всё будет хорошо. И вы будете изучать Rust, и думать, какие хорошие люди его написали. В нём есть автоопределение типов, безопасные указатели aka ссылки, столько синтаксического сахара, что любой Kotlin позавидует, и плюс ко всему этому ещё и кроссплатформенность и no-std режим, если вы вдруг решите запрограммировать кофеварку.
А потом одной чёрной-чёрной ночью вы обнаружите там...

Interior Mutability

Переменные, которые вы объявите через let, нельзя взять и поменять, а те, что объявлены через let mut, — можно:

fn main() {
  let a = 5;
  let mut b = 7;
  // a = 11; // не компилируется
  b = 9;
  println!("{a} {b}");
}

Если вы в функцию передаёте ссылку, созданную через &, то, на что указывает ссылка, менять нельзя, а если ссылка создана через &mut, то можно:

fn main() {
    let mut a=7;
    let mut b=5;
    println!("Было: a={a}, b={b}");
    swap_two_ints_wrong(&mut a, &mut b);
    println!("swap_two_ints_wrong: a={a}, b={b}");
    // swap_two_ints(&a, &b); // не компилируется
    swap_two_ints(&mut a, &mut b);
    println!("swap_two_ints: a={a}, b={b}");
    let c=1;
    let d=8;
    // swap_two_ints(&mut c, &mut d); // не компилируется 
}
fn swap_two_ints_wrong(a: &isize, b: &isize) {
    let temp = *a;
    // *a = *b; // не компилируется
    // *b = temp; // не компилируется
}
fn swap_two_ints(a: &mut isize, b: &mut isize) {
    let temp = *a;
    *a = *b;
    *b = temp;
}

Круто, то есть я могу контролировать, может ли моя переменная измениться и где? Определё...

use std::cell::RefCell;

fn main() {
    let /*mut*/ r = RefCell::new(7);
    println!("Было: {}", r.borrow());
    nasty_function(&r);
    println!("Стало: {}", r.borrow());
}

fn nasty_function(r: &/*mut*/ RefCell<isize>) {
    let rc = RefCell::new(17);
    r.swap(&rc);
}

Ещё раз: мы только что поменяли то, что лежит внутри переменной r, при этом в коде нет ни одного mut!
Опа, я нашёл баг!!! А вот и нет! Мне даже официальный туториал говорит, что так можно:

A consequence of the borrowing rules is that when you have an immutable value, you can’t borrow it mutably.
...
However, there are situations in which it would be useful for a value to mutate itself in its methods...

Чего? Вот так и пишут.

but appear immutable to other code.

Похоже "не писать pub" больше не вариант, надо что-нибудь ещё изобрести!

PartialOrd, PartialEq

Предположим, у вас есть структура:

struct NamedNumber(i64, char);

И вам нужно понять, какая из переменных с типом NamedNumber больше:

fn main() {
    let a = NamedNumber(10, 'A');
    let b = NamedNumber(12, 'B');
    if a > b {
        println!("a is more than b")
    } else if a == b {
        println!("a is equal to b")
    } else if a<b {
        println!("a is less than b")
    } else {
        println!("it is impossible...")
    }
}

Вам Rust говорит, что нужно, чтобы для этого объекта я определил PartialOrd, иначе их не сравнить:

impl PartialOrd for NamedNumber {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        if self.0 > other.0 {
            Some(Ordering::Greater)
        } else if self.0 == other.0 {
            Some(Ordering::Equal) // запомните это место, особенно слово Equal
        } else {
            Some(Ordering::Less)
        }
    }
}

// всё остальное как раньше...

Вроде всё логично, мы объясняем Rust, как понять, что первая больше второй, первая меньше второй, или первая равна второй...нет, вы этого не определяли!

error[E0277]: can't compare `NamedNumber` with `NamedNumber`
  --> src/main.rs:25:16
   |
25 |     } else if a<b {
   |                ^ no implementation for `NamedNumber == NamedNumber`
   |
   = help: the trait `PartialEq` is not implemented for `NamedNumber`

Хорошо, ты меня убедил! Сделаем так:

use std::cmp::Ordering;

struct NamedNumber(i64, char);

impl PartialOrd for NamedNumber {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        if self.0 > other.0 {
            Some(Ordering::Greater)
        } else if self.0 == other.0 {
            println!("Это сообщение всё равно никто не напечатает, я ведь уже в PartialEq проверил, что они равны");
            Some(Ordering::Equal)
        } else {
            Some(Ordering::Less)
        }
    }
}

impl PartialEq for NamedNumber {
    fn eq(&self, other: &Self) -> bool {
        self.0 == other.0
    }
}


fn main() {
    let a = NamedNumber(10, 'A');
    let b = NamedNumber(10, 'B');
    if a > b {
        println!("a is more than b")
    } else if a == b {
        println!("a is equal to b")
    } else if a<b {
        println!("a is less than b")
    } else {
        println!("it is impossible...")
    }
}

И выводит моя программа:

Это сообщение всё равно никто не напечатает, я ведь уже в PartialEq проверил, что они равны
a is equal to b

Понял, а зачем я тогда этот PartialEq определял?

use std::cmp::Ordering;

struct NamedNumber(i64, char);

impl PartialOrd for NamedNumber {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        if self.0 > other.0 {
            Some(Ordering::Greater)
        } else if self.0 == other.0 {
            Some(Ordering::Equal)
        } else {
            Some(Ordering::Less)
        }
    }
}

impl PartialEq for NamedNumber {
    fn eq(&self, other: &Self) -> bool {
        println!("Это сообщение всё равно никто не напечатает, я ведь уже в PartialOrd проверил, что они равны"); // теперь эта строчка тут
        self.0 == other.0
    }
}


fn main() {
    let a = NamedNumber(10, 'A');
    let b = NamedNumber(10, 'B');
    if a > b {
        println!("a is more than b")
    } else if a == b {
        println!("a is equal to b")
    } else if a<b {
        println!("a is less than b")
    } else {
        println!("it is impossible...")
    }
}

И моя программа печатает...

Это сообщение всё равно никто не напечатает, я ведь уже в PartialOrd проверил, что они равны
a is equal to b

То есть, получается, моя программа:

1. Сравнивает a и b через PartialOrd

2. Понимает, что они равны

3. Ещё раз сравнивает, но теперь уже через PartialEq

4. Понимает, что они равны

5. Ещё раз сравнивает Наконец-то выводит a is equal to b

А можно оптимальнее???

А теперь подумаем, ЗАЧЕМ он это делает?

impl PartialOrd for NamedNumber {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        if self.0 > other.0 {
            Some(Ordering::Greater)
        } else if self.0 == other.0 {
            println!("Сравним через PartialOrd: {} и {}", self.1, other.1);
            Some(Ordering::Equal)
        } else {
            Some(Ordering::Less)
        }
    }
}

impl PartialEq for NamedNumber {
    fn eq(&self, other: &Self) -> bool {
        println!("Пробуем сравнить через PartialEq, чтоб наверняка: {} и {}", self.1, other.1);
        false
    }
}

// всё остальное как и раньше

Делайте ставки, что выведет программа!

Спорим, вы не угадали?

Сравним через PartialOrd: A и B
Пробуем сравнить через PartialEq, чтоб наверняка: A и B
Сравним через PartialOrd: A и B
it is impossible...

Итак, программа:

1. Сравнивает a и b через PartialOrd

2. Понимает, что они равны

3. Ещё раз сравнивает, но теперь уже через PartialEq

4. Понимает, что они НЕ равны

5. Сравнивает a и b через PartialOrd

6. Понимает, что они равны

7. Пишет it is impossible...

А можно оптимальнее???

Несложные сообщения об ошибках

Если вы вдруг упустили mut, или .into(), или тип перепутали, или ещё что-нибудь, Rust вам об этом заботливо скажет, например:

error[E0308]: mismatched types
 --> src/main.rs:2:21
  |
2 |     let x: String = 181;
  |            ------   ^^^- help: try using a conversion method: `.to_string()`
  |            |        |
  |            |        expected `String`, found integer
  |            expected due to this

For more information about this error, try `rustc --explain E0308`.

А потом вы проснулись. Например, вы в обработчике запроса захватили какую-то переменную, которая не реализует ни Send, ни Sync, ни 'static. Код:

use std::io;

use axum::{routing::get, serve, Router};
use tokio::{net::TcpListener, sync::Mutex};

#[tokio::main]
async fn main() -> io::Result<()> {
    let x = Mutex::new(0);
    let r = Router::new()
        .route("/", get(|| async move {
            let mut l = x.lock().await;
            *l += 1;
            format!("Вы посетили эту страницу {l} раз")
        }));
    serve(TcpListener::bind("0.0.0.0:8080").await?, r).await.unwrap();
    Ok(())
}

И Rust мне выводит достаточно понятный и несложный для прочтения лог, в котором рассказывает, что именно пошло не так:

error[E0277]: the trait bound `tokio::sync::Mutex<i32>: Clone` is not satisfied in `{closure@src/main.rs:10:25: 10:27}`
   --> src/main.rs:10:25
    |
10  |           .route("/", get(|| async move {
    |                       --- ^-
    |                       |   |
    |  _____________________|___within this `{closure@src/main.rs:10:25: 10:27}`
    | |                     |
    | |                     required by a bound introduced by this call
11  | |             let mut l = x.lock().await;
12  | |             *l += 1;
13  | |             format!("Вы посетили эту страницу {l} раз")
14  | |         }));
    | |_________^ within `{closure@src/main.rs:10:25: 10:27}`, the trait `Clone` is not implemented for `tokio::sync::Mutex<i32>`, which is required by `{closure@src/main.rs:10:25: 10:27}: Handler<_, _>`
    |
    = help: the following other types implement trait `Handler<T, S>`:
              `Layered<L, H, T, S>` implements `Handler<T, S>`
              `MethodRouter<S>` implements `Handler<(), S>`
note: required because it's used within this closure
   --> src/main.rs:10:25
    |
10  |         .route("/", get(|| async move {
    |                         ^^
    = note: required for `{closure@src/main.rs:10:25: 10:27}` to implement `Handler<((),), ()>`
note: required by a bound in `axum::routing::get`
   --> /home/mallo_c/.cargo/registry/src/index.crates.io-6f17d22bba15001f/axum-0.7.9/src/routing/method_routing.rs:439:1
    |
439 | top_level_handler_fn!(get, GET);
    | ^^^^^^^^^^^^^^^^^^^^^^---^^^^^^
    | |                     |
    | |                     required by a bound in this function
    | required by this bound in `get`
    = note: this error originates in the macro `top_level_handler_fn` (in Nightly builds, run with -Z macro-backtrace for more info)

For more information about this error, try `rustc --explain E0277`.

Чего??? А что я не так сделал? Где я не так сделал? Ай-ай-ай, ну что за позор, ты же мысли читать умеешь, возьми да прочитай!

На самом деле надо этот x обернуть в какой-нибудь Arc, например так:

use std::{io, sync::Arc};

use axum::{routing::get, serve, Router};
use tokio::{net::TcpListener, sync::Mutex};

#[tokio::main]
async fn main() -> io::Result<()> {
    let x = Arc::new(Mutex::new(0)); // меняем всё тут
    let r = Router::new()
        .route("/", get(|| async move {
            let mut l = x.lock().await; // это проблемная строчка
            *l += 1;
            format!("Вы посетили эту страницу {l} раз")
        }));
    serve(TcpListener::bind("0.0.0.0:8080").await?, r).await.unwrap();
    Ok(())
}

И заметьте, ни на одну из отмеченных строчек компилятор мне не указал!

ZeroVer

У нас в Rust есть SemVer. Это значит, что первая цифра определяет что-то ну совсем важное, что совсем всё сломает, вторая цифра определяет, что-нибудь чуть менее важное, где можно чуть поменять код, и всё будет работать, третья цифра определяет что-то, где можно даже не менять код, и всё по прежнему будет работать. Причём, если первая цифра 0, это означает, что это unstable-релиз и разработчик может вот хоть прям щас сломать библиотеку, и это всё будет по SemVerу.

Смотрим:
axum - v0.7.6
tower - v0.5.1
sqlx - v0.8.1

Окей, с вебом понятно, может с чем-то базовым получше?
rand - v0.8.5
num - v0.4.3
hashbrown - v0.14.5
itertools - v0.13.0

И, наконец, мой любимец:
base64 - v0.22.1

Алгоритм кодирования в base64 же у нас каждые полгода меняется и всё никак не хочет стабилизироваться? :]

Removed vs Not yet released (Rust 1.82)

Однажды в Rust появился оператор ?, который позволяет просто взять и вернуть ошибку из функции.

Пусть вы делаете программу, которая читает файл и записывает в stdout только первые 5 байтов или меньше (что-то вроде head -c 5).

Сравните:

fn head_c_5(file_path: &str) -> io::Result<()> {
    let mut bytes = [0u8; 5];
    let n = File::open(file_path)?.read(&mut bytes)?;
    io::stdout().write_all(&bytes[0..n])
}

vs

fn head_c_5(file_path: &str) -> io::Result<()> {
    let mut bytes = [0u8; 5];
    let mut file = match File::open(file_path) {
        Ok(f) => f,
        Err(e) => return Err(e)
    };
    let n = match file.read(&mut bytes) {
        Ok(n) => n,
        Err(e) => return Err(e)
    };
    io::stdout().write_all(&bytes[0..n])
}

Классная идея с этим оператором! Тем более, что вдруг разработчики Rust решили: давайте-ка мы сделаем трейт std::ops::Try, чтобы не только для Result можно было ставить знак вопроса!

Сделали-то они сделали, но вот потом они подумали, что как-то плохо сделали и надо бы по другому. Делают-делают, делают-делают, а пока можно и оставить старый... Нет, оставили только новый! Давайте-ка его испытаем...

error[E0554]: `#![feature]` may not be used on the stable release channel

То есть нет мне ни старого способа, ни нового... По крайней мере, на stable-версии.

Тем временем Python две версии подряд вежливо предлагал разработчикам перейти на setuptools, при этом он не удалял свой distutils аж до 3.12! Нет, разработчики Rust так не умеют, они - люди решительные.

Методы на все случаи жизни

Например, у итераторов есть product, который должен считать произведение элементов:

fn main() {
    println!("{}", (1..100).product::<u128>())
}

Посмотрим, как это работает:

thread 'main' panicked at /rustc/a7399ba69d37b019677a9c47fe89ceb8dd82db2d/library/core/src/iter/traits/accum.rs:149:1:
attempt to multiply with overflow

А немножко не влезает в u128!

Похоже, что разработчики, которые писали product, не учли, что иногда произведение элементов всё же вылезает за u<что-нибудь>.

Может, сделаем Iterator.product_mod и будем считать произведение по модулю? Не, лень.

Или вот sum():

fn main() {
    println!("{}", (1..100).sum::<u32>())
}

И чем их не устроил .fold(0, |a, b| a+b)?

В Rust можно так:

fn main() {
    println!("{}", (1..100).reduce(|a, b| a+b).unwrap_or(0));
}

А можно так:

fn main() {
    println!("{}", (1..100).fold(0, |a, b| a+b));
}

В Rust можно так:

fn main() {
    let iter = (1..100).map(|x| {
        println!("{x}");
        x
    });
    let v: Vec<u64> = iter.collect();
    // Что-нибудь делаем с v
}

А можно так:

fn main() {
    let iter = (1..100).inspect(|x| {
        println!("{x}");
    });
    let v: Vec<u64> = iter.collect();
    // Что-нибудь делаем с v
}

Я конечно понимаю, что каждый пишет, как хочет, но давайте не будем это доводить до абсурда!

Выводы

Я не сомневаюсь, Rust - действительно красивый язык.
Но иногда я эту красоту просто не понимаю.

Всем спасибо!