Rust и иммутабельность

Привет, Хабр!

Иммутабельность данных в Rust – это основа для создания систем, устойчивых к ошибкам и сайд-эффектам. В этой статье рассмотрим, как Rust позволяет использовать неизменяемые структуры данных для улучшения производительности и безопасности приложений.

Начнем с синтаксических особенностей.

Синтаксические особенности

В Rust переменные по умолчанию иммутабельны. То есть после их инициализации изменить значение нельзя. Это основной аспект языка, который помогает предотвратить множество видов ошибок, связанных с состоянием данных. Для объявления переменной используется ключевое слово let:

let x = 5; // x = 6; // это вызовет ошибку компиляции, так как x неизменяемая

Если нужно изменить значение переменной, можно использовать модификатор mut, который явно указывает, что переменная может быть изменена:

let mut y = 5; y = 6; // теперь это корректный код

Ссылки в Rust также иммутабельны по умолчанию. То есть нельзя изменить данные, на которые ссылаетесь, без явного указания:

let z = 10; let r = &z; // *r = 11; // ошибка, так как r — иммутабельная ссылка

Для изменения данных через ссылку нужно использовать изменяемую ссылку:

let mut a = 10; let b = &mut a; *b = 11; // корректно, так как b — изменяемая ссылка

Структуры данных в Rust также подчиняются правилам иммутабельности. Если создается экземпляр структуры с помощью let, все его поля будут неизменяемыми, если только каждое поле явно не объявлено как mut:

struct Point {     x: i32,     y: i32, }  let point = Point { x: 0, y: 0 }; // point.x = 5; // ошибка, так как поля структуры неизменяемы

Помимо всего этого, есть ряд функциональных возможностей, которые способствуют работе с иммутабельными структурами данных. Одна из таких возможностей — это шаблон Создатель, позволяющий изменять данные структуры в процессе её создания, но предоставляя в результате неизменяемый объект:

#[derive(Debug)] struct Rectangle {     width: u32,     height: u32, }  impl Rectangle {     fn new() -> Rectangle {         Rectangle { width: 0, height: 0 }     }      fn set_width(&mut self, width: u32) -> &mut Rectangle {         self.width = width;         self     }      fn set_height(&mut self, height: u32) -> &mut Rectangle {         self.height = height;         self     }      fn build(self) -> Rectangle {         self     } }  let rect = Rectangle::new().set_width(10).set_height(20).build(); // rect.width = 15; // ошибка, так как rect неизменяемый после создания

Здесь Rectangle создается как изменяемый для настройки его размеров, но после вызова метода build он становится неизменяемым.

Типичные иммутабельные структуры

Иммутабельные векторы

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

use im::vector::Vector;  fn main() {     let vec = Vector::new();     let updated_vec = vec.push_back(42);     println!("Original vector: {:?}", vec);     println!("Updated vector: {:?}", updated_vec); }

Здесь updated_vec является новым вектором, содержащим добавленные элементы, в то время как оригинальный вектор vec остается неизменным.

Структурный общий доступ

Структурный общий доступ позволяет иммутабельным структурам данных делиться частями своего состояния с другими структурами, минимизируя тем самым необходимость копирования данных. Пример можно реализовать с помощью библиотеки rpds, которая имеет персистентные структуры данных:

use rpds::Vector;  fn main() {     let vec = Vector::new().push_back(10).push_back(20);     let vec2 = vec.push_back(30);     println!("vec2 shares structure with vec: {:?}", vec2); }

vec2 использует большую часть данных из vec, добавляя только новые элементы.

Иммутабельные связные списки

Иммутабельные связные списки полезны в функциональном программировании. Пример использования персистентного связного списка:

use im::conslist::ConsList;  fn main() {     let list = ConsList::new();     let list = list.cons(1).cons(2).cons(3);     println!("Persistent list: {:?}", list); }

Каждая операция cons создает новый список, который содержит новый элемент наряду со ссылкой на предыдущий список.

Иммутабельные хэш-карты

Иммутабельные хэш-карты могут использоваться для хранения и доступа к данным по ключу:

use im::HashMap;  fn main() {     let mut map = HashMap::new();     map = map.update("key1", "value1");     let map2 = map.update("key2", "value2");     println!("Map1: {:?}", map);     println!("Map2: {:?}", map2); }

Здесь map2 добавляет новую пару ключ-значение, при этом map остается неизменной.

Иммутабельные деревья

Иммутабельные деревья можно использовать для создания сложных структур данных с операциями поиска и вставки:

use im::OrdMap;  fn main() {     let tree = OrdMap::new();     let tree = tree.update(1, "a").update(2, "b");     let tree2 = tree.update(3, "c");     println!("Tree1: {:?}", tree);     println!("Tree2: {:?}", tree2); }

Примеры использования

Многопоточный доступ к конфигурации

Разработаем примеры системы, где множество потоков должны получать доступ к общей конфигурации без риска гонок данных. Иммутабельность здесь полезна тем, что гарантирует, что данные не будут случайно изменены, что, как мы знаем, очень важно в многопоточном окружении.

Определим иммутабельную структуру AppConfig, содержащую конфигурационные параметры:

#[derive(Clone, Debug)] struct UserState {     user_id: u32,     preferences: Vec<String>, }

Создадим глобально доступный Arc для этой конфигурации, чтобы безопасно делиться между потоками:

impl UserState {     fn add_preference(&self, preference: String) -> Self {         let mut new_preferences = self.preferences.clone();         new_preferences.push(preference);         UserState {             user_id: self.user_id,             preferences: new_preferences,         }     } }

Здесь каждый поток получает безопасный доступ к конфигурации, что исключает возможность её изменения, т.к данные защищены иммутабельностью и Arc.

Управление состоянием в функциональном веб-приложении

Второй кейс — это веб-приложение, где состояние пользователя обновляется без мутаций, используя концепции ФП для улучшения управляемости состояния и упрощения тестирования.

Определим иммутабельную структуру состояния пользователя:

#[derive(Clone, Debug)] struct UserState {     user_id: u32,     preferences: Vec<String>, }

Функция обновления состояния, возвращающая новое состояние:

impl UserState {     fn add_preference(&self, preference: String) -> Self {         let mut new_preferences = self.preferences.clone();         new_preferences.push(preference);         UserState {             user_id: self.user_id,             preferences: new_preferences,         }     } }

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

fn handle_request(current_state: &UserState) -> UserState {     let updated_state = current_state.add_preference("new_preference".to_string());     updated_state }

Здесь каждый вызов add_preference создаёт новую версию состояния UserState.

Полезные библиотеки

im — это высокопроизводительная библиотека для работы с иммутабельными структурами данных в Rust. Она имеет полный набор персистентных структур данных: списки, векторы, карты и множества, которые сохраняют предыдущие версии себя при модификациях и позволяют разделять данные между состояниями без необходимости их полного копирования.

Пример иммутабельного списка:

use im::ConsList;  fn main() {     let list = ConsList::new();     let list = list.cons(1).cons(2).cons(3);     println!("Persistent list: {:?}", list); }

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

rpds, которую мы применяли чуть выше, предоставляет коллекцию иммутабельных и персистентных структур данных. Библиотека поддерживает функциональный стиль, предлагая структуры, которые автоматом сохраняют историю изменений.

Пример использования иммутабельного словаря:

use rpds::HashTrieMap;  fn main() {     let map = HashTrieMap::new();     let map = map.insert("key1", "value1");     let map2 = map.insert("key2", "value2");     println!("Map1: {:?}", map);     println!("Map2: {:?}", map2); }

Здесь map2 создается на основе map с добавлением новой пары ключ-значение, при этом оригинальный map остается неизменным.

---

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

В завершение хочу пригласить вас на бесплатный вебинар, где мы подробно рассмотрим различия и особенности разработки на Rust для классического backend и для блокчейн-систем. Регистрация доступна по ссылке.