🦀 ИТЕРАТОРЫ 🦀

Как вы знаете, 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

🦀 CAS 🦀

Сейчас прокачаем ваш многопоточный код 🤔

CAS (Compare-And-Swap) - это атомарная операция, которая позволяет безопасно изменять данные в многопоточных программах БЕЗ мутексов!

СAS работает по следующему принципу: 🧐

1. Читаем текущее значение
2. Вычисляем новое
3. Пытаемся заменить, но ТОЛЬКО если значение не изменилось
4. Если кто-то успел раньше - повторяем


Простой пример со счетчиками:

use std::sync::atomic::{AtomicU64, Ordering};

let counter = AtomicU64::new(0);

// В цикле пробуем увеличить счётчик
loop {
    let current = counter.load(Ordering::Acquire);
    let new = current + 1;
    
    // Если успели — выходим, если нет — повторяем
    if counter.compare_exchange(
        current, 
        new,
        Ordering::Release,
        Ordering::Acquire
    ).is_ok() {
        break;
    }
}

Конечно, в многопоточке можно использовать и Mutex, но у CAS есть очевидные преимущества:

🔥 Скорость: в 10-100 раз быстрее при низкой конкуренции
🔥 Нет блокировок: потоки не ждут друг друга
🔥 Нет дедлоков: просто невозможны по дизайну

Используйте CAS для создания быстрых параллельных процессов! ⚡️

🚀 Пост Guru Rust: @PaulEdd

🦀 Асинхронка 🦀

Я уверен, вы уже привыкли к тому, что в Rust очень много zero-cost абстракций. Асинхронка дополняет список.

Давайте посмотрим, как работать с асинхронными функциями в Rust.🧐

Простой пример - загрузка файла

use tokio;

async fn download_file(url: &str) -> String {
    println!("Начинаю загрузку {}", url);
    let response = reqwest::get(url).await.unwrap();
    println!("Получил ответ!");
    let content = response.text().await.unwrap();
    println!("Загрузил {} байт", content.len());
    content
}

#[tokio::main]
async fn main() {
    let task1 = download_file("https://example.com/file1");
    let task2 = download_file("https://example.com/file2");
    
    // Запускаем параллельно!
    let (content1, content2) = tokio::join!(task1, task2);
}

Код с виду выглядит синхронным, а компилятор под капотом превращает его в эффективный автомат состояний. И никаких накладных расходов в рантайме.

Что происходит под капотом? 🤔

1️⃣ Компилятор создаёт конечный автомат состояний.

Ваша async-функция превращается в enum с состояниями:

// Примерно так видит компилятор вашу функцию
enum DownloadFileState {
    Start {
        url: String,
    },
    WaitingForResponse {
        url: String,
        response_future: ResponseFuture,
    },
    WaitingForText {
        text_future: TextFuture,
    },
    Done,
}

2️⃣ Каждый `.await` - это точка приостановки

Когда вы пишете .await, компилятор:
- Сохраняет текущее состояние функции (все локальные переменные)
- Возвращает управление планировщику
- Запоминает, где продолжить выполнение

// Это:
let response = reqwest::get(url).await;
let content = response.text().await;

// Превращается в переключение между состояниями:
// Start → WaitingForResponse → WaitingForText → Done

Пока одна задача ждёт ответа от сервера, планировщик переключается на другие задачи. Никакого блокирования потока!

3️⃣ Рантайм крутит все задачи

Tokio/async-std работает как диспетчер:
- Опрашивает каждую задачу: "Ты готова продолжить?"
- Если нет → переключается на следующую
- Если да → выполняет следующий кусок кода до .await

Вся работа получается очень быстрой:⚡️
- Можно создать миллионы асинхронных задач
- Переключение = просто вызов функции (наносекунды)
- Нет тяжёлых системных вызовов

И в рантайме получаем только эффективный машинный код! 🚀

🚀 Пост Guru Rust: @PaulEdd