Nurked предложил оригинальный способ прочтения "the book" — читать главы надо не по порядку, а в последовательности [4, 3, 5, 6, 8, 4, 9, 7, 10, 4, 13, 17, 15, 16].

Можно пойти дальше. Мне представляется, что читать будет гораздо легче и быстрее, если выкинуть бо?льшую часть текста и заменить некоторые примеры. Ниже представлен "пробник" в виде сильно сокращенной главы 4. Чтение его подразумевает наличие опыта разработки на других языках — объяснения типа "чем отличается стек от кучи", естественно, попали под оптимизацию.

Финализация через drop()

Когда объект покидает область видимости (variable scope), его "финализируют" через вызов метода drop(). В этом деструкторе можно произвести некие завершающие действия — возвратить память в кучу, закрыть соединение и т.д. Для примера создадим экземпляр типа String с помощью фабрики String::from():

    {
        let s = String::from("hello"); // s is valid from this point forward

        // do stuff with s
    }                      
    // This scope is now over, and s is no longer valid
    // Rust calls s.drop() automatically at the closing curly bracket.

Компилятор Rust любезно обеспечит неявный вызов s.drop() после закрывающей скобки.

The book утверждает, что управление памятью осуществляется через "владение" с набором правил, которые компилятор проверяет во время компиляции программы. Полезно сразу иметь в виду (напомню — материал для опытных камикадзе), что есть некие:

- Box<T> для распределения значений в куче (памяти)
- Rc<T> тип счётчика ссылок, который допускает множественное владение
- Типы Ref<T> и RefMut<T>, доступ к которым осуществляется через тип RefCell<T>, который обеспечивает правила заимствования во время выполнения, вместо времени компиляции
- Rust допускает утечки памяти, используя типы Rc<T> и RefCell<T> можно создавать связи, где элементы ссылаются друг на друга в цикле

Короче, если память выделяется в куче, а полученные объекты ссылаются друг на друга — будь готов к граблям, засадам и к поиску утечек памяти.

use std::cell::RefCell;
use std::rc::{Rc, Weak};

// The `derive` attribute automatically creates the implementation
// required to make this `struct` printable with `fmt::Debug`.
#[derive(Debug)]
struct Node {
    value: i32,
    parent: RefCell<Weak<Node>>,
    children: RefCell<Vec<Rc<Node>>>,
}

fn main() {
    let leaf = Rc::new(Node {
        value: 3,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![]),
    });

    println!("leaf parent = {:?}", leaf.parent.borrow().upgrade());

    let branch = Rc::new(Node {
        value: 5,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![Rc::clone(&leaf)]),
    });

    *leaf.parent.borrow_mut() = Rc::downgrade(&branch);

    println!("leaf parent = {:?}", leaf.parent.borrow().upgrade());
}

Изменяемость переменных

fn intro_string_type(){
    let immutable_string = String::from("I'm immutable");
    // immutable_string.push_str("!"); // ERR: ^ cannot borrow as mutable

    let mut mutable_string = String::from("I'm mutable");
    mutable_string.push_str("!");

    println!("immutable_string: {}", immutable_string);
    println!("mutable_string: {}", mutable_string);
}

• Примеры можно покрутить тут
• intro_string_type(), ого, змеиная нотация — так надо
• Переменные, объявленные через let, изменять нельзя
• Если надо менять используем let mut
• Вывод на печать осуществляется причудливой конструкцией println! (тут может возникнуть справедливое подозрение, что это не "обычная функция")

Владение (Ownership) и его передача присваиванием (Move)

Каждое значение имеет одного и только одного владельца-переменную. После операции присваивания переменная типа String перестает владеть своим бывшим значением, и ее нельзя больше использовать:

fn once_assigned_string_may_not_be_used_anymore(){
    let s1 = String::from("5");
    let s2 = s1; // Ownership is moved here
    // let s3 = s1; // ERR: value used here after move
    // println!("{}, world!", s1); // ERR: value borrowed here after move
}

Для простых типов (primitive types), однако, значение копируется, а не передается, и для них многократное присваивание выглядит обычным образом:

fn primitives_are_copied(){
    let i1 = 5;
    let i2 = i1;
    let i3 = i1;
}

• Есть trait (как бы interface) Copy, если тип его реализует, при присваивании/передаче в функцию/возврате значения происходит копирование
• Copy реализован для простых скалярных типов, а также для неких кортежей (tuples), при условии, что эти загадочные пока tuples содержат только типы, реализующие Copy
• Тип String не реализует Copy
• Из неочевидного: Copy несовместим с Drop (это где drop()). Несовместим, даже если не сам тип, а только его некоторые части реализуют Drop

Передача и возврат параметра по значению

При передаче переменной в функцию по значению происходит и передача владения (если тип не реализует интерфейс trait Copy):

fn use_str_by_value(s: String){
    println!("{}", s);
}

fn passing_by_value_moves_ownership(){
    let s1 = String::from("5");
    use_str_by_value(s1);
    // let s2 = s1; // ERR: value used here after move
}

Возврат значения (пример для расширения кругозора):

fn calculate_length(s: String) -> (String, usize) {
    let length = s.len();
    return (s, length)
}

fn calculate_length2(s: String) -> (String, usize) {
    let length = s.len();
    (s, length)
}

• Из функции можно вернуть несколько значений (тот самый кортеж, или tuple)
• usize означает целый беззнаковый тип, который вмещает указатель (the pointer-sized unsigned integer type)
• return можно не писать
• При возврате переменной "по значению" функция возвращает и владение (опять же, если не реализован Copy)

Ссылки и заимствование (References and Borrowing)

Необязательно брать значение во владение, его можно "занять" (borrow):

fn borrow(){
    let mut s = String::from("hello");

    let r1 = &s; // First immutable borrow occurs here
    let r2 = &s; // Second immutable borrow occurs here
    // let r3 = &mut s; // Err: mutable borrow occurs here
    // r3.push_str(" world");
    let r3 = &s; // Third immutable borrow occurs here

    println!("{}, {}, and {}", r1, r2, r3);
}

• Занять можно как для чтения (&), так и для записи (&mut)
• Занять для чтения (immutable borrow) можно сколько угодно раз в "области видимости переменной" (variable scope)
• Занять для записи (mutable borrow) — только один раз
• Нельзя занимать одновременно для чтения и записи (все это похоже на read/write locks)
• Результат заимствования называется ссылкой (reference)

От перестановки строк из примера выше результат меняется и становится компилируемым:

fn borrow2(){
    let mut s = String::from("hello");

    let r1 = &s; // First immutable borrow occurs here
    let r2 = &s; // Second immutable borrow occurs here
    println!("{}, {}", r1, r2); // hello, hello

    let r3 = &mut s; // Mutable borrow occurs here, r1 & r2 are not used anymore and out of scope
    r3.push_str(" world");
    println!("{}", r3); // hello world

}

• Видимость ссылки заканчивается там, где она последний раз используется

Висячие ссылки (Dangling References)

Компилятор Rust гарантирует, что эта проблема искоренена полностью. Компилятор откажется работать с попытками подвесить ссылки, в качестве причины отказа он приведет загадочную формулировку "error[E0106]: missing lifetime specifier":

fn dangling_reference() -> &str {
    let s = String::from("hello");
    return &s
}

Загадка lifetime specifier получит раскрытие в следующих главах.

//go:noinline
func ReturnPointerToLocal() *int{
    a := 10
    return &a
}

;*** main.go#9    >func ReturnPointerToLocal() *int{
...
;*** main.go#10   >     a := 10
0x4a7a04     488d0575b00000         LEAQ type.*+43648(SB), AX
0x4a7a0b     48890424               MOVQ AX, 0(SP)
0x4a7a0f     e84c5bf6ff             CALL runtime.newobject(SB)
0x4a7a14     488b442408             MOVQ 0x8(SP), AX
0x4a7a19     48c7000a000000         MOVQ $0xa, 0(AX)

;*** main.go#11   >     return &a
0x4a7a20     4889442420             MOVQ AX, 0x20(SP)
0x4a7a25     488b6c2410             MOVQ 0x10(SP), BP
0x4a7a2a     4883c418               ADDQ $0x18, SP
0x4a7a2e     c3                     RET

Срезы (Slices)

Очевидное:

fn string_slice(){
    let s = String::from("Yandex");
    let the_third_and_fourth_bytes_slice  = &s[2..4]; // nd
    let the_whole_string_slice  = &s[..]; // Yandex
    let first_two_bytes_slice  = &s[..2]; // Ya
    let from_the_third_byte_slice  = &s[2..]; // ndex
}

Невероятное:

fn string_slice_multibyte(){
    let s = String::from("y?andex");
    // let slice = &s[0..1]; // ERR: thread 'main' panicked at 'byte index 1 is not a char boundary...
    // let slice = &s[0..2]; // ERR: thread 'main' panicked at 'byte index 1 is not a char boundary...
    let valid_slice = &s[0..3];
    println!("valid_slice: {}", valid_slice); // y?
}

• Срезы строк можно делать только по труъ-unicode-границам, иначе паника
• Подробнее тут или here, кому что любо

Но то строки, с байтами ситуация попроще:

fn byte_slice(){
    let s = String::from("y?andex");
    let bytes = s.as_bytes();
    let slice = &bytes[0..2];
    println!("{:?}, len: {}", slice, slice.len()); // [121, 204], len: 2
}

Теперь, собственно, про владение. Взятие среза "одалживает" всю последовательность на чтение, менять ее теперь нельзя:

fn slice_borrow_the_whole_sequence() {
    let mut s = String::from("hello");
    let first_two_bytes_slice  = &s[..2]; // he
    // s.push_str(" world"); // Err: cannot borrow `s` as mutable because it is also borrowed as immutable
    println!("{}", first_two_bytes_slice);
}

• Не зря это делается при помощи &
• the book, раскрывая внутреннюю кухню, указывает, что в основе String лежат три значения (ptr, len, capacity), а slice довольствуется первыми двумя

Явное указание типов для slice не всегда очевидно:

fn return_slices(s: &String) -> (&str, &[u8]){
    let bytes = s.as_bytes();
    return (&s[..], &bytes[..])
}

• Срез строки имеет особенный тип &str
• Срез для as_bytes() имеет тип &[u8], что соответствует руководству: "slice type is &[T]"

Ссылки

• Примеры из статьи
• Как мы ржавели. История внедрения и обучения
• Understanding Ownership (the book)
• Понимание владения
• A half-hour to learn Rust