#Собес #rust
🤔 Можно ли обьявить несколько переменных в одной строке кода?

💬 Кратко:
Да, в Rust можно обьявить несколько переменных в одной строке с помощью деструктуризации. Например, из кортежа.

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

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

#полезное
🥄 Энергоэффективный транспайлер Python в Rust

Depyler — это транспайлер, который преобразует код Python в безопасный и производительный Rust, снижая потребление энергии на 75-85%. Он предлагает мощные инструменты для тестирования и верификации, обеспечивая высокое качество кода и поддержку CI/CD.

Основные моменты:
🔵 Эффективное преобразование Python в Rust
🔵 Поддержка многоуровневого тестирования и верификации
🔵 Интеграция с AI для улучшения качества кода
🔵 Поддержка формата Ruchy для функционального программирования
🔵 Высокие стандарты безопасности и производительности

GitHub: https://github.com/paiml/depyler

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

#Собес #rust
🤔 Что такое трейты в Rust?

💬 Кратко:
Трейты в Rust - это механизм определения поведения, который типы могут реализовывать. Это похоже на интерфейсы в других языках, но с уникальными особенностями.

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

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

🔥 Механизм заимствования - еще одна причина, по которой Rust код не падает в продакшене.


На прошлой неделе мы говорили о механизме владения. Сегодня разберем еще один важный механизм Rust - заимствование (borrowing). Этот механизм помогает писать безопасный и эффективный код 🛟

Что такое заимствование?❓

Заимствование позволяет передать доступ к значению без передачи владения. Вместо самого значения ты передаёшь ссылку (&T или &mut T).

Тем самым ты избегаешь лишнего копирования и сохраняешь единственный источник истины. А компилятор отлавливает ошибки работы с памятью ещё до запуска программы.

🧑‍🎓Существует два типа ссылок:

1. Неизменяемая ссылка &T
Позволяет только читать данные, но не изменять их.

fn len(s: &String) -> usize { 
  // s.push_str("!")  Здесь будет ошибка. Не можем изменить
  s.len() 
} 

2. Изменяемая ссылка &mut T
Позволяет и читать, и изменять данные.

fn shout(s: &mut String) { 
  s.push_str("!")   // Сработает. Можем изменять
  s.len() 
}    

⚠️На ссылки накладываются определенные правила. Эти правила проверяет часть компилятора Rust, которая называется borrow checker.

1. Много читателей ИЛИ один писатель.
Можно:
- Любое количество неизменяемых ссылок &T одновременно
- Ровно одну изменяемую ссылку &mut T

Нельзя:
- Одновременно иметь &T и &mut T

let mut name = String::from("Rust");

// много неизменяемых ссылок - работает
let a = &name;
let b = &name;
println!("{a} {b}");

// неизменяемая + изменяемая одновременно - ошибка
let c = &name;
let d = &mut name;

Это правило предотвращает гонки данных на уровне компиляции. Если один поток читает данные, а другой их изменяет - это может привести к непредсказуемому поведению.

2. Ссылки не могут пережить данные.

Ссылка должна быть действительна все время своего использования. Нельзя создать ссылку на данные, которые уже освобождены.

fn bad_ref() -> &String {
    let s = String::from("oops");
    &s // Строка s будет очищена после выхода из функции - не сработает
}

Это защищает от висячих указателей - одного из самых частых источников ошибок в C/C++.

На собеседованиях будь готов к этим вопросам 😎
- Какие правила проверяет borrow checker?
- Почему нельзя одновременно иметь &T и &mut T?
- Почему Rust не позволяет возвращать из функции ссылку на локальную переменную?

🚀 Пост Guru Rust: @PaulEdd

#Собес #rust
🤔 Что такое обобщения (generics) в Rust?

💬 Кратко:
Обобщения дают возможность создавать код, который работает с любым типом, указанным при его вызове. При этом можно задавать ограничения (трейты), которые тип должен соблюдать. Это делает код более гибким и повторно используемым.

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

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

#новости
🤯 Ларс Бергстром (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