Блог*

Отлично, теперь переходим к самому вкусному: написанию макроса! Нам нужно разобрать match, так что начнём с этого:

macro_rules! ascii_case_insensitive {
    (match $value:ident {
        $(... ,)*
        _ => $catch_all:expr $(,)?
    }) => { ... }
}

А теперь на минуту остановимся и подумаем, что из себя представляет паттерн, который мы пытаемся разобрать. В прошлый раз я совершенно упустил из виду, что обычно мы можем перечислить несколько паттернов, разделив их |, равно как и то, что паттерн может также предваряться |. Таким образом, корректный кусок макроса для распознавания паттернов должен выглядеть так:

$(|)? $($pattern:literal)|+

$(|)? отвечает за опциональную черту в начале. $pattern:literal говорит, что $pattern — это литерал, а $(...)|+ говорит о том, что то, что внутри скобок, повторяется один или более раз, и что повторы разделены |. Но постойте-ка, есть же ещё и опциональное охранное выражение! С учётом всего этого паттерн для одной ветви принимает такой вид:

$(|)? $($pattern:literal)|+ $(if $condition:expr)? => $arm:expr,

Отлично, с разбором мы справились (правда, всё так же упустив возможность привязать имена к паттернам). Что мы со всем этим делаем? Мы проверяем, что все строки в нижнем регистре:

#[deny(const_err)]
const _ARE_ALL_ASCII_LOWERCASE: [(); 1] = [(); are_all_ascii_lowercase(&[$($($pattern,)+)*]) as _];

И что они все разные:

#[allow(dead_code)]
fn non_repeating(s: &str) {
    #[deny(unreachable_patterns)]
    match s {
        $($(| $pattern)+ => (),)*
        _ => (),
    }
}

А что нам делать непосредственно самой проверкой? Мы проверяем, что значение равно, за вычетом ASCII-регистра, одному из паттернов... И что охранное выражение также справедливо, если оно есть:

x if ($(x.eq_ignore_ascii_case($pattern))||+) $(&& $condition)? => $arm,

Обратите внимание, здесь мы повторяем (+) выражения для паттернов, разделив их ||.

Что ж, давайте опробуем макрос в действии:

#[derive(Debug)]
enum Example {
    Foo,
    Bar,
    FourtyTwo,
}

impl std::str::FromStr for Example {
    type Err = String;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Ok(ascii_case_insensitive!(match s {
            "foo" => Self::Foo,
            "bar" if s.as_bytes()[0].is_ascii_lowercase() => Self::Bar,
            "fourtytwo" | "fourty_two" | "42" => Self::FourtyTwo,
            _ => return Err(s.into()),
        }))
    }
}

fn main() {
    let inputs = [
        "foo",
        "Foo",
        "FOO",
        "bar",
        "bAr",
        "BAR", // ошибка, первый символ в верхнем регистре
        "fourtytwo",
        "Fourtytwo",
        "FOURTYTWO",
        "fourty_two",
        "fOuRtY_tWo",
        "42",
        "bogus",
    ];
    for &input in &inputs[..] {
        println!("{:?}", input.parse::<Example>());
    }
}

Эта программа выдаёт следующее:

Ok(Foo)
Ok(Foo)
Ok(Foo)
Ok(Bar)
Ok(Bar)
Err("BAR")
Ok(FourtyTwo)
Ok(FourtyTwo)
Ok(FourtyTwo)
Ok(FourtyTwo)
Ok(FourtyTwo)
Ok(FourtyTwo)
Err("bogus")

...как и ожидалось. Что будет, если мы попытаемся сделать два одинаковых паттерна? Скажем, так:

            ...
            "foo" | "foo" => Self::Foo,
            ...

Компилятор жалуется:

error: unreachable pattern

А если один из паттернов не в нижнем регистре:

            ...
            "Foo" => Self::Foo,
            ...

то компилятор опять жалуется:

error[E0308]: mismatched types

Всё работает, как и ожидалось! Как всегда, весь код в гисте.