enums - Как гарантировать, что каждый вариант enum может быть возвращен из определенной функции во время компиляции?




rust (2)

Решением было бы сгенерировать все перечисление, варианты и элементы перевода с помощью макроса:

macro_rules! operations {
    (
        $($name:ident: $chr:expr)*
    ) => {
        #[derive(Debug)]
        pub enum Operation {
            $($name,)*
        }
        impl Operation {
            fn from(s: &str) -> Result<Self, &str> {
                match s {
                    $($chr => Ok(Self::$name),)*
                    _ => Err("Invalid operation"),
                }
            }
        }
    }
}

operations! {
    Add: "+"
    Subtract: "-"
}

Таким образом, добавление варианта тривиально, и вы не можете забыть разбор. Это также очень СУХОЕ решение.

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

playground

У меня есть перечисление:

enum Operation {
    Add,
    Subtract,
}

impl Operation {
    fn from(s: &str) -> Result<Self, &str> {
        match s {
            "+" => Ok(Self::Add),
            "-" => Ok(Self::Subtract),
            _ => Err("Invalid operation"),
        }
    }
}

Я хочу убедиться, что во время компиляции каждый вариант enum обрабатывается в функции from .

Зачем мне это нужно? Например, я мог бы добавить операцию Product и забыть обработать этот случай в функции from :

enum Operation {
    // ...
    Product,
}

impl Operation {
    fn from(s: &str) -> Result<Self, &str> {
        // No changes, I forgot to add a match arm for `Product`, "*".
    }
}

Можно ли гарантировать, что выражение соответствия возвращает каждый вариант перечисления? Если нет, то как лучше всего подражать этому поведению?


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

Если вы обеспокоены тем, что тесты могут продолжать проходить после добавления новых вариантов в перечисление, вы можете использовать макрос, чтобы гарантировать, что все варианты проверены:

#[derive(PartialEq, Debug)]
enum Operation {
    Add,
    Subtract,
}

impl Operation {
    fn from(s: &str) -> Result<Self, &str> {
        match s {
            "+" => Ok(Self::Add),
            "-" => Ok(Self::Subtract),
            _ => Err("Invalid operation"),
        }
    }
}

macro_rules! ensure_mapping {
    ($($str: literal => $variant: path),+ $(,)?) => {
        // assert that the given strings produce the expected variants
        $(assert_eq!(Operation::from($str), Ok($variant));)+

        // this generated fn will never be called but will produce a 
        // non-exhaustive pattern error if you've missed a variant
        fn check_all_covered(op: Operation) {
            match op {
                $($variant => {})+
            };
        }
    }
}

#[test]
fn all_variants_are_returned_by_from() {
   ensure_mapping! {
      "+" => Operation::Add,
       "-" => Operation::Subtract,
   }
}






rust