Почему в Rust так сложно сделать заглавной первую букву строки?

Онлайн-тренажер Python для начинающих

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

Начать курс

Почему капитализация первой буквы строки в Rust — это вызов?

Если вы когда-либо писали на Python или JavaScript, то знаете, что сделать заглавной первую букву строки — это буквально одна строка кода: 'hello'.capitalize() или 'hello'[0].toUpperCase() + 'hello'.slice(1). Всё просто и элегантно.

Но как только вы переходите на Rust, вас ждёт сюрприз. Вопрос "Why is capitalizing the first letter of a string so convoluted in Rust?" на Stack Overflow собрал тысячи просмотров и сотни комментариев. И это не случайно — за кажущейся простотой скрывается глубокая философия языка, его отношение к безопасности, производительности и Unicode.

В этой статье мы не просто дадим готовое решение. Мы разберём, почему Rust не предлагает встроенного метода .capitalize(), какие компромиссы стоят за этим решением и как написать свою эффективную реализацию, не теряя в скорости и корректности.

Проблема: Unicode и графемы

Первое, что нужно понять: строка в Rust — это не массив ASCII-символов. Это последовательность байт в кодировке UTF-8. А «первый символ» строки — это не обязательно один байт. Например, символ «é» занимает 2 байта, а эмодзи «😊» — целых 4.

Более того, существуют так называемые графемы — видимые символы, которые могут состоять из нескольких Unicode-кодовых точек. Например, «é» может быть представлена как один символ (U+00E9) или как комбинация «e» + «◌́» (U+0065 + U+0301).

Теперь представьте, что мы хотим сделать заглавной первую букву строки "straße". В немецком языке буква «ß» при капитализации превращается в «SS» — то есть один символ становится двумя. Это означает, что длина строки может измениться! В Rust, где строки неизменяемы по умолчанию (если не использовать String), такое преобразование требует выделения новой памяти.

Именно поэтому простого str[0].to_uppercase() недостаточно. Rust заставляет вас явно обрабатывать эти случаи, чтобы избежать неявных ошибок, которые могли бы привести к панике или некорректному поведению.

Производительность: почему Rust не делает это за вас?

Rust — язык системного программирования. Он не прощает «ленивых» решений. Встроенный метод .capitalize() должен был бы учитывать все возможные Unicode-нюансы, что сделало бы его медленным и тяжёлым для большинства тривиальных случаев.

Представьте: вы пишете высоконагруженный сервер, который обрабатывает миллионы строк в секунду. Если каждая капитализация будет проверять, не является ли первый символ частью графемы, и не превращается ли он в несколько символов — вы потеряете драгоценные циклы CPU.

Rust даёт вам контроль. Вы сами решаете, насколько «правильной» должна быть ваша капитализация:

Если вы работаете только с ASCII — используйте простую проверку байтов. Это будет молниеносно.
Если вам нужна полная Unicode-корректность — используйте крейт unicode-segmentation.
Если вы обрабатываете только английские тексты — можно пожертвовать редкими случаями в пользу скорости.

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

Решения: от простого к правильному

Решение 1: Простое (только ASCII)

Если вы уверены, что ваша строка содержит только ASCII-символы, то можно сделать так:

fn capitalize_ascii(s: &str) -> String {
    let mut chars = s.chars();
    match chars.next() {
        None => String::new(),
        Some(first) => first.to_uppercase().to_string() + chars.as_str(),
    }
}

fn main() {
    let s = "hello world";
    println!("{}", capitalize_ascii(s)); // "Hello world"
}

Этот метод работает быстро, но сломается на не-ASCII символах. Например, "straße" превратится в "Straße" вместо правильного "Straße" (заглавная S и строчная ß). В немецком это допустимо, но для полной корректности нужно другое решение.

Решение 2: С использованием char::to_uppercase

Метод to_uppercase() у типа char уже умеет обрабатывать Unicode и возвращает итератор, так как один символ может превратиться в несколько:

fn capitalize_unicode(s: &str) -> String {
    let mut chars = s.chars();
    match chars.next() {
        None => String::new(),
        Some(first) => {
            first.to_uppercase().collect::<String>() + chars.as_str()
        }
    }
}

fn main() {
    let s = "straße";
    println!("{}", capitalize_unicode(s)); // "Straße" — верно!
    
    let s2 = "éclair";
    println!("{}", capitalize_unicode(s2)); // "Éclair"
}

Это уже лучше, но всё ещё не идеально. Проблема — в графемах. Например, строка "a\u{0301}" (a + ударение) будет воспринята как два символа: chars.next() вернёт только 'a', а ударение останется. В результате мы получим "A\u{0301}" — внешне правильно, но с точки зрения Unicode это не единый символ, а два.

Решение 3: Правильное (с учётом графем)

Для полной корректности нужно использовать крейт unicode-segmentation, который умеет разбивать строку на графемные кластеры:

use unicode_segmentation::UnicodeSegmentation;

fn capitalize_correct(s: &str) -> String {
    let mut graphemes = s.graphemes(true);
    match graphemes.next() {
        None => String::new(),
        Some(first) => {
            // Капитализируем первый графемный кластер
            let capitalized: String = first
                .chars()
                .flat_map(|c| c.to_uppercase())
                .collect();
            capitalized + graphemes.collect::<String>().as_str()
        }
    }
}

fn main() {
    let s = "a\u{0301}bc"; // a с ударением
    println!("{}", capitalize_correct(s)); // "A\u{0301}bc" — корректно!
}

Добавьте в Cargo.toml зависимость:

[dependencies]
unicode-segmentation = "1.10"

Это решение — самое правильное, но оно добавляет зависимость и небольшое снижение производительности. Для большинства проектов достаточно решения 2.