Rust

🦀 Rust-задача с подвохом: “Ловушка безопасного кэша” 📘 Условие Ты хочешь реализовать простой кэш — если значение уже вычислено, вернуть его, иначе — сохранить и вернуть. Вот пример:

use std::collections::HashMap;

fn main() {
    let mut cache = HashMap::new();
    let key = "user_123".to_string();

    let result = get_or_insert(&mut cache, &key, || {
        println!("Computing...");
        "result for user_123".to_string()
    });

    println!("Result: {}", result);
}

fn get_or_insert<'a, F>(map: &'a mut HashMap<String, String>, key: &str, compute: F) -> &'a String
where
    F: FnOnce() -> String,
{
    map.entry(key.to_string()).or_insert_with(compute)
}

❓ Вопрос: 1) Почему этот код не компилируется, хотя кажется безопасным? 2) Где именно проблема с lifetime'ами? 3) Как можно переписать этот код так, чтобы он компилировался и оставался эффективным? --- ✅ Подвох и разбор 💥 Проблема в or_insert_with(compute) и владении ключом. Метод .entry() требует ключ во владение (`String`), а key у нас — &str. Внутри or_insert_with происходит вызов compute(), который может вернуть ссылку на строку, но Rust не может доказать, что ссылка будет жить достаточно долго. Но главная причина — возвращаемое значение &'a String, полученное из HashMap::entry, не может быть безопасно связано с временем жизни `map`, потому что key.to_string() создаёт временное значение, и lifetime не совместим. 📌 Ошибка компилятора: borrow may not live long enough. ✅ Как исправить Вариант 1 — использовать `Entry` напрямую и разбить на шаги: ```rust fn get_or_insert<'a, F>(map: &'a mut HashMap<String, String>, key: &str, compute: F) -> &'a String where F: FnOnce() -> String, { use std::collections::hash_map::Entry; match map.entry(key.to_string()) { Entry::Occupied(entry) => entry.into_mut(), Entry::Vacant(entry) => entry.insert(compute()), } } ``` Теперь Rust понимает, как обрабатывается владение, и может гарантировать корректный lifetime. --- ⚠️ Подвох • `.or_insert_with(...)` выглядит безопасным, но может скрывать временные владения • Проблемы начинаются, когда `key.to_string()` создаёт временное значение, и Rust не может связать его lifetime • Даже опытные разработчики удивляются ошибке компилятора, потому что map.entry().or_insert_with() выглядит «канонично» 🎯 Отлично подходит для проверки глубокого понимания владения и жизненных циклов в Rust.

Virviil/oci2git Это консольное приложение на Rust, которое преобразует контейнерные образы (Docker и др.) в Git-репозитории. Каждая слоя образа превращается в отдельный коммит, что позволяет сохранять всю историю и структуру исходного образа Основные возможности: - Поддержка разбора Docker-образов и извлечения информации о слоях. - Генерация Git-репозитория, где каждый слой соответствует одному коммиту (включая «пустые» слои вроде ENV и WORKDIR) - Экспорт всей метаинформации об образе в файл Image.md в формате Markdown. - Расширяемая архитектура для работы с разными движками контейнеров (docker, nerdctl, tar) - Типичные сценарии использования: - Сравнение слоёв (Layer Diffing): благодаря git diff можно увидеть точные изменения между любыми двумя слоями образа и выявить, какие файлы были добавлены, изменены или удалены - Отслеживание происхождения (Origin Tracking): команда git blame помогает быстро понять, в каком слое и какой Dockerfile-инструкции был впервые создан или изменён конкретный файл GitHub - История файла (File Lifecycle): с помощью git log --follow можно проследить путь любого файла через все слои: от создания до удаления GitHub - Исследование слоёв (Layer Exploration): переключаясь на любой коммит, вы получаете файловую систему образа в состоянии этого слоя, что удобно для отладки и аудита безопасности Github

Senior Rust Developer в BlockSniper Удалёнка | full-time | 400–700K ₽ + премии Мы лидеры в снайпинге токенов на Solana. Пишем трейдинг-ботов и высокоскоростные стратегии. Уже 4 года в деле, 50 человек в команде, работаем без бюрократии — только результат. Премии от прибыли: топы получают +300K к зп. 💻 Что важно: — Опыт в Rust, Solana (Anchor, CLI, деплой) — Знание JS/TS, понимание RPC/DApps/PoS — Опыт с HFT, трейдингом или ботами — Умение вести проект от идеи до продакшена 🧩 Ищем тех, кто не боится челленджей: у нас нужно разбираться, предлагать, выстраивать. Самостоятельность — must-have. Взамен даём максимум свободы, зп и роста. 🎁 Можете быть уверены в: — Конкурентной зп + доход от прибыли команды — Полной удаленке, оплачиваемом отпуске и больничном — Том, что мы вкладываемся в рост: обсуждаем бенефиты, помогаем развиваться Напиши нашему HR Маргарите 👉 @m_dereviakina, если ищешь место, где можно развиваться, расти и хорошо зарабатывать.

💫 GlueSQL — SQL-движок, превращающий любые данные в полноценную базу данных. Этот инструмент умеет выполнять JOIN между CSV и MongoDB, работать с Git как с хранилищем данных и даже запускать SQL-запросы прямо в браузере через WebAssembly. Что отличает GlueSQL от классических СУБД? - Поддержка schemaless-данных - Встроенные адаптеры для 10+ форматов - Возможность добавлять свои хранилища через реализацию двух traits на Rust Проект активно развивается: недавно добавили поддержку транзакций в Sled-бэкенде и анонсировали облачную версию. Для теста достаточно cargo add gluesql и уже можно писать SQL-запросы к данным в памяти. 🤖 GitHub

С этим вашим Kubernetes отладка превратилась в квест на выживание! Часами гребёшься в логах, метрики пляшут как попало, а деплой через Helmfile — вообще отдельный вид искусства. Чтобы K8s помогал, а не топил в рутине, нужно понять, как он работает под капотом. Иначе — вечные страдания 🥲 ➡️ Приходи на курс «Kubernetes для разработчиков» от Слёрма. Там ты: 👉 Научишься нормально дебажить свои приложения прямо в Кубе 👉 Разберёшься с логами и метриками 👉 Подружишься с Helm’ом 👉 Наконец заведёшь CI/CD как надо То есть получишь скиллы, чтобы работать с K8s в кайф. 📅 Старт — 26 мая 🔗 Запрыгивай на борт курса «Kubernetes для разработчиков» — пока есть места! Реклама ООО «Слёрм» ИНН 3652901451

🔥 Burn — Rust-фреймворк для глубокого обучения с акцентом на производительность. В отличие от монолитных решений вроде PyTorch, Burn изначально заточен под кросс-платформенное выполнение: одна и та же модель может работать на NVIDIA/AMD GPU через CUDA/ROCm, на Apple-чипах через Metal и даже в браузере через WebGPU. Главная фишка проекта в модульной архитектуре с подключаемым бэкендом и автоматической оптимизацией вычислений. Например, система умеет объединять операции ядер без ручного вмешательства. Для исследователей есть встроенный дашборд для мониторинга обучения, а для продакшна простая конвертация в ONNX. 🤖 GitHub

🛡Безопасность в разработке dApps: уязвимости и защита На уроке мы разберем основные угрозы безопасности в децентрализованных приложениях (dApps) и научимся защищать смарт-контракты от атак. Вы узнаете, какие уязвимости наиболее распространены в Solidity, как хакеры эксплуатируют ошибки в коде и какие методы защиты можно применять. В практической части занятия мы рассмотрим реальные примеры атак на смарт-контракты, проанализируем их причины и предложим решения для их предотвращения. В результате занятия получите: - Понимание ключевых уязвимостей в Solidity и способах их эксплуатации - Практические навыки защиты смарт-контрактов от атак - Разбор реальных кейсов атак и методов их предотвращения -Четкое представление о том, как разрабатывать безопасные dApps 👉 Регистрация и подробности о курсе “Разработка децентрализованных приложений” https://otus.pw/t9GS/ Реклама. ООО "ОТУС ОНЛАЙН-ОБРАЗОВАНИЕ", ИНН: 9705100963

👣 Pyrefly — это новая, высокопроизводительная система статической типизации и IDE-платформа, написанная на Rust, для Python, разрабатываемая командой Facebook. Главное: 🔍 Наследник Pyre Pyrefly задуман как следующая версия проверяльщика типов Pyre от Meta, но с упором на скорость, модульную архитектуру и возможность генерации «типизированного» AST. 🚀 Реализовано на Rust Большая часть кода написана на Rust для лучшей безопасности памяти и конкурентности. Только ~1 % кода в Python и ~6 % в TypeScript (для интерфейса сайта и LSP). ⚙️ Три этапа проверки Сбор экспорта каждого модуля (решение всех import * рекурсивно) Преобразование кода в набор «байндингов» (definitions, uses, anon) с учётом потоковых типов Решение этих байндингов (flow-types, phi-функции при ветвлениях и рекурсии) 💡 Масштабируемость и инкрементальность Модульно-ориентированный подход: проверка каждого модуля целиком, с возможностью параллельного запуска и минимальной сложности по сравнению с тонкозернистыми DAG-алгоритмами. 🛠️ Интеграция и упаковка Разработчикам Rust: cargo build, cargo test Во внутренних проектах Meta: запуск через Buck2 (buck2 run pyrefly -- check file.py) Для PyPI: сборка колес через Maturin (pip install maturin && maturin build) 📡 IDE-функции и LSP Включена поддержка Language Server Protocol для автодополнения, перехода к определению и интерактивной отладки в редакторах. 📆 Планы Полная замена Pyre к концу 2025 года с выпуском стабильных версий на PyPI каждую неделю. 📜 Лицензия MIT — свободное использование и вклад в проект приветствуются. 🔜 Узнать подробнее и принять участие можно в репозитории: Github @pythonl

🔥CocoIndex — это современный ETL-фреймворк с открытым исходным кодом, предназначенный для подготовки данных к использованию в системах искусственного интеллекта. Он поддерживает пользовательскую логику трансформации и инкрементальные обновления, что делает его особенно полезным для задач индексации данных. 🔧 Основные возможности - Инкрементальная обработка данных: CocoIndex отслеживает изменения в исходных данных и логике трансформации, обновляя только изменённые части индекса, что снижает вычислительные затраты. - Поддержка пользовательской логики: Фреймворк позволяет интегрировать собственные функции обработки данных, обеспечивая гибкость при построении пайплайнов. - Модульная архитектура: Встроенные компоненты для чтения данных (локальные файлы, Google Drive), обработки (разбиение на чанки, генерация эмбеддингов) и сохранения результатов (PostgreSQL с pgvector, Qdrant). - Поддержка различных форматов данных: Поддержка текстовых документов, кода, PDF и структурированных данных, что делает CocoIndex универсальным инструментом. 🚀 Примеры использования - Семантический поиск: Индексация текстовых документов и кода с эмбеддингами для семантического поиска. - Извлечение знаний: Построение графов знаний из структурированных данных, извлечённых из документов. - Интеграция с LLM: Извлечение структурированной информации из неструктурированных данных с помощью больших языковых моделей. ## ⚙️ Быстрый старт 1. Установите библиотеку CocoIndex:

   pip install -U cocoindex
   

https://github.com/cocoindex-io/cocoindex 2. Настройте базу данных PostgreSQL с расширением pgvector. 3. Создайте файл quickstart.py и настройте пайплайн обработки данных. 4. Запустите пайплайн для обработки и индексации данных. 🟢 Github

🎥 Cap — open-source проект Cap, предлагающий функционал, аналогичный популярному сервису Loom. Инструмент уже сейчас позволяет записывать и редактировать видео прямо с рабочего стола, а в ближайших планах — запуск self-hosted версий для Vercel и Render. Гибридная архитектура проекта сочетает Rust для десктоп-приложения и Next.js для веб-версии, с единой системой компонентов на React. Разработчики активно привлекают сообщество к доработке, особенно в части создания инструкций по самостоятельному развертыванию. 🤖 GitHub @react_tg

🧑🏻‍💻Хотите научиться писать нейросети на одном из самых быстрых и безопасных языков программирования?  На открытом уроке 6 мая в 20:00 МСК мы научим вас создавать простейшую нейросеть с нуля, используя минимальные библиотеки. Вы не только познакомитесь с Rust, но и узнаете, как оптимизировать вычисления для работы с нейронными сетями. Вы сможете писать быстрые и эффективные нейросети на Rust — языке, который сегодня активно используется для решения высоконагруженных задач. 👉Присоединяйтесь к открытому уроку и получите скидку на программу обучения «Rust Developer. Basic»: https://otus.pw/AFkT/?erid=2W5zFFzMsCC  Реклама. ООО "ОТУС ОНЛАЙН-ОБРАЗОВАНИЕ". ИНН 9705100963.

🦀 Компания System76 представила седьмую альфа-версию своей революционной DE COSMIC — полностью написанной на Rust альтернативы GNOME. Новый выпуск примечателен не только встроенным Wayland-композитором, но и уникальными режимами работы с окнами: гибридной мозаичной компоновкой и браузерным группированием вкладок. Среди свежих изменений — улучшенная навигация между рабочими столами, экспериментальное дробное масштабирование для XWayland и тонкие настройки звука. При этом проект остаётся кроссплатформенным: пакеты уже доступны для Fedora, Arch, NixOS и даже нишевых дистрибутивов вроде Redox. 🔗 Ссылка - *клик* @rust_code

👣 Задача: "Безопасная многопоточная очередь с приоритетами в Rust" 📌 Условие: Реализуйте потокобезопасную структуру данных — очередь с приоритетами (`PriorityQueue`), которая: - Позволяет добавлять элементы с приоритетом через push(value: T, priority: u32). - Позволяет забирать элемент с наивысшим приоритетом через pop() -> Option<T>. - Гарантирует: - Безопасную работу из нескольких потоков без блокировок на долгие периоды (желательно через минимальные локи или атомарные операции). - Отдачу элементов в порядке убывания приоритета. - Высокую производительность при массовых операциях. Ограничения: - Можно использовать стандартные библиотеки Rust (`std::sync`, `std::collections`). - Нельзя использовать внешние библиотеки вроде tokio, crossbeam, rayon и др. - Структура должна быть универсальной (`Generic`), т.е. работать с любыми типами данных. --- ▪️ Подсказки: - Для внутреннего хранения можно использовать BinaryHeap из std::collections. - Для обеспечения многопоточности можно использовать Arc<Mutex<...>>. - Чтобы минимизировать блокировки, можно подумать о: - Разделении кучи на несколько шардов (`sharding`), - Использовании тонкой блокировки только на операции изменения состояния. --- ▪️ Что оценивается: - Умение правильно работать с владением (`ownership`) и заимствованием (`borrowing`) в многопоточной среде. - Аккуратное управление блокировками (`Mutex`, `RwLock`). - Оптимизация под высокую нагрузку (минимизация времени блокировки). - Чистота и читабельность кода. - Способность правильно обрабатывать ошибки (`PoisonError` при падении потока). --- ▪️ Разбор возможного решения: Идея архитектуры: - Основная структура — Arc<Mutex<BinaryHeap<...>>>. - Каждый push и pop блокирует мьютекс на короткое время (захватывает лок на минимальное изменение). - При push(value, priority): - Оборачиваем значение в структуру, которая реализует Ord так, чтобы приоритет был главным критерием сортировки. - При pop(): - Просто pop() из BinaryHeap. - Обработка ошибок: - При отравлении мьютекса (`PoisonError`) безопасно восстанавливать структуру или пробрасывать ошибку выше. --- ▪️ Мини-пример структуры:

use std::collections::BinaryHeap;
use std::sync::{Arc, Mutex};

#[derive(Eq, PartialEq)]
struct Item<T> {
    priority: u32,
    value: T,
}

impl<T> Ord for Item<T> {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        other.priority.cmp(&self.priority) // обратный порядок для max-heap
    }
}

impl<T> PartialOrd for Item<T> {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

pub struct PriorityQueue<T> {
    heap: Arc<Mutex<BinaryHeap<Item<T>>>>,
}

impl<T> PriorityQueue<T> {
    pub fn new() -> Self {
        PriorityQueue {
            heap: Arc::new(Mutex::new(BinaryHeap::new())),
        }
    }

    pub fn push(&self, value: T, priority: u32) {
        let mut heap = self.heap.lock().unwrap();
        heap.push(Item { priority, value });
    }

    pub fn pop(&self) -> Option<T> {
        let mut heap = self.heap.lock().unwrap();
        heap.pop().map(|item| item.value)
    }
}

--- ▪️ Возможные подводные камни: - ❗ Не обработать PoisonError — если поток паникует при блокировке, вся очередь будет "сломана". - ❗ Долгая блокировка внутри push или pop, особенно при больших объемах данных. - ❗ Возможная гонка состояний, если попытаться вручную обойти Mutex через небезопасный код (`unsafe`). --- ▪️ Дополнительные вопросы на собеседовании: - Как модифицировать структуру для поддержки тайм-аутов на pop() (если очередь пуста — ждать максимум N миллисекунд)? - Как бы вы реализовали "разделение очереди на несколько шардов" для снижения конкуренции потоков? - Как сделать неблокирующую версию через Atomic примитивы? --- @rust_code

⚡️Легкий способ получать свежие обновления и следить за трендами в разработке на вашем языке. Находите свой стек и подписывайтесь: Python: t.me/pythonl Linux: t.me/linuxacademiya Собеседования DS: t.me/machinelearning_interview Нерйросети t.me/ai_machinelearning_big_data C++ t.me/cpluspluc Docker: t.me/DevopsDocker Хакинг: t.me/linuxkalii Devops: t.me/DevOPSitsec Data Science: t.me/data_analysis_ml Javascript: t.me/javascriptv C#: t.me/csharp_ci Java: t.me/javatg Базы данных: t.me/sqlhub Python собеседования: t.me/python_job_interview Мобильная разработка: t.me/mobdevelop Golang: t.me/Golang_google React: t.me/react_tg Rust: t.me/rust_code ИИ: t.me/vistehno PHP: t.me/phpshka Android: t.me/android_its Frontend: t.me/front Big Data: t.me/bigdatai МАТЕМАТИКА: t.me/data_math Kubernets: t.me/kubernetc Разработка игр: https://t.me/gamedev Haskell: t.me/haskell_tg Физика: t.me/fizmat 💼 Папка с вакансиями: t.me/addlist/_zyy_jQ_QUsyM2Vi Папка Go разработчика: t.me/addlist/MUtJEeJSxeY2YTFi Папка Python разработчика: t.me/addlist/eEPya-HF6mkxMGIy Папка ML: https://t.me/addlist/2Ls-snqEeytkMDgy Папка FRONTEND: https://t.me/addlist/mzMMG3RPZhY2M2Iy 😆ИТ-Мемы: t.me/memes_prog 🇬🇧Английский: t.me/english_forprogrammers 🧠ИИ: t.me/vistehno 🎓954ГБ ОПЕНСОРС КУРСОВ: @courses 📕Ит-книги бесплатно: https://t.me/addlist/BkskQciUW_FhNjEy

👣 Tessa-Rust-T1-7B-Q8_0-GGUF — компактная 8-битная версия Rust-ориентированной модели Tessa-Rust-T1 в формате GGUF для llama.cpp. Создана для генерации и автодополнения кода на Rust с учётом лучших практик языка. Hugging Face 🚀 Обзор модели Архитектура: трансформер на базе Qwen2.5-Coder-7B-Instruct, дообученный на специализированном Rust-датаcете от Tesslate. Цель: автономная генерация идиоматичного Rust-кода — функции, структуры, трейты и модули; интеграция в AI-агенты для автоматизации backend-разработки и CLI-утилит. Hugging Face Размер: ~7.62 B параметров (после квантования Q8_0) → файл ~8.1 GB в формате GGUF. ⚙️ Ключевые особенности Глубокое Rust-мышление: поддерживает включение «think-тегов» в промпт для структурированного, многоэтапного рассуждения перед выдачей результата. Контекстно-чувствительная генерация: учитывает зависимости (crates), lifetimes и идиомы Rust, что снижает количество ошибок после генерации. Интеграция с агентами: модель готова для использования в автономных системах разработки, быстрой генерации backend-логики, тестов и CLI-утилит. https://huggingface.co/Tesslate/Tessa-Rust-T1-7B-Q8_0-GGUF @rust_code

🧠 Задача на Rust — для продвинутых разработчиков

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

fn main() {
    let a = Rc::new(RefCell::new(1));
    let b = a.clone();

    let c = {
        let mut val = b.borrow_mut();
        *val += 1;
        Rc::try_unwrap(b).ok().unwrap().into_inner()
    };

    println!("a: {}", a.borrow());
    println!("c: {}", c);
}

Что выведет код? A. a: 2 c: 2 B. a: 1 c: 2 C. Panic at runtime due to unwrap failure ✅ D. Compilation error due to ownership rules 📌 Ответ: Правильный ответ: C — Panic at runtime due to unwrap failure Почему: Мы создаем a как Rc<RefCell<i32>>, из него делаем b = a.clone() → теперь у Rc два владельца. Мы мутируем значение через b.borrow_mut(), увеличиваем его на 1. Затем пытаемся сделать Rc::try_unwrap(b). ⚠️ Rc::try_unwrap требует, чтобы Rc был единственным владельцем. Но у нас всё ещё есть a, то есть ссылка остаётся → unwrap не срабатывает и unwrap() вызывает паник на runtime. @rust_code

Возможность для backend разработчиков, Яндекс Практикум ищет экспертов! Яндекс Практикум — сервис онлайн-образования, где реально освоить востребованную цифровую профессию. Что делает программный эксперт: ✔️ формирует программу на основе требований рынка и лучших практик в отрасли, ✔️ курирует набор авторов, а затем их работу над обучающим контентом, ✔️ проводит фактчекинг, вносит корректировки — заботится о том, чтобы курс стал по-настоящему полезным и востребованным. От кандидата ожидают: Опыт в коммерческой backend разработке на Rust от 4 лет. Если вы имеете опыт в коммерческой backend разработке на Rust от 4 лет и вы точно знаете «как это должно работать» — добро пожаловать! Узнайте больше о курсе и роли программного эксперта здесь. Ждём ваших откликов, коллеги!

💡 Задача Linux: Пропажа файла после echo У вас есть файл /tmp/testfile с важным содержимым. Вы решили добавить в него строку "Hello, world!" с помощью команды:

echo "Hello, world!" > /tmp/testfile

Однако после выполнения этой команды вы замечаете, что всё старое содержимое исчезло и осталась только одна строка "Hello, world!". Вопрос: Почему это произошло? Как правильно было добавить строку, не потеряв содержимое? ✅ Решение и объяснение: 🔍 Что делает >? Символ > в Bash — это перезапись (truncate) файла. Когда вы пишете: ```bash echo "Hello, world!" > /tmp/testfile``` Это значит: Shell открывает файл на запись с обнулением (truncate). Весь предыдущий контент удаляется, прежде чем echo записывает новую строку. Вот подвох: даже если echo кажется безобидной командой, сам процесс перенаправления (>) выполняется до запуска echo. ✅ Как сделать правильно? Чтобы добавить строку, нужно использовать >>, а не >: ```bash echo "Hello, world!" >> /tmp/testfile ``` >> открывает файл в режиме append, не трогая текущее содержимое. ⚠️ Бонусный подвох (для профи) Выполните это: ```bash cat /tmp/testfile > /tmp/testfile ``` После этого файл станет пустым. Почему? ➡️ Ответ: cat читает из /tmp/testfile, но перенаправление > делает truncate сразу, еще до запуска cat. То есть: Файл обнуляется, Потом cat читает его… но он уже пустой! Чтобы избежать такого поведения, можно использовать временный файл: ```bash cat /tmp/testfile > /tmp/tmpfile && mv /tmp/tmpfile /tmp/testfile```

Смарт-контракты: Автоматизация и сравнение реализаций в Ethereum, TON и Solana Введение в смарт-контракты. Как смарт-контракты заменяют традиционные процессы? Расскажем на открытом уроке! Результаты урока:   - Понимание принципов работы смарт-контрактов и их роли в Web3.   - Навык чтения кода на Solidity, FunC и Rust.   - Умение выбирать блокчейн под конкретные задачи (стоимость, скорость, масштабируемость).   - Готовые примеры для дальнейшего изучения.   👉 Регистрация и подробности о курсе “Разработка децентрализованных приложений” https://otus.pw/ytvC/?erid=2W5zFHbg3ix Реклама. ООО "ОТУС ОНЛАЙН-ОБРАЗОВАНИЕ". ИНН 9705100963.

🔍 Вопрос: что выведет этот код на Rust?

fn main() {
    let mut v = vec![1, 2, 3];
    let first = &v[0];

    v.push(4);

    println!("First: {}", first);
}

--- ✔️ Правильный ответ: Ошибка компиляции --- 🧠 Разбор: - let first = &v[0]; ➜ иммутабельная ссылка - v.push(4); ➜ мутабельная операция Rust запрещает это: нельзя иметь и иммутабельную ссылку, и мутабельную операцию одновременно! 📚 Rust выдаст ошибку компиляции: error[E0502]: cannot borrow v as mutable because it is also borrowed as immutable 💥 Подвох: в C++, Go или JS это бы сработало. Rust завернет такое на стадии компиляции ✅ @rust_code