Хабр, привет! Меня зовут Никита, я Rust-разработчик.

Статью «Вам не нужны bool и Option» я вообще не хотел выпускать. Казалось, все уже пишут код с ИИ, а я со своими советами про типы напоминаю людям пристегнуть ремень, когда они садятся в машину. Вроде всё правильно, но ощущение, что объясняешь очевидное.

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

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

Небольшой дисклеймер. Примеры здесь учебные и упрощённые. С постановкой задач и решениями можно поспорить, и в своём проекте вы вполне можете сделать иначе. Важны именно практические приёмы и выводы.

Коротко о типах

Примеры будут на Rust. Под примитивными типами здесь я понимаю базовые типы для отдельных значений, например чисел и строк. Они задают, какие значения можно хранить, но сами по себе не объясняют, что эти значения означают в нашей задаче.

String тоже включаю сюда с точки зрения бизнес-логики. В Rust это структура стандартной библиотеки, которая гарантирует корректный UTF-8. Формат строки мы проверяем отдельно.

Сюда же отношу числовой Decimal из крейта rust_decimal.

Под коллекциями здесь понимаю контейнеры для набора значений: массивы, списки, словари, множества и другие структуры данных. В примере рассмотрим Vec<T>, который хранит последовательность элементов типа T.

Примитивные типы в аргументах

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

Например, создаём лимитную заявку на бирже. Объём и цену представляем типом Decimal из rust_decimal. В нашем примере объём измеряется в акциях, а цена — в рублях за акцию. Хотим продать одну акцию по 1000 рублей:

use rust_decimal::Decimal;

enum OrderSide {
    BUY,
    SELL,
}

fn create_limit_order(price: Decimal, volume: Decimal, side: OrderSide) {
    /* отправка заявки */
}

let price = Decimal::ONE_THOUSAND;
let volume = Decimal::ONE;

create_limit_order(volume, price, OrderSide::SELL);

Объём и цену переставили. Получается заявка на продажу 1000 акций по рублю (вот у кого-то праздник будет) вместо одной за 1000 рублей.

Допустим, появился язык Rust++, который поддерживает именованные аргументы:

create_limit_order(price=price, volume=volume, side=OrderSide::SELL)

Теперь порядок аргументов не важен. Но оба параметра всё ещё принимают Decimal, поэтому можно перепутать сами значения:

create_limit_order(price=volume, volume=price, side=OrderSide::SELL)

Сделаем Price и Volume отдельными типами:

struct Price(Decimal);
struct Volume(Decimal);

fn create_limit_order(price: Price, volume: Volume, side: OrderSide) {
    /* отправка заявки */
}

let price = Price(Decimal::ONE_THOUSAND);
let volume = Volume(Decimal::ONE);

create_limit_order(price, volume, OrderSide::SELL);

Теперь компилятор не даст передать Price вместо Volume, хотя внутри у обоих типов хранится Decimal.

Примитивный тип допускает лишние значения

В u8 помещается любое целое от 0 до 255, а в String любая строка в UTF-8. Требования задачи обычно строже: число должно попадать в диапазон, строка соответствовать формату. Имя параметра и комментарий эти требования не проверяют.

Если значение уже проверили, по u8 или String этого тоже не видно. В функции, которая получает такое значение, приходится снова его проверять или искать проверку в вызывающем коде.

1. Диапазон значений

Диапазон числового типа может быть шире, чем нам нужно.

Например, в нашем магазине скидку задают в целых процентах от 1 до 100 включительно (дробных скидок вроде 0,5% у нас нет, чтобы не усложнять пример). Скидку храним в поле discount: Option<DiscountPercent>. В прошлой статье я оставлял Option, когда смысл отсутствия значения однозначен. Здесь None означает «без скидки», так что Option подходит.

u8 вмещает нужные числа, но в него помещаются и ноль, и числа от 101 до 255. Со скидкой 150% магазин ещё и доплатит покупателю.

Возьмём NonZeroU8, чтобы исключить ноль. А числа больше 100 отсеем в конструкторе DiscountPercent. Поле с исходным числом сделаем приватным, чтобы нельзя было обойти проверку:

mod discount {
    use std::num::NonZeroU8;

    pub struct DiscountPercent(NonZeroU8);

    #[derive(Debug)]
    pub struct InvalidDiscount;

    impl DiscountPercent {
        pub fn new(value: u8) -> Result<Self, InvalidDiscount> {
            let percent = NonZeroU8::new(value)
                .filter(|value| value.get() <= 100)
                .ok_or(InvalidDiscount)?;

            Ok(Self(percent))
        }

        pub fn value(&self) -> u8 {
            self.0.get()
        }
    }
}

Конструктор принимает обычный u8. Из числа от 1 до 100 получится DiscountPercent, на остальных вернётся ошибка:

use discount::DiscountPercent;

let discount = DiscountPercent::new(12).unwrap();
assert_eq!(discount.value(), 12);

assert!(DiscountPercent::new(0).is_err());
assert!(DiscountPercent::new(150).is_err());

2. Формат значения

Если функция принимает String, вызывающий код может передать в неё строку, которая не подходит по формату.

Поле email: String выглядит понятно, пока не начинаешь разбираться, кто положил туда строку. Может, адрес уже проверили. А может, там "C++". С UTF-8 у C++ всё в порядке.

Синтаксис адреса описан в RFC 5322, и разбирать его вручную я не стану. В крейте email_address уже есть тип EmailAddress.

use email_address::EmailAddress;

fn send_receipt(to: &EmailAddress) {
    /* отправка письма */
}

let email: EmailAddress = "nikita@example.com".parse().unwrap();
send_receipt(&email);

assert!("C++".parse::<EmailAddress>().is_err());

Здесь parse() проверяет формат адреса, и send_receipt получает уже разобранный EmailAddress. Передать в неё строку "C++" компилятор не даст.

Тип элемента не задаёт ограничения коллекции

У коллекции могут быть ограничения на минимальное или максимальное число элементов. Их нужно проверять отдельно, даже если каждый элемент внутри уже проверен. В типе Vec<T> эти границы не указаны.

В нашем учебном магазине корзина может быть пустой: пользователь ещё выбирает товары или удалил последнюю позицию. Но для оформления заказа нужна хотя бы одна позиция. У позиции есть идентификатор товара, а количество хранится в NonZeroU32:

use std::num::NonZeroU32;

pub struct ProductId(u64);

pub struct OrderLine {
    product_id: ProductId,
    quantity: NonZeroU32,
}

fn place_order(items: Vec<OrderLine>) {
    /* оформление заказа */
}

place_order(Vec::new());

NonZeroU32 исключает нулевое количество товара в позиции. Сейчас в place_order можно передать пустой вектор, поэтому внутри функции понадобится отдельная проверка.

Проверку на пустоту добавим в конструктор OrderItems. В place_order будем принимать OrderItems вместо Vec<OrderLine>. Поле с вектором сделаем приватным и добавим метод as_slice() для чтения позиций:

mod order_items {
    use super::OrderLine;

    pub struct OrderItems(Vec<OrderLine>);

    #[derive(Debug)]
    pub struct EmptyOrder;

    impl OrderItems {
        pub fn new(items: Vec<OrderLine>) -> Result<Self, EmptyOrder> {
            if items.is_empty() {
                return Err(EmptyOrder);
            }
            Ok(Self(items))
        }

        pub fn as_slice(&self) -> &[OrderLine] {
            &self.0
        }
    }
}
use order_items::OrderItems;

fn place_order(items: OrderItems) {
    /* оформление заказа */
}

Теперь place_order(Vec::new()) не подходит по типу. При оформлении нужно сначала получить OrderItems. Если корзина пустая, конструктор вернёт ошибку, которую можно пробросить выше:

let empty_cart = Vec::new();
assert!(OrderItems::new(empty_cart).is_err());

let line = OrderLine {
    product_id: ProductId(1001),
    quantity: NonZeroU32::new(2).unwrap(),
};

let cart = vec![line];
let items = OrderItems::new(cart).unwrap();
place_order(items);

Внутри place_order проверять пустоту больше не нужно, потому что конструктор не создаёт OrderItems без позиций.

Где я оставляю примитивные типы и коллекции

Для индекса вектора мне подходит usize, а для локального вычисления может быть достаточно f64, если у числа нет дополнительных ограничений. Если длительность можно выразить через Duration, возьму готовый тип. Для ненулевого числа уже есть NonZeroU32.

Канал цвета в RGB принимает значения от 0 до 255, как и u8, поэтому здесь я оставляю u8. Но в вызове set_color(255, 128, 0) не сразу понятно, какое число к какому каналу относится. Тут бы пригодился Rust++ с именованными аргументами.

Список результатов поиска может быть пустым, поэтому здесь оставлю обычный Vec.

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