enums - ¿Cómo asegurar que cada variante enum pueda ser devuelta desde una función específica en tiempo de compilación?

rust

Question

Tengo una enumeración:

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

Quiero asegurarme en tiempo de compilación de que cada variante enum se maneja en la función from .

¿Por qué necesito esto? Por ejemplo, podría agregar una operación de Product y olvidarme de manejar este caso en la función from :

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

¿Es posible garantizar que la expresión de coincidencia devuelva cada variante de una enumeración? Si no, ¿cuál es la mejor manera de imitar este comportamiento?

Answer 1

Si bien existe una forma complicada, y frágil, de inspeccionar su código con macros de procedimiento, una ruta mucho mejor es utilizar pruebas. Las pruebas son más robustas, mucho más rápidas de escribir y verificarán las circunstancias en las que se devuelve cada variante, no solo que aparece en algún lugar.

Si le preocupa que las pruebas continúen pasando después de agregar nuevas variantes a la enumeración, puede usar una macro para asegurarse de que se prueben todos los casos:

#[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,
}
}

Answer 2

Una solución sería generar toda la enumeración, variantes y brazos de traducción con una macro:

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: "-"
}

De esta manera, agregar una variante es trivial y no puede olvidar un análisis. También es una solución muy SECA.

Es fácil extender esta construcción con otras funciones (por ejemplo, la traducción inversa) que seguramente necesitará más adelante y no tendrá que duplicar el análisis de caracteres.

playground