#новости
🤯 Ларс Бергстром (Google) объявил об инвестициях в Rust в размере $350k:

🟠 $250k — в Rust Foundation на интероперабельность языка
🟠 $100k — в инфраструктуру Crater

По его словам, Rust помог снизить число уязвимостей в Android. Приятно видеть продолжение корпоративных инвестиций

👉Новости 👉База вопросов

#Собес #rust
🤔 Как использовать заимствование данных в структуре Rust?

💬 Кратко:
Чтобы структура могла заимствовать данные, используются аннотации времён жизни ('а ). Они гарантируют, что заимствованные данные существуют до тех пор, пока существует структура.

📌 Полный разбор + примеры использования — на платформе:
👉 Перейти к разбору

📣 Хочешь получать больше таких разборов?
Подпишись на наш главный канал

#новости
😬 Rust 1.90.0 вышел

Основные изменения:

LLD по умолчанию на x86_64-unknown-linux-gnu
Заметное ускорение линковки, особенно для больших проектов и incremental builds. Откат через -C linker-features=-lld.

cargo publish --workspace
Публикация всех crates в workspace одной командой с правильным порядком зависимостей.

x86_64-apple-darwin → Tier 2
Понижение из-за прекращения GitHub macOS x86_64 runners и планов Apple. Билды пока доступны через rustup.

Стабилизированные API:
• u{n}::checked_sub_signed, wrapping_sub_signed, saturating_sub_signed, overflowing_sub_signed
• Copy и Hash для IntErrorKind
• const контекст: <[T]>::reverse(), математические функции для float
• PartialEq между CStr/CString/Cow<CStr>

Изменения совместимости:
• Tier 3 musl targets линкуются динамически по умолчанию
• Небазовые extern "{abi}" формы теперь последовательно отвергаются

https://blog.rust-lang.org/2025/09/18/Rust-1.90.0

👉Новости 👉База вопросов

Знаете, что спрашивают на каждом втором собесе по Rust? Правильно, умные указатели 👆
Давайте разберёмся раз и навсегда 🗒

Что такое умные указатели? ❓

Умные указатели - это обёртки над обычными указателями, которые управляют памятью автоматически и предоставляют дополнительные гарантии безопасности.

В отличие от сырых указателей, они знают, когда нужно освободить память, следят за правилами владения и вообще делают вашу жизнь проще. Главное - правильно выбрать инструмент под задачу 🛠

Святая троица: Box, Rc, RefCell

Box<T> 📦
Самый базовый умный указатель. Аллоцирует данные в куче вместо стека.

Когда использовать:
- Размер типа неизвестен на этапе компиляции (рекурсивные структуры)
- Трейт-объекты (Box<dyn Trait>)

// Классика: связный список
enum List {
    Cons(i32, Box<List>),
    Nil,
}

Никакого оверхеда в рантайме. Просто аллокация в куче с одним владельцем.

Rc<T> - когда владельцев много
Reference Counting. Позволяет иметь несколько владельцев одних и тех же данных.
Rc ведёт подсчёт ссылок, и когда последний владелец исчезает - память освобождается.

Ограничения:
- Только для однопоточного кода (для многопоточки используется Arc)
- Данные неизменяемы (только shared reference)

let data = Rc::new(vec![1, 2, 3]);
let data2 = Rc::clone(&data); // Увеличили счётчик
// Оба указателя владеют данными

Идеально для графов, деревьев и других структур с разделяемым владением.

RefCell<T> - внутренняя изменяемость 🤔
Обычно в Rust компилятор проверяет правила заимствования на этапе компиляции: либо много иммутабельных ссылок &T, либо одна мутабельная &mut T.
Но иногда вам нужна гибкость: изменять данные через иммутабельную ссылку. RefCell переносит эти проверки с компиляции на время выполнения.

Как это работает:
- borrow() (получить иммутабельную ссылку)
- borrow_mut() (получить мутабельную ссылку)
- Правила те же: либо много borrow(), либо один borrow_mut()
- Если нарушите правила - получите панику в рантайме

let data = RefCell::new(5);

// Изменяем значение
*data.borrow_mut() += 1;

// Читаем значение
println!("{}", data.borrow()); // 6

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

Комбинация Rc<RefCell<T>> 🤝
А теперь самое интересное. Что если нужно и множественное владение, и внутренняя изменяемость?

Объединяем силы:

use std::rc::Rc;
use std::cell::RefCell;

let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
let clone1 = Rc::clone(&shared_data);
let clone2 = Rc::clone(&shared_data);

// Каждый клон может изменять данные
clone1.borrow_mut().push(4);
clone2.borrow_mut().push(5);

println!("{:?}", shared_data.borrow()); // [1, 2, 3, 4, 5]

⚠️ Помните: Это не бесплатно. Оверхед на подсчёт ссылок + проверки заимствования в рантайме.

Подведем итог
Умные указатели - это конкретные инструменты под конкретные задачи. Box для базовой работы с кучей, Rc для разделяемого владения, RefCell для внутренней изменяемости.

На собесе главное - не теряться и объяснить, когда какой указатель использовать и в чем их особенности💪

Успехов на собесах! 🚀

🚀 Пост Guru Rust: @PaulEdd

#полезное
🤯 smol — простой и эффективный рантайм асинхронности для Rust.

Де-факто на текущий момент является заменой async-std (который пока что press F).
Для того же Axum есть интеграции вроде smol-axum.

Так что если у вас уже кошмары от Send + 'static, — пробуйте smol :3

👉Новости 👉База вопросов

#полезное
🤯 smol — простой и эффективный рантайм асинхронности для Rust.

Де-факто на текущий момент является заменой async-std (который пока что press F).
Для того же Axum есть интеграции вроде smol-axum.

Так что если у вас уже кошмары от Send + 'static, — пробуйте smol :3

👉Новости 👉База вопросов

#полезное
😊 rust-censure — это порт библиотеки py-censure с питона на раст

Поддерживает два языка: русский и английский.
Будет полезно, например, для авто-модерации чатов.

В плане оптимизации крейт делает две вещи:
🟠 Использует regex для обычных регулярок и fancy-regex для более тяжелых (через фолбэк)
🟠 Компилирует и кэширует регулярки по запросу

👉Новости 👉База вопросов

#Собес #git
🤔 Что делает команда git stash?

💬 Кратко:
Команда git stash сохраняет текущие незавершённые изменения в специальное место (стек), чтобы вы могли переключиться на другую ветку или выполнить другие действия. Эти изменения можно позже восстановить с ПОМОЩЬЮ git stash apply или git stash pop .

📌 Полный разбор + примеры использования — на платформе:
👉 Перейти к разбору

📣 Хочешь получать больше таких разборов?
Подпишись на наш главный канал

🦀 ИТЕРАТОРЫ 🦀

Как вы знаете, Rust напичкан мощными абстракциями, которые упрощают жизнь программисту да еще и без потери производительности. Одна из таких абстракций - итераторы.
Разберемся, как они работают 🤨

Что такое итераторы?

Итератор - любой тип, реализующий трейт Iterator.

Это паттерн для последовательного обхода элементов коллекции.

Чтобы создать собственный итератор, достаточно реализовать трейт с двумя элементами:

pub trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
}

Item - тип возвращаемых элементов, next() - метод, который возвращает следующий элемент или None, когда элементы закончились.


Рассмотрим на простом примере. Создадим структуру Counter, которая будет служить простым счетчиком до 5 ⏰
1. Определяем саму структуру. Она будет хранить внутреннее состояние - текущее значение счетчика.

struct Counter {
    count: u32,
}

impl Counter {
    fn new() -> Self {
        Counter { count: 0 }
    }
}

2. Задаем реализацию трейта Iterator для этой структуры:

impl Iterator for Counter {
    type Item = u32;
    
    fn next(&mut self) -> Option<Self::Item> {
        self.count += 1;
        if self.count <= 5 {
            Some(self.count)
        } else {
            None
        }
    }
}

Ассоциированный тип Item = u32 говорит, что итератор будет возвращать числа типа u32.
Метод next():
- Увеличивает счётчик на 1
- Если счётчик не превысил 5, возвращает Some(count)
- Иначе возвращает None, сигнализируя об окончании итерации

⚠️ Обратите внимание! Сигнатура &mut self необходима, потому что итератор изменяет своё внутреннее состояние при каждом вызове.

3. Используем итератор в простом цикле for:

let counter = Counter::new();
for num in counter {
    println!("{}", num); // 1, 2, 3, 4, 5
}

Компилятор автоматически вызывает next() до тех пор, пока не получит None.


В Rust выделяют три способа итерации по коллекциям 🤑

- iter() заимствует элементы: коллекция остаётся доступной
- iter_mut() изменяемое заимствование: можно модифицировать элементы
- into_iter() забирает владение: коллекция потребляется

let mut data = vec![1, 2, 3];

// iter() — неизменяемое заимствование (&T)
for x in data.iter() {
    println!("{}", x);
}
// data всё ещё доступен

// iter_mut() — изменяемое заимствование (&mut T)
for x in data.iter_mut() {
    *x *= 2;
}

// into_iter() — забирает владение (T)
for x in data.into_iter() {
    println!("{}", x);
}
// data больше недоступен

Выбор между ними зависит от того, что вам нужно делать с элементами и нужна ли коллекция после итерации.


Итак,
Итераторы в Rust - это мощный инструмент для написания выразительного кода 💪

А еще эту тему любят спрашивать на собеседованиях, так что ее точно нужно знать.

🚀 Пост Guru Rust: @PaulEdd

#Собес #git
🤔 Что такое HEAD с точки зрения Git?

💬 Кратко:
HEAD в Git - это указатель на текущую ветку или коммит. Он показывает, над чем вы сейчас работаете, и меняется при переключении веток или выполнении коммитов.

📌 Полный разбор + примеры использования — на платформе:
👉 Перейти к разбору

📣 Хочешь получать больше таких разборов?
Подпишись на наш главный канал

🦀 ТРЕЙТЫ 🦀 - это одна из самых мощных фич Rust, которая позволяет определять общее поведение для разных типов.
Если проводить аналогии, то это что-то среднее между интерфейсами из Java/C# и тайпклассами из Haskell.

Зачем нужны трейты?🤔
- Полиморфизм - пишем код, работающий с любыми типами, реализующими нужный трейт
- Абстракция - определяем контракт поведения без привязки к конкретной реализации
- Расширяемость - можем добавлять новую функциональность даже к чужим типам

Давайте рассмотрим пример 🧐:

trait Describable {
    fn describe(&self) -> String;
}

struct Cat { name: String }
struct Dog { name: String }

impl Describable for Cat {
    fn describe(&self) -> String {
        format!("Кот по имени {}", self.name)
    }
}

impl Describable for Dog {
    fn describe(&self) -> String {
        format!("Пёс по имени {}", self.name)
    }
}

1. В самом начале определяем трейт Describable. Любой тип, который хочет быть Describable, ДОЛЖЕН уметь описывать себя через метод describe.
2. Создаем две простые структуры - собака и кошка.
3. Реализуем трейт Describable для каждого типа.
4. И теперь мы можем написать функцию, которая работает с любым типом, реализующим Describable

let murzik = Cat { name: "Мурзик".to_string() };
let sharik = Dog { name: "Шарик".to_string() };

println!("{}", murzik.describe()); // Кот по имени Мурзик
println!("{}", sharik.describe()); // Пёс по имени Шарик

fn show_animal(animal: &impl Describable) {
    println!("Животное: {}", animal.describe());
}

show_animal(&murzik);
show_animal(&sharik);

Трейты делают Rust невероятно выразительным языком, где абстракции работают без затрат по производительности. 💡

Это zero-cost abstraction в действии! 🚀

🚀 Пост Guru Rust: @PaulEdd

🦀 COW<T> 🦀

Если вы слышали про клонирование в Rust, то наверняка знаете, что эта операция может быть затратной. Особенно когда клонируем большой объем данных. 💀
Но в Rust есть инструмент, который нам поможет и в этом случае. 😘

Проблема: клонирование или заимствование?

Представьте ситуацию: у вас есть функция, которая принимает строку. В 90% случаев она просто читает эту строку, но иногда (редко) нужно её модифицировать.

Как это реализовать?🤔

- Передать &str - быстро, но что делать, когда нужна модификация?
- Передать String - всегда клонируем, даже когда не нужно. Может быть затратно.
- Передать &mut String - а если модификация не нужна?

Получается дилемма: либо мы жертвуем производительностью (постоянно клонируем), либо усложняем API (делаем несколько версий функции). 🤑

Решение: Copy-on-Write (CoW)

Rust предлагает решение - тип Cow<T> (Copy-on-Write). Это умный указатель, который может содержать либо заимствованные данные, либо владеющие. 💡

Простой пример:

use std::borrow::Cow;

fn process_text(text: Cow<str>) -> Cow<str> {
    if text.contains("bug") {
        // Только здесь происходит клонирование!
        Cow::Owned(text.replace("bug", "feature"))
    } else {
        // Просто возвращаем заимствование
        text
    }
}

fn main() {
    let text1 = "Hello, world!";
    let result1 = process_text(Cow::Borrowed(text1));
    // Клонирования не было!

    let text2 = "Found a bug";
    let result2 = process_text(Cow::Borrowed(text2));
    // Клонирование произошло только здесь
}

Как это работает? 🗒

Cow - это enum с двумя вариантами:
- Borrowed(&T) - данные заимствованы, клонирования нет
- Owned(T) - данные принадлежат нам

Когда нужна модификация, вызывается метод .to_mut(), который:

1. Проверяет текущее состояние
2. Если данные заимствованы - клонирует их один раз
3. Если уже владеющие - просто возвращает мutable ссылку


Cow<T> отлично подходит в ситуациях, когда:

✅ Функция чаще читает, чем модифицирует

✅ Хотите избежать лишних аллокаций

✅ Нужна гибкость между заимствованием и владением

Но будьте внимательны, если:

❌ Всегда нужна модификация - используйте владеющие типы

❌ Всегда только чтение - используйте ссылки

Cow - это еще один zero-cost abstraction инструмент в Rust, который позволяет писать более гибкий и производительный код.

Пользуйтесь на здоровье!👍

🚀 Пост Guru Rust: @PaulEdd