regex - 如何从传递给regex::Regex::replace的闭包中冒出一个错误？

Question

我有一个函数，该函数通过一个对regex::Regex::replace执行一些操作的闭包，通过Captures就地执行字符串替换:

pub fn solve_dice_expression(expression: String) -> Result<i64, Box<dyn Error>> {
    lazy_static! {
        static ref PATTERN: Regex = Regex::new(r"(\d+)d(\d+)").expect("Problem compiling regex");
    }

    // For every match on the Dice expression regex, roll it in-place.
    let rolled_expression = PATTERN.replace(&expression, |caps: &Captures| {
        let diceroll_str = &caps.get(0).unwrap().as_str().to_string();
        let dice = Dice::from_string(&diceroll_str).unwrap();
        return format!("{}", roll_dice(&mut rng, &dice));
    });

    // Calculate the result
    let result = eval(&rolled_expression)?.as_int()?;

    return Ok(result);
}

我尝试通过返回 Result<..., Box<dyn Error>>来使错误冒泡，该方法主要通过 ?起作用。但是，在传递给 regex::Regex::replace的闭包中，我不确定如何传播可能发生的任何错误，因为它期望闭包返回 String而不是 Result。

处理该关闭中发生的错误的正确方法是什么？

Answer 1

你不容易。

您可以做的是使用可变的Option走私错误，然后在替换完成后检查一下:

use regex::{Captures, Regex}; // 1.3.3
use std::borrow::Cow;

type Error = Box<dyn std::error::Error>;
type Result<T, E = Error> = std::result::Result<T, E>;

fn example<'s>(r: &Regex, s: &'s str) -> Result<Cow<'s, str>> {
    let mut error = None;

    let v = r.replace(s, |caps: &Captures| {
        // TODO: Optimize by checking if we had an error already and exit early

        let digits = caps.get(0).unwrap().as_str();

        // Uncomment to see the failure
        // let digits = "bad";

        match digits.parse::<i32>() {
            Ok(v) => Cow::Owned((v + 1).to_string()),
            Err(e) => {
                // Save the error somewhere
                error = Some(e);
                // We are going to discard the replacement,
                // so it doesn't matter what we return
                Cow::Borrowed("")
            }
        }
    });

    match error {
        Some(e) => Err(Box::new(e)),
        None => Ok(v),
    }
}

fn main() {
    let r = Regex::new(r"\d+").unwrap();
    let v = example(&r, "1");
    println!("{:?}", v);
}

您也可以在自己的类型上实现 Replacer 特征，以简化此过程，并可能对其进行稍微优化。