时间戳

首页 > 解决方案 > 我需要帮助重构 Rust 中的错误处理

error-handling - 我需要帮助重构 Rust 中的错误处理

问题描述

我想重构这个 Rust 代码以计算最大系列产品，并使其尽可能高效和优雅。我觉得

lsp(string_digits: &str, span: usize) -> Result<u64, Error>

可以以一种比现在更优雅的方式完成。lsp 是否可以仅使用一系列链式迭代器方法来实现？

#[derive(Debug, PartialEq)]
pub enum Error {
    SpanTooLong,
    InvalidDigit(char),
}

fn sp(w: &[u8]) -> u64 {
    w.iter().fold(1u64, |acc, &d| acc * u64::from(d))
}

pub fn lsp(string_digits: &str, span: usize) -> Result<u64, Error> {
    let invalid_chars = string_digits
        .chars()
        .filter(|ch| !ch.is_numeric())
        .collect::<Vec<_>>();
    if span > string_digits.len() {
        return Err(Error::SpanTooLong);
    } else if !invalid_chars.is_empty() {
        return Err(Error::InvalidDigit(invalid_chars[0]));
    } else if span == 0 || string_digits.is_empty() {
        return Ok(1);
    }

    let vec_of_u8_digits = string_digits
        .chars()
        .map(|ch| ch.to_digit(10).unwrap() as u8)
        .collect::<Vec<_>>();
    let lsp = vec_of_u8_digits
        .windows(span)
        .max_by(|&w1, &w2| sp(w1).cmp(&sp(w2)))
        .unwrap();
    Ok(sp(lsp))
}

标签： error-handlingrustrefactoringrust-cargo

解决方案

不确定这是否是最优雅的方式，但我已经尝试过，希望新版本与给定程序等效。

在这种情况下需要两件事：首先，我们需要一个“动态”提供滑动窗口的数据结构，其次，如果转换产生错误，我们需要一个提前结束迭代的函数。

对于前者，我选择了 VecDeque，因为span它是动态的。对于后者process_results，在 itertools crate 中调用了一个函数。它将结果的迭代器转换为展开类型的迭代器，并在遇到错误时停止迭代。

我还稍微更改sp了 u8 上的任何迭代器的签名。

这是代码：

use std::collections::VecDeque;
use itertools::process_results;

#[derive(Debug, PartialEq)]
pub enum Error {
    SpanTooLong,
    InvalidDigit(char),
}

fn sp(w: impl Iterator<Item=u8>) -> u64 {
    w.fold(1u64, |acc, d| acc * u64::from(d))
}

pub fn lsp(string_digits: &str, span: usize) -> Result<u64, Error> {
    if span > string_digits.len() {
        return Err(Error::SpanTooLong);
    } else if span == 0 || string_digits.is_empty() {
        return Ok(1);
    }

    let mut init_state = VecDeque::new();
    init_state.resize(span, 0);

    process_results(string_digits.chars()
        .map(|ch| ch.to_digit(10)
            .map(|d| d as u8)
            .ok_or(Error::InvalidDigit(ch))),
        |digits|
            digits.scan(init_state, |state, digit| {
                state.pop_back();
                state.push_front(digit);
                Some(sp(state.iter().cloned()))
            })
            .max()
            .unwrap()
    )
}

推荐阅读