let a = String::from("test");
let b = a.deref();

Тип b будет &str (если бы там был вектор, тип бы стал &[i32]). Чувствуете разницу? Этот метод сделает указатель непосредственно на данные, но он не попытается эти данные куда-то перенести. Если же перед deref поставить звёздочку, то мы опять получим ошибку: *(a.deref()), потому что опять будет сделана попытка вытащить сами данные из heap и куда-то их перетащить. Фактически, здесь *(a.deref()) равносильно *a.

При этом для простых типов deref не имеет смысла. На типах вроде i32 его нет вовсе, на указателях это метод просто вернёт сам указатель:

let a: i32 = 5;
let b = &a;
let c = b.deref();

Тип c будет &i32, как у b.

Интересно, что в ряде случаев Rust умеет делать dereference автоматически для нашего же удобства. К примеру, есть функция:

fn call(s: &str) {
    println!("{}", s);
}

Она может принять как &str, так и String:

let a = "test";
let b = String::from(a);

call(a);
call(&b);

Работает это потому, что у String есть trait Deref (про него будет в видео), который умеет делать dereferencing в обычный &str.

То есть функция делает что-то такое:

let borrowed = &b;
let my_str = c.deref();

Тип my_str будет &str, то есть ровно то, что написано в функции. Хотя мы могли бы сделать слайс &str сами, это уж очень неудобно, ведь нужно получить сами данные из умного указателя, сделать заимствование, и потом создать слайс:

let borrowed = &b;
let my_str = &(*borrowed)[..];

А так deref() вызовется для нас, причём столько раз, сколько требуется, поэтому если функция принимает массив вида &[i32], то туда можно запихнуть и вектор с числами того же типа.

Теперь мы понимаем, какие есть указатели и как из них получать данные. Интересно, что мы можем создавать и свои умные указатели в Rust, и самым простым является Box - он положит наши данные в heap и сделает привязку к ним по аналогии с тем, что делает vector или string:

let a: Box<i32> = Box::new(42);

То есть наши число теперь торчит не в стеке, а в heap, и a содержит в себе умный указатель. Это значит, что мы можем тоже делать referencing и dereferencing:

let a: Box<i32> = Box::new(42);
let b: &Box<i32> = &a;
let c: &i32 = a.deref();
let d: i32 = *a;

Из аннотации типов можно легко видеть, где что получается. Кстати, *a тут тоже работает в отличие от истории с векторами и строками, потому что размер целого числа точно известен, его можно скопировать и поместить в стек. То есть в d будет число, независимое от того, на которое указывает a (там вообще выходит, что он сначала делает deref, потом звёздочку).
Однако вот так всё равно сделать нельзя: let e = *b;, как и в предыдущих примерах. *b укажет на сам Box<i32>, копировать его автоматом Rust не будет, так что там придётся написать clone()

Но тут вопрос: зачем нам вообще этот box нужен, если лучше хранить простые типы в стеке, который банально быстрее работает? Это так и есть, во многих случаях хранить обычное число "в коробке" смысла нет. Но если у нас есть данные, размер которых заранее неизвестен, то это может быть очень актуально.

К примеру, есть вот такая структура, описывающая кошку:

struct Cat {
    name: String,
    age: u8,
}

let cat = Cat {
    name: String::from("Mr. Buttons"),
    age: 3,
};

Где будет хранится наш Mr. Buttons? Сама структура будет в стеке, но строка как таковая будет в heap (в стеке же будет указатель на неё).

Однако предположим, что у кошки может быть предок, и это тоже кошка:

struct Cat {
    name: String,
    age: u8,
    parent: Option<Cat>,
}

Можно ли такую структуру запихнуть в стек? Нет, потому что она рекурсивная, и её размер во время компиляции определить невозможно. Дело в том, что у Mr. Buttons может быть потомок, у того свой потомок, и так до бесконечности. Поэтому родителя нужно хранить в heap, и это тот случай, когда нам нужен Box:

struct Cat {
    name: String,
    age: u8,
    parent: Option<Box<Cat>>,
}

Создадим двух кошек: