Проектирование библиотечного API — бесплатный тест онлайн

Вопрос 1 из 30

Какую регрессию должен ловить `std::borrow::Cow::Borrowed`?

assert!(matches!(normalize("rust"), std::borrow::Cow::Borrowed(_)));
assert_eq!(normalize("Rust"), "rust");

Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. Успешная ветвь служит достаточным доказательством поведения при ошибке и повторном выполнении. Тогда поведение `std::borrow` при раннем выходе выводили бы из обычного пути. Успешный запуск подтверждает корректность не только этого пути, но и остальных ветвей программы. Дополнительный сценарий вокруг `std::borrow::Cow::Borrowed` при таком толковании уже не требуется. Отсутствие сообщения инструмента означает, что опасная ветвь была выполнена и признана корректной. Дополнительный сценарий вокруг `std::borrow::Cow::Borrowed` при таком толковании уже не требуется. Тест закрепляет и семантический результат, и отсутствие выделения на уже нормализованном входе.

Вопрос 2 из 30

Чем завершится выполнение фрагмента с `Config`?

pub struct Config {
    pub timeout_ms: u64,
}

Код считается допустимым, потому что возврат impl Trait гарантирует пользователю возможность назвать конкретный скрытый тип. Код не пройдёт проверку: builder проверяет обязательные поля при build. До последней строки и наблюдаемого результата программа при таком разборе не доходит. Компиляция закончится диагностикой: integration test импортирует библиотеку как внешний crate. До последней строки и наблюдаемого результата программа при таком разборе не доходит. Добавление нового публичного поля к такой структуре ломает внешние struct literals; открытые поля уже являются частью конструктивного API. Фрагмент успешно соберётся: добавление нового публичного поля структуры не влияет на код с литералами структуры.

Вопрос 3 из 30

Какой принцип Rust объясняет обычный сценарий для «Совместимость версий Semver»?

Impl Trait в публичном результате раскрывает конкретный тип пользователю как часть сигнатуры. Возврат impl Trait гарантирует пользователю возможность назвать конкретный скрытый тип. По этой логике отдельная проверка «Совместимость версий Semver» на другом входе считалась бы лишней. Публичные поля структуры не входят в semver-контракт и могут свободно переименовываться. Такое рассуждение переносило бы вывод о «Совместимость версий Semver» на неисполненную ветвь. Semver для Rust учитывает не только имена функций, но и вывод типов, auto traits, blanket impl, exhaustiveness и возможность конструировать типы. Добавление нового публичного поля структуры не влияет на код с литералами структуры. Следовательно, поведение `Config` считалось бы одинаковым для всех допустимых типов.

Вопрос 4 из 30

Что нужно пересмотреть в использовании `std::borrow::Cow`, чтобы код стал корректным?

pub fn normalize(input: &str) -> std::borrow::Cow<'_, str> {
    if input.bytes().all(|b| !b.is_ascii_uppercase()) {
        std::borrow::Cow::Borrowed(input)
    } else {
        std::borrow::Cow::Owned(input.to_ascii_lowercase())
    }
}

Принимать только String и требовать clone от каждого пользователя, даже когда функция лишь читает текст. При каждом таком вызове появляется отдельный владелец и оплачивается копирование данных. Принимать &str/AsRef<str> по реальной потребности, возвращать Cow только если условная аллокация ощутима и lifetime не делает API труднее пользователя. Принимать и возвращать только владеющий `String` или `Vec`, чтобы не отражать время жизни и формы заимствования в API. Заменить типизированную ошибку `normalize` паникой или строкой, сохранив внешний текст как средство программного ветвления. Возвращать &str на внутренний временный буфер, чтобы избежать выделения и owned-результата. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым.

Вопрос 5 из 30

Какое объяснение механизма «Borrowed и owned формы» не смешивает компиляцию и выполнение?

Integration test имеет доступ к private API библиотеки так же, как модульный тест. В результате «Borrowed и owned формы» считали бы безопасным и на путях, которых пример не выполняет. Borrowed-вход уменьшает ненужные перемещения, owned-выход отделяет результат от входа, а Cow выражает условное владение в одном типе. Принимающий String API всегда удобнее, потому что явно получает владение. В результате «Borrowed и owned формы» считали бы безопасным и на путях, которых пример не выполняет. API, принимающий String, одинаково удобен для &str и String без дополнительных выделений. По этой логике отдельная проверка «Borrowed и owned формы» на другом входе считалась бы лишней. Cow всегда выделяет новую строку, чтобы унифицировать владение. Следовательно, поведение `std::borrow::Cow` считалось бы одинаковым для всех допустимых типов.

Вопрос 6 из 30

Где заканчивается гарантия обычного сценария для «Безопасность и производительность»?

Возврат ссылки связывает пользователя с lifetime self и может мешать долгому хранению; иногда Arc<[u8]> или owned snapshot является правильным компромиссом. Cow::Borrowed и Cow::Owned имеют одинаковую стоимость и не нуждаются в отдельном тесте. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Заимствованный аргумент можно сохранить внутри объекта без отражения времени жизни в типе. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Документация владения излишня, если код компилируется на типичном примере. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. Добавление обязательного метода в публичный трейт не требует default-реализации или major-версии. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение.

Вопрос 7 из 30

Что именно объясняет сообщение компилятора?

/// Parses a header.
///
/// # Errors
/// Returns `ParseError::InvalidHeader` when the magic bytes are absent.
///
/// # Examples
/// ```
/// # use mylib::parse_header;
/// assert!(parse_header(b"HDR\0").is_ok());
/// ```
pub fn parse_header(bytes: &[u8]) -> Result<Header, ParseError> { /* ... */ }

Фрагмент успешно соберётся: builder проверяет обязательные поля при build. Значит, выполнение должно пройти через `ParseError::InvalidHeader` без изменения сигнатуры. Rust примет этот код, поскольку integration test импортирует библиотеку как внешний crate. Документация описывает ошибку и содержит внешний компилируемый пример; скрытая строка импорта не загромождает отображение. Фрагмент успешно соберётся: текст Display ошибки является стабильным машинным контрактом библиотеки. Сборка пройдёт, поскольку документационный пример проверяет внутренние private-пути так же, как внешний пользователь.

Вопрос 8 из 30

Как лучше всего описать гарантию механизма «Тестирование и инструменты Cargo»?

Добавление варианта в публичный enum всегда обратно совместимо. Тогда поведение «Тестирование и инструменты Cargo» при раннем выходе выводили бы из обычного пути. Integration test имеет доступ к private API библиотеки так же, как модульный тест. Следовательно, поведение `typical_user_flow` считалось бы одинаковым для всех допустимых типов. Документационный пример проверяет внутренние private-пути так же, как внешний пользователь. Следовательно, поведение `typical_user_flow` считалось бы одинаковым для всех допустимых типов. Публичный API лучше тестировать с внешней точки зрения: импортами, feature-наборами и минимальной поддерживаемой версией компилятора. Публичные поля структуры не входят в semver-контракт и могут свободно переименовываться. Проверку ошибки для «Тестирование и инструменты Cargo» при таком подходе заменили бы успешным примером.

Вопрос 9 из 30

Какое свойство закрепляет сценарий `#[non_exhaustive]`?

#[non_exhaustive]
pub struct Config { pub timeout_ms: u64 }

Диагностика инструмента сама однозначно подсказывает безопасное исправление, поэтому разбирать контракт отдельно не нужно. Успешная ветвь служит достаточным доказательством поведения при ошибке и повторном выполнении. Из этого следовало бы, что иной порядок операций для «Совместимость версий Semver» ничего не меняет. Внешний crate больше не может создавать Config литералом без.., поэтому библиотека сохраняет возможность добавлять поля через конструктор. Отсутствие сообщения инструмента означает, что опасная ветвь была выполнена и признана корректной. Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. Дополнительный сценарий вокруг `#[non_exhaustive]` при таком толковании уже не требуется.

Вопрос 10 из 30

Какой принцип лежит в основе механизма «Безопасность и производительность»?

Параметр `String` по значению удобнее и для операций только чтения: явная передача владения упрощает контракт, а стоимость выделения можно считать второстепенной. Само использование `Cow` уже делает цену владения понятной, поэтому переход к ветви `Owned` можно не отражать в названии и документации операции. API должен делать стоимость и владение предсказуемыми: заимствованный view обычно дешевле, а owned-копия должна быть осознанной. Возврат `impl Trait` стоит предпочесть именованному типу даже тогда, когда пользователю важны дополнительные границы вроде `Send` и возможность явно назвать возвращаемый тип. Возврат `Cow` по стоимости эквивалентен заимствованному срезу: даже создание ветви `Owned` не меняет ожидаемую цену вызова для пользователя API.

Вопрос 11 из 30

Какое утверждение о механизме «Ошибки» можно переносить на другие примеры?

Добавление варианта в публичный enum всегда обратно совместимо. Из этого следовало бы, что иной порядок операций для «Ошибки» ничего не меняет. Публичные поля структуры не входят в semver-контракт и могут свободно переименовываться. Следовательно, для «Ошибки» не понадобилось бы явное предусловие. Документационный пример проверяет внутренние private-пути так же, как внешний пользователь. Контракт «Ошибки» считался бы одинаковым при любом состоянии входа. Текст Display ошибки является стабильным машинным контрактом библиотеки. Следовательно, поведение `#[non_exhaustive]` считалось бы одинаковым для всех допустимых типов. Тип ошибки является частью semver-контракта: варианты, поля, Send/Sync и source chain влияют на пользовательский код и совместимость.

Вопрос 12 из 30

Какой граничный случай важнее всего учесть для механизма «Совместимость версий Semver»?

Добавление обязательного метода в публичный трейт не требует default-реализации или major-версии. Если внутренние тесты проходят, внешний путь импорта и видимость можно не проверять. Переэкспорт типа по новому пути полностью сохраняет старый путь без явного pub use. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Проверка semver не нужна для generated API и feature-зависимых публичных элементов. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Добавление impl Trait для существующего типа может конфликтовать с downstream-обобщениями или изменить разрешение методов; «только новая реализация» не всегда безусловно совместима.

Вопрос 13 из 30

Как следует интерпретировать результат проверки `ParseError::InvalidHeader`?

/// Parses a header.
///
/// # Errors
/// Returns `ParseError::InvalidHeader` when the magic bytes are absent.
///
/// # Examples
/// ```
/// # use mylib::parse_header;
/// assert!(parse_header(b"HDR\0").is_ok());
/// ```
pub fn parse_header(bytes: &[u8]) -> Result<Header, ParseError> { /* ... */ }

# RUSTDOCFLAGS="-D warnings" cargo doc --no-deps
# cargo test --doc

Проверка синтаксиса исчерпывает задачу: поведение на запуске не добавляет новой информации. Тогда поведение `parse_header` при раннем выходе выводили бы из обычного пути. Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. Контракт `parse_header` считался бы одинаковым при любом состоянии входа. Совпадение полного текста диагностики является главным и стабильным контрактом этой проверки. После успешного запуска основной ветви отдельные проверки ошибки, отмены и повторного вызова становятся избыточными. Следовательно, для `parse_header` не понадобилось бы явное предусловие. Первая команда ловит сломанные intra-doc links и предупреждения документации, вторая запускает примеры.

Вопрос 14 из 30

Что нужно изменить вокруг `#[non_exhaustive]`, чтобы устранить первопричину?

#[non_exhaustive]
#[derive(Debug)]
pub enum ParseError {
    InvalidHeader,
    UnsupportedVersion(u16),
}

Принимать только String и требовать clone от каждого пользователя, даже когда функция лишь читает текст. Заменить типизированную ошибку `non_exhaustive` паникой или строкой, сохранив внешний текст как средство программного ветвления. Публично обещать категории, по которым пользователь может действовать, сохранять source и не раскрывать внутренние типы зависимостей без намерения. Внести изменение сигнатуры `non_exhaustive` в исправление patch-версии, полагаясь на простую миграцию пользователей. Сводить все ошибки к String и рекомендовать пользователям разбирать текст. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым.

Вопрос 15 из 30

Что ещё нужно проверить, прежде чем считать реализацию «Ошибки» надёжной?

Добавление обязательного метода в публичный трейт не требует default-реализации или major-версии. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Следовательно, для «Ошибки» не понадобилось бы явное предусловие. Box<dyn Error> упрощает прототип, но стирает категории; публичный generic E может переложить сложность на каждого пользователя и зафиксировать лишние детали. Если внутренние тесты проходят, внешний путь импорта и видимость можно не проверять. Такое рассуждение переносило бы вывод о «Ошибки» на неисполненную ветвь. Изменение формы ошибки не влияет на пользователей, пока текст Display похож. Следовательно, для «Ошибки» не понадобилось бы явное предусловие. Проверка semver не нужна для generated API и feature-зависимых публичных элементов. По этой логике отдельная проверка «Ошибки» на другом входе считалась бы лишней.

Вопрос 16 из 30

Какое изменение входа способно поменять вывод о механизме «Документация»?

Документированный пример может компилироваться, но быть плохой практикой или слишком дорогим; doctest проверяет код, а не полноту объяснения и эксплуатационные риски. Если внутренние тесты проходят, внешний путь импорта и видимость можно не проверять. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. Изменение формы ошибки не влияет на пользователей, пока текст Display похож. В результате «Документация» считали бы безопасным и на путях, которых пример не выполняет. Документация владения излишня, если код компилируется на типичном примере. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Добавление обязательного метода в публичный трейт не требует default-реализации или major-версии. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются.

Вопрос 17 из 30

Где заканчивается гарантия обычного сценария для «Borrowed и owned формы»?

Добавление обязательного метода в публичный трейт не требует default-реализации или major-версии. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. Поэтому ошибочный сценарий вокруг «Borrowed и owned формы» не проверяли бы отдельно. Изменение формы ошибки не влияет на пользователей, пока текст Display похож. Контракт «Borrowed и owned формы» считался бы одинаковым при любом состоянии входа. Заимствованный аргумент можно сохранить внутри объекта без отражения времени жизни в типе. Проверку ошибки для «Borrowed и owned формы» при таком подходе заменили бы успешным примером. Слишком обобщённый Into<String> в каждом аргументе может скрыть аллокации и усложнить вывод типов; гибкость должна служить конкретным сценариям. Cow::Borrowed и Cow::Owned имеют одинаковую стоимость и не нуждаются в отдельном тесте. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Из этого следовало бы, что иной порядок операций для «Borrowed и owned формы» ничего не меняет.

Вопрос 18 из 30

На какую часть контракта распространяется проверка `bytes`?

pub fn bytes(&self) -> Vec<u8> {
    self.data.clone()
}

# Профиль показывает 35% времени в memcpy из bytes(), вызываемого в цикле.

Совпадение полного текста диагностики является главным и стабильным контрактом этой проверки. В результате `bytes` считали бы безопасным и на путях, которых пример не выполняет. Проверка подтверждает производительность решения, даже если в ней нет измерения времени, памяти или аллокаций; результат проверки с `bytes` предлагается переносить на все остальные ветви. Диагностика инструмента сама однозначно подсказывает безопасное исправление, поэтому разбирать контракт отдельно не нужно. Дополнительный сценарий вокруг `bytes` при таком толковании уже не требуется. Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. Из этого следовало бы, что иной порядок операций для `bytes` ничего не меняет. Узкое место — скрытая полная копия; переход на borrowed slice устранит memcpy, если вызывающий не должен владеть снимком независимо.

Вопрос 19 из 30

Какая реализация выражает механизм «Документация» без лишнего копирования?

/// Parses a header.
///
/// # Errors
/// Returns `ParseError::InvalidHeader` when the magic bytes are absent.
///
/// # Examples
/// ```
/// # use mylib::parse_header;
/// assert!(parse_header(b"HDR\0").is_ok());
/// ```
pub fn parse_header(bytes: &[u8]) -> Result<Header, ParseError> { /* ... */ }

Внести изменение сигнатуры `Parses` в исправление patch-версии, полагаясь на простую миграцию пользователей. Заменить типизированную ошибку `Parses` паникой или строкой, сохранив внешний текст как средство программного ветвления. Документировать предусловия, ошибки, панику, безопасность и сложность там, где они влияют на выбор пользователя; примеры запускать как doctest. Принимать только String и требовать clone от каждого пользователя, даже когда функция лишь читает текст. Сводить все ошибки к String и рекомендовать пользователям разбирать текст. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым. Проверку ошибки для `parse_header` при таком подходе заменили бы успешным примером.

Вопрос 20 из 30

Что именно стало проверяемым благодаря сценарию `ParseError::UnsupportedVersion`?

fn handle(e: &ParseError) {
    match e {
        ParseError::UnsupportedVersion(v) => eprintln!("unsupported {v}"),
        _ => eprintln!("cannot parse"),
    }
}

Wildcard делает внешний код совместимым с будущими вариантами, сохраняя точную обработку версии. Совпадение полного текста диагностики является главным и стабильным контрактом этой проверки. Дополнительный сценарий вокруг `ParseError::UnsupportedVersion` при таком толковании уже не требуется. Одного успешного примера достаточно, чтобы считать проверенными и невыполненные ветви контракта. Тогда различия между обычным и граничным случаем для `handle` исчезли бы. Диагностика инструмента сама однозначно подсказывает безопасное исправление, поэтому разбирать контракт отдельно не нужно. Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. Дополнительный сценарий вокруг `ParseError::UnsupportedVersion` при таком толковании уже не требуется.

Вопрос 21 из 30

Что можно считать доказанным после успешного выполнения `typical_user_flow`?

// tests/public_api.rs
use mylib::Config;
#[test]
fn typical_user_flow() {
    let cfg = Config::builder().timeout_ms(500).build().unwrap();
    assert_eq!(cfg.timeout_ms(), 500);
}

Integration test компилируется как внешний crate и проверяет только публичный путь, поэтому замечает случайную зависимость примера от private API. Integration test компилируется как внешний crate и проверяет только закрытый путь, поэтому замечает случайную зависимость примера от private API. Проверка типов завершится ошибкой: builder проверяет обязательные поля при build. До последней строки и наблюдаемого результата программа при таком разборе не доходит. Ошибка возникнет на этапе компиляции: integration test импортирует библиотеку как внешний crate. До последней строки и наблюдаемого результата программа при таком разборе не доходит. Сборка пройдёт, поскольку документационный пример проверяет внутренние private-пути так же, как внешний пользователь. Следовательно, для `typical_user_flow` не понадобилось бы явное предусловие.

Вопрос 22 из 30

Чем завершится выполнение фрагмента с `#[non_exhaustive]`?

#[non_exhaustive]
#[derive(Debug)]
pub enum ParseError {
    InvalidHeader,
    UnsupportedVersion(u16),
}

non_exhaustive оставляет библиотеке возможность добавлять варианты, а пользователям требует wildcard при внешнем match. Сборка остановится: integration test импортирует библиотеку как внешний crate. Код не пройдёт проверку: builder проверяет обязательные поля при build. Код считается допустимым, потому что документационный пример проверяет внутренние private-пути так же, как внешний пользователь. До выполнения код дойдёт без ошибки компиляции, поскольку текст Display ошибки является стабильным машинным контрактом библиотеки.

Вопрос 23 из 30

Какой край контракта «Тестирование и инструменты Cargo» чаще всего остаётся незамеченным?

Проверка semver не нужна для generated API и feature-зависимых публичных элементов. Контракт «Тестирование и инструменты Cargo» считался бы одинаковым при любом состоянии входа. Документация владения излишня, если код компилируется на типичном примере. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Поэтому ошибочный сценарий вокруг «Тестирование и инструменты Cargo» не проверяли бы отдельно. Если внутренние тесты проходят, внешний путь импорта и видимость можно не проверять. Поэтому отдельный результат ошибки и отрицательный тест для этого случая не предусматриваются. Контракт «Тестирование и инструменты Cargo» считался бы одинаковым при любом состоянии входа. Добавление обязательного метода в публичный трейт не требует default-реализации или major-версии. По этой логике отдельная проверка «Тестирование и инструменты Cargo» на другом входе считалась бы лишней. Высокое покрытие строк private-реализации не гарантирует удобство и совместимость публичных сигнатур; тест сценария пользователя часто ценнее.

Вопрос 24 из 30

Какой способ правки делает использование `typical_user_flow` корректным и явным?

// tests/public_api.rs
use mylib::Config;
#[test]
fn typical_user_flow() {
    let cfg = Config::builder().timeout_ms(500).build().unwrap();
    assert_eq!(cfg.timeout_ms(), 500);
}

Скрытый тип `impl Trait` можно заменить без последствий, даже если новая реализация перестанет быть `Send` или изменит время жизни. Вариант `Cow::Owned` нарушает время жизни `Cow<'a, [u8]>`: такой тип допустим только для заимствованной ветви. Сочетать unit-тесты инвариантов, integration/doctest пользовательского API, compile-fail отрицательных контрактов и semver-проверку экспортов. Внести изменение сигнатуры `tests` в исправление patch-версии, полагаясь на простую миграцию пользователей. Возврат `&[u8]` не связывает пользователя с владельцем: хранение среза автоматически продлевает жизнь исходного буфера.

Вопрос 25 из 30

Как исправить контракт, нарушенный при использовании `Config`?

pub struct Config {
    pub timeout_ms: u64,
}

Скрыть поля и предоставить builder/конструкторы либо пометить публичную структуру non_exhaustive до релиза; изменения проверять semver-инструментом. Добавлять обязательный параметр в существующую функцию без нового метода или значения по умолчанию. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым. Заменить типизированную ошибку `Config` паникой или строкой, сохранив внешний текст как средство программного ветвления. Внести изменение сигнатуры `Config` в исправление patch-версии, полагаясь на простую миграцию пользователей. Публиковать поля структуры напрямую вместо методов и считать их изменение внутренней деталью. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым.

Вопрос 26 из 30

Что проверяет `typical_user_flow`, если не расширять вывод за пределы выполненного пути?

// tests/public_api.rs
use mylib::Config;
#[test]
fn typical_user_flow() {
    let cfg = Config::builder().timeout_ms(500).build().unwrap();
    assert_eq!(cfg.timeout_ms(), 500);
}

# cargo test --test public_api
# cargo semver-checks  # внешний инструмент

Диагностика инструмента сама однозначно подсказывает безопасное исправление, поэтому разбирать контракт отдельно не нужно. Если обычный путь проходит, поведение при отмене и повторном входе можно считать следствием того же теста. Из этого следовало бы, что иной порядок операций для `typical_user_flow` ничего не меняет. Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. В результате `typical_user_flow` считали бы безопасным и на путях, которых пример не выполняет. Первый тест проверяет поведение текущего API, второй сравнивает публичную поверхность с предыдущим релизом и ищет известные semver-нарушения. Отсутствие ошибки компиляции уже доказывает нужное свойство, поэтому поведение можно не проверять. Из этого следовало бы, что иной порядок операций для `typical_user_flow` ничего не меняет.

Вопрос 27 из 30

Чем завершится выполнение фрагмента с `bytes`?

pub fn bytes(&self) -> Vec<u8> {
    self.data.clone()
}

Код компилируется, но заимствованный аргумент автоматически копируется библиотекой на весь срок хранения. Код компилируется и даёт ожидаемый результат: принимающий String API всегда удобнее, а явно получает владение. Safe API прост, но каждый вызов перемещает весь буфер и скрывает стоимость за безобидным именем bytes. До выполнения код дойдёт без ошибки компиляции, поскольку возврат impl Trait гарантирует пользователю возможность назвать конкретный скрытый тип. Safe API прост, но каждый вызов копирует весь буфер и скрывает стоимость за безобидным именем bytes.

Вопрос 28 из 30

Что нужно изменить вокруг `bytes`, чтобы устранить первопричину?

pub fn bytes(&self) -> Vec<u8> {
    self.data.clone()
}

Принимать только String и требовать clone от каждого пользователя, даже когда функция лишь читает текст. При каждом таком вызове появляется отдельный владелец и оплачивается копирование данных. Заменить типизированную ошибку `bytes` паникой или строкой, сохранив внешний текст как средство программного ветвления. Внести изменение сигнатуры `bytes` в исправление patch-версии, полагаясь на простую миграцию пользователей. Вернуть &[u8] для чтения, iterator/chunks для потока или явно назвать to_vec, если владение нужно; не раскрывать &mut внутреннего буфера без инварианта. Возвращать &str на внутренний временный буфер, чтобы избежать выделения и owned-результата. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым.

Вопрос 29 из 30

Какой путь выполнения выберет Rust после `std::borrow::Cow`?

pub fn normalize(input: &str) -> std::borrow::Cow<'_, str> {
    if input.bytes().all(|b| !b.is_ascii_uppercase()) {
        std::borrow::Cow::Borrowed(input)
    } else {
        std::borrow::Cow::Owned(input.to_ascii_lowercase())
    }
}

API возвращает заимствованный текст без выделения, когда изменений нет, и owned String только при нормализации. Rust не примет такую запись, поскольку публичный контракт описывает владение результата. Код считается допустимым, потому что cow всегда выделяет новую строку, чтобы унифицировать владение. Код компилируется и даёт ожидаемый результат: принимающий String API всегда удобнее, а явно получает владение. Проверку ошибки для `normalize` при таком подходе заменили бы успешным примером. Код компилируется, но заимствованный аргумент автоматически копируется библиотекой на весь срок хранения. Тогда поведение `normalize` при раннем выходе выводили бы из обычного пути.

Вопрос 30 из 30

Какое правило Rust точнее всего описывает механизм «Документация»?

API, принимающий String, одинаково удобен для &str и String без дополнительных выделений. Поэтому ошибочный сценарий вокруг «Документация» не проверяли бы отдельно. Rustdoc является частью API: ссылки, examples, разделы Errors/Panics/Safety и re-export пути помогают пользоваться контрактом без чтения реализации. Текст Display ошибки является стабильным машинным контрактом библиотеки. Поэтому ошибочный сценарий вокруг «Документация» не проверяли бы отдельно. Документационный пример проверяет внутренние private-пути так же, как внешний пользователь. Такое рассуждение переносило бы вывод о «Документация» на неисполненную ветвь. Display ошибки предназначен для стабильного программного ветвления пользователей. Тогда различия между обычным и граничным случаем для «Документация» исчезли бы.