Краткий ответ

Имя в идентификаторном шаблоне по умолчанию создаёт новую привязку, а не сравнивается со значением одноимённой внешней переменной. Такая привязка может затенить внешнее имя внутри arm или другого участка, где действует шаблон. Для сравнения со значением нужно использовать константу в пути или связать новое имя и выполнить сравнение в guard.

Исторический контекст

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

Такое правило устраняет неоднозначность между «сопоставить со значением» и «ввести имя». Для сопоставления с фиксированным значением Rust использует константные шаблоны, обычно записанные через путь к константе.

Постановка проблемы

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

Это может сделать последующие arms недостижимыми, привести к предупреждению о неиспользуемой переменной и, главное, незаметно изменить логику обработки данных. Ошибка особенно опасна в маршрутизации команд, разборе протокола и обработке кодов статуса.

Подробное решение

Идентификаторный шаблон вроде candidate означает: «сопоставить любое значение и связать его с именем candidate». Если такое имя уже объявлено снаружи, шаблон не обращается к внешней переменной, а создаёт новую привязку, затеняющую её в соответствующей области.

Для динамического значения используют отдельное имя и условие-сопоставление, или guard:

const LIMIT: i32 = 10;

fn classify(value: i32, threshold: i32) -> &'static str {
    match value {
        LIMIT => "constant",
        candidate if candidate == threshold => "argument",
        _ => "other",
    }
}

LIMIT здесь является константным шаблоном и сопоставляется со значением константы. candidate связывает входное значение, после чего guard сравнивает его с параметром threshold.

Произвольный вызов функции или вычисляемое выражение нельзя просто использовать как обычный шаблон. Если значение известно на этапе компиляции и удовлетворяет требованиям Rust к константному шаблону, его можно вынести в const; если значение получается во время выполнения, применяют guard либо предварительное условие if.

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

Ситуация из практики

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

Вариант с константой не подходит, потому что код конфигурации известен только во время выполнения. Можно было сначала выполнить обычное сравнение через if, что проще для одного условия, но при большом числе форматов это ухудшает структуру маршрутизации. Выбран вариант с guard: он сохраняет единый match, явно связывает входное значение и корректно сравнивает его с динамическим параметром.

После исправления специальный arm стал срабатывать только для нужного кода, а остальные варианты продолжили обрабатываться отдельными arms. Дополнительный плюс решения — намерение видно непосредственно в шаблоне и условии, без зависимости от неочевидного затенения имён.

Что кандидаты часто упускают

Можно ли использовать имя внешней переменной в шаблоне для сравнения с её значением?

Нет. Простое имя в позиции шаблона создаёт новую привязку. Для динамической внешней переменной нужно связать значение под другим именем и сравнить его в guard либо выполнить сравнение до match.
Чем константный шаблон отличается от идентификаторного?

Константа, записанная как путь, интерпретируется как значение для сопоставления, а не как новая переменная. Поэтому путь к const может выбирать конкретный arm, тогда как простое имя принимает любое значение. Для константных шаблонов также действуют правила Rust о типе и допустимости значения в pattern matching.
Затеняет ли привязка из шаблона внешнюю переменную навсегда?

Нет. Затенение действует только в области, где доступна новая привязка, например внутри тела соответствующего arm. После завершения этой области внешнее имя снова доступно. Однако внутри guard и тела arm нужно внимательно учитывать, какое именно имя разрешается, поскольку новая привязка может скрыть внешнюю переменную с тем же именем.