9 полезных крейтов в Rust

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

Rust, как любимый многими разработчиками знаменит своей скоростью и безопасностью. Но его истинная сила заключается в экосистеме крейтов — библиотек и инструментов, которые могут превратить сложные и трудоёмкие задачи в удивительно простые и приятные процессы.

Крейты в Rust – это пакеты, которые можно использовать для расширения функциональности проектов.

В этой статье рассмотрим 9 полезных крейтов в Rust.

Для начала о том, как устанавливать крейты

Нужен естественно Rust и Cargo. Rust поддерживает Windows, Linux, macOS, FreeBSD и NetBSD. Установка Rust на Unix-системах происходит через терминал с помощью команды curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh, а на Windows - скачиванием и запуском файла rustup-init.exe с официального сайта.

Для создания проекта юзаем команду cargo new <название_проекта>, которая сгенерирует базовую структуру проекта, включая файл Cargo.toml для конфигурации и зависимостей.

Чтобы добавить крейт как зависимость, нужно отредактировать файл Cargo.toml, добавив строку в секцию [dependencies], например: serde = "1.0". Это можно сделать вручную или с помощью команды cargo add serde, если установлен cargo-edit.

cargo install <имя_крейта> позволяет установить бинарные крейты, то есть программы или инструменты, которые можно запускать из командной строки. Можно уточнить версию с помощью флага --version, выбрать конкретный бинарный файл с --bin или установить примеры с --example.

Чтобы обновить зависимости проекта до последних версий, юзаем cargo update. Для удаления бинарного крейта, установленного через cargo install, юзаемcargo uninstall <имя_крейта>.

Для компиляции проекта используем cargo build, а для запуска - cargo run. Эти команды автоматически скачивают и устанавливают необходимые зависимости, компилируют проект и, в случае cargo run, запускают выполнение программы.

Сериализация данных с serde

Serde — это фреймворк для сериализации и десериализации структур данных Rust. В отличие от многих ЯПов, которые полагаются на рефлексию во время выполнения для сериализации данных, Serde основан на мощной системе трейтов Rust. Структуры данных, которые знают, как сериализоваться и десериализоваться, реализуют трейты Serialize и Deserialize Serde или используют атрибуты derive для автоматической генерации реализаций на этапе компиляции.

Для сериализации и десериализации в JSON используется крейт serde_json. Например, для структуры Person:

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct Person {
    name: String,
    age: u8,
    is_active: bool,
}

Для сериализации объекта Person в строку JSON и обратно:

let person = Person {
    name: "Alex".to_owned(),
    age: 28,
    is_active: true,
};

let serialized = serde_json::to_string(&person).unwrap();
println!("serialized = {}", serialized);

let deserialized: Person = serde_json::from_str(&serialized).unwrap();
println!("deserialized = {:?}", deserialized);

Serde поддерживает множество форматов, таких как JSON, YAML, TOML и др. Например, для работы с YAML используется крейт serde_yaml, а для TOML — крейт toml.

Для более сложных случаев, таких как условное включение полей или изменение структуры сериализуемого объекта, Serde предоставляет различные атрибуты. Например, можно использовать атрибут #[serde(flatten)], чтобы "сплющить" структуру при сериализации, избегая лишнего уровня вложенности:

#[derive(Serialize, Deserialize)]
struct Request {
    calculation: Calculation,
    #[serde(flatten)]
    shape: Shape,
}

Более подробные примеры использования и документацию можно найти на официальном сайте Serde и в документации крейта.

Асинхронное программирование с tokio

Tokio — это асинхронный runtime для Раста, предназначенный для создания сетевых приложений и поддержки асинхронных операций ввода-вывода, масштабируемых и надёжных.

Для создания нового проекта на Tokio, нужно установить зависимости вCargo.toml. Для большинства проектов достаточно использовать флаг features = ["full"] для включения всех доступных функций:

tokio = { version = "1", features = ["full"] }

Простейший пример использования Tokio — это асинхронная функция main, аннотированная с #[tokio::main], что позволяет использовать async/await синтаксис:

#[tokio::main]
async fn main() {
    println!("Hello, Tokio!");
}

А вот так может выглядеть асинхронная задача задержки с использованием Tokio:

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    println!("Start delay");
    sleep(Duration::from_secs(5)).await;
    println!("Delay complete");
}

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

Также имеются инструменты для работы с асинхронным вводом-выводом, включая поддержку TCP, UDP, таймеров и др. Вот пример асинхронного TCP эхо-сервера на Tokio:

use tokio::net::TcpListener;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let listener = TcpListener::bind("127.0.0.1:8080").await?;
    loop {
        let (mut socket, _) = listener.accept().await?;
        tokio::spawn(async move {
            let mut buf = [0; 1024];
            loop {
                let n = match socket.read(&mut buf).await {
                    Ok(n) if n == 0 => return,
                    Ok(n) => n,
                    Err(e) => {
                        eprintln!("failed to read from socket; err = {:?}", e);
                        return;
                    },
                };
                if let Err(e) = socket.write_all(&buf[0..n]).await {
                    eprintln!("failed to write to socket; err = {:?}", e);
                    return;
                }
            }
        });
    }
}

Веб-разработка с warp

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

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

#[tokio::main]
async fn main() {
    let route = warp::path::end().map(|| warp::reply::html("Hello, Habr!"));
    warp::serve(route).run(([127, 0, 0, 1], 3030)).await;
}

Для работы с JSON в Warp используются макросы Serialize и Deserialize из крейта serde. Пример создания эндпоинта, принимающего JSON, выглядит так:

#[derive(Deserialize, Serialize, Clone)]
struct Item {
    name: String,
    quantity: i32,
}

fn json_body() -> impl Filter<Extract = (Item,), Error = warp::Rejection> + Clone {
    warp::body::content_length_limit(1024 * 16).and(warp::body::json())
}

#[tokio::main]
async fn main() {
    let add_items = warp::post()
        .and(warp::path("item"))
        .and(json_body())
        .map(|item: Item| {
            warp::reply::json(&item)
        });
    warp::serve(add_items).run(([127, 0, 0, 1], 3030)).await;
}

Создание полноценного CRUD API требует организации работы с БД и обработки различных HTTP методов. В Warp это можно организовать с помощью фильтров и асинхронных функций. Например, для обработки GET и POST запросов можно использовать следующий код:

let get_route = warp::get()
    .and(warp::path("items"))
    .and(with_db(pool.clone()))
    .and_then(handlers::get_items);

let post_route = warp::post()
    .and(warp::path("items"))
    .and(json_body())
    .and(with_db(pool.clone()))
    .and_then(handlers::add_item);

let routes = get_route.or(post_route);
warp::serve(routes).run(([127, 0, 0, 1], 3030)).await;

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

Подробнее с warp можно ознакомиться здесь.

Работа с БД с diesel

Diesel представляет собой ORM и конструктор запросов, который поддерживает работу с PostgreSQL, MySQL и SQLite. Он предназначен для упрощения взаимодействия с БД, минимизации шаблонного кода и предотвращения ошибок времени выполнения, не жертвуя при этом производительностью. Diesel полностью интегрируется с системой типов Rust!

Для начала работы с Diesel необходимо добавить его в Cargo.toml файл, указав нужные функциональности, в зависимости от того, с какой БД идет работа.

[dependencies]
diesel = { version = "1.0", features = ["postgres", "sqlite", "mysql"] }

После добавления зависимости идентификация схемы БД и генерация соответствующего кода осуществляется через использование макросов Diesel и команды Diesel CLI для миграций.

Миграции позволяют контролировать версии схемы БД аналогично системам контроля версий кода. В Diesel CLI это делается так:

diesel migration generate create_students

Это создаст структуру каталогов для миграций, включая файлы up.sql и down.sql для каждой миграции, в которые добавляется SQL код для изменений схемы и отката изменений соответственно.

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

#[derive(Queryable)]
pub struct Post {
    pub id: i32,
    pub title: String,
    pub body: String,
    pub published: bool,
}

А для вставки новых записей используется Insertable:

#[derive(Insertable)]
#[table_name="posts"]
pub struct NewPost<'a> {
    pub title: &'a str,
    pub body: &'a str,
}

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

pub fn create_post<'a>(conn: &PgConnection, title: &'a str, body: &'a str) -> Post {
    let new_post = NewPost {
        title: title,
        body: body,
    };

    diesel::insert_into(posts::table)
        .values(&new_post)
        .get_result(conn)
        .expect("Error saving new post")
}

Этот код вставляет новую запись в таблицу и возвращает её как структуру Post.

Также есть механизмы чтения. Например, для получения всех записей, которые соответствуют определённым критериям:

let results = posts.filter(published.eq(true))
    .limit(5)
    .load::<Post>(&connection)
    .expect("Error loading posts");

Diesel поддерживает сложные запросы и операции, такие как соединения, фильтрация, сортировка и пагинаци.

Подробнее с Diesel можно ознакомиться здесь.

Многопоточность и параллелизм с rayon

Rayon очень мощная вещь, которая позволяет достигать параллелизма данных в Rust. Она позволяет легко выполнять операции в параллельном режиме.

Для начала работы с Rayon, добавьте зависимость в ваш Cargo.toml:

[dependencies]
rayon = "1.5.1"

И импортируйте трейты, предоставляемые Rayon, используя предварительную загрузку:

use rayon::prelude::*;

Параллельные итераторы являются самым простым и часто наиболее используемым способом использования Rayon. Они позволяют автоматически преобразовать последовательные вычисления в параллельные, обеспечивая при этом защиту от гонок данных. Параллельные итераторы поддерживают множество методов, аналогичных обычным итераторам в Rust, включая map, for_each, filter, fold и многие другие.

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

use rayon::prelude::*;

fn main() {
    let mut arr = [0, 7, 9, 11];
    arr.par_iter_mut().for_each(|p| *p -= 1);
    println!("{:?}", arr);
}

Код параллельно уменьшит каждый элемент массива на единицу.

Для более тонкой настройки параллельных вычислений Rayon предлагает использовать методы join и scope, которые позволяют делить работу на параллельные задачи. Метод join используется для одновременного выполнения двух замыканий, а scope создает область видимости, в которой можно создать произвольное количество параллельных задач.

Пример использования метода join для параллельного выполнения двух задач:

rayon::join(|| do_something(), || do_something_else());

Метод хорош для задач, привязанных к CPU, но его не следует использовать для блокирующих операций, таких как ввод-вывод.

Подробнее про крейт - здесь.

GUI разработка с iced

Iced является кросс-платформенной библиотекой для создания графических пользовательских интерфейсов на Rust, которая ориентирована на простоту и типобезопасность. Вдохновлённая Elm, Iced предлагает интуитивно понятную модель для создания реактивных приложений с чётким разделением состояния приложения, пользовательских взаимодействий, логики отображения и обновления состояния.

Основные возможности Iced:

• Простой и удобный API "всё включено".

• Реактивная модель программирования на основе типов.

• Поддержка кросс-платформенности: Windows, macOS, Linux и веб.

• Адаптивная компоновка.

• Встроенные виджеты (текстовые поля, прокрутка и многое другое).

• Поддержка пользовательских виджетов.

• Отладочная панель с метриками производительности.

• Встроенная поддержка асинхронных действий через futures.

• Модульная экосистема с возможностью интеграции в существующие системы【.

Рассмотрим пример кода для создания простого GUI приложения с счётчиком. Реализуем основные концепции Iced, такие как моделирование состояния, обработка сообщений от пользователя, логика отображения и обновления состояния:

use iced::{button, executor, Application, Button, Column, Command, Element, Settings, Text};

pub fn main() -> iced::Result {
    Counter::run(Settings::default())
}

struct Counter {
    value: i32,
    increment_button: button::State,
    decrement_button: button::State,
}

#[derive(Debug, Clone, Copy)]
enum Message {
    IncrementPressed,
    DecrementPressed,
}

impl Application for Counter {
    type Executor = executor::Default;
    type Message = Message;
    type Flags = ();

    fn new(_flags: ()) -> (Counter, Command<Self::Message>) {
        (
            Counter {
                value: 0,
                increment_button: button::State::new(),
                decrement_button: button::State::new(),
            },
            Command::none(),
        )
    }

    fn title(&self) -> String {
        String::from("A simple counter")
    }

    fn update(&mut self, message: Self::Message) -> Command<Self::Message> {
        match message {
            Message::IncrementPressed => {
                self.value += 1;
            }
            Message::DecrementPressed => {
                self.value -= 1;
            }
        }

        Command::none()
    }

    fn view(&self) -> Element<Self::Message> {
        Column::new()
            .push(
                Button::new(&mut self.increment_button, Text::new("Increment"))
                    .on_press(Message::IncrementPressed),
            )
            .push(Text::new(self.value.to_string()).size(50))
            .push(
                Button::new(&mut self.decrement_button, Text::new("Decrement"))
                    .on_press(Message::DecrementPressed),
            )
            .into()
    }
}

Здесь будет простое приложение с счётчиком, который можно увеличивать и уменьшать с помощью двух кнопок. Состояние счётчика хранится в поле value структуры Counter. Для каждой кнопки создается свой экземпляр button::State, который используется для отслеживания состояния кнопки. Взаимодействия юзера с кнопками генерируют сообщения Message, которые обрабатываются в методе update, изменяя состояние счётчика. Виджеты для отображения составляются в методе view, который возвращает layout с кнопками и текстом, отображающим текущее значение счётчика.

Парсинг и анализ кода с syn и quote

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

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

Пример макроса, который парсит атрибут с переменными и добавляет вывод в консоль при их изменении:

#[proc_macro_attribute]
pub fn trace_vars(metadata: TokenStream, input: TokenStream) -> TokenStream {
    let input_fn = parse_macro_input!(input as ItemFn);
    // парсинг аргументов макроса
    let args = parse_macro_input!(metadata as Args);
    // генерация нового кода
    TokenStream::from(quote!{fn dummy(){}})
}

quote используется для генерации кода Rust. Он позволяет встраивать фрагменты кода в макросы, используя интерполяцию переменных.

Простой пример макроса с использованием quote, который генерирует функцию:

#[proc_macro]
pub fn minimal(input: TokenStream) -> TokenStream {
    let Combinations { name, n } = parse_macro_input!(input as Combinations);
    (quote!{
        fn #name() -> i32 {
            #n
        }
    }).into()
}

Рассмотрим пример, в котором создадим процедурный макрос на Rust, использующий syn и quote для анализа структуры и генерации функции, которая считает сумму значений её числовых полей.

Представим, что есть структура Point, содержащая два поля x и y, и мы хотим сгенерировать функцию sum, которая будет возвращать их сумму.

Сначала определим структуру Point и напишем макрос derive_summation, который будет генерировать функцию sum:

// в файле lib.rs крейта с процедурными макросами

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput};

#[proc_macro_derive(SumFields)]
pub fn derive_summation(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    
    // получение имени структуры
    let name = &input.ident;
    
    // генерация кода функции sum
    let gen = quote! {
        impl #name {
            pub fn sum(&self) -> i32 {
                self.x + self.y
            }
        }
    };
    
    gen.into()
}

Теперь в основном проекте или другом крейте, юзаем макрос SumFields для автоматической генерации метода sum для структуры Point.

use my_macro_crate::SumFields; // Замените my_macro_crate на имя вашего крейта с макросами

#[derive(SumFields)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let point = Point { x: 1, y: 2 };
    println!("Sum of fields: {}", point.sum());
}

Кстати, подробнее про макросы можно по читать в нашей статье про макросы в Rust.

---

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

А про главные особенности разработки приложения на Rust мои коллеги из OTUS расскажут в рамках бесплатного вебинара.